blob_id stringlengths 40 40 | directory_id stringlengths 40 40 | path stringlengths 4 201 | content_id stringlengths 40 40 | detected_licenses listlengths 0 85 | license_type stringclasses 2
values | repo_name stringlengths 7 100 | snapshot_id stringlengths 40 40 | revision_id stringlengths 40 40 | branch_name stringclasses 260
values | visit_date timestamp[us] | revision_date timestamp[us] | committer_date timestamp[us] | github_id int64 11.4k 681M ⌀ | star_events_count int64 0 209k | fork_events_count int64 0 110k | gha_license_id stringclasses 17
values | gha_event_created_at timestamp[us] | gha_created_at timestamp[us] | gha_language stringclasses 80
values | src_encoding stringclasses 28
values | language stringclasses 1
value | is_vendor bool 1
class | is_generated bool 2
classes | length_bytes int64 8 9.86M | extension stringclasses 52
values | content stringlengths 8 9.86M | authors listlengths 1 1 | author stringlengths 0 119 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
9d6e44a5bcc52ae7fa2e520de2e05ab26f8d79ed | 545fa9e3a0d42e7058d8634af7380556d1842e46 | /Include/Core/System/Value4.hpp | d70c0ee3ef840ca35c4b0a0a225860ed6c565ecf | [
"MIT"
] | permissive | FelixCpp/Core | 36ce6fc02ffad27de12cb144811324fce59f7599 | 6d74a317ed41514c2f55367c69ca7bf5c35236c5 | refs/heads/main | 2022-05-09T15:06:35.945404 | 2022-03-29T23:03:32 | 2022-03-29T23:03:32 | 323,312,133 | 1 | 0 | null | 2021-01-14T17:42:07 | 2020-12-21T11:10:41 | C++ | UTF-8 | C++ | false | false | 7,434 | hpp | //
// Value4.hpp
// Core
//
// Created by Felix Busch on 24.02.2022.
// Copyright © 2022 Felix Busch. All rights reserved.
//
#pragma once
#include <Core/System/Value2.hpp>
#include <Core/System/Value3.hpp>
#include <cstdint>
namespace Core
{
template<typename T>
class Value4
{
public:
////////////////////////////////////////////////////////////
/// \brief Default constructor
///
////////////////////////////////////////////////////////////
constexpr Value4():
X(T{}), Y(T{}), Z(T{}), W(T{})
{
}
constexpr Value4(T x, T y, T z, T w) :
X(x), Y(y), Z(z), W(w)
{
}
constexpr explicit Value4(const Value2<T>& xy, T z, T w):
Value4(xy.X, xy.Y, z, w)
{}
constexpr explicit Value4(T x, const Value2<T>& yz, T w):
Value4(x, yz.X, yz.Y, w)
{}
constexpr explicit Value4(T x, T y, const Value2<T>& zw):
Value4(x, y, zw.X, zw.Y)
{}
constexpr explicit Value4(const Value2<T>& xy, const Value2<T>& zw):
Value4(xy.X, xy.Y, zw.X, zw.Y)
{}
constexpr explicit Value4(const Value3<T>& xyz, T w):
Value4(xyz.X, xyz.Y, xyz.Z, w)
{}
constexpr explicit Value4(T x, const Value3<T>& yzw):
Value4(x, yzw.X, yzw.Y, yzw.Z)
{}
template<typename O> requires std::is_convertible_v<O, T>
constexpr explicit Value4(const Value4<O>& other):
X((T)other.X), Y((T)other.Y), Z((T)other.Z), W((T)other.W)
{}
T Dot(const Value4& other) const { return X * other.X + Y * other.Y + Z * other.Z + W * other.W; }
T LengthSq() const { return Dot(*this); }
T Length() const { return std::sqrt(LengthSq()); }
Value4 Floored() const { return { std::floor(X), std::floor(Y), std::floor(Z), std::floor(W) }; }
Value4 Ceiled() const { return { std::ceil(X), std::ceil(Y), std::ceil(Z), std::ceil(W) }; }
Value4 Max(const Value4& other) const { return { std::max(X, other.X), std::max(Y, other.Y), std::max(Z, other.Z), std::max(W, other.W) }; }
Value4 Min(const Value4& other) const { return { std::min(X, other.X), std::min(Y, other.Y), std::min(Z, other.Z), std::min(W, other.W) }; }
Value4 Abs() const { return { std::abs(X), std::abs(Y), std::abs(Z), std::abs(W) }; }
Value4 Neg() const { return { -std::abs(X), -std::abs(Y), -std::abs(Z), -std::abs(W) }; }
Value4 Normalized() const
{
const T length = Length();
if(length != (T)0.0)
{
return *this / length;
}
return *this;
}
////////////////////////////////////////////////////////////
/// Member data
///
////////////////////////////////////////////////////////////
union
{
struct // X-Y-Z-W
{
union
{
struct // X-Y-Z
{
union // XY
{
struct { T X, Y; };
Value2<T> XY;
};
T Z;
};
Value3<T> XYZ;
};
T W;
};
struct // XYZW
{
T X, Y, Z, W;
} XYZW;
};
};
////////////////////////////////////////////////////////////
/// Boolean operators
///
////////////////////////////////////////////////////////////
template<typename T> constexpr bool operator == (const Value4<T>& lhs, const Value4<T>& rhs) { return lhs.X == rhs.R && lhs.Y == rhs.Y && lhs.Z == rhs.Z && lhs.W == rhs.W; }
template<typename T> constexpr bool operator != (const Value4<T>& lhs, const Value4<T>& rhs) { return lhs.X != rhs.R || lhs.Y != rhs.Y || lhs.Z != rhs.Z || lhs.W != rhs.W; }
////////////////////////////////////////////////////////////
/// Mathematical operators v4 => v4
///
////////////////////////////////////////////////////////////
template<typename T> constexpr Value4<T> operator + (const Value4<T>& lhs, const Value4<T>& rhs) { return { lhs.X + rhs.X, lhs.Y + rhs.Y, lhs.Z + rhs.Z, lhs.W + rhs.W }; }
template<typename T> constexpr Value4<T> operator - (const Value4<T>& lhs, const Value4<T>& rhs) { return { lhs.X - rhs.X, lhs.Y - rhs.Y, lhs.Z - rhs.Z, lhs.W - rhs.W }; }
template<typename T> constexpr Value4<T> operator / (const Value4<T>& lhs, const Value4<T>& rhs) { return { lhs.X / rhs.X, lhs.Y / rhs.Y, lhs.Z / rhs.Z, lhs.W / rhs.W }; }
template<typename T> constexpr Value4<T> operator * (const Value4<T>& lhs, const Value4<T>& rhs) { return { lhs.X * rhs.X, lhs.Y * rhs.Y, lhs.Z * rhs.Z, lhs.W * rhs.W }; }
////////////////////////////////////////////////////////////
/// Mathematical operators v4& => v4
///
////////////////////////////////////////////////////////////
template<typename T> constexpr Value4<T>& operator += (Value4<T>& lhs, const Value4<T>& rhs) { return lhs = lhs + rhs; }
template<typename T> constexpr Value4<T>& operator -= (Value4<T>& lhs, const Value4<T>& rhs) { return lhs = lhs - rhs; }
template<typename T> constexpr Value4<T>& operator /= (Value4<T>& lhs, const Value4<T>& rhs) { return lhs = lhs / rhs; }
template<typename T> constexpr Value4<T>& operator *= (Value4<T>& lhs, const Value4<T>& rhs) { return lhs = lhs * rhs; }
////////////////////////////////////////////////////////////
/// Mathematical operators v4 => value
///
////////////////////////////////////////////////////////////
template<typename T> constexpr Value4<T> operator + (const Value4<T>& lhs, const T& value) { return { lhs.X + value, lhs.Y + value, lhs.Z + value, lhs.W + value }; }
template<typename T> constexpr Value4<T> operator - (const Value4<T>& lhs, const T& value) { return { lhs.X - value, lhs.Y - value, lhs.Z - value, lhs.W - value }; }
template<typename T> constexpr Value4<T> operator / (const Value4<T>& lhs, const T& value) { return { lhs.X / value, lhs.Y / value, lhs.Z / value, lhs.W / value }; }
template<typename T> constexpr Value4<T> operator * (const Value4<T>& lhs, const T& value) { return { lhs.X * value, lhs.Y * value, lhs.Z * value, lhs.W * value }; }
////////////////////////////////////////////////////////////
/// Mathematical operators v4& => value
///
////////////////////////////////////////////////////////////
template<typename T> constexpr Value4<T>& operator += (Value4<T>& lhs, const T& value) { return lhs = lhs + value; }
template<typename T> constexpr Value4<T>& operator -= (Value4<T>& lhs, const T& value) { return lhs = lhs - value; }
template<typename T> constexpr Value4<T>& operator /= (Value4<T>& lhs, const T& value) { return lhs = lhs / value; }
template<typename T> constexpr Value4<T>& operator *= (Value4<T>& lhs, const T& value) { return lhs = lhs * value; }
////////////////////////////////////////////////////////////
/// Sign operators
///
////////////////////////////////////////////////////////////
template<typename T> constexpr Value4<T> operator + (const Value4<T>& lhs) { return { +lhs.X, +lhs.Y, +lhs.Z, +lhs.W }; }
template<typename T> constexpr Value4<T> operator - (const Value4<T>& lhs) { return { -lhs.X, -lhs.Y, -lhs.Z, -lhs.W }; }
template<typename T> constexpr Value4<T> operator | (const Value2<T>& xy, const Value2<T>& zw) { return Value4<T>(xy, zw); }
template<typename T> constexpr Value4<T> operator | (const Value3<T>& xyz, const T& w) { return Value4<T>(xyz, w); }
template<typename T> constexpr Value4<T> operator | (const T& x, const Value3<T>& yzw) { return Value4<T>(x, yzw); }
////////////////////////////////////////////////////////////
/// Type definitions
///
////////////////////////////////////////////////////////////
using Int4 = Value4<int32_t>;
using UInt4 = Value4<uint32_t>;
using Float4 = Value4<float>;
using int4 = Value4<int32_t>;
using uint4 = Value4<uint32_t>;
using float4 = Value4<float>;
} | [
"fix.busch@gmail.com"
] | fix.busch@gmail.com |
fd4a589d1d86636eb5d41b83d5e3ad344b86a07a | cdfcadc73ef9734ffef96d67b0628596d261893e | /Data-Structures-and-Algorithms/DSA2-assignment3/useGraph.cpp | c7a238b25e9d411e97dea3d8183c1f07f0de5abe | [
"MIT"
] | permissive | StanleyZheng/Coursework-CooperUnion | 60d9b096c45a6fc537c7bb923fa650e6ff72a0f1 | 27269cfab2df6e05761246365c4b0614e500d1ce | refs/heads/master | 2021-01-13T04:26:16.529248 | 2017-02-12T19:08:44 | 2017-02-12T19:08:44 | 79,876,960 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,396 | cpp | /*
Stanley Zheng
Data Structures and Algorithms II, Fall 2016
Programming Assignment #3
Due: November 15, 2016
- implementation of Dijkstra's algorithm to solve the single-source shortest path problem.
- asks user to enter:
a file specifying the graph
a starting vertex
an output file to write to
- all edge costs are > 0 and < 1 Million
- assumes file is valid if it can be opened.
*/
#include <iostream>
#include <fstream>
#include <sstream>
#include <string>
#include <cstdlib>
#include <ctime>
#include "heap.h"
#include "graph.h"
using namespace std;
int main(){
string infile, outfile;
string start_vertex;
clock_t t1, t2;
double timeDiff;
//open and read graph file
cout << "Enter name of graph file: ";
cin >> infile;
ifstream input(infile.c_str());
if(!input){
cerr << "Error: could not open " << infile << endl;
exit(1);
}
//load graph.txt into hash table
graph myGraph = graph(1000000); //mapping size of 1 million
string line, source, destin;
int edge_cost;
while(getline(input, line)){
//used stringstream to parse the line from file
stringstream strline;
strline << line; //parse line into strline
strline >> source;
strline >> destin;
strline >> edge_cost;
myGraph.insert(source, destin, edge_cost);
}
//have user input valid vertex
do {
cout << "Enter a valid vertex id for the string vertex: ";
cin >> start_vertex;
} while(!(myGraph.contains(start_vertex))); //while the heap constains string returns false
//perform dijkstras algorithm on the Graph
t1 = clock();
myGraph.dijkstra(start_vertex);
t2 = clock();
timeDiff = ((double) (t2 - t1)) / CLOCKS_PER_SEC;
cout << "Total time (in seconds) to apply Dijkstra's algorithm: " << timeDiff << endl;
//open and write to output file
cout << "Enter name of output file: ";
cin >> outfile;
ofstream output(outfile.c_str());
if(!output){
cerr << "Error: could not open " << outfile << endl;
exit(1);
}
//write to output file
myGraph.printPaths(start_vertex, output);
//close files;
input.close();
output.close();
return 0;
} | [
"szheng1689@gmail.com"
] | szheng1689@gmail.com |
b6b5164b6457ceb4fa8da69d9df75f9156e9dedd | d92a44473f2f9a1dea287ca80fbb8f034b5b4e38 | /Graphics/GraphicsEngineD3D11/src/PipelineStateD3D11Impl.cpp | 25e45808f4ee3f21b4a088772d6d6bb17f45f059 | [
"Apache-2.0"
] | permissive | elix22/DiligentCore | 84748079cdc30959cfc7ef690d6e541ffb7aaa99 | f758fc53ec95113a5fbb7453cec8b1c79922e6b0 | refs/heads/master | 2020-07-30T14:25:34.725213 | 2019-09-18T16:12:16 | 2019-09-18T16:12:16 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 16,036 | cpp | /* Copyright 2019 Diligent Graphics LLC
*
* 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
*
* 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 OF ANY PROPRIETARY RIGHTS.
*
* In no event and under no legal theory, whether in tort (including negligence),
* contract, or otherwise, unless required by applicable law (such as deliberate
* and grossly negligent acts) or agreed to in writing, shall any Contributor be
* liable for any damages, including any direct, indirect, special, incidental,
* or consequential damages of any character arising as a result of this License or
* out of the use or inability to use the software (including but not limited to damages
* for loss of goodwill, work stoppage, computer failure or malfunction, or any and
* all other commercial damages or losses), even if such Contributor has been advised
* of the possibility of such damages.
*/
#include "pch.h"
#include <array>
#include "PipelineStateD3D11Impl.h"
#include "RenderDeviceD3D11Impl.h"
#include "ShaderResourceBindingD3D11Impl.h"
#include "EngineMemory.h"
#include "ShaderD3D11Impl.h"
namespace Diligent
{
PipelineStateD3D11Impl::PipelineStateD3D11Impl(IReferenceCounters* pRefCounters,
RenderDeviceD3D11Impl* pRenderDeviceD3D11,
const PipelineStateDesc& PipelineDesc) :
TPipelineStateBase(pRefCounters, pRenderDeviceD3D11, PipelineDesc),
m_SRBMemAllocator(GetRawAllocator()),
m_StaticSamplers(STD_ALLOCATOR_RAW_MEM(StaticSamplerInfo, GetRawAllocator(), "Allocator for vector<StaticSamplerInfo>"))
{
if (PipelineDesc.IsComputePipeline)
{
auto* pCS = ValidatedCast<ShaderD3D11Impl>(PipelineDesc.ComputePipeline.pCS);
m_pCS = pCS;
if (m_pCS == nullptr)
{
LOG_ERROR_AND_THROW("Compute shader is null");
}
if (m_pCS && m_pCS->GetDesc().ShaderType != SHADER_TYPE_COMPUTE)
{
LOG_ERROR_AND_THROW(GetShaderTypeLiteralName(SHADER_TYPE_COMPUTE), " shader is expeceted while ", GetShaderTypeLiteralName(m_pCS->GetDesc().ShaderType), " provided");
}
m_ShaderResourceLayoutHash = pCS->GetD3D11Resources()->GetHash();
}
else
{
#define INIT_SHADER(ShortName, ExpectedType)\
{ \
auto* pShader = ValidatedCast<ShaderD3D11Impl>(PipelineDesc.GraphicsPipeline.p##ShortName); \
m_p##ShortName = pShader; \
if (m_p##ShortName && m_p##ShortName->GetDesc().ShaderType != ExpectedType) \
{ \
LOG_ERROR_AND_THROW( GetShaderTypeLiteralName(ExpectedType), " shader is expeceted while ", GetShaderTypeLiteralName(m_p##ShortName->GetDesc().ShaderType)," provided" ); \
} \
if(pShader!=nullptr) \
HashCombine(m_ShaderResourceLayoutHash, pShader->GetD3D11Resources()->GetHash() ); \
}
INIT_SHADER(VS, SHADER_TYPE_VERTEX);
INIT_SHADER(PS, SHADER_TYPE_PIXEL);
INIT_SHADER(GS, SHADER_TYPE_GEOMETRY);
INIT_SHADER(DS, SHADER_TYPE_DOMAIN);
INIT_SHADER(HS, SHADER_TYPE_HULL);
#undef INIT_SHADER
if (m_pVS == nullptr)
{
LOG_ERROR_AND_THROW("Vertex shader is null");
}
auto* pDeviceD3D11 = pRenderDeviceD3D11->GetD3D11Device();
D3D11_BLEND_DESC D3D11BSDesc = {};
BlendStateDesc_To_D3D11_BLEND_DESC(PipelineDesc.GraphicsPipeline.BlendDesc, D3D11BSDesc);
CHECK_D3D_RESULT_THROW( pDeviceD3D11->CreateBlendState( &D3D11BSDesc, &m_pd3d11BlendState ),
"Failed to create D3D11 blend state object" );
D3D11_RASTERIZER_DESC D3D11RSDesc = {};
RasterizerStateDesc_To_D3D11_RASTERIZER_DESC(PipelineDesc.GraphicsPipeline.RasterizerDesc, D3D11RSDesc);
CHECK_D3D_RESULT_THROW( pDeviceD3D11->CreateRasterizerState( &D3D11RSDesc, &m_pd3d11RasterizerState ),
"Failed to create D3D11 rasterizer state" );
D3D11_DEPTH_STENCIL_DESC D3D11DSSDesc = {};
DepthStencilStateDesc_To_D3D11_DEPTH_STENCIL_DESC(PipelineDesc.GraphicsPipeline.DepthStencilDesc, D3D11DSSDesc);
CHECK_D3D_RESULT_THROW( pDeviceD3D11->CreateDepthStencilState( &D3D11DSSDesc, &m_pd3d11DepthStencilState ),
"Failed to create D3D11 depth stencil state" );
// Create input layout
const auto& InputLayout = m_Desc.GraphicsPipeline.InputLayout;
if (InputLayout.NumElements > 0)
{
std::vector<D3D11_INPUT_ELEMENT_DESC, STDAllocatorRawMem<D3D11_INPUT_ELEMENT_DESC> > d311InputElements(STD_ALLOCATOR_RAW_MEM(D3D11_INPUT_ELEMENT_DESC, GetRawAllocator(), "Allocator for vector<D3D11_INPUT_ELEMENT_DESC>") );
LayoutElements_To_D3D11_INPUT_ELEMENT_DESCs(InputLayout, d311InputElements);
ID3DBlob* pVSByteCode = m_pVS.RawPtr<ShaderD3D11Impl>()->GetBytecode();
if( !pVSByteCode )
LOG_ERROR_AND_THROW( "Vertex Shader byte code does not exist" );
CHECK_D3D_RESULT_THROW( pDeviceD3D11->CreateInputLayout(d311InputElements.data(), static_cast<UINT>(d311InputElements.size()), pVSByteCode->GetBufferPointer(), pVSByteCode->GetBufferSize(), &m_pd3d11InputLayout ),
"Failed to create the Direct3D11 input layout");
}
}
m_pStaticResourceLayouts = ALLOCATE(GetRawAllocator(), "Raw memory for ShaderResourceLayoutD3D11", ShaderResourceLayoutD3D11, m_NumShaders);
m_pStaticResourceCaches = ALLOCATE(GetRawAllocator(), "Raw memory for ShaderResourceCacheD3D11", ShaderResourceCacheD3D11, m_NumShaders);
const auto& ResourceLayout = PipelineDesc.ResourceLayout;
#ifdef DEVELOPMENT
{
const ShaderResources* pResources[MaxShadersInPipeline] = {};
for (Uint32 s = 0; s < m_NumShaders; ++s)
{
auto* pShader = GetShader<const ShaderD3D11Impl>(s);
pResources[s] = &(*pShader->GetD3D11Resources());
}
ShaderResources::DvpVerifyResourceLayout(ResourceLayout, pResources, m_NumShaders);
}
#endif
decltype(m_StaticSamplers) StaticSamplers(STD_ALLOCATOR_RAW_MEM(StaticSamplerInfo, GetRawAllocator(), "Allocator for vector<StaticSamplerInfo>"));
std::array<size_t, MaxShadersInPipeline> ShaderResLayoutDataSizes = {};
std::array<size_t, MaxShadersInPipeline> ShaderResCacheDataSizes = {};
for (Uint32 s = 0; s < m_NumShaders; ++s)
{
auto* pShader = GetShader<const ShaderD3D11Impl>(s);
const auto& ShaderResources = *pShader->GetD3D11Resources();
new (m_pStaticResourceCaches+s) ShaderResourceCacheD3D11;
// Do not initialize the cache as this will be performed by the resource layout
// Shader resource layout will only contain dynamic and mutable variables
const SHADER_RESOURCE_VARIABLE_TYPE StaticVarTypes[] = {SHADER_RESOURCE_VARIABLE_TYPE_STATIC};
new (m_pStaticResourceLayouts + s)
ShaderResourceLayoutD3D11
{
*this,
pShader->GetD3D11Resources(),
m_Desc.ResourceLayout,
StaticVarTypes,
_countof(StaticVarTypes),
m_pStaticResourceCaches[s],
GetRawAllocator(),
GetRawAllocator()
};
// Initialize static samplers
for(Uint32 sam = 0; sam < ShaderResources.GetNumSamplers(); ++sam)
{
const auto& SamplerAttribs = ShaderResources.GetSampler(sam);
auto SrcStaticSamplerInd = ShaderResources.FindStaticSampler(SamplerAttribs, ResourceLayout);
if (SrcStaticSamplerInd >= 0)
{
const auto& SrcStaticSamplerInfo = ResourceLayout.StaticSamplers[SrcStaticSamplerInd];
RefCntAutoPtr<ISampler> pStaticSampler;
pRenderDeviceD3D11->CreateSampler(SrcStaticSamplerInfo.Desc, &pStaticSampler);
StaticSamplers.emplace_back(SamplerAttribs, std::move(pStaticSampler));
}
}
m_StaticSamplerOffsets[s + 1] = static_cast<Uint16>(StaticSamplers.size());
if (PipelineDesc.SRBAllocationGranularity > 1)
{
const SHADER_RESOURCE_VARIABLE_TYPE SRBVarTypes[] = { SHADER_RESOURCE_VARIABLE_TYPE_MUTABLE, SHADER_RESOURCE_VARIABLE_TYPE_DYNAMIC };
ShaderResLayoutDataSizes[s] = ShaderResourceLayoutD3D11::GetRequiredMemorySize(ShaderResources, ResourceLayout, SRBVarTypes, _countof(SRBVarTypes));
ShaderResCacheDataSizes[s] = ShaderResourceCacheD3D11::GetRequriedMemorySize(ShaderResources);
}
auto ShaderInd = GetShaderTypeIndex(pShader->GetDesc().ShaderType);
m_ResourceLayoutIndex[ShaderInd] = static_cast<Int8>(s);
}
if (PipelineDesc.SRBAllocationGranularity > 1)
{
m_SRBMemAllocator.Initialize(PipelineDesc.SRBAllocationGranularity, m_NumShaders, ShaderResLayoutDataSizes.data(), m_NumShaders, ShaderResCacheDataSizes.data());
}
m_StaticSamplers.reserve(StaticSamplers.size());
for(auto& Sam : StaticSamplers)
m_StaticSamplers.emplace_back(std::move(Sam));
for (Uint32 s = 0; s < m_NumShaders; ++s)
{
// Initialize static samplers in the static resource cache to avoid warning messages
SetStaticSamplers(m_pStaticResourceCaches[s], s);
}
}
PipelineStateD3D11Impl::~PipelineStateD3D11Impl()
{
for (Uint32 s = 0; s < m_NumShaders; ++s)
{
m_pStaticResourceCaches[s].Destroy(GetRawAllocator());
m_pStaticResourceCaches[s].~ShaderResourceCacheD3D11();
}
GetRawAllocator().Free(m_pStaticResourceCaches);
for (Uint32 l = 0; l < m_NumShaders; ++l)
{
m_pStaticResourceLayouts[l].~ShaderResourceLayoutD3D11();
}
GetRawAllocator().Free(m_pStaticResourceLayouts);
}
IMPLEMENT_QUERY_INTERFACE( PipelineStateD3D11Impl, IID_PipelineStateD3D11, TPipelineStateBase )
ID3D11BlendState* PipelineStateD3D11Impl::GetD3D11BlendState()
{
return m_pd3d11BlendState;
}
ID3D11RasterizerState* PipelineStateD3D11Impl::GetD3D11RasterizerState()
{
return m_pd3d11RasterizerState;
}
ID3D11DepthStencilState* PipelineStateD3D11Impl::GetD3D11DepthStencilState()
{
return m_pd3d11DepthStencilState;
}
ID3D11InputLayout* PipelineStateD3D11Impl::GetD3D11InputLayout()
{
return m_pd3d11InputLayout;
}
void PipelineStateD3D11Impl::CreateShaderResourceBinding(IShaderResourceBinding** ppShaderResourceBinding, bool InitStaticResources)
{
auto* pRenderDeviceD3D11 = ValidatedCast<RenderDeviceD3D11Impl>( GetDevice() );
auto &SRBAllocator = pRenderDeviceD3D11->GetSRBAllocator();
auto pShaderResBinding = NEW_RC_OBJ(SRBAllocator, "ShaderResourceBindingD3D11Impl instance", ShaderResourceBindingD3D11Impl)(this, false);
if (InitStaticResources)
pShaderResBinding->InitializeStaticResources(nullptr);
pShaderResBinding->QueryInterface(IID_ShaderResourceBinding, reinterpret_cast<IObject**>(static_cast<IShaderResourceBinding**>(ppShaderResourceBinding)));
}
bool PipelineStateD3D11Impl::IsCompatibleWith(const IPipelineState* pPSO)const
{
VERIFY_EXPR(pPSO != nullptr);
if (pPSO == this)
return true;
const PipelineStateD3D11Impl* pPSOD3D11 = ValidatedCast<const PipelineStateD3D11Impl>(pPSO);
if (m_ShaderResourceLayoutHash != pPSOD3D11->m_ShaderResourceLayoutHash)
return false;
if (m_NumShaders != pPSOD3D11->m_NumShaders)
return false;
for (Uint32 s = 0; s < m_NumShaders; ++s)
{
auto* pShader0 = GetShader<const ShaderD3D11Impl>(s);
auto* pShader1 = pPSOD3D11->GetShader<const ShaderD3D11Impl>(s);
if (pShader0->GetDesc().ShaderType != pShader1->GetDesc().ShaderType)
return false;
const auto& Res0 = *pShader0->GetD3D11Resources();
const auto& Res1 = *pShader1->GetD3D11Resources();
if (!Res0.IsCompatibleWith(Res1))
return false;
}
return true;
}
ID3D11VertexShader* PipelineStateD3D11Impl::GetD3D11VertexShader()
{
if(!m_pVS)return nullptr;
auto* pVSD3D11 = m_pVS.RawPtr<ShaderD3D11Impl>();
return static_cast<ID3D11VertexShader*>(pVSD3D11->GetD3D11Shader());
}
ID3D11PixelShader* PipelineStateD3D11Impl::GetD3D11PixelShader()
{
if(!m_pPS)return nullptr;
auto* pPSD3D11 = m_pPS.RawPtr<ShaderD3D11Impl>();
return static_cast<ID3D11PixelShader*>(pPSD3D11->GetD3D11Shader());
}
ID3D11GeometryShader* PipelineStateD3D11Impl::GetD3D11GeometryShader()
{
if(!m_pGS)return nullptr;
auto* pGSD3D11 = m_pGS.RawPtr<ShaderD3D11Impl>();
return static_cast<ID3D11GeometryShader*>(pGSD3D11->GetD3D11Shader());
}
ID3D11DomainShader* PipelineStateD3D11Impl::GetD3D11DomainShader()
{
if(!m_pDS)return nullptr;
auto* pDSD3D11 = m_pDS.RawPtr<ShaderD3D11Impl>();
return static_cast<ID3D11DomainShader*>(pDSD3D11->GetD3D11Shader());
}
ID3D11HullShader* PipelineStateD3D11Impl::GetD3D11HullShader()
{
if(!m_pHS)return nullptr;
auto* pHSD3D11 = m_pHS.RawPtr<ShaderD3D11Impl>();
return static_cast<ID3D11HullShader*>(pHSD3D11->GetD3D11Shader());
}
ID3D11ComputeShader* PipelineStateD3D11Impl::GetD3D11ComputeShader()
{
if(!m_pCS)return nullptr;
auto* pCSD3D11 = m_pCS.RawPtr<ShaderD3D11Impl>();
return static_cast<ID3D11ComputeShader*>(pCSD3D11->GetD3D11Shader());
}
void PipelineStateD3D11Impl::BindStaticResources(Uint32 ShaderFlags, IResourceMapping* pResourceMapping, Uint32 Flags)
{
for (Uint32 s=0; s < m_NumShaders; ++s)
{
auto& StaticResLayout = m_pStaticResourceLayouts[s];
if ( (ShaderFlags & StaticResLayout.GetShaderType()) != 0 )
StaticResLayout.BindResources(pResourceMapping, Flags, m_pStaticResourceCaches[s]);
}
}
Uint32 PipelineStateD3D11Impl::GetStaticVariableCount(SHADER_TYPE ShaderType) const
{
const auto LayoutInd = m_ResourceLayoutIndex[GetShaderTypeIndex(ShaderType)];
if (LayoutInd < 0)
return 0;
return m_pStaticResourceLayouts[LayoutInd].GetTotalResourceCount();
}
IShaderResourceVariable* PipelineStateD3D11Impl::GetStaticVariableByName(SHADER_TYPE ShaderType, const Char* Name)
{
const auto LayoutInd = m_ResourceLayoutIndex[GetShaderTypeIndex(ShaderType)];
if (LayoutInd < 0)
return nullptr;
return m_pStaticResourceLayouts[LayoutInd].GetShaderVariable(Name);
}
IShaderResourceVariable* PipelineStateD3D11Impl::GetStaticVariableByIndex(SHADER_TYPE ShaderType, Uint32 Index)
{
const auto LayoutInd = m_ResourceLayoutIndex[GetShaderTypeIndex(ShaderType)];
if (LayoutInd < 0)
return nullptr;
return m_pStaticResourceLayouts[LayoutInd].GetShaderVariable(Index);
}
void PipelineStateD3D11Impl::SetStaticSamplers(ShaderResourceCacheD3D11& ResourceCache, Uint32 ShaderInd)const
{
auto NumCachedSamplers = ResourceCache.GetSamplerCount();
for (Uint32 s = m_StaticSamplerOffsets[ShaderInd]; s < m_StaticSamplerOffsets[ShaderInd+1]; ++s)
{
auto& SamplerInfo = m_StaticSamplers[s];
const auto& SamAttribs = SamplerInfo.Attribs;
auto* pSamplerD3D11Impl = SamplerInfo.pSampler.RawPtr<SamplerD3D11Impl>();
// Limiting EndBindPoint is required when initializing static samplers in a Shader's static cache
auto EndBindPoint = std::min( static_cast<Uint32>(SamAttribs.BindPoint) + SamAttribs.BindCount, NumCachedSamplers);
for (Uint32 BindPoint = SamAttribs.BindPoint; BindPoint < EndBindPoint; ++BindPoint )
ResourceCache.SetSampler(BindPoint, pSamplerD3D11Impl);
}
}
}
| [
"egor.yusov@gmail.com"
] | egor.yusov@gmail.com |
f7287ea93447ea9f3abc4800299b6de0c653ba4d | bf2f653924bc1b747422d4b0b63bf4b586ed8b40 | /STM32_E30_Sensor_V1.0.0_alpha/STM32_E30_Sensor_V1.0.0_alpha.ino | 5751eed95cea3178df3a45895aa395c5bc38d92c | [] | no_license | Arrogantyunya/STM32_E30_Sensor | 0e11edeac70bc33920f5dd25b8c60cc4a5eeedab | f0a74cec6a553aa699ec832cc066c40d1556e861 | refs/heads/master | 2022-11-24T07:24:11.879490 | 2020-08-05T01:56:41 | 2020-08-05T01:56:41 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 5,822 | ino | #define TINY_GSM_MODEM_SIM800
#include "GSM/TinyGsmClient.h"
#include <Arduino.h>
#include <libmaple/nvic.h>
#include <libmaple/pwr.h>
#include <libmaple/bkp.h>
#include "memory.h"
#include "Private_Sensor.h"
#include "data_transmit.h"
#include "private_delay.h"
#include "Periph.h"
#include "Private_RTC.h"
#include "AT24C1024.h"
#include "OLED.h"
#define Print_test 1
TinyGsm modem(GSM_Serial);
TinyGsmClient client(modem);
unsigned int Run_Time_Out_Sec = 0; //运行超时计数
char Toggle = 0; //状态灯闪灭位翻转
uint8_t t=' ';
void setup()
{
Some_GPIO_Init(); //IO口初始化定义
Serial.begin(115200); //USB serial port.
ModBus_Serial.begin(9600);
GSM_Serial.begin(9600);
#if Print_test
/* File :D:\刘家辉\代码\STM32_12Way_Irrigation_Controller\STM32_12Way_Irrigation_ControllerV6.0.0_beta\STM32_12Way_Irrigation_ControllerV6.0.0_beta.ino */
Serial.println(String("File :") + __FILE__);
/* Data :Jun 19 2020 *//* 显示的是编译的日期 */
Serial.println(String("Data :") + __DATE__);
/* Time :10:15:31 *//* 显示的是编译的日期 */
Serial.println(String("Time :") + __TIME__);
/* Line :135 */
Serial.println(String("Line :") + __LINE__);
/* Func :setup */
Serial.println(String("Func :") + __func__);
#endif
// #if (DEVICE_V2_5 || E30_DEVICE_V1_0)
// EP_Write_Enable();
// #endif
// EpromDb.open(EEPROM_BASE_ADDR);
// EpromDb.clear();
// #if (DEVICE_V2_5 || E30_DEVICE_V1_0)
// EP_Write_Disable();
// #endif
bkp_init();
Serial.println("bkp初始化完成");
//初始化RTC闹钟
Init_RTC(180);
Serial.println("RTC闹钟初始化完成");
//初始化OLED
OLED_Init();
OLED_ColorTurn(0);//0正常显示 1反色显示
OLED_DisplayTurn(0);//0正常显示 1翻转180度显示
Serial.println("OLED初始化完成");
//如果电池电压小于xxV，设备休眠
if (Get_Bat_Voltage(DEFAULT_VOL_CHANGE_TIMES) < MIN_BAT_VOL)
{
Serial.println("电压极低，进入休眠状态");
delay(100);
SYS_Sleep();
}
//显示电量
MyOLED.Display_Electricity(Get_Bat_Voltage(DEFAULT_VOL_CHANGE_TIMES));
System_ID_Self_Check(SysHostID); //系统ID自检
Serial.println("系统ID自检完成");
Key_Clear_Device_Parameter(); //按键2清除系统参数，慎用
Key_Clear_Muti_Sensor_Data(); //按键1清除存储在EP中的传感器数据
//初始化定时器2
Timer2.setChannel1Mode(TIMER_OUTPUTCOMPARE);
Timer2.setPeriod(1000000); // in microseconds，1S
Timer2.setCompare1(1); // overflow might be small
Timer2.attachCompare1Interrupt(Time2_Handler);
Serial.println("定时器2初始化完成");
//RS485模块开始采集传感器数据
Serial.println("开始采集传感器数据...");
MyOLED.Display_Collecting();//显示正在采集
Data_Acquisition();
Serial.println(String("RTC: ") + RtcTime.year + "年" + RtcTime.month + "月" +
RtcTime.day + "日" + RtcTime.hour + "时" + RtcTime.minutes + "分" + RtcTime.seconds + "秒");
MyOLED.Display_Sensor_Data();//
MyOLED.Display_Collect_time();//
}
void loop()
{
// MyOLED.Display_Sensor_Data();//
// MyOLED.Display_Collect_time();//
// Data_Acquisition();
if(Get_Bat_Voltage(DEFAULT_VOL_CHANGE_TIMES) < MIN_BAT_VOL)
{
Serial.println("电压极低，进入休眠状态");
delay(100);
SYS_Sleep();
}
MyOLED.Display_Signal();
if(!Pre_Access_Network())//注册到网络
{
Serial.println("注册到网络失败，进入休眠 <Pre_Access_Network>");
delay(100);
SYS_Sleep();
}
if(!Connect_to_The_Server())//连接到服务器
{
Serial.println("连接到服务器失败，进入休眠 <Connect_to_The_Server>");
delay(100);
SYS_Sleep();
}
if (Send_Data_To_Server() == true)
{
Serial.println("发送数据至服务器完成，进入休眠 <Send_Data_To_Server>");
delay(2000);
SYS_Sleep();
}
else
{
Serial.println("发送数据至服务器失败，重启 <Send_Data_To_Server>");
delay(100);
nvic_sys_reset();
}
}
/*
*brief : 关闭相关电源，进入待机模式
*para : 无
*return :
*/
void SYS_Sleep(void)
{
#if E30_DEVICE_V1_0
Timer2.detachCompare1Interrupt();
LED1_OFF;
LED2_OFF;
GPRS_PWR_OFF;
Sensor3V3_PWR_OFF;
OLED_PWR_OFF;
PWR_WakeUpPinCmd(ENABLE); //使能唤醒引脚，默认PA0
PWR_ClearFlag(PWR_FLAG_WU);
PWR_EnterSTANDBYMode(); //进入待机
#else
Timer2.detachCompare1Interrupt();
LED1_OFF;
LED2_OFF;
LED3_OFF;
LED4_OFF;
GPRS_PWR_OFF;
DC12V_PWR_OFF;
USB_PORT_DIS;
GPS_ANT_PWR_OFF;
PWR_WakeUpPinCmd(ENABLE); //使能唤醒引脚，默认PA0
PWR_ClearFlag(PWR_FLAG_WU);
PWR_EnterSTANDBYMode(); //进入待机
#endif
}
/*
*brief : 按键2清除储存的系统相关参数
*para : 无
*return : 无
*/
void Key_Clear_Device_Parameter(void)
{
if (digitalRead(KEY2_INPUT) == LOW)
{
GSM_STATUS_LED_ON;
Delay_ms(1000);
if (digitalRead(KEY2_INPUT) == LOW)
{
Clear_HostID = true;
Serial.println("Clear System parameter OK...");
GSM_STATUS_LED_OFF;
}
}
}
/*
*brief : 按键1清除储存在EP中的传感器数据
*para : 无
*return : 无
*/
void Key_Clear_Muti_Sensor_Data(void)
{
if (digitalRead(KEY1_INPUT) == LOW)
{
GSM_STATUS_LED_ON;
Delay_ms(1000);
if (digitalRead(KEY1_INPUT) == LOW)
{
#if (DEVICE_V2_5 || GS100_DEVICE_V1_0)
EP_Write_Enable();
#endif
EpromDb.open(EEPROM_BASE_ADDR);
EpromDb.clear();
#if (DEVICE_V2_5 || GS100_DEVICE_V1_0)
EP_Write_Disable();
#endif
Serial.println("Clear Sensor Data OK...");
GSM_STATUS_LED_OFF;
}
}
}
/*
*brief : 定时器2中断函数
*para : 无
*return : 无
*/
void Time2_Handler(void)
{
Toggle ^= 1;
digitalWrite(LED1, Toggle); //状态灯闪烁
Run_Time_Out_Sec++;
//如果运行超时，复位
if (Run_Time_Out_Sec >= 300)
{
Run_Time_Out_Sec = 0;
nvic_sys_reset();
}
}
| [
"liujiahiu@qq.com"
] | liujiahiu@qq.com |
b79d10412ba17b7e05b79f6e524c845699e9cc80 | 193dcf0041cc0a9d0c82d1be3e872ffcc50c683b | /cell_server/src/gui/GUI.h | 8bd27fecc769b62d1d05a5c9c7dd58a1f75f0bae | [] | no_license | llenroc/Cell | f4c6df43cba78f2f628e6360464745a4e0e70779 | 2edfd7ddafdac1c42aad49edb5576407e77cc91c | refs/heads/master | 2021-01-17T18:04:20.777455 | 2014-03-04T17:00:13 | 2014-03-04T17:00:13 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,323 | h | //
// GUI.h
// emptyExample
//
// Created by James Alliban on 25/06/2013.
//
//
#pragma once
#include "ofMain.h"
#include "GUIManager.h"
class testApp;
class GUI : GUIManager
{
public:
virtual void setup();
virtual bool getVisible();
int getClientCalibrationVisible();
void addKeyboardShortcutsGUI();
void addCameraGUI();
void addTagShaderGUI();
void addLineAppearanceGUI();
void addTagAnimationGUI();
void addTagAdditionGUI();
void addTagBoundariesGUI();
void addMotionFields1GUI();
void addMotionFields2GUI();
void addColourFieldsGUI();
void addKinectGlobalGUI();
void addSkeletonCalibrationAllGUI();
void addKinectCalibration0GUI();
void addKinectCalibration1GUI();
void addKinectCalibration2GUI();
void addKinectCalibration3GUI();
void addKinectCalibration4GUI();
void addDuplicatesGUI();
void addKinectUserDegugGUI();
void addVariousGUI();
void variousGUIEvent(ofxUIEventArgs &e);
void addTagShaderGUIEvent(ofxUIEventArgs &e);
void addTagAnimationGUIEvent(ofxUIEventArgs &e);
void addKinectUserDegugGUIEvent(ofxUIEventArgs &e);
//void cameraGUIEvent(ofxUIEventArgs &e);
virtual void update();
virtual void draw();
float skelOffsetRange;
testApp* app;
};
| [
"j.alliban@gmail.com"
] | j.alliban@gmail.com |
09bac44e8bf2f130c33c2e25ee38323b3a803bab | 68582f780762c099046090edc3ad4d786134e492 | /Source/InstrumentLoader.h | a82e0f6f8498dd9daa9a4f4a44364b15310f8e7c | [] | no_license | Penhorse/Instrument-Browser | 47c19ba17a5cd68bff7d8baf3c6ae0c65e655f0c | 5f563b85c1b94821e4cbacf1b10f0564310064ea | refs/heads/master | 2021-01-17T14:17:21.681249 | 2017-04-26T14:36:53 | 2017-04-26T14:36:53 | 45,424,357 | 16 | 5 | null | 2016-07-02T10:35:41 | 2015-11-02T21:48:25 | C++ | UTF-8 | C++ | false | false | 1,190 | h | /*
==============================================================================
InstrumentLoader.h
Created: 31 Oct 2015 2:36:54pm
Author: Chris
==============================================================================
*/
#ifndef INSTRUMENTLOADER_H_INCLUDED
#define INSTRUMENTLOADER_H_INCLUDED
#include <memory>
#include "../JuceLibraryCode/JuceHeader.h"
#include "Instrument.h"
#include "ISMSnoopWrapper.h"
class ErrorReceiver;
class InstrumentReceiver;
class InstrumentLoader : public Thread
{
public:
InstrumentLoader(
const StringArray & directories,
std::shared_ptr<ISMSnoopWrapper> ismsnoop,
InstrumentReceiver * instrument_receiver,
ErrorReceiver * error_receiver);
void run();
private:
int try_load_directory(const File & dir) const;
int load_directory(const File & dir) const;
void load_file(const File & file) const;
std::string get_name(ISMSnoopInstrument * ism) const;
Instrument::Icon get_icon(ISMSnoopInstrument * ism) const;
StringArray directories_;
std::shared_ptr<ISMSnoopWrapper> ismsnoop_;
InstrumentReceiver * instrument_receiver_;
ErrorReceiver * error_receiver_;
};
#endif // INSTRUMENTLOADER_H_INCLUDED
| [
"chris@pleasesendhelp.com"
] | chris@pleasesendhelp.com |
34fa22207e1799ce1a90d4a9eeddc541051480b8 | c71d9862169295dd650390ca44f2ebeb2e6740af | /src/gui/itemviews/qtreewidget.cpp | aaabc490e228ba8966a17fc5d6a6ec3bf2235ab6 | [] | no_license | maoxingda/qt-src | d23c8d0469f234f89fdcbdbe6f3d50fa16e7a0e3 | e01aee06520bf526975b0bedafe78eb003b5ead6 | refs/heads/master | 2020-04-14T00:05:16.292626 | 2019-01-05T05:49:42 | 2019-01-05T05:49:42 | 163,524,224 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 102,892 | cpp | /****************************************************************************
**
** Copyright (C) 2012 Nokia Corporation and/or its subsidiary(-ies).
** Contact: http://www.qt-project.org/
**
** This file is part of the QtGui module of the Qt Toolkit.
**
** $QT_BEGIN_LICENSE:LGPL$
** GNU Lesser General Public License Usage
** This file may be used under the terms of the GNU Lesser General Public
** License version 2.1 as published by the Free Software Foundation and
** appearing in the file LICENSE.LGPL included in the packaging of this
** file. Please review the following information to ensure the GNU Lesser
** General Public License version 2.1 requirements will be met:
** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
**
** In addition, as a special exception, Nokia gives you certain additional
** rights. These rights are described in the Nokia Qt LGPL Exception
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
**
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU General
** Public License version 3.0 as published by the Free Software Foundation
** and appearing in the file LICENSE.GPL included in the packaging of this
** file. Please review the following information to ensure the GNU General
** Public License version 3.0 requirements will be met:
** http://www.gnu.org/copyleft/gpl.html.
**
** Other Usage
** Alternatively, this file may be used in accordance with the terms and
** conditions contained in a signed written agreement between you and Nokia.
**
**
**
**
**
**
** $QT_END_LICENSE$
**
****************************************************************************/
#include "qtreewidget.h"
#ifndef QT_NO_TREEWIDGET
#include <qheaderview.h>
#include <qpainter.h>
#include <qitemdelegate.h>
#include <qstack.h>
#include <qdebug.h>
#include <private/qtreewidget_p.h>
#include <private/qwidgetitemdata_p.h>
#include <private/qtreewidgetitemiterator_p.h>
QT_BEGIN_NAMESPACE
// workaround for VC++ 6.0 linker bug (?)
typedef bool(*LessThan)(const QPair<QTreeWidgetItem*,int>&,const QPair<QTreeWidgetItem*,int>&);
class QTreeModelLessThan
{
public:
inline bool operator()(QTreeWidgetItem *i1, QTreeWidgetItem *i2) const
{ return *i1 < *i2; }
};
class QTreeModelGreaterThan
{
public:
inline bool operator()(QTreeWidgetItem *i1, QTreeWidgetItem *i2) const
{ return *i2 < *i1; }
};
/*
\class QTreeModel
\brief The QTreeModel class manages the items stored in a tree view.
\ingroup model-view
*/
/*!
\enum QTreeWidgetItem::ChildIndicatorPolicy
\since 4.3
\value ShowIndicator The controls for expanding and collapsing will be shown for this item even if there are no children.
\value DontShowIndicator The controls for expanding and collapsing will never be shown even if there are children. If the node is forced open the user will not be able to expand or collapse the item.
\value DontShowIndicatorWhenChildless The controls for expanding and collapsing will be shown if the item contains children.
*/
/*!
\fn void QTreeWidgetItem::setDisabled(bool disabled)
\since 4.3
Disables the item if \a disabled is true; otherwise enables the item.
\sa setFlags()
*/
/*!
\fn bool QTreeWidgetItem::isDisabled() const
\since 4.3
Returns true if the item is disabled; otherwise returns false.
\sa setFlags()
*/
/*!
\internal
Constructs a tree model with a \a parent object and the given
number of \a columns.
*/
QTreeModel::QTreeModel(int columns, QTreeWidget *parent)
: QAbstractItemModel(parent), rootItem(new QTreeWidgetItem),
headerItem(new QTreeWidgetItem), skipPendingSort(false)
{
rootItem->view = parent;
rootItem->itemFlags = Qt::ItemIsDropEnabled;
headerItem->view = parent;
setColumnCount(columns);
}
/*!
\internal
*/
QTreeModel::QTreeModel(QTreeModelPrivate &dd, QTreeWidget *parent)
: QAbstractItemModel(dd, parent), rootItem(new QTreeWidgetItem),
headerItem(new QTreeWidgetItem), skipPendingSort(false)
{
rootItem->view = parent;
rootItem->itemFlags = Qt::ItemIsDropEnabled;
headerItem->view = parent;
}
/*!
\internal
Destroys this tree model.
*/
QTreeModel::~QTreeModel()
{
clear();
delete headerItem;
rootItem->view = 0;
delete rootItem;
}
/*!
\internal
Removes all items in the model.
*/
void QTreeModel::clear()
{
SkipSorting skipSorting(this);
for (int i = 0; i < rootItem->childCount(); ++i) {
QTreeWidgetItem *item = rootItem->children.at(i);
item->par = 0;
item->view = 0;
delete item;
}
rootItem->children.clear();
sortPendingTimer.stop();
reset();
}
/*!
\internal
Sets the number of \a columns in the tree model.
*/
void QTreeModel::setColumnCount(int columns)
{
SkipSorting skipSorting(this);
if (columns < 0)
return;
if (!headerItem) {
headerItem = new QTreeWidgetItem();
headerItem->view = view();
}
int count = columnCount();
if (count == columns)
return;
if (columns < count) {
beginRemoveColumns(QModelIndex(), columns, count - 1);
headerItem->values.resize(columns);
endRemoveColumns();
} else {
beginInsertColumns(QModelIndex(), count, columns - 1);
headerItem->values.resize(columns);
for (int i = count; i < columns; ++i) {// insert data without emitting the dataChanged signal
headerItem->values[i].append(QWidgetItemData(Qt::DisplayRole, QString::number(i + 1)));
headerItem->d->display.append(QString::number(i + 1));
}
endInsertColumns();
}
}
/*!
\internal
Returns the tree view item corresponding to the \a index given.
\sa QModelIndex
*/
QTreeWidgetItem *QTreeModel::item(const QModelIndex &index) const
{
if (!index.isValid())
return 0;
return static_cast<QTreeWidgetItem*>(index.internalPointer());
}
/*!
\internal
Returns the model index that refers to the
tree view \a item and \a column.
*/
QModelIndex QTreeModel::index(const QTreeWidgetItem *item, int column) const
{
executePendingSort();
if (!item || (item == rootItem))
return QModelIndex();
const QTreeWidgetItem *par = item->parent();
QTreeWidgetItem *itm = const_cast<QTreeWidgetItem*>(item);
if (!par)
par = rootItem;
int row;
int guess = item->d->rowGuess;
if (guess >= 0
&& par->children.count() > guess
&& par->children.at(guess) == itm) {
row = guess;
} else {
row = par->children.lastIndexOf(itm);
itm->d->rowGuess = row;
}
return createIndex(row, column, itm);
}
/*!
\internal
\reimp
Returns the model index with the given \a row,
\a column and \a parent.
*/
QModelIndex QTreeModel::index(int row, int column, const QModelIndex &parent) const
{
executePendingSort();
int c = columnCount(parent);
if (row < 0 || column < 0 || column >= c)
return QModelIndex();
QTreeWidgetItem *parentItem = parent.isValid() ? item(parent) : rootItem;
if (parentItem && row < parentItem->childCount()) {
QTreeWidgetItem *itm = parentItem->child(row);
if (itm)
return createIndex(row, column, itm);
return QModelIndex();
}
return QModelIndex();
}
/*!
\internal
\reimp
Returns the parent model index of the index given as
the \a child.
*/
QModelIndex QTreeModel::parent(const QModelIndex &child) const
{
SkipSorting skipSorting(this); //The reason we don't sort here is that this might be called from a valid QPersistentModelIndex
//We don't want it to become suddenly invalid
if (!child.isValid())
return QModelIndex();
QTreeWidgetItem *itm = static_cast<QTreeWidgetItem *>(child.internalPointer());
if (!itm || itm == rootItem)
return QModelIndex();
QTreeWidgetItem *parent = itm->parent();
return index(parent, 0);
}
/*!
\internal
\reimp
Returns the number of rows in the \a parent model index.
*/
int QTreeModel::rowCount(const QModelIndex &parent) const
{
if (!parent.isValid())
return rootItem->childCount();
QTreeWidgetItem *parentItem = item(parent);
if (parentItem)
return parentItem->childCount();
return 0;
}
/*!
\internal
\reimp
Returns the number of columns in the item referred to by
the given \a index.
*/
int QTreeModel::columnCount(const QModelIndex &index) const
{
Q_UNUSED(index);
if (!headerItem)
return 0;
return headerItem->columnCount();
}
bool QTreeModel::hasChildren(const QModelIndex &parent) const
{
if (!parent.isValid())
return (rootItem->childCount() > 0);
QTreeWidgetItem *itm = item(parent);
if (!itm)
return false;
switch (itm->d->policy) {
case QTreeWidgetItem::ShowIndicator:
return true;
case QTreeWidgetItem::DontShowIndicator:
return false;
case QTreeWidgetItem::DontShowIndicatorWhenChildless:
return (itm->childCount() > 0);
}
return false;
}
/*!
\internal
\reimp
Returns the data corresponding to the given model \a index
and \a role.
*/
QVariant QTreeModel::data(const QModelIndex &index, int role) const
{
if (!index.isValid())
return QVariant();
QTreeWidgetItem *itm = item(index);
if (itm)
return itm->data(index.column(), role);
return QVariant();
}
/*!
\internal
\reimp
Sets the data for the item specified by the \a index and \a role
to that referred to by the \a value.
Returns true if successful; otherwise returns false.
*/
bool QTreeModel::setData(const QModelIndex &index, const QVariant &value, int role)
{
if (!index.isValid())
return false;
QTreeWidgetItem *itm = item(index);
if (itm) {
itm->setData(index.column(), role, value);
return true;
}
return false;
}
QMap<int, QVariant> QTreeModel::itemData(const QModelIndex &index) const
{
QMap<int, QVariant> roles;
QTreeWidgetItem *itm = item(index);
if (itm) {
int column = index.column();
if (column < itm->values.count()) {
for (int i = 0; i < itm->values.at(column).count(); ++i) {
roles.insert(itm->values.at(column).at(i).role,
itm->values.at(column).at(i).value);
}
}
// the two special cases
QVariant displayValue = itm->data(column, Qt::DisplayRole);
if (displayValue.isValid())
roles.insert(Qt::DisplayRole, displayValue);
QVariant checkValue = itm->data(column, Qt::CheckStateRole);
if (checkValue.isValid())
roles.insert(Qt::CheckStateRole, checkValue);
}
return roles;
}
/*!
\internal
\reimp
*/
bool QTreeModel::insertRows(int row, int count, const QModelIndex &parent)
{
SkipSorting skipSorting(this);
if (count < 1 || row < 0 || row > rowCount(parent) || parent.column() > 0)
return false;
beginInsertRows(parent, row, row + count - 1);
QTreeWidgetItem *par = item(parent);
while (count > 0) {
QTreeWidgetItem *item = new QTreeWidgetItem();
item->view = view();
item->par = par;
if (par)
par->children.insert(row++, item);
else
rootItem->children.insert(row++, item);
--count;
}
endInsertRows();
return true;
}
/*!
\internal
\reimp
*/
bool QTreeModel::insertColumns(int column, int count, const QModelIndex &parent)
{
SkipSorting skipSorting(this);
if (count < 1 || column < 0 || column > columnCount(parent) || parent.column() > 0 || !headerItem)
return false;
beginInsertColumns(parent, column, column + count - 1);
int oldCount = columnCount(parent);
column = qBound(0, column, oldCount);
headerItem->values.resize(oldCount + count);
for (int i = oldCount; i < oldCount + count; ++i) {
headerItem->values[i].append(QWidgetItemData(Qt::DisplayRole, QString::number(i + 1)));
headerItem->d->display.append(QString::number(i + 1));
}
QStack<QTreeWidgetItem*> itemstack;
itemstack.push(0);
while (!itemstack.isEmpty()) {
QTreeWidgetItem *par = itemstack.pop();
QList<QTreeWidgetItem*> children = par ? par->children : rootItem->children;
for (int row = 0; row < children.count(); ++row) {
QTreeWidgetItem *child = children.at(row);
if (child->children.count())
itemstack.push(child);
child->values.insert(column, count, QVector<QWidgetItemData>());
}
}
endInsertColumns();
return true;
}
/*!
\internal
\reimp
*/
bool QTreeModel::removeRows(int row, int count, const QModelIndex &parent) {
if (count < 1 || row < 0 || (row + count) > rowCount(parent))
return false;
beginRemoveRows(parent, row, row + count - 1);
bool blockSignal = signalsBlocked();
blockSignals(true);
QTreeWidgetItem *itm = item(parent);
for (int i = row + count - 1; i >= row; --i) {
QTreeWidgetItem *child = itm ? itm->takeChild(i) : rootItem->children.takeAt(i);
Q_ASSERT(child);
child->view = 0;
delete child;
child = 0;
}
blockSignals(blockSignal);
endRemoveRows();
return true;
}
/*!
\internal
\reimp
Returns the header data corresponding to the given header \a section,
\a orientation and data \a role.
*/
QVariant QTreeModel::headerData(int section, Qt::Orientation orientation, int role) const
{
if (orientation != Qt::Horizontal)
return QVariant();
if (headerItem)
return headerItem->data(section, role);
if (role == Qt::DisplayRole)
return QString::number(section + 1);
return QVariant();
}
/*!
\internal
\reimp
Sets the header data for the item specified by the header \a section,
\a orientation and data \a role to the given \a value.
Returns true if successful; otherwise returns false.
*/
bool QTreeModel::setHeaderData(int section, Qt::Orientation orientation,
const QVariant &value, int role)
{
if (section < 0 || orientation != Qt::Horizontal || !headerItem || section >= columnCount())
return false;
headerItem->setData(section, role, value);
return true;
}
/*!
\reimp
Returns the flags for the item referred to the given \a index.
*/
Qt::ItemFlags QTreeModel::flags(const QModelIndex &index) const
{
if (!index.isValid())
return rootItem->flags();
QTreeWidgetItem *itm = item(index);
Q_ASSERT(itm);
return itm->flags();
}
/*!
\internal
Sorts the entire tree in the model in the given \a order,
by the values in the given \a column.
*/
void QTreeModel::sort(int column, Qt::SortOrder order)
{
SkipSorting skipSorting(this);
sortPendingTimer.stop();
if (column < 0 || column >= columnCount())
return;
//layoutAboutToBeChanged and layoutChanged will be called by sortChildren
rootItem->sortChildren(column, order, true);
}
/*!
\internal
*/
void QTreeModel::ensureSorted(int column, Qt::SortOrder order,
int start, int end, const QModelIndex &parent)
{
if (isChanging())
return;
sortPendingTimer.stop();
if (column < 0 || column >= columnCount())
return;
SkipSorting skipSorting(this);
QTreeWidgetItem *itm = item(parent);
if (!itm)
itm = rootItem;
QList<QTreeWidgetItem*> lst = itm->children;
int count = end - start + 1;
QVector < QPair<QTreeWidgetItem*,int> > sorting(count);
for (int i = 0; i < count; ++i) {
sorting[i].first = lst.at(start + i);
sorting[i].second = start + i;
}
LessThan compare = (order == Qt::AscendingOrder ? &itemLessThan : &itemGreaterThan);
qStableSort(sorting.begin(), sorting.end(), compare);
QModelIndexList oldPersistentIndexes;
QModelIndexList newPersistentIndexes;
QList<QTreeWidgetItem*>::iterator lit = lst.begin();
bool changed = false;
for (int i = 0; i < count; ++i) {
int oldRow = sorting.at(i).second;
QTreeWidgetItem *item = lst.takeAt(oldRow);
lit = sortedInsertionIterator(lit, lst.end(), order, item);
int newRow = qMax(lit - lst.begin(), 0);
if ((newRow < oldRow) && !(*item < *lst.at(oldRow - 1)) && !(*lst.at(oldRow - 1) < *item ))
newRow = oldRow;
lit = lst.insert(lit, item);
if (newRow != oldRow) {
// we are going to change the persistent indexes, so we need to prepare
if (!changed) { // this will only happen once
changed = true;
emit layoutAboutToBeChanged(); // the selection model needs to know
oldPersistentIndexes = persistentIndexList();
newPersistentIndexes = oldPersistentIndexes;
}
for (int j = i + 1; j < count; ++j) {
int otherRow = sorting.at(j).second;
if (oldRow < otherRow && newRow >= otherRow)
--sorting[j].second;
else if (oldRow > otherRow && newRow <= otherRow)
++sorting[j].second;
}
for (int k = 0; k < newPersistentIndexes.count(); ++k) {
QModelIndex pi = newPersistentIndexes.at(k);
if (pi.parent() != parent)
continue;
int oldPersistentRow = pi.row();
int newPersistentRow = oldPersistentRow;
if (oldPersistentRow == oldRow)
newPersistentRow = newRow;
else if (oldRow < oldPersistentRow && newRow >= oldPersistentRow)
newPersistentRow = oldPersistentRow - 1;
else if (oldRow > oldPersistentRow && newRow <= oldPersistentRow)
newPersistentRow = oldPersistentRow + 1;
if (newPersistentRow != oldPersistentRow)
newPersistentIndexes[k] = createIndex(newPersistentRow,
pi.column(), pi.internalPointer());
}
}
}
if (changed) {
itm->children = lst;
changePersistentIndexList(oldPersistentIndexes, newPersistentIndexes);
emit layoutChanged();
}
}
/*!
\internal
Returns true if the value of the \a left item is
less than the value of the \a right item.
Used by the sorting functions.
*/
bool QTreeModel::itemLessThan(const QPair<QTreeWidgetItem*,int> &left,
const QPair<QTreeWidgetItem*,int> &right)
{
return *(left.first) < *(right.first);
}
/*!
\internal
Returns true if the value of the \a left item is
greater than the value of the \a right item.
Used by the sorting functions.
*/
bool QTreeModel::itemGreaterThan(const QPair<QTreeWidgetItem*,int> &left,
const QPair<QTreeWidgetItem*,int> &right)
{
return *(right.first) < *(left.first);
}
/*!
\internal
*/
QList<QTreeWidgetItem*>::iterator QTreeModel::sortedInsertionIterator(
const QList<QTreeWidgetItem*>::iterator &begin,
const QList<QTreeWidgetItem*>::iterator &end,
Qt::SortOrder order, QTreeWidgetItem *item)
{
if (order == Qt::AscendingOrder)
return qLowerBound(begin, end, item, QTreeModelLessThan());
return qLowerBound(begin, end, item, QTreeModelGreaterThan());
}
QStringList QTreeModel::mimeTypes() const
{
return view()->mimeTypes();
}
QMimeData *QTreeModel::internalMimeData() const
{
return QAbstractItemModel::mimeData(cachedIndexes);
}
QMimeData *QTreeModel::mimeData(const QModelIndexList &indexes) const
{
QList<QTreeWidgetItem*> items;
for (int i = 0; i < indexes.count(); ++i) {
if (indexes.at(i).column() == 0) // only one item per row
items << item(indexes.at(i));
}
// cachedIndexes is a little hack to avoid copying from QModelIndexList to
// QList<QTreeWidgetItem*> and back again in the view
cachedIndexes = indexes;
QMimeData *mimeData = view()->mimeData(items);
cachedIndexes.clear();
return mimeData;
}
bool QTreeModel::dropMimeData(const QMimeData *data, Qt::DropAction action,
int row, int column, const QModelIndex &parent)
{
if (row == -1 && column == -1)
row = rowCount(parent); // append
return view()->dropMimeData(item(parent), row, data, action);
}
Qt::DropActions QTreeModel::supportedDropActions() const
{
return view()->supportedDropActions();
}
void QTreeModel::itemChanged(QTreeWidgetItem *item)
{
SkipSorting skipSorting(this); //this is kind of wrong, but not doing this would kill performence
QModelIndex left = index(item, 0);
QModelIndex right = index(item, item->columnCount() - 1);
emit dataChanged(left, right);
}
bool QTreeModel::isChanging() const
{
Q_D(const QTreeModel);
return !d->changes.isEmpty();
}
/*!
\internal
Emits the dataChanged() signal for the given \a item.
if column is -1 then all columns have changed
*/
void QTreeModel::emitDataChanged(QTreeWidgetItem *item, int column)
{
if (signalsBlocked())
return;
if (headerItem == item && column < item->columnCount()) {
if (column == -1)
emit headerDataChanged(Qt::Horizontal, 0, columnCount() - 1);
else
emit headerDataChanged(Qt::Horizontal, column, column);
return;
}
SkipSorting skipSorting(this); //This is a little bit wrong, but not doing it would kill performence
QModelIndex bottomRight, topLeft;
if (column == -1) {
topLeft = index(item, 0);
bottomRight = createIndex(topLeft.row(), columnCount() - 1, item);
} else {
topLeft = index(item, column);
bottomRight = topLeft;
}
emit dataChanged(topLeft, bottomRight);
}
void QTreeModel::beginInsertItems(QTreeWidgetItem *parent, int row, int count)
{
QModelIndex par = index(parent, 0);
beginInsertRows(par, row, row + count - 1);
}
void QTreeModel::endInsertItems()
{
endInsertRows();
}
void QTreeModel::beginRemoveItems(QTreeWidgetItem *parent, int row, int count)
{
Q_ASSERT(row >= 0);
Q_ASSERT(count > 0);
beginRemoveRows(index(parent, 0), row, row + count - 1);
if (!parent)
parent = rootItem;
// now update the iterators
for (int i = 0; i < iterators.count(); ++i) {
for (int j = 0; j < count; j++) {
QTreeWidgetItem *c = parent->child(row + j);
iterators[i]->d_func()->ensureValidIterator(c);
}
}
}
void QTreeModel::endRemoveItems()
{
endRemoveRows();
}
void QTreeModel::sortItems(QList<QTreeWidgetItem*> *items, int column, Qt::SortOrder order)
{
// see QTreeViewItem::operator<
Q_UNUSED(column);
if (isChanging())
return;
// store the original order of indexes
QVector< QPair<QTreeWidgetItem*,int> > sorting(items->count());
for (int i = 0; i < sorting.count(); ++i) {
sorting[i].first = items->at(i);
sorting[i].second = i;
}
// do the sorting
LessThan compare = (order == Qt::AscendingOrder ? &itemLessThan : &itemGreaterThan);
qStableSort(sorting.begin(), sorting.end(), compare);
QModelIndexList fromList;
QModelIndexList toList;
int colCount = columnCount();
for (int r = 0; r < sorting.count(); ++r) {
int oldRow = sorting.at(r).second;
if (oldRow == r)
continue;
QTreeWidgetItem *item = sorting.at(r).first;
items->replace(r, item);
for (int c = 0; c < colCount; ++c) {
QModelIndex from = createIndex(oldRow, c, item);
if (static_cast<QAbstractItemModelPrivate *>(d_ptr.data())->persistent.indexes.contains(from)) {
QModelIndex to = createIndex(r, c, item);
fromList << from;
toList << to;
}
}
}
changePersistentIndexList(fromList, toList);
}
void QTreeModel::timerEvent(QTimerEvent *ev)
{
if (ev->timerId() == sortPendingTimer.timerId()) {
executePendingSort();
} else {
QAbstractItemModel::timerEvent(ev);
}
}
/*!
\class QTreeWidgetItem
\brief The QTreeWidgetItem class provides an item for use with the
QTreeWidget convenience class.
\ingroup model-view
Tree widget items are used to hold rows of information for tree widgets.
Rows usually contain several columns of data, each of which can contain
a text label and an icon.
The QTreeWidgetItem class is a convenience class that replaces the
QListViewItem class in Qt 3. It provides an item for use with
the QTreeWidget class.
Items are usually constructed with a parent that is either a QTreeWidget
(for top-level items) or a QTreeWidgetItem (for items on lower levels of
the tree). For example, the following code constructs a top-level item
to represent cities of the world, and adds a entry for Oslo as a child
item:
\snippet doc/src/snippets/qtreewidget-using/mainwindow.cpp 3
Items can be added in a particular order by specifying the item they
follow when they are constructed:
\snippet doc/src/snippets/qtreewidget-using/mainwindow.cpp 5
Each column in an item can have its own background brush which is set with
the setBackground() function. The current background brush can be
found with background().
The text label for each column can be rendered with its own font and brush.
These are specified with the setFont() and setForeground() functions,
and read with font() and foreground().
The main difference between top-level items and those in lower levels of
the tree is that a top-level item has no parent(). This information
can be used to tell the difference between items, and is useful to know
when inserting and removing items from the tree.
Children of an item can be removed with takeChild() and inserted at a
given index in the list of children with the insertChild() function.
By default, items are enabled, selectable, checkable, and can be the source
of a drag and drop operation.
Each item's flags can be changed by calling setFlags() with the appropriate
value (see \l{Qt::ItemFlags}). Checkable items can be checked and unchecked
with the setCheckState() function. The corresponding checkState() function
indicates whether the item is currently checked.
\section1 Subclassing
When subclassing QTreeWidgetItem to provide custom items, it is possible to
define new types for them so that they can be distinguished from standard
items. The constructors for subclasses that require this feature need to
call the base class constructor with a new type value equal to or greater
than \l UserType.
\sa QTreeWidget, QTreeWidgetItemIterator, {Model/View Programming},
QListWidgetItem, QTableWidgetItem
*/
/*!
\enum QTreeWidgetItem::ItemType
This enum describes the types that are used to describe tree widget items.
\value Type The default type for tree widget items.
\value UserType The minimum value for custom types. Values below UserType are
reserved by Qt.
You can define new user types in QTreeWidgetItem subclasses to ensure that
custom items are treated specially; for example, when items are sorted.
\sa type()
*/
/*!
\fn int QTreeWidgetItem::type() const
Returns the type passed to the QTreeWidgetItem constructor.
*/
/*!
\fn void QTreeWidgetItem::sortChildren(int column, Qt::SortOrder order)
\since 4.2
Sorts the children of the item using the given \a order,
by the values in the given \a column.
\note This function does nothing if the item is not associated with a
QTreeWidget.
*/
/*!
\fn QTreeWidget *QTreeWidgetItem::treeWidget() const
Returns the tree widget that contains the item.
*/
/*!
\fn void QTreeWidgetItem::setSelected(bool select)
\since 4.2
Sets the selected state of the item to \a select.
\sa isSelected()
*/
/*!
\fn bool QTreeWidgetItem::isSelected() const
\since 4.2
Returns true if the item is selected, otherwise returns false.
\sa setSelected()
*/
/*!
\fn void QTreeWidgetItem::setHidden(bool hide)
\since 4.2
Hides the item if \a hide is true, otherwise shows the item.
\sa isHidden()
*/
/*!
\fn bool QTreeWidgetItem::isHidden() const
\since 4.2
Returns true if the item is hidden, otherwise returns false.
\sa setHidden()
*/
/*!
\fn void QTreeWidgetItem::setExpanded(bool expand)
\since 4.2
Expands the item if \a expand is true, otherwise collapses the item.
\warning The QTreeWidgetItem must be added to the QTreeWidget before calling this function.
\sa isExpanded()
*/
/*!
\fn bool QTreeWidgetItem::isExpanded() const
\since 4.2
Returns true if the item is expanded, otherwise returns false.
\sa setExpanded()
*/
/*!
\fn void QTreeWidgetItem::setFirstColumnSpanned(bool span)
\since 4.3
Sets the first section to span all columns if \a span is true;
otherwise all item sections are shown.
\sa isFirstColumnSpanned()
*/
/*!
\fn bool QTreeWidgetItem::isFirstColumnSpanned() const
\since 4.3
Returns true if the item is spanning all the columns in a row; otherwise returns false.
\sa setFirstColumnSpanned()
*/
/*!
\fn QString QTreeWidgetItem::text(int column) const
Returns the text in the specified \a column.
\sa setText()
*/
/*!
\fn void QTreeWidgetItem::setText(int column, const QString &text)
Sets the text to be displayed in the given \a column to the given \a text.
\sa text() setFont() setForeground()
*/
/*!
\fn QIcon QTreeWidgetItem::icon(int column) const
Returns the icon that is displayed in the specified \a column.
\sa setIcon(), {QAbstractItemView::iconSize}{iconSize}
*/
/*!
\fn void QTreeWidgetItem::setIcon(int column, const QIcon &icon)
Sets the icon to be displayed in the given \a column to \a icon.
\sa icon(), setText(), {QAbstractItemView::iconSize}{iconSize}
*/
/*!
\fn QString QTreeWidgetItem::statusTip(int column) const
Returns the status tip for the contents of the given \a column.
\sa setStatusTip()
*/
/*!
\fn void QTreeWidgetItem::setStatusTip(int column, const QString &statusTip)
Sets the status tip for the given \a column to the given \a statusTip.
QTreeWidget mouse tracking needs to be enabled for this feature to work.
\sa statusTip() setToolTip() setWhatsThis()
*/
/*!
\fn QString QTreeWidgetItem::toolTip(int column) const
Returns the tool tip for the given \a column.
\sa setToolTip()
*/
/*!
\fn void QTreeWidgetItem::setToolTip(int column, const QString &toolTip)
Sets the tooltip for the given \a column to \a toolTip.
\sa toolTip() setStatusTip() setWhatsThis()
*/
/*!
\fn QString QTreeWidgetItem::whatsThis(int column) const
Returns the "What's This?" help for the contents of the given \a column.
\sa setWhatsThis()
*/
/*!
\fn void QTreeWidgetItem::setWhatsThis(int column, const QString &whatsThis)
Sets the "What's This?" help for the given \a column to \a whatsThis.
\sa whatsThis() setStatusTip() setToolTip()
*/
/*!
\fn QFont QTreeWidgetItem::font(int column) const
Returns the font used to render the text in the specified \a column.
\sa setFont()
*/
/*!
\fn void QTreeWidgetItem::setFont(int column, const QFont &font)
Sets the font used to display the text in the given \a column to the given
\a font.
\sa font() setText() setForeground()
*/
/*!
\fn QColor QTreeWidgetItem::backgroundColor(int column) const
\obsolete
This function is deprecated. Use background() instead.
*/
/*!
\fn void QTreeWidgetItem::setBackgroundColor(int column, const QColor &color)
\obsolete
This function is deprecated. Use setBackground() instead.
*/
/*!
\fn QBrush QTreeWidgetItem::background(int column) const
\since 4.2
Returns the brush used to render the background of the specified \a column.
\sa foreground()
*/
/*!
\fn void QTreeWidgetItem::setBackground(int column, const QBrush &brush)
\since 4.2
Sets the background brush of the label in the given \a column to the
specified \a brush.
\sa setForeground()
*/
/*!
\fn QColor QTreeWidgetItem::textColor(int column) const
\obsolete
This function is deprecated. Use foreground() instead.
*/
/*!
\fn void QTreeWidgetItem::setTextColor(int column, const QColor &color)
\obsolete
This function is deprecated. Use setForeground() instead.
*/
/*!
\fn QBrush QTreeWidgetItem::foreground(int column) const
\since 4.2
Returns the brush used to render the foreground (e.g. text) of the
specified \a column.
\sa background()
*/
/*!
\fn void QTreeWidgetItem::setForeground(int column, const QBrush &brush)
\since 4.2
Sets the foreground brush of the label in the given \a column to the
specified \a brush.
\sa setBackground()
*/
/*!
\fn Qt::CheckState QTreeWidgetItem::checkState(int column) const
Returns the check state of the label in the given \a column.
\sa Qt::CheckState
*/
/*!
\fn void QTreeWidgetItem::setCheckState(int column, Qt::CheckState state)
Sets the item in the given \a column check state to be \a state.
\sa checkState()
*/
/*!
\fn QSize QTreeWidgetItem::sizeHint(int column) const
\since 4.1
Returns the size hint set for the tree item in the given
\a column (see \l{QSize}).
*/
/*!
\fn void QTreeWidgetItem::setSizeHint(int column, const QSize &size)
\since 4.1
Sets the size hint for the tree item in the given \a column to be \a size.
If no size hint is set, the item delegate will compute the size hint based
on the item data.
*/
/*!
\fn QTreeWidgetItem *QTreeWidgetItem::parent() const
Returns the item's parent.
\sa child()
*/
/*!
\fn QTreeWidgetItem *QTreeWidgetItem::child(int index) const
Returns the item at the given \a index in the list of the item's children.
\sa parent()
*/
/*!
\fn int QTreeWidgetItem::childCount() const
Returns the number of child items.
*/
/*!
\fn int QTreeWidgetItem::columnCount() const
Returns the number of columns in the item.
*/
/*!
\fn int QTreeWidgetItem::textAlignment(int column) const
Returns the text alignment for the label in the given \a column
(see \l{Qt::AlignmentFlag}).
*/
/*!
\fn void QTreeWidgetItem::setTextAlignment(int column, int alignment)
Sets the text alignment for the label in the given \a column to
the \a alignment specified (see \l{Qt::AlignmentFlag}).
*/
/*!
\fn int QTreeWidgetItem::indexOfChild(QTreeWidgetItem *child) const
Returns the index of the given \a child in the item's list of children.
*/
/*!
Constructs a tree widget item of the specified \a type. The item
must be inserted into a tree widget.
\sa type()
*/
QTreeWidgetItem::QTreeWidgetItem(int type)
: rtti(type), view(0), d(new QTreeWidgetItemPrivate(this)), par(0),
itemFlags(Qt::ItemIsSelectable
|Qt::ItemIsUserCheckable
|Qt::ItemIsEnabled
|Qt::ItemIsDragEnabled
|Qt::ItemIsDropEnabled)
{
}
/*!
Constructs a tree widget item of the specified \a type. The item
must be inserted into a tree widget.
The given list of \a strings will be set as the item text for each
column in the item.
\sa type()
*/
QTreeWidgetItem::QTreeWidgetItem(const QStringList &strings, int type)
: rtti(type), view(0), d(new QTreeWidgetItemPrivate(this)), par(0),
itemFlags(Qt::ItemIsSelectable
|Qt::ItemIsUserCheckable
|Qt::ItemIsEnabled
|Qt::ItemIsDragEnabled
|Qt::ItemIsDropEnabled)
{
for (int i = 0; i < strings.count(); ++i)
setText(i, strings.at(i));
}
/*!
\fn QTreeWidgetItem::QTreeWidgetItem(QTreeWidget *parent, int type)
Constructs a tree widget item of the specified \a type and appends it
to the items in the given \a parent.
\sa type()
*/
QTreeWidgetItem::QTreeWidgetItem(QTreeWidget *view, int type)
: rtti(type), view(0), d(new QTreeWidgetItemPrivate(this)), par(0),
itemFlags(Qt::ItemIsSelectable
|Qt::ItemIsUserCheckable
|Qt::ItemIsEnabled
|Qt::ItemIsDragEnabled
|Qt::ItemIsDropEnabled)
{
if (view && view->model()) {
QTreeModel *model = qobject_cast<QTreeModel*>(view->model());
model->rootItem->addChild(this);
values.reserve(model->headerItem->columnCount());
}
}
/*!
\fn QTreeWidgetItem::QTreeWidgetItem(QTreeWidget *parent, const QStringList &strings, int type)
Constructs a tree widget item of the specified \a type and appends it
to the items in the given \a parent. The given list of \a strings will be set as
the item text for each column in the item.
\sa type()
*/
QTreeWidgetItem::QTreeWidgetItem(QTreeWidget *view, const QStringList &strings, int type)
: rtti(type), view(0), d(new QTreeWidgetItemPrivate(this)), par(0),
itemFlags(Qt::ItemIsSelectable
|Qt::ItemIsUserCheckable
|Qt::ItemIsEnabled
|Qt::ItemIsDragEnabled
|Qt::ItemIsDropEnabled)
{
for (int i = 0; i < strings.count(); ++i)
setText(i, strings.at(i));
if (view && view->model()) {
QTreeModel *model = qobject_cast<QTreeModel*>(view->model());
model->rootItem->addChild(this);
values.reserve(model->headerItem->columnCount());
}
}
/*!
\fn QTreeWidgetItem::QTreeWidgetItem(QTreeWidget *parent, QTreeWidgetItem *preceding, int type)
Constructs a tree widget item of the specified \a type and inserts it into
the given \a parent after the \a preceding item.
\sa type()
*/
QTreeWidgetItem::QTreeWidgetItem(QTreeWidget *view, QTreeWidgetItem *after, int type)
: rtti(type), view(0), d(new QTreeWidgetItemPrivate(this)), par(0),
itemFlags(Qt::ItemIsSelectable
|Qt::ItemIsUserCheckable
|Qt::ItemIsEnabled
|Qt::ItemIsDragEnabled
|Qt::ItemIsDropEnabled)
{
if (view) {
QTreeModel *model = qobject_cast<QTreeModel*>(view->model());
if (model) {
int i = model->rootItem->children.indexOf(after) + 1;
model->rootItem->insertChild(i, this);
values.reserve(model->headerItem->columnCount());
}
}
}
/*!
Constructs a tree widget item and append it to the given \a parent.
\sa type()
*/
QTreeWidgetItem::QTreeWidgetItem(QTreeWidgetItem *parent, int type)
: rtti(type), view(0), d(new QTreeWidgetItemPrivate(this)), par(0),
itemFlags(Qt::ItemIsSelectable
|Qt::ItemIsUserCheckable
|Qt::ItemIsEnabled
|Qt::ItemIsDragEnabled
|Qt::ItemIsDropEnabled)
{
if (parent)
parent->addChild(this);
}
/*!
Constructs a tree widget item and append it to the given \a parent.
The given list of \a strings will be set as the item text for each column in the item.
\sa type()
*/
QTreeWidgetItem::QTreeWidgetItem(QTreeWidgetItem *parent, const QStringList &strings, int type)
: rtti(type), view(0), d(new QTreeWidgetItemPrivate(this)), par(0),
itemFlags(Qt::ItemIsSelectable
|Qt::ItemIsUserCheckable
|Qt::ItemIsEnabled
|Qt::ItemIsDragEnabled
|Qt::ItemIsDropEnabled)
{
for (int i = 0; i < strings.count(); ++i)
setText(i, strings.at(i));
if (parent)
parent->addChild(this);
}
/*!
\fn QTreeWidgetItem::QTreeWidgetItem(QTreeWidgetItem *parent, QTreeWidgetItem *preceding, int type)
Constructs a tree widget item of the specified \a type that is inserted
into the \a parent after the \a preceding child item.
\sa type()
*/
QTreeWidgetItem::QTreeWidgetItem(QTreeWidgetItem *parent, QTreeWidgetItem *after, int type)
: rtti(type), view(0), d(new QTreeWidgetItemPrivate(this)), par(0),
itemFlags(Qt::ItemIsSelectable
|Qt::ItemIsUserCheckable
|Qt::ItemIsEnabled
|Qt::ItemIsDragEnabled
|Qt::ItemIsDropEnabled)
{
if (parent) {
int i = parent->children.indexOf(after) + 1;
parent->insertChild(i, this);
}
}
/*!
Destroys this tree widget item.
The item will be removed from \l{QTreeWidget}s to which it has
been added. This makes it safe to delete an item at any time.
*/
QTreeWidgetItem::~QTreeWidgetItem()
{
QTreeModel *model = (view ? qobject_cast<QTreeModel*>(view->model()) : 0);
bool wasSkipSort = false;
if (model) {
wasSkipSort = model->skipPendingSort;
model->skipPendingSort = true;
}
if (par) {
int i = par->children.indexOf(this);
if (i >= 0) {
if (model) model->beginRemoveItems(par, i, 1);
// users _could_ do changes when connected to rowsAboutToBeRemoved,
// so we check again to make sure 'i' is valid
if (!par->children.isEmpty() && par->children.at(i) == this)
par->children.takeAt(i);
if (model) model->endRemoveItems();
}
} else if (model) {
if (this == model->headerItem) {
model->headerItem = 0;
} else {
int i = model->rootItem->children.indexOf(this);
if (i >= 0) {
model->beginRemoveItems(0, i, 1);
// users _could_ do changes when connected to rowsAboutToBeRemoved,
// so we check again to make sure 'i' is valid
if (!model->rootItem->children.isEmpty() && model->rootItem->children.at(i) == this)
model->rootItem->children.takeAt(i);
model->endRemoveItems();
}
}
}
// at this point the persistent indexes for the children should also be invalidated
// since we invalidated the parent
for (int i = 0; i < children.count(); ++i) {
QTreeWidgetItem *child = children.at(i);
// make sure the child does not try to remove itself from our children list
child->par = 0;
// make sure the child does not try to remove itself from the top level list
child->view = 0;
delete child;
}
children.clear();
delete d;
if (model) {
model->skipPendingSort = wasSkipSort;
}
}
/*!
Creates a deep copy of the item and of its children.
*/
QTreeWidgetItem *QTreeWidgetItem::clone() const
{
QTreeWidgetItem *copy = 0;
QStack<const QTreeWidgetItem*> stack;
QStack<QTreeWidgetItem*> parentStack;
stack.push(this);
parentStack.push(0);
QTreeWidgetItem *root = 0;
const QTreeWidgetItem *item = 0;
QTreeWidgetItem *parent = 0;
while (!stack.isEmpty()) {
// get current item, and copied parent
item = stack.pop();
parent = parentStack.pop();
// copy item
copy = new QTreeWidgetItem(*item);
if (!root)
root = copy;
// set parent and add to parents children list
if (parent) {
copy->par = parent;
parent->children.insert(0, copy);
}
for (int i = 0; i < item->childCount(); ++i) {
stack.push(item->child(i));
parentStack.push(copy);
}
}
return root;
}
/*!
Sets the item indicator \a policy. This policy decides when the
tree branch expand/collapse indicator is shown.
The default value is ShowForChildren.
\sa childIndicatorPolicy()
*/
void QTreeWidgetItem::setChildIndicatorPolicy(QTreeWidgetItem::ChildIndicatorPolicy policy)
{
if (d->policy == policy)
return;
d->policy = policy;
if (!view)
return;
view->scheduleDelayedItemsLayout();
}
/*!
Returns the item indicator policy. This policy decides when the
tree branch expand/collapse indicator is shown.
\sa setChildIndicatorPolicy()
*/
QTreeWidgetItem::ChildIndicatorPolicy QTreeWidgetItem::childIndicatorPolicy() const
{
return d->policy;
}
/*!
\fn void QTreeWidgetItem::setFlags(Qt::ItemFlags flags)
Sets the flags for the item to the given \a flags. These determine whether
the item can be selected or modified. This is often used to disable an item.
\sa flags()
*/
void QTreeWidgetItem::setFlags(Qt::ItemFlags flags)
{
const bool enable = (flags & Qt::ItemIsEnabled);
const bool changedState = bool(itemFlags & Qt::ItemIsEnabled) != enable;
const bool changedExplicit = d->disabled != !enable;
d->disabled = !enable;
if (enable && par && !(par->itemFlags & Qt::ItemIsEnabled)) // inherit from parent
itemFlags = flags & ~Qt::ItemIsEnabled;
else // this item is explicitly disabled or has no parent
itemFlags = flags;
if (changedState && changedExplicit) { // if the propagate the change to the children
QStack<QTreeWidgetItem*> parents;
parents.push(this);
while (!parents.isEmpty()) {
QTreeWidgetItem *parent = parents.pop();
for (int i = 0; i < parent->children.count(); ++i) {
QTreeWidgetItem *child = parent->children.at(i);
if (!child->d->disabled) { // if not explicitly disabled
parents.push(child);
if (enable)
child->itemFlags = child->itemFlags | Qt::ItemIsEnabled;
else
child->itemFlags = child->itemFlags & ~Qt::ItemIsEnabled;
child->itemChanged(); // ### we may want to optimize this
}
}
}
}
itemChanged();
}
void QTreeWidgetItemPrivate::propagateDisabled(QTreeWidgetItem *item)
{
Q_ASSERT(item);
const bool enable = item->par ? (item->par->itemFlags.testFlag(Qt::ItemIsEnabled)) : true;
QStack<QTreeWidgetItem*> parents;
parents.push(item);
while (!parents.isEmpty()) {
QTreeWidgetItem *parent = parents.pop();
if (!parent->d->disabled) { // if not explicitly disabled
Qt::ItemFlags oldFlags = parent->itemFlags;
if (enable)
parent->itemFlags = parent->itemFlags | Qt::ItemIsEnabled;
else
parent->itemFlags = parent->itemFlags & ~Qt::ItemIsEnabled;
if (parent->itemFlags != oldFlags)
parent->itemChanged();
}
for (int i = 0; i < parent->children.count(); ++i) {
QTreeWidgetItem *child = parent->children.at(i);
parents.push(child);
}
}
}
/*!
\fn Qt::ItemFlags QTreeWidgetItem::flags() const
Returns the flags used to describe the item. These determine whether
the item can be checked, edited, and selected.
The default value for flags is
Qt::ItemIsSelectable | Qt::ItemIsUserCheckable | Qt::ItemIsEnabled | Qt::ItemIsDragEnabled.
If the item was constructed with a parent, flags will in addition contain Qt::ItemIsDropEnabled.
\sa setFlags()
*/
Qt::ItemFlags QTreeWidgetItem::flags() const
{
return itemFlags;
}
/*!
Sets the value for the item's \a column and \a role to the given
\a value.
The \a role describes the type of data specified by \a value, and is defined by
the Qt::ItemDataRole enum.
*/
void QTreeWidgetItem::setData(int column, int role, const QVariant &value)
{
if (column < 0)
return;
QTreeModel *model = (view ? qobject_cast<QTreeModel*>(view->model()) : 0);
switch (role) {
case Qt::EditRole:
case Qt::DisplayRole: {
if (values.count() <= column) {
if (model && this == model->headerItem)
model->setColumnCount(column + 1);
else
values.resize(column + 1);
}
if (d->display.count() <= column) {
for (int i = d->display.count() - 1; i < column - 1; ++i)
d->display.append(QVariant());
d->display.append(value);
} else if (d->display[column] != value) {
d->display[column] = value;
} else {
return; // value is unchanged
}
} break;
case Qt::CheckStateRole:
if (itemFlags & Qt::ItemIsTristate) {
for (int i = 0; i < children.count(); ++i) {
QTreeWidgetItem *child = children.at(i);
if (child->data(column, role).isValid()) {// has a CheckState
Qt::ItemFlags f = itemFlags; // a little hack to avoid multiple dataChanged signals
itemFlags &= ~Qt::ItemIsTristate;
child->setData(column, role, value);
itemFlags = f;
}
}
}
// Don't break, but fall through
default:
if (column < values.count()) {
bool found = false;
QVector<QWidgetItemData> column_values = values.at(column);
for (int i = 0; i < column_values.count(); ++i) {
if (column_values.at(i).role == role) {
if (column_values.at(i).value == value)
return; // value is unchanged
values[column][i].value = value;
found = true;
break;
}
}
if (!found)
values[column].append(QWidgetItemData(role, value));
} else {
if (model && this == model->headerItem)
model->setColumnCount(column + 1);
else
values.resize(column + 1);
values[column].append(QWidgetItemData(role, value));
}
}
if (model) {
model->emitDataChanged(this, column);
if (role == Qt::CheckStateRole) {
QTreeWidgetItem *p;
for (p = par; p && (p->itemFlags & Qt::ItemIsTristate); p = p->par)
model->emitDataChanged(p, column);
}
}
}
/*!
Returns the value for the item's \a column and \a role.
*/
QVariant QTreeWidgetItem::data(int column, int role) const
{
switch (role) {
case Qt::EditRole:
case Qt::DisplayRole:
if (column >= 0 && column < d->display.count())
return d->display.at(column);
break;
case Qt::CheckStateRole:
// special case for check state in tristate
if (children.count() && (itemFlags & Qt::ItemIsTristate))
return childrenCheckState(column);
// fallthrough intended
default:
if (column >= 0 && column < values.size()) {
const QVector<QWidgetItemData> &column_values = values.at(column);
for (int i = 0; i < column_values.count(); ++i)
if (column_values.at(i).role == role)
return column_values.at(i).value;
}
}
return QVariant();
}
/*!
Returns true if the text in the item is less than the text in the
\a other item, otherwise returns false.
*/
bool QTreeWidgetItem::operator<(const QTreeWidgetItem &other) const
{
int column = view ? view->sortColumn() : 0;
const QVariant v1 = data(column, Qt::DisplayRole);
const QVariant v2 = other.data(column, Qt::DisplayRole);
return QAbstractItemModelPrivate::variantLessThan(v1, v2);
}
#ifndef QT_NO_DATASTREAM
/*!
Reads the item from stream \a in. This only reads data into a single item.
\sa write()
*/
void QTreeWidgetItem::read(QDataStream &in)
{
// convert from streams written before we introduced display (4.2.0)
if (in.version() < QDataStream::Qt_4_2) {
d->display.clear();
in >> values;
// move the display value over to the display string list
for (int column = 0; column < values.count(); ++column) {
d->display << QVariant();
for (int i = 0; i < values.at(column).count(); ++i) {
if (values.at(column).at(i).role == Qt::DisplayRole) {
d->display[column] = values.at(column).at(i).value;
values[column].remove(i--);
}
}
}
} else {
in >> values >> d->display;
}
}
/*!
Writes the item to stream \a out. This only writes data from one single item.
\sa read()
*/
void QTreeWidgetItem::write(QDataStream &out) const
{
out << values << d->display;
}
#endif // QT_NO_DATASTREAM
/*!
\since 4.1
Constructs a copy of \a other. Note that type() and treeWidget()
are not copied.
This function is useful when reimplementing clone().
\sa data(), flags()
*/
QTreeWidgetItem::QTreeWidgetItem(const QTreeWidgetItem &other)
: rtti(Type), values(other.values), view(0),
d(new QTreeWidgetItemPrivate(this)), par(0),
itemFlags(other.itemFlags)
{
d->display = other.d->display;
}
/*!
Assigns \a other's data and flags to this item. Note that type()
and treeWidget() are not copied.
This function is useful when reimplementing clone().
\sa data(), flags()
*/
QTreeWidgetItem &QTreeWidgetItem::operator=(const QTreeWidgetItem &other)
{
values = other.values;
d->display = other.d->display;
d->policy = other.d->policy;
itemFlags = other.itemFlags;
return *this;
}
/*!
Appends the \a child item to the list of children.
\sa insertChild() takeChild()
*/
void QTreeWidgetItem::addChild(QTreeWidgetItem *child)
{
if (child) {
insertChild(children.count(), child);
child->d->rowGuess = children.count() - 1;
}
}
/*!
Inserts the \a child item at \a index in the list of children.
If the child has already been inserted somewhere else it wont be inserted again.
*/
void QTreeWidgetItem::insertChild(int index, QTreeWidgetItem *child)
{
if (index < 0 || index > children.count() || child == 0 || child->view != 0 || child->par != 0)
return;
if (QTreeModel *model = (view ? qobject_cast<QTreeModel*>(view->model()) : 0)) {
const bool wasSkipSort = model->skipPendingSort;
model->skipPendingSort = true;
if (model->rootItem == this)
child->par = 0;
else
child->par = this;
if (view->isSortingEnabled()) {
// do a delayed sort instead
if (!model->sortPendingTimer.isActive())
model->sortPendingTimer.start(0, model);
}
model->beginInsertItems(this, index, 1);
int cols = model->columnCount();
QStack<QTreeWidgetItem*> stack;
stack.push(child);
while (!stack.isEmpty()) {
QTreeWidgetItem *i = stack.pop();
i->view = view;
i->values.reserve(cols);
for (int c = 0; c < i->children.count(); ++c)
stack.push(i->children.at(c));
}
children.insert(index, child);
model->endInsertItems();
model->skipPendingSort = wasSkipSort;
} else {
child->par = this;
children.insert(index, child);
}
if (child->par)
d->propagateDisabled(child);
}
/*!
Removes the given item indicated by \a child.
The removed item will not be deleted.
*/
void QTreeWidgetItem::removeChild(QTreeWidgetItem *child)
{
(void)takeChild(children.indexOf(child));
}
/*!
Removes the item at \a index and returns it, otherwise return 0.
*/
QTreeWidgetItem *QTreeWidgetItem::takeChild(int index)
{
// we move this outside the check of the index to allow executing
// pending sorts from inline functions, using this function (hack)
QTreeModel *model = (view ? qobject_cast<QTreeModel*>(view->model()) : 0);
if (model) {
// This will trigger a layoutChanged signal, thus we might want to optimize
// this function by not emitting the rowsRemoved signal etc to the view.
// On the other hand we also need to make sure that the selectionmodel
// is updated in case we take an item that is selected.
model->skipPendingSort = false;
model->executePendingSort();
}
if (index >= 0 && index < children.count()) {
if (model) model->beginRemoveItems(this, index, 1);
QTreeWidgetItem *item = children.takeAt(index);
item->par = 0;
QStack<QTreeWidgetItem*> stack;
stack.push(item);
while (!stack.isEmpty()) {
QTreeWidgetItem *i = stack.pop();
i->view = 0;
for (int c = 0; c < i->children.count(); ++c)
stack.push(i->children.at(c));
}
d->propagateDisabled(item);
if (model) model->endRemoveRows();
return item;
}
return 0;
}
/*!
\since 4.1
Appends the given list of \a children to the item.
\sa insertChildren() takeChildren()
*/
void QTreeWidgetItem::addChildren(const QList<QTreeWidgetItem*> &children)
{
insertChildren(this->children.count(), children);
}
/*!
\since 4.1
Inserts the given list of \a children into the list of the item children at \a index .
Children that have already been inserted somewhere else wont be inserted.
*/
void QTreeWidgetItem::insertChildren(int index, const QList<QTreeWidgetItem*> &children)
{
if (view && view->isSortingEnabled()) {
for (int n = 0; n < children.count(); ++n)
insertChild(index, children.at(n));
return;
}
QTreeModel *model = (view ? qobject_cast<QTreeModel*>(view->model()) : 0);
QStack<QTreeWidgetItem*> stack;
QList<QTreeWidgetItem*> itemsToInsert;
for (int n = 0; n < children.count(); ++n) {
QTreeWidgetItem *child = children.at(n);
if (child->view || child->par)
continue;
itemsToInsert.append(child);
if (view && model) {
if (child->childCount() == 0)
child->view = view;
else
stack.push(child);
}
if (model && (model->rootItem == this))
child->par = 0;
else
child->par = this;
}
if (!itemsToInsert.isEmpty()) {
while (!stack.isEmpty()) {
QTreeWidgetItem *i = stack.pop();
i->view = view;
for (int c = 0; c < i->children.count(); ++c)
stack.push(i->children.at(c));
}
if (model) model->beginInsertItems(this, index, itemsToInsert.count());
for (int n = 0; n < itemsToInsert.count(); ++n) {
QTreeWidgetItem *child = itemsToInsert.at(n);
this->children.insert(index + n, child);
if (child->par)
d->propagateDisabled(child);
}
if (model) model->endInsertItems();
}
}
/*!
\since 4.1
Removes the list of children and returns it, otherwise returns an empty list.
*/
QList<QTreeWidgetItem*> QTreeWidgetItem::takeChildren()
{
QList<QTreeWidgetItem*> removed;
if (children.count() > 0) {
QTreeModel *model = (view ? qobject_cast<QTreeModel*>(view->model()) : 0);
if (model) {
// This will trigger a layoutChanged signal, thus we might want to optimize
// this function by not emitting the rowsRemoved signal etc to the view.
// On the other hand we also need to make sure that the selectionmodel
// is updated in case we take an item that is selected.
model->executePendingSort();
}
if (model) model->beginRemoveItems(this, 0, children.count());
for (int n = 0; n < children.count(); ++n) {
QTreeWidgetItem *item = children.at(n);
item->par = 0;
QStack<QTreeWidgetItem*> stack;
stack.push(item);
while (!stack.isEmpty()) {
QTreeWidgetItem *i = stack.pop();
i->view = 0;
for (int c = 0; c < i->children.count(); ++c)
stack.push(i->children.at(c));
}
d->propagateDisabled(item);
}
removed = children;
children.clear(); // detach
if (model) model->endRemoveItems();
}
return removed;
}
void QTreeWidgetItemPrivate::sortChildren(int column, Qt::SortOrder order, bool climb)
{
QTreeModel *model = (q->view ? qobject_cast<QTreeModel*>(q->view->model()) : 0);
if (!model)
return;
model->sortItems(&q->children, column, order);
if (climb) {
QList<QTreeWidgetItem*>::iterator it = q->children.begin();
for (; it != q->children.end(); ++it) {
//here we call the private object's method to avoid emitting
//the layoutAboutToBeChanged and layoutChanged signals
(*it)->d->sortChildren(column, order, climb);
}
}
}
/*!
\internal
Sorts the children by the value in the given \a column, in the \a order
specified. If \a climb is true, the items below each of the children will
also be sorted.
*/
void QTreeWidgetItem::sortChildren(int column, Qt::SortOrder order, bool climb)
{
QTreeModel *model = (view ? qobject_cast<QTreeModel*>(view->model()) : 0);
if (!model)
return;
if (model->isChanging())
return;
QTreeModel::SkipSorting skipSorting(model);
int oldSortColumn = view->d_func()->explicitSortColumn;
view->d_func()->explicitSortColumn = column;
emit model->layoutAboutToBeChanged();
d->sortChildren(column, order, climb);
emit model->layoutChanged();
view->d_func()->explicitSortColumn = oldSortColumn;
}
/*!
\internal
Calculates the checked state of the item based on the checked state
of its children. E.g. if all children checked => this item is also
checked; if some children checked => this item is partially checked;
if no children checked => this item is unchecked.
*/
QVariant QTreeWidgetItem::childrenCheckState(int column) const
{
if (column < 0)
return QVariant();
bool checkedChildren = false;
bool uncheckedChildren = false;
for (int i = 0; i < children.count(); ++i) {
QVariant value = children.at(i)->data(column, Qt::CheckStateRole);
if (!value.isValid())
return QVariant();
switch (static_cast<Qt::CheckState>(value.toInt()))
{
case Qt::Unchecked:
uncheckedChildren = true;
break;
case Qt::Checked:
checkedChildren = true;
break;
case Qt::PartiallyChecked:
default:
return Qt::PartiallyChecked;
}
}
if (uncheckedChildren && checkedChildren)
return Qt::PartiallyChecked;
if (uncheckedChildren)
return Qt::Unchecked;
else if (checkedChildren)
return Qt::Checked;
else
return QVariant(); // value was not defined
}
/*!
\since 4.5
Causes the model associated with this item to emit a
\l{QAbstractItemModel::dataChanged()}{dataChanged}() signal for this
item.
You normally only need to call this function if you have subclassed
QTreeWidgetItem and reimplemented data() and/or setData().
\sa setData()
*/
void QTreeWidgetItem::emitDataChanged()
{
itemChanged();
}
/*!
\internal
*/
void QTreeWidgetItem::itemChanged()
{
if (QTreeModel *model = (view ? qobject_cast<QTreeModel*>(view->model()) : 0))
model->itemChanged(this);
}
/*!
\internal
*/
void QTreeWidgetItem::executePendingSort() const
{
if (QTreeModel *model = (view ? qobject_cast<QTreeModel*>(view->model()) : 0))
model->executePendingSort();
}
#ifndef QT_NO_DATASTREAM
/*!
\relates QTreeWidgetItem
Writes the tree widget item \a item to stream \a out.
This operator uses QTreeWidgetItem::write().
\sa {Serializing Qt Data Types}
*/
QDataStream &operator<<(QDataStream &out, const QTreeWidgetItem &item)
{
item.write(out);
return out;
}
/*!
\relates QTreeWidgetItem
Reads a tree widget item from stream \a in into \a item.
This operator uses QTreeWidgetItem::read().
\sa {Serializing Qt Data Types}
*/
QDataStream &operator>>(QDataStream &in, QTreeWidgetItem &item)
{
item.read(in);
return in;
}
#endif // QT_NO_DATASTREAM
void QTreeWidgetPrivate::_q_emitItemPressed(const QModelIndex &index)
{
Q_Q(QTreeWidget);
emit q->itemPressed(item(index), index.column());
}
void QTreeWidgetPrivate::_q_emitItemClicked(const QModelIndex &index)
{
Q_Q(QTreeWidget);
emit q->itemClicked(item(index), index.column());
}
void QTreeWidgetPrivate::_q_emitItemDoubleClicked(const QModelIndex &index)
{
Q_Q(QTreeWidget);
emit q->itemDoubleClicked(item(index), index.column());
}
void QTreeWidgetPrivate::_q_emitItemActivated(const QModelIndex &index)
{
Q_Q(QTreeWidget);
emit q->itemActivated(item(index), index.column());
}
void QTreeWidgetPrivate::_q_emitItemEntered(const QModelIndex &index)
{
Q_Q(QTreeWidget);
emit q->itemEntered(item(index), index.column());
}
void QTreeWidgetPrivate::_q_emitItemChanged(const QModelIndex &index)
{
Q_Q(QTreeWidget);
QTreeWidgetItem *indexItem = item(index);
if (indexItem)
emit q->itemChanged(indexItem, index.column());
}
void QTreeWidgetPrivate::_q_emitItemExpanded(const QModelIndex &index)
{
Q_Q(QTreeWidget);
emit q->itemExpanded(item(index));
}
void QTreeWidgetPrivate::_q_emitItemCollapsed(const QModelIndex &index)
{
Q_Q(QTreeWidget);
emit q->itemCollapsed(item(index));
}
void QTreeWidgetPrivate::_q_emitCurrentItemChanged(const QModelIndex ¤t,
const QModelIndex &previous)
{
Q_Q(QTreeWidget);
QTreeWidgetItem *currentItem = item(current);
QTreeWidgetItem *previousItem = item(previous);
emit q->currentItemChanged(currentItem, previousItem);
}
void QTreeWidgetPrivate::_q_sort()
{
if (sortingEnabled) {
int column = header->sortIndicatorSection();
Qt::SortOrder order = header->sortIndicatorOrder();
treeModel()->sort(column, order);
}
}
void QTreeWidgetPrivate::_q_selectionChanged(const QItemSelection &selected, const QItemSelection &deselected)
{
Q_Q(QTreeWidget);
QModelIndexList indices = selected.indexes();
int i;
QTreeModel *m = treeModel();
for (i = 0; i < indices.count(); ++i) {
QTreeWidgetItem *item = m->item(indices.at(i));
item->d->selected = true;
}
indices = deselected.indexes();
for (i = 0; i < indices.count(); ++i) {
QTreeWidgetItem *item = m->item(indices.at(i));
item->d->selected = false;
}
emit q->itemSelectionChanged();
}
void QTreeWidgetPrivate::_q_dataChanged(const QModelIndex &topLeft,
const QModelIndex &bottomRight)
{
if (sortingEnabled && topLeft.isValid() && bottomRight.isValid()
&& !treeModel()->sortPendingTimer.isActive()) {
int column = header->sortIndicatorSection();
if (column >= topLeft.column() && column <= bottomRight.column()) {
Qt::SortOrder order = header->sortIndicatorOrder();
treeModel()->ensureSorted(column, order, topLeft.row(),
bottomRight.row(), topLeft.parent());
}
}
}
/*!
\class QTreeWidget
\brief The QTreeWidget class provides a tree view that uses a predefined
tree model.
\ingroup model-view
The QTreeWidget class is a convenience class that provides a standard
tree widget with a classic item-based interface similar to that used by
the QListView class in Qt 3.
This class is based on Qt's Model/View architecture and uses a default
model to hold items, each of which is a QTreeWidgetItem.
Developers who do not need the flexibility of the Model/View framework
can use this class to create simple hierarchical lists very easily. A more
flexible approach involves combining a QTreeView with a standard item model.
This allows the storage of data to be separated from its representation.
In its simplest form, a tree widget can be constructed in the following way:
\snippet doc/src/snippets/code/src_gui_itemviews_qtreewidget.cpp 0
Before items can be added to the tree widget, the number of columns must
be set with setColumnCount(). This allows each item to have one or more
labels or other decorations. The number of columns in use can be found
with the columnCount() function.
The tree can have a header that contains a section for each column in
the widget. It is easiest to set up the labels for each section by
supplying a list of strings with setHeaderLabels(), but a custom header
can be constructed with a QTreeWidgetItem and inserted into the tree
with the setHeaderItem() function.
The items in the tree can be sorted by column according to a predefined
sort order. If sorting is enabled, the user can sort the items by clicking
on a column header. Sorting can be enabled or disabled by calling
\l{QTreeView::setSortingEnabled()}{setSortingEnabled()}. The
\l{QTreeView::isSortingEnabled()}{isSortingEnabled()} function indicates
whether sorting is enabled.
\table 100%
\row \o \inlineimage windowsxp-treeview.png Screenshot of a Windows XP style tree widget
\o \inlineimage macintosh-treeview.png Screenshot of a Macintosh style tree widget
\o \inlineimage plastique-treeview.png Screenshot of a Plastique style tree widget
\row \o A \l{Windows XP Style Widget Gallery}{Windows XP style} tree widget.
\o A \l{Macintosh Style Widget Gallery}{Macintosh style} tree widget.
\o A \l{Plastique Style Widget Gallery}{Plastique style} tree widget.
\endtable
\sa QTreeWidgetItem, QTreeWidgetItemIterator, QTreeView,
{Model/View Programming}, {Settings Editor Example}
*/
/*!
\property QTreeWidget::columnCount
\brief the number of columns displayed in the tree widget
By default, this property has a value of 1.
*/
/*!
\fn void QTreeWidget::itemActivated(QTreeWidgetItem *item, int column)
This signal is emitted when the user activates an item by single-
or double-clicking (depending on the platform, i.e. on the
QStyle::SH_ItemView_ActivateItemOnSingleClick style hint) or
pressing a special key (e.g., \key Enter).
The specified \a item is the item that was clicked, or 0 if no
item was clicked. The \a column is the item's column that was
clicked, or -1 if no item was clicked.
*/
/*!
\fn void QTreeWidget::itemPressed(QTreeWidgetItem *item, int column)
This signal is emitted when the user presses a mouse button inside
the widget.
The specified \a item is the item that was clicked, or 0 if no
item was clicked. The \a column is the item's column that was
clicked, or -1 if no item was clicked.
*/
/*!
\fn void QTreeWidget::itemClicked(QTreeWidgetItem *item, int column)
This signal is emitted when the user clicks inside the widget.
The specified \a item is the item that was clicked. The \a column is the
item's column that was clicked. If no item was clicked, no signal will be
emitted.
*/
/*!
\fn void QTreeWidget::itemDoubleClicked(QTreeWidgetItem *item, int column)
This signal is emitted when the user double clicks inside the
widget.
The specified \a item is the item that was clicked, or 0 if no
item was clicked. The \a column is the item's column that was
clicked. If no item was double clicked, no signal will be emitted.
*/
/*!
\fn void QTreeWidget::itemExpanded(QTreeWidgetItem *item)
This signal is emitted when the specified \a item is expanded so that
all of its children are displayed.
\note This signal will not be emitted if an item changes its state when
expandAll() is invoked.
\sa QTreeWidgetItem::isExpanded(), itemCollapsed(), expandItem()
*/
/*!
\fn void QTreeWidget::itemCollapsed(QTreeWidgetItem *item)
This signal is emitted when the specified \a item is collapsed so that
none of its children are displayed.
\note This signal will not be emitted if an item changes its state when
collapseAll() is invoked.
\sa QTreeWidgetItem::isExpanded(), itemExpanded(), collapseItem()
*/
/*!
\fn void QTreeWidget::currentItemChanged(QTreeWidgetItem *current, QTreeWidgetItem *previous)
This signal is emitted when the current item changes. The current
item is specified by \a current, and this replaces the \a previous
current item.
\sa setCurrentItem()
*/
/*!
\fn void QTreeWidget::itemSelectionChanged()
This signal is emitted when the selection changes in the tree widget.
The current selection can be found with selectedItems().
*/
/*!
\fn void QTreeWidget::itemEntered(QTreeWidgetItem *item, int column)
This signal is emitted when the mouse cursor enters an \a item over the
specified \a column.
QTreeWidget mouse tracking needs to be enabled for this feature to work.
*/
/*!
\fn void QTreeWidget::itemChanged(QTreeWidgetItem *item, int column)
This signal is emitted when the contents of the \a column in the specified
\a item changes.
*/
/*!
\since 4.3
\fn void QTreeWidget::removeItemWidget(QTreeWidgetItem *item, int column)
Removes the widget set in the given \a item in the given \a column.
*/
/*!
Constructs a tree widget with the given \a parent.
*/
QTreeWidget::QTreeWidget(QWidget *parent)
: QTreeView(*new QTreeWidgetPrivate(), parent)
{
QTreeView::setModel(new QTreeModel(1, this));
connect(this, SIGNAL(pressed(QModelIndex)),
SLOT(_q_emitItemPressed(QModelIndex)));
connect(this, SIGNAL(clicked(QModelIndex)),
SLOT(_q_emitItemClicked(QModelIndex)));
connect(this, SIGNAL(doubleClicked(QModelIndex)),
SLOT(_q_emitItemDoubleClicked(QModelIndex)));
connect(this, SIGNAL(activated(QModelIndex)),
SLOT(_q_emitItemActivated(QModelIndex)));
connect(this, SIGNAL(entered(QModelIndex)),
SLOT(_q_emitItemEntered(QModelIndex)));
connect(this, SIGNAL(expanded(QModelIndex)),
SLOT(_q_emitItemExpanded(QModelIndex)));
connect(this, SIGNAL(collapsed(QModelIndex)),
SLOT(_q_emitItemCollapsed(QModelIndex)));
connect(selectionModel(), SIGNAL(currentChanged(QModelIndex,QModelIndex)),
this, SLOT(_q_emitCurrentItemChanged(QModelIndex,QModelIndex)));
connect(model(), SIGNAL(dataChanged(QModelIndex,QModelIndex)),
this, SLOT(_q_emitItemChanged(QModelIndex)));
connect(model(), SIGNAL(dataChanged(QModelIndex,QModelIndex)),
this, SLOT(_q_dataChanged(QModelIndex,QModelIndex)));
connect(model(), SIGNAL(columnsRemoved(QModelIndex,int,int)),
this, SLOT(_q_sort()));
connect(selectionModel(), SIGNAL(selectionChanged(QItemSelection,QItemSelection)),
this, SLOT(_q_selectionChanged(QItemSelection,QItemSelection)));
header()->setClickable(false);
}
/*!
Destroys the tree widget and all its items.
*/
QTreeWidget::~QTreeWidget()
{
}
/*
Retuns the number of header columns in the view.
\sa sortColumn(), currentColumn(), topLevelItemCount()
*/
int QTreeWidget::columnCount() const
{
Q_D(const QTreeWidget);
return d->model->columnCount();
}
/*
Sets the number of header \a columns in the tree widget.
*/
void QTreeWidget::setColumnCount(int columns)
{
Q_D(QTreeWidget);
if (columns < 0)
return;
d->treeModel()->setColumnCount(columns);
}
/*!
\since 4.2
Returns the tree widget's invisible root item.
The invisible root item provides access to the tree widget's top-level items
through the QTreeWidgetItem API, making it possible to write functions that
can treat top-level items and their children in a uniform way; for example,
recursive functions.
*/
QTreeWidgetItem *QTreeWidget::invisibleRootItem() const
{
Q_D(const QTreeWidget);
return d->treeModel()->rootItem;
}
/*!
Returns the top level item at the given \a index, or 0 if the item does
not exist.
\sa topLevelItemCount(), insertTopLevelItem()
*/
QTreeWidgetItem *QTreeWidget::topLevelItem(int index) const
{
Q_D(const QTreeWidget);
return d->treeModel()->rootItem->child(index);
}
/*!
\property QTreeWidget::topLevelItemCount
\brief the number of top-level items
By default, this property has a value of 0.
\sa columnCount(), currentItem()
*/
int QTreeWidget::topLevelItemCount() const
{
Q_D(const QTreeWidget);
return d->treeModel()->rootItem->childCount();
}
/*!
Inserts the \a item at \a index in the top level in the view.
If the item has already been inserted somewhere else it wont be inserted.
\sa addTopLevelItem(), columnCount()
*/
void QTreeWidget::insertTopLevelItem(int index, QTreeWidgetItem *item)
{
Q_D(QTreeWidget);
d->treeModel()->rootItem->insertChild(index, item);
}
/*!
\since 4.1
Appends the \a item as a top-level item in the widget.
\sa insertTopLevelItem()
*/
void QTreeWidget::addTopLevelItem(QTreeWidgetItem *item)
{
insertTopLevelItem(topLevelItemCount(), item);
}
/*!
Removes the top-level item at the given \a index in the tree and
returns it, otherwise returns 0;
\sa insertTopLevelItem(), topLevelItem(), topLevelItemCount()
*/
QTreeWidgetItem *QTreeWidget::takeTopLevelItem(int index)
{
Q_D(QTreeWidget);
return d->treeModel()->rootItem->takeChild(index);
}
/*!
\internal
*/
int QTreeWidget::indexOfTopLevelItem(QTreeWidgetItem *item)
{
Q_D(QTreeWidget);
d->treeModel()->executePendingSort();
return d->treeModel()->rootItem->children.indexOf(item);
}
/*!
Returns the index of the given top-level \a item, or -1 if the item
cannot be found.
\sa sortItems(), topLevelItemCount()
*/
int QTreeWidget::indexOfTopLevelItem(QTreeWidgetItem *item) const
{
Q_D(const QTreeWidget);
d->treeModel()->executePendingSort();
return d->treeModel()->rootItem->children.indexOf(item);
}
/*!
\since 4.1
Inserts the list of \a items at \a index in the top level in the view.
Items that have already been inserted somewhere else wont be inserted.
\sa addTopLevelItems()
*/
void QTreeWidget::insertTopLevelItems(int index, const QList<QTreeWidgetItem*> &items)
{
Q_D(QTreeWidget);
d->treeModel()->rootItem->insertChildren(index, items);
}
/*!
Appends the list of \a items as a top-level items in the widget.
\sa insertTopLevelItems()
*/
void QTreeWidget::addTopLevelItems(const QList<QTreeWidgetItem*> &items)
{
insertTopLevelItems(topLevelItemCount(), items);
}
/*!
Returns the item used for the tree widget's header.
\sa setHeaderItem()
*/
QTreeWidgetItem *QTreeWidget::headerItem() const
{
Q_D(const QTreeWidget);
return d->treeModel()->headerItem;
}
/*!
Sets the header \a item for the tree widget. The label for each column in
the header is supplied by the corresponding label in the item.
The tree widget takes ownership of the item.
\sa headerItem(), setHeaderLabels()
*/
void QTreeWidget::setHeaderItem(QTreeWidgetItem *item)
{
Q_D(QTreeWidget);
if (!item)
return;
item->view = this;
int oldCount = columnCount();
if (oldCount < item->columnCount())
d->treeModel()->beginInsertColumns(QModelIndex(), oldCount, item->columnCount());
else
d->treeModel()->beginRemoveColumns(QModelIndex(), item->columnCount(), oldCount);
delete d->treeModel()->headerItem;
d->treeModel()->headerItem = item;
if (oldCount < item->columnCount())
d->treeModel()->endInsertColumns();
else
d->treeModel()->endRemoveColumns();
d->treeModel()->headerDataChanged(Qt::Horizontal, 0, oldCount);
}
/*!
Adds a column in the header for each item in the \a labels list, and sets
the label for each column.
Note that setHeaderLabels() won't remove existing columns.
\sa setHeaderItem(), setHeaderLabel()
*/
void QTreeWidget::setHeaderLabels(const QStringList &labels)
{
Q_D(QTreeWidget);
if (columnCount() < labels.count())
setColumnCount(labels.count());
QTreeWidgetItem *item = d->treeModel()->headerItem;
for (int i = 0; i < labels.count(); ++i)
item->setText(i, labels.at(i));
}
/*!
\fn void QTreeWidget::setHeaderLabel(const QString &label)
\since 4.2
Same as setHeaderLabels(QStringList(\a label)).
*/
/*!
Returns the current item in the tree widget.
\sa setCurrentItem(), currentItemChanged()
*/
QTreeWidgetItem *QTreeWidget::currentItem() const
{
Q_D(const QTreeWidget);
return d->item(currentIndex());
}
/*!
\since 4.1
Returns the current column in the tree widget.
\sa setCurrentItem(), columnCount()
*/
int QTreeWidget::currentColumn() const
{
return currentIndex().column();
}
/*!
Sets the current \a item in the tree widget.
Unless the selection mode is \l{QAbstractItemView::}{NoSelection},
the item is also be selected.
\sa currentItem(), currentItemChanged()
*/
void QTreeWidget::setCurrentItem(QTreeWidgetItem *item)
{
setCurrentItem(item, 0);
}
/*!
\since 4.1
Sets the current \a item in the tree widget and the current column to \a column.
\sa currentItem()
*/
void QTreeWidget::setCurrentItem(QTreeWidgetItem *item, int column)
{
Q_D(QTreeWidget);
setCurrentIndex(d->index(item, column));
}
/*!
\since 4.4
Sets the current \a item in the tree widget and the current column to \a column,
using the given \a command.
\sa currentItem()
*/
void QTreeWidget::setCurrentItem(QTreeWidgetItem *item, int column,
QItemSelectionModel::SelectionFlags command)
{
Q_D(QTreeWidget);
d->selectionModel->setCurrentIndex(d->index(item, column), command);
}
/*!
Returns a pointer to the item at the coordinates \a p. The coordinates
are relative to the tree widget's \l{QAbstractScrollArea::}{viewport()}.
\sa visualItemRect()
*/
QTreeWidgetItem *QTreeWidget::itemAt(const QPoint &p) const
{
Q_D(const QTreeWidget);
return d->item(indexAt(p));
}
/*!
\fn QTreeWidgetItem *QTreeWidget::itemAt(int x, int y) const
\overload
Returns a pointer to the item at the coordinates (\a x, \a y). The coordinates
are relative to the tree widget's \l{QAbstractScrollArea::}{viewport()}.
*/
/*!
Returns the rectangle on the viewport occupied by the item at \a item.
\sa itemAt()
*/
QRect QTreeWidget::visualItemRect(const QTreeWidgetItem *item) const
{
Q_D(const QTreeWidget);
//the visual rect for an item is across all columns. So we need to determine
//what is the first and last column and get their visual index rects
QModelIndex base = d->index(item);
const int firstVisiblesection = header()->logicalIndexAt(- header()->offset());
const int lastVisibleSection = header()->logicalIndexAt(header()->length() - header()->offset() - 1);
QModelIndex first = base.sibling(base.row(), header()->logicalIndex(firstVisiblesection));
QModelIndex last = base.sibling(base.row(), header()->logicalIndex(lastVisibleSection));
return visualRect(first) | visualRect(last);
}
/*!
\since 4.1
Returns the column used to sort the contents of the widget.
\sa sortItems()
*/
int QTreeWidget::sortColumn() const
{
Q_D(const QTreeWidget);
return (d->explicitSortColumn != -1
? d->explicitSortColumn
: header()->sortIndicatorSection());
}
/*!
Sorts the items in the widget in the specified \a order by the values in
the given \a column.
\sa sortColumn()
*/
void QTreeWidget::sortItems(int column, Qt::SortOrder order)
{
Q_D(QTreeWidget);
header()->setSortIndicator(column, order);
d->model->sort(column, order);
}
/*!
\internal
### Qt 5: remove
*/
void QTreeWidget::setSortingEnabled(bool enable)
{
QTreeView::setSortingEnabled(enable);
}
/*!
\internal
### Qt 5: remove
*/
bool QTreeWidget::isSortingEnabled() const
{
return QTreeView::isSortingEnabled();
}
/*!
Starts editing the \a item in the given \a column if it is editable.
*/
void QTreeWidget::editItem(QTreeWidgetItem *item, int column)
{
Q_D(QTreeWidget);
edit(d->index(item, column));
}
/*!
Opens a persistent editor for the \a item in the given \a column.
\sa closePersistentEditor()
*/
void QTreeWidget::openPersistentEditor(QTreeWidgetItem *item, int column)
{
Q_D(QTreeWidget);
QAbstractItemView::openPersistentEditor(d->index(item, column));
}
/*!
Closes the persistent editor for the \a item in the given \a column.
This function has no effect if no persistent editor is open for this
combination of item and column.
\sa openPersistentEditor()
*/
void QTreeWidget::closePersistentEditor(QTreeWidgetItem *item, int column)
{
Q_D(QTreeWidget);
QAbstractItemView::closePersistentEditor(d->index(item, column));
}
/*!
\since 4.1
Returns the widget displayed in the cell specified by \a item and the given \a column.
\note The tree takes ownership of the widget.
*/
QWidget *QTreeWidget::itemWidget(QTreeWidgetItem *item, int column) const
{
Q_D(const QTreeWidget);
return QAbstractItemView::indexWidget(d->index(item, column));
}
/*!
\since 4.1
Sets the given \a widget to be displayed in the cell specified by the given
\a item and \a column.
The given \a widget's \l {QWidget::}{autoFillBackground} property must be
set to true, otherwise the widget's background will be transparent, showing
both the model data and the tree widget item.
This function should only be used to display static content in the place of
a tree widget item. If you want to display custom dynamic content or
implement a custom editor widget, use QTreeView and subclass QItemDelegate
instead.
This function cannot be called before the item hierarchy has been set up,
i.e., the QTreeWidgetItem that will hold \a widget must have been added to
the view before \a widget is set.
\note The tree takes ownership of the widget.
\sa {Delegate Classes}
*/
void QTreeWidget::setItemWidget(QTreeWidgetItem *item, int column, QWidget *widget)
{
Q_D(QTreeWidget);
QAbstractItemView::setIndexWidget(d->index(item, column), widget);
}
/*!
Returns true if the \a item is selected; otherwise returns false.
\sa itemSelectionChanged()
\obsolete
This function is deprecated. Use \l{QTreeWidgetItem::isSelected()} instead.
*/
bool QTreeWidget::isItemSelected(const QTreeWidgetItem *item) const
{
if (!item)
return false;
return item->d->selected;
}
/*!
If \a select is true, the given \a item is selected; otherwise it is
deselected.
\sa itemSelectionChanged()
\obsolete
This function is deprecated. Use \l{QTreeWidgetItem::setSelected()} instead.
*/
void QTreeWidget::setItemSelected(const QTreeWidgetItem *item, bool select)
{
Q_D(QTreeWidget);
if (!item)
return;
selectionModel()->select(d->index(item), (select ? QItemSelectionModel::Select
: QItemSelectionModel::Deselect)
|QItemSelectionModel::Rows);
item->d->selected = select;
}
/*!
Returns a list of all selected non-hidden items.
\sa itemSelectionChanged()
*/
QList<QTreeWidgetItem*> QTreeWidget::selectedItems() const
{
Q_D(const QTreeWidget);
QModelIndexList indexes = selectionModel()->selectedIndexes();
QList<QTreeWidgetItem*> items;
items.reserve(indexes.count());
QSet<QTreeWidgetItem *> seen;
seen.reserve(indexes.count());
for (int i = 0; i < indexes.count(); ++i) {
QTreeWidgetItem *item = d->item(indexes.at(i));
if (isItemHidden(item) || seen.contains(item))
continue;
seen.insert(item);
items.append(item);
}
return items;
}
/*!
Returns a list of items that match the given \a text, using the given \a flags, in the given \a column.
*/
QList<QTreeWidgetItem*> QTreeWidget::findItems(const QString &text, Qt::MatchFlags flags, int column) const
{
Q_D(const QTreeWidget);
QModelIndexList indexes = d->model->match(model()->index(0, column, QModelIndex()),
Qt::DisplayRole, text, -1, flags);
QList<QTreeWidgetItem*> items;
for (int i = 0; i < indexes.size(); ++i)
items.append(d->item(indexes.at(i)));
return items;
}
/*!
Returns true if the \a item is explicitly hidden, otherwise returns false.
\obsolete
This function is deprecated. Use \l{QTreeWidgetItem::isHidden()} instead.
*/
bool QTreeWidget::isItemHidden(const QTreeWidgetItem *item) const
{
Q_D(const QTreeWidget);
if (item == d->treeModel()->headerItem)
return header()->isHidden();
if (d->hiddenIndexes.isEmpty())
return false;
QTreeModel::SkipSorting skipSorting(d->treeModel());
return d->isRowHidden(d->index(item));
}
/*!
Hides the given \a item if \a hide is true; otherwise shows the item.
\sa itemChanged()
\obsolete
This function is deprecated. Use \l{QTreeWidgetItem::setHidden()} instead.
*/
void QTreeWidget::setItemHidden(const QTreeWidgetItem *item, bool hide)
{
Q_D(QTreeWidget);
if (item == d->treeModel()->headerItem) {
header()->setHidden(hide);
} else {
const QModelIndex index = d->index(item);
setRowHidden(index.row(), index.parent(), hide);
}
}
/*!
Returns true if the given \a item is open; otherwise returns false.
\sa itemExpanded()
\obsolete
This function is deprecated. Use \l{QTreeWidgetItem::isExpanded()} instead.
*/
bool QTreeWidget::isItemExpanded(const QTreeWidgetItem *item) const
{
Q_D(const QTreeWidget);
QTreeModel::SkipSorting skipSorting(d->treeModel());
return isExpanded(d->index(item));
}
/*!
Sets the item referred to by \a item to either closed or opened,
depending on the value of \a expand.
\sa expandItem(), collapseItem(), itemExpanded()
\obsolete
This function is deprecated. Use \l{QTreeWidgetItem::setExpanded()} instead.
*/
void QTreeWidget::setItemExpanded(const QTreeWidgetItem *item, bool expand)
{
Q_D(QTreeWidget);
QTreeModel::SkipSorting skipSorting(d->treeModel());
setExpanded(d->index(item), expand);
}
/*!
\since 4.3
Returns true if the given \a item is set to show only one section over all columns;
otherwise returns false.
\sa setFirstItemColumnSpanned()
*/
bool QTreeWidget::isFirstItemColumnSpanned(const QTreeWidgetItem *item) const
{
Q_D(const QTreeWidget);
if (item == d->treeModel()->headerItem)
return false; // We can't set the header items to spanning
const QModelIndex index = d->index(item);
return isFirstColumnSpanned(index.row(), index.parent());
}
/*!
\since 4.3
Sets the given \a item to only show one section for all columns if \a span is true;
otherwise the item will show one section per column.
\sa isFirstItemColumnSpanned()
*/
void QTreeWidget::setFirstItemColumnSpanned(const QTreeWidgetItem *item, bool span)
{
Q_D(QTreeWidget);
if (item == d->treeModel()->headerItem)
return; // We can't set header items to spanning
const QModelIndex index = d->index(item);
setFirstColumnSpanned(index.row(), index.parent(), span);
}
/*!
\since 4.3
Returns the item above the given \a item.
*/
QTreeWidgetItem *QTreeWidget::itemAbove(const QTreeWidgetItem *item) const
{
Q_D(const QTreeWidget);
if (item == d->treeModel()->headerItem)
return 0;
const QModelIndex index = d->index(item);
const QModelIndex above = indexAbove(index);
return d->item(above);
}
/*!
\since 4.3
Returns the item visually below the given \a item.
*/
QTreeWidgetItem *QTreeWidget::itemBelow(const QTreeWidgetItem *item) const
{
Q_D(const QTreeWidget);
if (item == d->treeModel()->headerItem)
return 0;
const QModelIndex index = d->index(item);
const QModelIndex below = indexBelow(index);
return d->item(below);
}
/*!
\reimp
*/
void QTreeWidget::setSelectionModel(QItemSelectionModel *selectionModel)
{
Q_D(QTreeWidget);
QTreeView::setSelectionModel(selectionModel);
QItemSelection newSelection = selectionModel->selection();
if (!newSelection.isEmpty())
d->_q_selectionChanged(newSelection, QItemSelection());
}
/*!
Ensures that the \a item is visible, scrolling the view if necessary using
the specified \a hint.
\sa currentItem(), itemAt(), topLevelItem()
*/
void QTreeWidget::scrollToItem(const QTreeWidgetItem *item, QAbstractItemView::ScrollHint hint)
{
Q_D(QTreeWidget);
QTreeView::scrollTo(d->index(item), hint);
}
/*!
Expands the \a item. This causes the tree containing the item's children
to be expanded.
\sa collapseItem(), currentItem(), itemAt(), topLevelItem(), itemExpanded()
*/
void QTreeWidget::expandItem(const QTreeWidgetItem *item)
{
Q_D(QTreeWidget);
QTreeModel::SkipSorting skipSorting(d->treeModel());
expand(d->index(item));
}
/*!
Closes the \a item. This causes the tree containing the item's children
to be collapsed.
\sa expandItem(), currentItem(), itemAt(), topLevelItem()
*/
void QTreeWidget::collapseItem(const QTreeWidgetItem *item)
{
Q_D(QTreeWidget);
QTreeModel::SkipSorting skipSorting(d->treeModel());
collapse(d->index(item));
}
/*!
Clears the tree widget by removing all of its items and selections.
\bold{Note:} Since each item is removed from the tree widget before being
deleted, the return value of QTreeWidgetItem::treeWidget() will be invalid
when called from an item's destructor.
\sa takeTopLevelItem(), topLevelItemCount(), columnCount()
*/
void QTreeWidget::clear()
{
Q_D(QTreeWidget);
selectionModel()->clear();
d->treeModel()->clear();
}
/*!
Returns a list of MIME types that can be used to describe a list of
treewidget items.
\sa mimeData()
*/
QStringList QTreeWidget::mimeTypes() const
{
return model()->QAbstractItemModel::mimeTypes();
}
/*!
Returns an object that contains a serialized description of the specified
\a items. The format used to describe the items is obtained from the
mimeTypes() function.
If the list of items is empty, 0 is returned rather than a serialized
empty list.
*/
QMimeData *QTreeWidget::mimeData(const QList<QTreeWidgetItem*> items) const
{
Q_D(const QTreeWidget);
if (d->treeModel()->cachedIndexes.isEmpty()) {
QList<QModelIndex> indexes;
for (int i = 0; i < items.count(); ++i) {
QTreeWidgetItem *item = items.at(i);
for (int c = 0; c < item->values.count(); ++c) {
indexes << indexFromItem(item, c);
}
}
return d->model->QAbstractItemModel::mimeData(indexes);
}
return d->treeModel()->internalMimeData();
}
/*!
Handles the \a data supplied by a drag and drop operation that ended with
the given \a action in the \a index in the given \a parent item.
The default implementation returns true if the drop was
successfully handled by decoding the mime data and inserting it
into the model; otherwise it returns false.
\sa supportedDropActions()
*/
bool QTreeWidget::dropMimeData(QTreeWidgetItem *parent, int index,
const QMimeData *data, Qt::DropAction action)
{
QModelIndex idx;
if (parent) idx = indexFromItem(parent);
return model()->QAbstractItemModel::dropMimeData(data, action , index, 0, idx);
}
/*!
Returns the drop actions supported by this view.
\sa Qt::DropActions
*/
Qt::DropActions QTreeWidget::supportedDropActions() const
{
return model()->QAbstractItemModel::supportedDropActions() | Qt::MoveAction;
}
/*!
\obsolete
Returns an empty list
\sa mimeData()
*/
QList<QTreeWidgetItem*> QTreeWidget::items(const QMimeData *data) const
{
Q_UNUSED(data);
return QList<QTreeWidgetItem*>();
}
/*!
Returns the QModelIndex assocated with the given \a item in the given \a column.
\sa itemFromIndex(), topLevelItem()
*/
QModelIndex QTreeWidget::indexFromItem(QTreeWidgetItem *item, int column) const
{
Q_D(const QTreeWidget);
return d->index(item, column);
}
/*!
Returns a pointer to the QTreeWidgetItem assocated with the given \a index.
\sa indexFromItem()
*/
QTreeWidgetItem *QTreeWidget::itemFromIndex(const QModelIndex &index) const
{
Q_D(const QTreeWidget);
return d->item(index);
}
#ifndef QT_NO_DRAGANDDROP
/*! \reimp */
void QTreeWidget::dropEvent(QDropEvent *event) {
Q_D(QTreeWidget);
if (event->source() == this && (event->dropAction() == Qt::MoveAction ||
dragDropMode() == QAbstractItemView::InternalMove)) {
QModelIndex topIndex;
int col = -1;
int row = -1;
if (d->dropOn(event, &row, &col, &topIndex)) {
QList<QModelIndex> idxs = selectedIndexes();
QList<QPersistentModelIndex> indexes;
for (int i = 0; i < idxs.count(); i++)
indexes.append(idxs.at(i));
if (indexes.contains(topIndex))
return;
// When removing items the drop location could shift
QPersistentModelIndex dropRow = model()->index(row, col, topIndex);
// Remove the items
QList<QTreeWidgetItem *> taken;
for (int i = indexes.count() - 1; i >= 0; --i) {
QTreeWidgetItem *parent = itemFromIndex(indexes.at(i));
if (!parent || !parent->parent()) {
taken.append(takeTopLevelItem(indexes.at(i).row()));
} else {
taken.append(parent->parent()->takeChild(indexes.at(i).row()));
}
}
// insert them back in at their new positions
for (int i = 0; i < indexes.count(); ++i) {
// Either at a specific point or appended
if (row == -1) {
if (topIndex.isValid()) {
QTreeWidgetItem *parent = itemFromIndex(topIndex);
parent->insertChild(parent->childCount(), taken.takeFirst());
} else {
insertTopLevelItem(topLevelItemCount(), taken.takeFirst());
}
} else {
int r = dropRow.row() >= 0 ? dropRow.row() : row;
if (topIndex.isValid()) {
QTreeWidgetItem *parent = itemFromIndex(topIndex);
parent->insertChild(qMin(r, parent->childCount()), taken.takeFirst());
} else {
insertTopLevelItem(qMin(r, topLevelItemCount()), taken.takeFirst());
}
}
}
event->accept();
// Don't want QAbstractItemView to delete it because it was "moved" we already did it
event->setDropAction(Qt::CopyAction);
}
}
QTreeView::dropEvent(event);
}
#endif
/*!
\reimp
*/
void QTreeWidget::setModel(QAbstractItemModel * /*model*/)
{
Q_ASSERT(!"QTreeWidget::setModel() - Changing the model of the QTreeWidget is not allowed.");
}
/*!
\reimp
*/
bool QTreeWidget::event(QEvent *e)
{
Q_D(QTreeWidget);
if (e->type() == QEvent::Polish)
d->treeModel()->executePendingSort();
return QTreeView::event(e);
}
QT_END_NAMESPACE
#include "moc_qtreewidget.cpp"
#endif // QT_NO_TREEWIDGET
| [
"39357378+maoxingda@users.noreply.github.com"
] | 39357378+maoxingda@users.noreply.github.com |
750af75f043e3339f23aea7a2b046464521d9d1c | c91e87183f41a29f52d7aed69ef3591f5e941808 | /Classes/scene/MainMenu.h | a0a88d1756557715e455a94787b2d6d108c72548 | [] | no_license | ricolynx/ProtoConnect | 3532d60efc904431695c0e1b5a5664df6aa10071 | a3d104d5563872c1175d13942de0cb09eb1d25fe | refs/heads/master | 2020-04-16T11:11:34.975980 | 2014-08-13T05:04:32 | 2014-08-13T05:04:32 | 22,395,177 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 532 | h | //
// MainMenu.h
// Reflex
//
// Created by Eric Giraud on 01/11/2013.
//
//
#ifndef __ProtoConnect__MainMenu__
#define __ProtoConnect__MainMenu__
#include "cocos2d.h"
#include "SceneManager.h"
class MainMenu : public cocos2d::Layer
{
private :
bool showLogs;
cocos2d::SpriteBatchNode* batchNode;
public :
virtual bool init();
static cocos2d::Scene* scene();
void playCallback(Ref* pSender);
CREATE_FUNC(MainMenu);
};
#endif // __Reflex__MainMenu__
| [
"eric.giraud@gmail.com"
] | eric.giraud@gmail.com |
8d665c716b87038653519fe74caf2d7446f30c6a | fc5cf6e087df5b7934ceed7d2a1d22b094197ff1 | /processed_old/93-3658-1.cc | 0e4ffd89bac63f06cf7260fa0df739cad3816682 | [
"MIT",
"GPL-2.0-only",
"GPL-1.0-or-later"
] | permissive | giulianobelinassi/LTO-Timing-Analysis | 80767a682960d2f2b1944edaf116466a784ac984 | 12eb7f3444f6c938c0a225f61aec47e419526490 | refs/heads/master | 2023-01-30T09:20:12.705767 | 2020-12-10T00:30:16 | 2020-12-10T00:30:16 | 263,368,860 | 1 | 0 | MIT | 2020-10-27T23:16:33 | 2020-05-12T14:59:34 | C++ | UTF-8 | C++ | false | false | 1,209,953 | cc | # 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
# 1 "/home/giulianob/gcc_git_gnu/build_temp/gcc//"
# 1 "<built-in>"
# 1 "<command-line>"
# 1 "/usr/include/stdc-predef.h" 1 3 4
# 1 "<command-line>" 2
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
# 26 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
# 1 "./config.h" 1
# 1 "./auto-host.h" 1
# 7 "./config.h" 2
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/../include/ansidecl.h" 1
# 40 "/home/giulianob/gcc_git_gnu/gcc/gcc/../include/ansidecl.h"
extern "C" {
# 433 "/home/giulianob/gcc_git_gnu/gcc/gcc/../include/ansidecl.h"
}
# 9 "./config.h" 2
# 27 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 2
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/system.h" 1
# 32 "/home/giulianob/gcc_git_gnu/gcc/gcc/system.h"
# 1 "/usr/lib/gcc/x86_64-linux-gnu/10/include/stdarg.h" 1 3 4
# 40 "/usr/lib/gcc/x86_64-linux-gnu/10/include/stdarg.h" 3 4
# 40 "/usr/lib/gcc/x86_64-linux-gnu/10/include/stdarg.h" 3 4
typedef __builtin_va_list __gnuc_va_list;
# 99 "/usr/lib/gcc/x86_64-linux-gnu/10/include/stdarg.h" 3 4
typedef __gnuc_va_list va_list;
# 33 "/home/giulianob/gcc_git_gnu/gcc/gcc/system.h" 2
# 43 "/home/giulianob/gcc_git_gnu/gcc/gcc/system.h"
# 1 "/usr/lib/gcc/x86_64-linux-gnu/10/include/stddef.h" 1 3 4
# 143 "/usr/lib/gcc/x86_64-linux-gnu/10/include/stddef.h" 3 4
typedef long int ptrdiff_t;
# 209 "/usr/lib/gcc/x86_64-linux-gnu/10/include/stddef.h" 3 4
typedef long unsigned int size_t;
# 415 "/usr/lib/gcc/x86_64-linux-gnu/10/include/stddef.h" 3 4
typedef struct {
long long __max_align_ll __attribute__((__aligned__(__alignof__(long long))));
long double __max_align_ld __attribute__((__aligned__(__alignof__(long double))));
# 426 "/usr/lib/gcc/x86_64-linux-gnu/10/include/stddef.h" 3 4
} max_align_t;
typedef decltype(nullptr) nullptr_t;
# 44 "/home/giulianob/gcc_git_gnu/gcc/gcc/system.h" 2
# 1 "/usr/include/stdio.h" 1 3 4
# 27 "/usr/include/stdio.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/libc-header-start.h" 1 3 4
# 33 "/usr/include/x86_64-linux-gnu/bits/libc-header-start.h" 3 4
# 1 "/usr/include/features.h" 1 3 4
# 461 "/usr/include/features.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/sys/cdefs.h" 1 3 4
# 452 "/usr/include/x86_64-linux-gnu/sys/cdefs.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/wordsize.h" 1 3 4
# 453 "/usr/include/x86_64-linux-gnu/sys/cdefs.h" 2 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/long-double.h" 1 3 4
# 454 "/usr/include/x86_64-linux-gnu/sys/cdefs.h" 2 3 4
# 462 "/usr/include/features.h" 2 3 4
# 485 "/usr/include/features.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/gnu/stubs.h" 1 3 4
# 10 "/usr/include/x86_64-linux-gnu/gnu/stubs.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/gnu/stubs-64.h" 1 3 4
# 11 "/usr/include/x86_64-linux-gnu/gnu/stubs.h" 2 3 4
# 486 "/usr/include/features.h" 2 3 4
# 34 "/usr/include/x86_64-linux-gnu/bits/libc-header-start.h" 2 3 4
# 28 "/usr/include/stdio.h" 2 3 4
extern "C" {
# 1 "/usr/lib/gcc/x86_64-linux-gnu/10/include/stddef.h" 1 3 4
# 34 "/usr/include/stdio.h" 2 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/types.h" 1 3 4
# 27 "/usr/include/x86_64-linux-gnu/bits/types.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/wordsize.h" 1 3 4
# 28 "/usr/include/x86_64-linux-gnu/bits/types.h" 2 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/timesize.h" 1 3 4
# 29 "/usr/include/x86_64-linux-gnu/bits/types.h" 2 3 4
typedef unsigned char __u_char;
typedef unsigned short int __u_short;
typedef unsigned int __u_int;
typedef unsigned long int __u_long;
typedef signed char __int8_t;
typedef unsigned char __uint8_t;
typedef signed short int __int16_t;
typedef unsigned short int __uint16_t;
typedef signed int __int32_t;
typedef unsigned int __uint32_t;
typedef signed long int __int64_t;
typedef unsigned long int __uint64_t;
typedef __int8_t __int_least8_t;
typedef __uint8_t __uint_least8_t;
typedef __int16_t __int_least16_t;
typedef __uint16_t __uint_least16_t;
typedef __int32_t __int_least32_t;
typedef __uint32_t __uint_least32_t;
typedef __int64_t __int_least64_t;
typedef __uint64_t __uint_least64_t;
typedef long int __quad_t;
typedef unsigned long int __u_quad_t;
typedef long int __intmax_t;
typedef unsigned long int __uintmax_t;
# 141 "/usr/include/x86_64-linux-gnu/bits/types.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/typesizes.h" 1 3 4
# 142 "/usr/include/x86_64-linux-gnu/bits/types.h" 2 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/time64.h" 1 3 4
# 143 "/usr/include/x86_64-linux-gnu/bits/types.h" 2 3 4
typedef unsigned long int __dev_t;
typedef unsigned int __uid_t;
typedef unsigned int __gid_t;
typedef unsigned long int __ino_t;
typedef unsigned long int __ino64_t;
typedef unsigned int __mode_t;
typedef unsigned long int __nlink_t;
typedef long int __off_t;
typedef long int __off64_t;
typedef int __pid_t;
typedef struct { int __val[2]; } __fsid_t;
typedef long int __clock_t;
typedef unsigned long int __rlim_t;
typedef unsigned long int __rlim64_t;
typedef unsigned int __id_t;
typedef long int __time_t;
typedef unsigned int __useconds_t;
typedef long int __suseconds_t;
typedef int __daddr_t;
typedef int __key_t;
typedef int __clockid_t;
typedef void * __timer_t;
typedef long int __blksize_t;
typedef long int __blkcnt_t;
typedef long int __blkcnt64_t;
typedef unsigned long int __fsblkcnt_t;
typedef unsigned long int __fsblkcnt64_t;
typedef unsigned long int __fsfilcnt_t;
typedef unsigned long int __fsfilcnt64_t;
typedef long int __fsword_t;
typedef long int __ssize_t;
typedef long int __syscall_slong_t;
typedef unsigned long int __syscall_ulong_t;
typedef __off64_t __loff_t;
typedef char *__caddr_t;
typedef long int __intptr_t;
typedef unsigned int __socklen_t;
typedef int __sig_atomic_t;
# 39 "/usr/include/stdio.h" 2 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h" 1 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h" 1 3 4
# 13 "/usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h" 3 4
typedef struct
{
int __count;
union
{
unsigned int __wch;
char __wchb[4];
} __value;
} __mbstate_t;
# 6 "/usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h" 2 3 4
typedef struct _G_fpos_t
{
__off_t __pos;
__mbstate_t __state;
} __fpos_t;
# 40 "/usr/include/stdio.h" 2 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h" 1 3 4
# 10 "/usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h" 3 4
typedef struct _G_fpos64_t
{
__off64_t __pos;
__mbstate_t __state;
} __fpos64_t;
# 41 "/usr/include/stdio.h" 2 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/types/__FILE.h" 1 3 4
struct _IO_FILE;
typedef struct _IO_FILE __FILE;
# 42 "/usr/include/stdio.h" 2 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/types/FILE.h" 1 3 4
struct _IO_FILE;
typedef struct _IO_FILE FILE;
# 43 "/usr/include/stdio.h" 2 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h" 1 3 4
# 35 "/usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h" 3 4
struct _IO_FILE;
struct _IO_marker;
struct _IO_codecvt;
struct _IO_wide_data;
typedef void _IO_lock_t;
struct _IO_FILE
{
int _flags;
char *_IO_read_ptr;
char *_IO_read_end;
char *_IO_read_base;
char *_IO_write_base;
char *_IO_write_ptr;
char *_IO_write_end;
char *_IO_buf_base;
char *_IO_buf_end;
char *_IO_save_base;
char *_IO_backup_base;
char *_IO_save_end;
struct _IO_marker *_markers;
struct _IO_FILE *_chain;
int _fileno;
int _flags2;
__off_t _old_offset;
unsigned short _cur_column;
signed char _vtable_offset;
char _shortbuf[1];
_IO_lock_t *_lock;
__off64_t _offset;
struct _IO_codecvt *_codecvt;
struct _IO_wide_data *_wide_data;
struct _IO_FILE *_freeres_list;
void *_freeres_buf;
size_t __pad5;
int _mode;
char _unused2[15 * sizeof (int) - 4 * sizeof (void *) - sizeof (size_t)];
};
# 44 "/usr/include/stdio.h" 2 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/types/cookie_io_functions_t.h" 1 3 4
# 27 "/usr/include/x86_64-linux-gnu/bits/types/cookie_io_functions_t.h" 3 4
typedef __ssize_t cookie_read_function_t (void *__cookie, char *__buf,
size_t __nbytes);
typedef __ssize_t cookie_write_function_t (void *__cookie, const char *__buf,
size_t __nbytes);
typedef int cookie_seek_function_t (void *__cookie, __off64_t *__pos, int __w);
typedef int cookie_close_function_t (void *__cookie);
typedef struct _IO_cookie_io_functions_t
{
cookie_read_function_t *read;
cookie_write_function_t *write;
cookie_seek_function_t *seek;
cookie_close_function_t *close;
} cookie_io_functions_t;
# 47 "/usr/include/stdio.h" 2 3 4
# 63 "/usr/include/stdio.h" 3 4
typedef __off_t off_t;
typedef __off64_t off64_t;
typedef __ssize_t ssize_t;
typedef __fpos_t fpos_t;
typedef __fpos64_t fpos64_t;
# 133 "/usr/include/stdio.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/stdio_lim.h" 1 3 4
# 134 "/usr/include/stdio.h" 2 3 4
extern FILE *stdin;
extern FILE *stdout;
extern FILE *stderr;
extern int remove (const char *__filename) throw ();
extern int rename (const char *__old, const char *__new) throw ();
extern int renameat (int __oldfd, const char *__old, int __newfd,
const char *__new) throw ();
# 164 "/usr/include/stdio.h" 3 4
extern int renameat2 (int __oldfd, const char *__old, int __newfd,
const char *__new, unsigned int __flags) throw ();
extern FILE *tmpfile (void) ;
# 183 "/usr/include/stdio.h" 3 4
extern FILE *tmpfile64 (void) ;
extern char *tmpnam (char *__s) throw () ;
extern char *tmpnam_r (char *__s) throw () ;
# 204 "/usr/include/stdio.h" 3 4
extern char *tempnam (const char *__dir, const char *__pfx)
throw () __attribute__ ((__malloc__)) ;
extern int fclose (FILE *__stream);
extern int fflush (FILE *__stream);
# 227 "/usr/include/stdio.h" 3 4
extern int fflush_unlocked (FILE *__stream);
# 237 "/usr/include/stdio.h" 3 4
extern int fcloseall (void);
# 246 "/usr/include/stdio.h" 3 4
extern FILE *fopen (const char *__restrict __filename,
const char *__restrict __modes) ;
extern FILE *freopen (const char *__restrict __filename,
const char *__restrict __modes,
FILE *__restrict __stream) ;
# 270 "/usr/include/stdio.h" 3 4
extern FILE *fopen64 (const char *__restrict __filename,
const char *__restrict __modes) ;
extern FILE *freopen64 (const char *__restrict __filename,
const char *__restrict __modes,
FILE *__restrict __stream) ;
extern FILE *fdopen (int __fd, const char *__modes) throw () ;
extern FILE *fopencookie (void *__restrict __magic_cookie,
const char *__restrict __modes,
cookie_io_functions_t __io_funcs) throw () ;
extern FILE *fmemopen (void *__s, size_t __len, const char *__modes)
throw () ;
extern FILE *open_memstream (char **__bufloc, size_t *__sizeloc) throw () ;
extern void setbuf (FILE *__restrict __stream, char *__restrict __buf) throw ();
extern int setvbuf (FILE *__restrict __stream, char *__restrict __buf,
int __modes, size_t __n) throw ();
extern void setbuffer (FILE *__restrict __stream, char *__restrict __buf,
size_t __size) throw ();
extern void setlinebuf (FILE *__stream) throw ();
extern int fprintf (FILE *__restrict __stream,
const char *__restrict __format, ...);
extern int printf (const char *__restrict __format, ...);
extern int sprintf (char *__restrict __s,
const char *__restrict __format, ...) throw ();
extern int vfprintf (FILE *__restrict __s, const char *__restrict __format,
__gnuc_va_list __arg);
extern int vprintf (const char *__restrict __format, __gnuc_va_list __arg);
extern int vsprintf (char *__restrict __s, const char *__restrict __format,
__gnuc_va_list __arg) throw ();
extern int snprintf (char *__restrict __s, size_t __maxlen,
const char *__restrict __format, ...)
throw () __attribute__ ((__format__ (__printf__, 3, 4)));
extern int vsnprintf (char *__restrict __s, size_t __maxlen,
const char *__restrict __format, __gnuc_va_list __arg)
throw () __attribute__ ((__format__ (__printf__, 3, 0)));
extern int vasprintf (char **__restrict __ptr, const char *__restrict __f,
__gnuc_va_list __arg)
throw () __attribute__ ((__format__ (__printf__, 2, 0))) ;
extern int __asprintf (char **__restrict __ptr,
const char *__restrict __fmt, ...)
throw () __attribute__ ((__format__ (__printf__, 2, 3))) ;
extern int asprintf (char **__restrict __ptr,
const char *__restrict __fmt, ...)
throw () __attribute__ ((__format__ (__printf__, 2, 3))) ;
extern int vdprintf (int __fd, const char *__restrict __fmt,
__gnuc_va_list __arg)
__attribute__ ((__format__ (__printf__, 2, 0)));
extern int dprintf (int __fd, const char *__restrict __fmt, ...)
__attribute__ ((__format__ (__printf__, 2, 3)));
extern int fscanf (FILE *__restrict __stream,
const char *__restrict __format, ...) ;
extern int scanf (const char *__restrict __format, ...) ;
extern int sscanf (const char *__restrict __s,
const char *__restrict __format, ...) throw ();
extern int fscanf (FILE *__restrict __stream, const char *__restrict __format, ...) __asm__ ("" "__isoc99_fscanf")
;
extern int scanf (const char *__restrict __format, ...) __asm__ ("" "__isoc99_scanf")
;
extern int sscanf (const char *__restrict __s, const char *__restrict __format, ...) throw () __asm__ ("" "__isoc99_sscanf")
;
# 432 "/usr/include/stdio.h" 3 4
extern int vfscanf (FILE *__restrict __s, const char *__restrict __format,
__gnuc_va_list __arg)
__attribute__ ((__format__ (__scanf__, 2, 0))) ;
extern int vscanf (const char *__restrict __format, __gnuc_va_list __arg)
__attribute__ ((__format__ (__scanf__, 1, 0))) ;
extern int vsscanf (const char *__restrict __s,
const char *__restrict __format, __gnuc_va_list __arg)
throw () __attribute__ ((__format__ (__scanf__, 2, 0)));
extern int vfscanf (FILE *__restrict __s, const char *__restrict __format, __gnuc_va_list __arg) __asm__ ("" "__isoc99_vfscanf")
__attribute__ ((__format__ (__scanf__, 2, 0))) ;
extern int vscanf (const char *__restrict __format, __gnuc_va_list __arg) __asm__ ("" "__isoc99_vscanf")
__attribute__ ((__format__ (__scanf__, 1, 0))) ;
extern int vsscanf (const char *__restrict __s, const char *__restrict __format, __gnuc_va_list __arg) throw () __asm__ ("" "__isoc99_vsscanf")
__attribute__ ((__format__ (__scanf__, 2, 0)));
# 485 "/usr/include/stdio.h" 3 4
extern int fgetc (FILE *__stream);
extern int getc (FILE *__stream);
extern int getchar (void);
extern int getc_unlocked (FILE *__stream);
extern int getchar_unlocked (void);
# 510 "/usr/include/stdio.h" 3 4
extern int fgetc_unlocked (FILE *__stream);
# 521 "/usr/include/stdio.h" 3 4
extern int fputc (int __c, FILE *__stream);
extern int putc (int __c, FILE *__stream);
extern int putchar (int __c);
# 537 "/usr/include/stdio.h" 3 4
extern int fputc_unlocked (int __c, FILE *__stream);
extern int putc_unlocked (int __c, FILE *__stream);
extern int putchar_unlocked (int __c);
extern int getw (FILE *__stream);
extern int putw (int __w, FILE *__stream);
extern char *fgets (char *__restrict __s, int __n, FILE *__restrict __stream)
;
# 587 "/usr/include/stdio.h" 3 4
extern char *fgets_unlocked (char *__restrict __s, int __n,
FILE *__restrict __stream) ;
# 603 "/usr/include/stdio.h" 3 4
extern __ssize_t __getdelim (char **__restrict __lineptr,
size_t *__restrict __n, int __delimiter,
FILE *__restrict __stream) ;
extern __ssize_t getdelim (char **__restrict __lineptr,
size_t *__restrict __n, int __delimiter,
FILE *__restrict __stream) ;
extern __ssize_t getline (char **__restrict __lineptr,
size_t *__restrict __n,
FILE *__restrict __stream) ;
extern int fputs (const char *__restrict __s, FILE *__restrict __stream);
extern int puts (const char *__s);
extern int ungetc (int __c, FILE *__stream);
extern size_t fread (void *__restrict __ptr, size_t __size,
size_t __n, FILE *__restrict __stream) ;
extern size_t fwrite (const void *__restrict __ptr, size_t __size,
size_t __n, FILE *__restrict __s);
# 662 "/usr/include/stdio.h" 3 4
extern int fputs_unlocked (const char *__restrict __s,
FILE *__restrict __stream);
# 673 "/usr/include/stdio.h" 3 4
extern size_t fread_unlocked (void *__restrict __ptr, size_t __size,
size_t __n, FILE *__restrict __stream) ;
extern size_t fwrite_unlocked (const void *__restrict __ptr, size_t __size,
size_t __n, FILE *__restrict __stream);
extern int fseek (FILE *__stream, long int __off, int __whence);
extern long int ftell (FILE *__stream) ;
extern void rewind (FILE *__stream);
# 707 "/usr/include/stdio.h" 3 4
extern int fseeko (FILE *__stream, __off_t __off, int __whence);
extern __off_t ftello (FILE *__stream) ;
# 731 "/usr/include/stdio.h" 3 4
extern int fgetpos (FILE *__restrict __stream, fpos_t *__restrict __pos);
extern int fsetpos (FILE *__stream, const fpos_t *__pos);
# 750 "/usr/include/stdio.h" 3 4
extern int fseeko64 (FILE *__stream, __off64_t __off, int __whence);
extern __off64_t ftello64 (FILE *__stream) ;
extern int fgetpos64 (FILE *__restrict __stream, fpos64_t *__restrict __pos);
extern int fsetpos64 (FILE *__stream, const fpos64_t *__pos);
extern void clearerr (FILE *__stream) throw ();
extern int feof (FILE *__stream) throw () ;
extern int ferror (FILE *__stream) throw () ;
extern void clearerr_unlocked (FILE *__stream) throw ();
extern int feof_unlocked (FILE *__stream) throw () ;
extern int ferror_unlocked (FILE *__stream) throw () ;
extern void perror (const char *__s);
# 1 "/usr/include/x86_64-linux-gnu/bits/sys_errlist.h" 1 3 4
# 26 "/usr/include/x86_64-linux-gnu/bits/sys_errlist.h" 3 4
extern int sys_nerr;
extern const char *const sys_errlist[];
extern int _sys_nerr;
extern const char *const _sys_errlist[];
# 782 "/usr/include/stdio.h" 2 3 4
extern int fileno (FILE *__stream) throw () ;
extern int fileno_unlocked (FILE *__stream) throw () ;
# 800 "/usr/include/stdio.h" 3 4
extern FILE *popen (const char *__command, const char *__modes) ;
extern int pclose (FILE *__stream);
extern char *ctermid (char *__s) throw ();
extern char *cuserid (char *__s);
struct obstack;
extern int obstack_printf (struct obstack *__restrict __obstack,
const char *__restrict __format, ...)
throw () __attribute__ ((__format__ (__printf__, 2, 3)));
extern int obstack_vprintf (struct obstack *__restrict __obstack,
const char *__restrict __format,
__gnuc_va_list __args)
throw () __attribute__ ((__format__ (__printf__, 2, 0)));
extern void flockfile (FILE *__stream) throw ();
extern int ftrylockfile (FILE *__stream) throw () ;
extern void funlockfile (FILE *__stream) throw ();
# 858 "/usr/include/stdio.h" 3 4
extern int __uflow (FILE *);
extern int __overflow (FILE *, int);
# 1 "/usr/include/x86_64-linux-gnu/bits/stdio.h" 1 3 4
# 38 "/usr/include/x86_64-linux-gnu/bits/stdio.h" 3 4
extern __inline __attribute__ ((__gnu_inline__)) int
vprintf (const char *__restrict __fmt, __gnuc_va_list __arg)
{
return vfprintf (stdout, __fmt, __arg);
}
extern __inline __attribute__ ((__gnu_inline__)) int
getchar (void)
{
return getc (stdin);
}
extern __inline __attribute__ ((__gnu_inline__)) int
fgetc_unlocked (FILE *__fp)
{
return (__builtin_expect (((__fp)->_IO_read_ptr >= (__fp)->_IO_read_end), 0) ? __uflow (__fp) : *(unsigned char *) (__fp)->_IO_read_ptr++);
}
extern __inline __attribute__ ((__gnu_inline__)) int
getc_unlocked (FILE *__fp)
{
return (__builtin_expect (((__fp)->_IO_read_ptr >= (__fp)->_IO_read_end), 0) ? __uflow (__fp) : *(unsigned char *) (__fp)->_IO_read_ptr++);
}
extern __inline __attribute__ ((__gnu_inline__)) int
getchar_unlocked (void)
{
return (__builtin_expect (((stdin)->_IO_read_ptr >= (stdin)->_IO_read_end), 0) ? __uflow (stdin) : *(unsigned char *) (stdin)->_IO_read_ptr++);
}
extern __inline __attribute__ ((__gnu_inline__)) int
putchar (int __c)
{
return putc (__c, stdout);
}
extern __inline __attribute__ ((__gnu_inline__)) int
fputc_unlocked (int __c, FILE *__stream)
{
return (__builtin_expect (((__stream)->_IO_write_ptr >= (__stream)->_IO_write_end), 0) ? __overflow (__stream, (unsigned char) (__c)) : (unsigned char) (*(__stream)->_IO_write_ptr++ = (__c)));
}
extern __inline __attribute__ ((__gnu_inline__)) int
putc_unlocked (int __c, FILE *__stream)
{
return (__builtin_expect (((__stream)->_IO_write_ptr >= (__stream)->_IO_write_end), 0) ? __overflow (__stream, (unsigned char) (__c)) : (unsigned char) (*(__stream)->_IO_write_ptr++ = (__c)));
}
extern __inline __attribute__ ((__gnu_inline__)) int
putchar_unlocked (int __c)
{
return (__builtin_expect (((stdout)->_IO_write_ptr >= (stdout)->_IO_write_end), 0) ? __overflow (stdout, (unsigned char) (__c)) : (unsigned char) (*(stdout)->_IO_write_ptr++ = (__c)));
}
extern __inline __attribute__ ((__gnu_inline__)) __ssize_t
getline (char **__lineptr, size_t *__n, FILE *__stream)
{
return __getdelim (__lineptr, __n, '\n', __stream);
}
extern __inline __attribute__ ((__gnu_inline__)) int
__attribute__ ((__leaf__)) feof_unlocked (FILE *__stream) throw ()
{
return (((__stream)->_flags & 0x0010) != 0);
}
extern __inline __attribute__ ((__gnu_inline__)) int
__attribute__ ((__leaf__)) ferror_unlocked (FILE *__stream) throw ()
{
return (((__stream)->_flags & 0x0020) != 0);
}
# 865 "/usr/include/stdio.h" 2 3 4
# 873 "/usr/include/stdio.h" 3 4
}
# 47 "/home/giulianob/gcc_git_gnu/gcc/gcc/system.h" 2
# 103 "/home/giulianob/gcc_git_gnu/gcc/gcc/system.h"
# 103 "/home/giulianob/gcc_git_gnu/gcc/gcc/system.h"
extern "C" {
# 187 "/home/giulianob/gcc_git_gnu/gcc/gcc/system.h"
}
# 209 "/home/giulianob/gcc_git_gnu/gcc/gcc/system.h"
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/../include/safe-ctype.h" 1
# 57 "/home/giulianob/gcc_git_gnu/gcc/gcc/../include/safe-ctype.h"
enum {
_sch_isblank = 0x0001,
_sch_iscntrl = 0x0002,
_sch_isdigit = 0x0004,
_sch_islower = 0x0008,
_sch_isprint = 0x0010,
_sch_ispunct = 0x0020,
_sch_isspace = 0x0040,
_sch_isupper = 0x0080,
_sch_isxdigit = 0x0100,
_sch_isidst = 0x0200,
_sch_isvsp = 0x0400,
_sch_isnvsp = 0x0800,
_sch_isalpha = _sch_isupper|_sch_islower,
_sch_isalnum = _sch_isalpha|_sch_isdigit,
_sch_isidnum = _sch_isidst|_sch_isdigit,
_sch_isgraph = _sch_isalnum|_sch_ispunct,
_sch_iscppsp = _sch_isvsp|_sch_isnvsp,
_sch_isbasic = _sch_isprint|_sch_iscppsp
};
extern const unsigned short _sch_istable[256];
# 110 "/home/giulianob/gcc_git_gnu/gcc/gcc/../include/safe-ctype.h"
extern const unsigned char _sch_toupper[256];
extern const unsigned char _sch_tolower[256];
# 122 "/home/giulianob/gcc_git_gnu/gcc/gcc/../include/safe-ctype.h"
# 1 "/usr/include/ctype.h" 1 3 4
# 28 "/usr/include/ctype.h" 3 4
# 28 "/usr/include/ctype.h" 3 4
extern "C" {
# 39 "/usr/include/ctype.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/endian.h" 1 3 4
# 35 "/usr/include/x86_64-linux-gnu/bits/endian.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/endianness.h" 1 3 4
# 36 "/usr/include/x86_64-linux-gnu/bits/endian.h" 2 3 4
# 40 "/usr/include/ctype.h" 2 3 4
enum
{
_ISupper = ((0) < 8 ? ((1 << (0)) << 8) : ((1 << (0)) >> 8)),
_ISlower = ((1) < 8 ? ((1 << (1)) << 8) : ((1 << (1)) >> 8)),
_ISalpha = ((2) < 8 ? ((1 << (2)) << 8) : ((1 << (2)) >> 8)),
_ISdigit = ((3) < 8 ? ((1 << (3)) << 8) : ((1 << (3)) >> 8)),
_ISxdigit = ((4) < 8 ? ((1 << (4)) << 8) : ((1 << (4)) >> 8)),
_ISspace = ((5) < 8 ? ((1 << (5)) << 8) : ((1 << (5)) >> 8)),
_ISprint = ((6) < 8 ? ((1 << (6)) << 8) : ((1 << (6)) >> 8)),
_ISgraph = ((7) < 8 ? ((1 << (7)) << 8) : ((1 << (7)) >> 8)),
_ISblank = ((8) < 8 ? ((1 << (8)) << 8) : ((1 << (8)) >> 8)),
_IScntrl = ((9) < 8 ? ((1 << (9)) << 8) : ((1 << (9)) >> 8)),
_ISpunct = ((10) < 8 ? ((1 << (10)) << 8) : ((1 << (10)) >> 8)),
_ISalnum = ((11) < 8 ? ((1 << (11)) << 8) : ((1 << (11)) >> 8))
};
# 79 "/usr/include/ctype.h" 3 4
extern const unsigned short int **__ctype_b_loc (void)
throw () __attribute__ ((__const__));
extern const __int32_t **__ctype_tolower_loc (void)
throw () __attribute__ ((__const__));
extern const __int32_t **__ctype_toupper_loc (void)
throw () __attribute__ ((__const__));
# 108 "/usr/include/ctype.h" 3 4
extern int isalnum (int) throw ();
extern int isalpha (int) throw ();
extern int iscntrl (int) throw ();
extern int isdigit (int) throw ();
extern int islower (int) throw ();
extern int isgraph (int) throw ();
extern int isprint (int) throw ();
extern int ispunct (int) throw ();
extern int isspace (int) throw ();
extern int isupper (int) throw ();
extern int isxdigit (int) throw ();
extern int tolower (int __c) throw ();
extern int toupper (int __c) throw ();
extern int isblank (int) throw ();
extern int isctype (int __c, int __mask) throw ();
extern int isascii (int __c) throw ();
extern int toascii (int __c) throw ();
extern int _toupper (int) throw ();
extern int _tolower (int) throw ();
# 174 "/usr/include/ctype.h" 3 4
extern __inline __attribute__ ((__gnu_inline__)) int isalnum (int __c) throw () { return (*__ctype_b_loc ())[(int) (__c)] & (unsigned short int) _ISalnum; }
extern __inline __attribute__ ((__gnu_inline__)) int isalpha (int __c) throw () { return (*__ctype_b_loc ())[(int) (__c)] & (unsigned short int) _ISalpha; }
extern __inline __attribute__ ((__gnu_inline__)) int iscntrl (int __c) throw () { return (*__ctype_b_loc ())[(int) (__c)] & (unsigned short int) _IScntrl; }
extern __inline __attribute__ ((__gnu_inline__)) int isdigit (int __c) throw () { return (*__ctype_b_loc ())[(int) (__c)] & (unsigned short int) _ISdigit; }
extern __inline __attribute__ ((__gnu_inline__)) int islower (int __c) throw () { return (*__ctype_b_loc ())[(int) (__c)] & (unsigned short int) _ISlower; }
extern __inline __attribute__ ((__gnu_inline__)) int isgraph (int __c) throw () { return (*__ctype_b_loc ())[(int) (__c)] & (unsigned short int) _ISgraph; }
extern __inline __attribute__ ((__gnu_inline__)) int isprint (int __c) throw () { return (*__ctype_b_loc ())[(int) (__c)] & (unsigned short int) _ISprint; }
extern __inline __attribute__ ((__gnu_inline__)) int ispunct (int __c) throw () { return (*__ctype_b_loc ())[(int) (__c)] & (unsigned short int) _ISpunct; }
extern __inline __attribute__ ((__gnu_inline__)) int isspace (int __c) throw () { return (*__ctype_b_loc ())[(int) (__c)] & (unsigned short int) _ISspace; }
extern __inline __attribute__ ((__gnu_inline__)) int isupper (int __c) throw () { return (*__ctype_b_loc ())[(int) (__c)] & (unsigned short int) _ISupper; }
extern __inline __attribute__ ((__gnu_inline__)) int isxdigit (int __c) throw () { return (*__ctype_b_loc ())[(int) (__c)] & (unsigned short int) _ISxdigit; }
extern __inline __attribute__ ((__gnu_inline__)) int isblank (int __c) throw () { return (*__ctype_b_loc ())[(int) (__c)] & (unsigned short int) _ISblank; }
# 206 "/usr/include/ctype.h" 3 4
extern __inline __attribute__ ((__gnu_inline__)) int
__attribute__ ((__leaf__)) tolower (int __c) throw ()
{
return __c >= -128 && __c < 256 ? (*__ctype_tolower_loc ())[__c] : __c;
}
extern __inline __attribute__ ((__gnu_inline__)) int
__attribute__ ((__leaf__)) toupper (int __c) throw ()
{
return __c >= -128 && __c < 256 ? (*__ctype_toupper_loc ())[__c] : __c;
}
# 237 "/usr/include/ctype.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/types/locale_t.h" 1 3 4
# 22 "/usr/include/x86_64-linux-gnu/bits/types/locale_t.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/types/__locale_t.h" 1 3 4
# 28 "/usr/include/x86_64-linux-gnu/bits/types/__locale_t.h" 3 4
struct __locale_struct
{
struct __locale_data *__locales[13];
const unsigned short int *__ctype_b;
const int *__ctype_tolower;
const int *__ctype_toupper;
const char *__names[13];
};
typedef struct __locale_struct *__locale_t;
# 23 "/usr/include/x86_64-linux-gnu/bits/types/locale_t.h" 2 3 4
typedef __locale_t locale_t;
# 238 "/usr/include/ctype.h" 2 3 4
# 251 "/usr/include/ctype.h" 3 4
extern int isalnum_l (int, locale_t) throw ();
extern int isalpha_l (int, locale_t) throw ();
extern int iscntrl_l (int, locale_t) throw ();
extern int isdigit_l (int, locale_t) throw ();
extern int islower_l (int, locale_t) throw ();
extern int isgraph_l (int, locale_t) throw ();
extern int isprint_l (int, locale_t) throw ();
extern int ispunct_l (int, locale_t) throw ();
extern int isspace_l (int, locale_t) throw ();
extern int isupper_l (int, locale_t) throw ();
extern int isxdigit_l (int, locale_t) throw ();
extern int isblank_l (int, locale_t) throw ();
extern int __tolower_l (int __c, locale_t __l) throw ();
extern int tolower_l (int __c, locale_t __l) throw ();
extern int __toupper_l (int __c, locale_t __l) throw ();
extern int toupper_l (int __c, locale_t __l) throw ();
# 327 "/usr/include/ctype.h" 3 4
}
# 123 "/home/giulianob/gcc_git_gnu/gcc/gcc/../include/safe-ctype.h" 2
# 210 "/home/giulianob/gcc_git_gnu/gcc/gcc/system.h" 2
# 1 "/usr/include/x86_64-linux-gnu/sys/types.h" 1 3 4
# 27 "/usr/include/x86_64-linux-gnu/sys/types.h" 3 4
extern "C" {
typedef __u_char u_char;
typedef __u_short u_short;
typedef __u_int u_int;
typedef __u_long u_long;
typedef __quad_t quad_t;
typedef __u_quad_t u_quad_t;
typedef __fsid_t fsid_t;
typedef __loff_t loff_t;
typedef __ino_t ino_t;
typedef __ino64_t ino64_t;
typedef __dev_t dev_t;
typedef __gid_t gid_t;
typedef __mode_t mode_t;
typedef __nlink_t nlink_t;
typedef __uid_t uid_t;
# 97 "/usr/include/x86_64-linux-gnu/sys/types.h" 3 4
typedef __pid_t pid_t;
typedef __id_t id_t;
# 114 "/usr/include/x86_64-linux-gnu/sys/types.h" 3 4
typedef __daddr_t daddr_t;
typedef __caddr_t caddr_t;
typedef __key_t key_t;
# 1 "/usr/include/x86_64-linux-gnu/bits/types/clock_t.h" 1 3 4
typedef __clock_t clock_t;
# 127 "/usr/include/x86_64-linux-gnu/sys/types.h" 2 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/types/clockid_t.h" 1 3 4
typedef __clockid_t clockid_t;
# 129 "/usr/include/x86_64-linux-gnu/sys/types.h" 2 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/types/time_t.h" 1 3 4
typedef __time_t time_t;
# 130 "/usr/include/x86_64-linux-gnu/sys/types.h" 2 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/types/timer_t.h" 1 3 4
typedef __timer_t timer_t;
# 131 "/usr/include/x86_64-linux-gnu/sys/types.h" 2 3 4
typedef __useconds_t useconds_t;
typedef __suseconds_t suseconds_t;
# 1 "/usr/lib/gcc/x86_64-linux-gnu/10/include/stddef.h" 1 3 4
# 145 "/usr/include/x86_64-linux-gnu/sys/types.h" 2 3 4
typedef unsigned long int ulong;
typedef unsigned short int ushort;
typedef unsigned int uint;
# 1 "/usr/include/x86_64-linux-gnu/bits/stdint-intn.h" 1 3 4
# 24 "/usr/include/x86_64-linux-gnu/bits/stdint-intn.h" 3 4
typedef __int8_t int8_t;
typedef __int16_t int16_t;
typedef __int32_t int32_t;
typedef __int64_t int64_t;
# 156 "/usr/include/x86_64-linux-gnu/sys/types.h" 2 3 4
typedef __uint8_t u_int8_t;
typedef __uint16_t u_int16_t;
typedef __uint32_t u_int32_t;
typedef __uint64_t u_int64_t;
typedef int register_t __attribute__ ((__mode__ (__word__)));
# 176 "/usr/include/x86_64-linux-gnu/sys/types.h" 3 4
# 1 "/usr/include/endian.h" 1 3 4
# 35 "/usr/include/endian.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/byteswap.h" 1 3 4
# 33 "/usr/include/x86_64-linux-gnu/bits/byteswap.h" 3 4
static __inline __uint16_t
__bswap_16 (__uint16_t __bsx)
{
return __builtin_bswap16 (__bsx);
}
static __inline __uint32_t
__bswap_32 (__uint32_t __bsx)
{
return __builtin_bswap32 (__bsx);
}
# 69 "/usr/include/x86_64-linux-gnu/bits/byteswap.h" 3 4
__extension__ static __inline __uint64_t
__bswap_64 (__uint64_t __bsx)
{
return __builtin_bswap64 (__bsx);
}
# 36 "/usr/include/endian.h" 2 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/uintn-identity.h" 1 3 4
# 32 "/usr/include/x86_64-linux-gnu/bits/uintn-identity.h" 3 4
static __inline __uint16_t
__uint16_identity (__uint16_t __x)
{
return __x;
}
static __inline __uint32_t
__uint32_identity (__uint32_t __x)
{
return __x;
}
static __inline __uint64_t
__uint64_identity (__uint64_t __x)
{
return __x;
}
# 37 "/usr/include/endian.h" 2 3 4
# 177 "/usr/include/x86_64-linux-gnu/sys/types.h" 2 3 4
# 1 "/usr/include/x86_64-linux-gnu/sys/select.h" 1 3 4
# 30 "/usr/include/x86_64-linux-gnu/sys/select.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/select.h" 1 3 4
# 22 "/usr/include/x86_64-linux-gnu/bits/select.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/wordsize.h" 1 3 4
# 23 "/usr/include/x86_64-linux-gnu/bits/select.h" 2 3 4
# 31 "/usr/include/x86_64-linux-gnu/sys/select.h" 2 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/types/sigset_t.h" 1 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/types/__sigset_t.h" 1 3 4
typedef struct
{
unsigned long int __val[(1024 / (8 * sizeof (unsigned long int)))];
} __sigset_t;
# 5 "/usr/include/x86_64-linux-gnu/bits/types/sigset_t.h" 2 3 4
typedef __sigset_t sigset_t;
# 34 "/usr/include/x86_64-linux-gnu/sys/select.h" 2 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h" 1 3 4
struct timeval
{
__time_t tv_sec;
__suseconds_t tv_usec;
};
# 38 "/usr/include/x86_64-linux-gnu/sys/select.h" 2 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h" 1 3 4
# 10 "/usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h" 3 4
struct timespec
{
__time_t tv_sec;
__syscall_slong_t tv_nsec;
# 26 "/usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h" 3 4
};
# 40 "/usr/include/x86_64-linux-gnu/sys/select.h" 2 3 4
# 49 "/usr/include/x86_64-linux-gnu/sys/select.h" 3 4
typedef long int __fd_mask;
# 59 "/usr/include/x86_64-linux-gnu/sys/select.h" 3 4
typedef struct
{
__fd_mask fds_bits[1024 / (8 * (int) sizeof (__fd_mask))];
} fd_set;
typedef __fd_mask fd_mask;
# 91 "/usr/include/x86_64-linux-gnu/sys/select.h" 3 4
extern "C" {
# 101 "/usr/include/x86_64-linux-gnu/sys/select.h" 3 4
extern int select (int __nfds, fd_set *__restrict __readfds,
fd_set *__restrict __writefds,
fd_set *__restrict __exceptfds,
struct timeval *__restrict __timeout);
# 113 "/usr/include/x86_64-linux-gnu/sys/select.h" 3 4
extern int pselect (int __nfds, fd_set *__restrict __readfds,
fd_set *__restrict __writefds,
fd_set *__restrict __exceptfds,
const struct timespec *__restrict __timeout,
const __sigset_t *__restrict __sigmask);
# 126 "/usr/include/x86_64-linux-gnu/sys/select.h" 3 4
}
# 180 "/usr/include/x86_64-linux-gnu/sys/types.h" 2 3 4
typedef __blksize_t blksize_t;
typedef __blkcnt_t blkcnt_t;
typedef __fsblkcnt_t fsblkcnt_t;
typedef __fsfilcnt_t fsfilcnt_t;
# 219 "/usr/include/x86_64-linux-gnu/sys/types.h" 3 4
typedef __blkcnt64_t blkcnt64_t;
typedef __fsblkcnt64_t fsblkcnt64_t;
typedef __fsfilcnt64_t fsfilcnt64_t;
# 1 "/usr/include/x86_64-linux-gnu/bits/pthreadtypes.h" 1 3 4
# 23 "/usr/include/x86_64-linux-gnu/bits/pthreadtypes.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/thread-shared-types.h" 1 3 4
# 44 "/usr/include/x86_64-linux-gnu/bits/thread-shared-types.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h" 1 3 4
# 21 "/usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/wordsize.h" 1 3 4
# 22 "/usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h" 2 3 4
# 45 "/usr/include/x86_64-linux-gnu/bits/thread-shared-types.h" 2 3 4
typedef struct __pthread_internal_list
{
struct __pthread_internal_list *__prev;
struct __pthread_internal_list *__next;
} __pthread_list_t;
typedef struct __pthread_internal_slist
{
struct __pthread_internal_slist *__next;
} __pthread_slist_t;
# 74 "/usr/include/x86_64-linux-gnu/bits/thread-shared-types.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/struct_mutex.h" 1 3 4
# 22 "/usr/include/x86_64-linux-gnu/bits/struct_mutex.h" 3 4
struct __pthread_mutex_s
{
int __lock;
unsigned int __count;
int __owner;
unsigned int __nusers;
int __kind;
short __spins;
short __elision;
__pthread_list_t __list;
# 53 "/usr/include/x86_64-linux-gnu/bits/struct_mutex.h" 3 4
};
# 75 "/usr/include/x86_64-linux-gnu/bits/thread-shared-types.h" 2 3 4
# 87 "/usr/include/x86_64-linux-gnu/bits/thread-shared-types.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/struct_rwlock.h" 1 3 4
# 23 "/usr/include/x86_64-linux-gnu/bits/struct_rwlock.h" 3 4
struct __pthread_rwlock_arch_t
{
unsigned int __readers;
unsigned int __writers;
unsigned int __wrphase_futex;
unsigned int __writers_futex;
unsigned int __pad3;
unsigned int __pad4;
int __cur_writer;
int __shared;
signed char __rwelision;
unsigned char __pad1[7];
unsigned long int __pad2;
unsigned int __flags;
# 55 "/usr/include/x86_64-linux-gnu/bits/struct_rwlock.h" 3 4
};
# 88 "/usr/include/x86_64-linux-gnu/bits/thread-shared-types.h" 2 3 4
struct __pthread_cond_s
{
__extension__ union
{
__extension__ unsigned long long int __wseq;
struct
{
unsigned int __low;
unsigned int __high;
} __wseq32;
};
__extension__ union
{
__extension__ unsigned long long int __g1_start;
struct
{
unsigned int __low;
unsigned int __high;
} __g1_start32;
};
unsigned int __g_refs[2] ;
unsigned int __g_size[2];
unsigned int __g1_orig_size;
unsigned int __wrefs;
unsigned int __g_signals[2];
};
# 24 "/usr/include/x86_64-linux-gnu/bits/pthreadtypes.h" 2 3 4
typedef unsigned long int pthread_t;
typedef union
{
char __size[4];
int __align;
} pthread_mutexattr_t;
typedef union
{
char __size[4];
int __align;
} pthread_condattr_t;
typedef unsigned int pthread_key_t;
typedef int pthread_once_t;
union pthread_attr_t
{
char __size[56];
long int __align;
};
typedef union pthread_attr_t pthread_attr_t;
typedef union
{
struct __pthread_mutex_s __data;
char __size[40];
long int __align;
} pthread_mutex_t;
typedef union
{
struct __pthread_cond_s __data;
char __size[48];
__extension__ long long int __align;
} pthread_cond_t;
typedef union
{
struct __pthread_rwlock_arch_t __data;
char __size[56];
long int __align;
} pthread_rwlock_t;
typedef union
{
char __size[8];
long int __align;
} pthread_rwlockattr_t;
typedef volatile int pthread_spinlock_t;
typedef union
{
char __size[32];
long int __align;
} pthread_barrier_t;
typedef union
{
char __size[4];
int __align;
} pthread_barrierattr_t;
# 228 "/usr/include/x86_64-linux-gnu/sys/types.h" 2 3 4
}
# 212 "/home/giulianob/gcc_git_gnu/gcc/gcc/system.h" 2
# 1 "/usr/include/errno.h" 1 3 4
# 28 "/usr/include/errno.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/errno.h" 1 3 4
# 26 "/usr/include/x86_64-linux-gnu/bits/errno.h" 3 4
# 1 "/usr/include/linux/errno.h" 1 3 4
# 1 "/usr/include/x86_64-linux-gnu/asm/errno.h" 1 3 4
# 1 "/usr/include/asm-generic/errno.h" 1 3 4
# 1 "/usr/include/asm-generic/errno-base.h" 1 3 4
# 6 "/usr/include/asm-generic/errno.h" 2 3 4
# 2 "/usr/include/x86_64-linux-gnu/asm/errno.h" 2 3 4
# 2 "/usr/include/linux/errno.h" 2 3 4
# 27 "/usr/include/x86_64-linux-gnu/bits/errno.h" 2 3 4
# 29 "/usr/include/errno.h" 2 3 4
extern "C" {
extern int *__errno_location (void) throw () __attribute__ ((__const__));
extern char *program_invocation_name;
extern char *program_invocation_short_name;
# 1 "/usr/include/x86_64-linux-gnu/bits/types/error_t.h" 1 3 4
# 22 "/usr/include/x86_64-linux-gnu/bits/types/error_t.h" 3 4
typedef int error_t;
# 49 "/usr/include/errno.h" 2 3 4
}
# 214 "/home/giulianob/gcc_git_gnu/gcc/gcc/system.h" 2
# 235 "/home/giulianob/gcc_git_gnu/gcc/gcc/system.h"
# 1 "/usr/include/c++/10/cstring" 1 3
# 39 "/usr/include/c++/10/cstring" 3
# 40 "/usr/include/c++/10/cstring" 3
# 1 "/usr/include/x86_64-linux-gnu/c++/10/bits/c++config.h" 1 3
# 262 "/usr/include/x86_64-linux-gnu/c++/10/bits/c++config.h" 3
namespace std
{
typedef long unsigned int size_t;
typedef long int ptrdiff_t;
typedef decltype(nullptr) nullptr_t;
}
# 284 "/usr/include/x86_64-linux-gnu/c++/10/bits/c++config.h" 3
namespace std
{
inline namespace __cxx11 __attribute__((__abi_tag__ ("cxx11"))) { }
}
namespace __gnu_cxx
{
inline namespace __cxx11 __attribute__((__abi_tag__ ("cxx11"))) { }
}
# 522 "/usr/include/x86_64-linux-gnu/c++/10/bits/c++config.h" 3
# 1 "/usr/include/x86_64-linux-gnu/c++/10/bits/os_defines.h" 1 3
# 523 "/usr/include/x86_64-linux-gnu/c++/10/bits/c++config.h" 2 3
# 1 "/usr/include/x86_64-linux-gnu/c++/10/bits/cpu_defines.h" 1 3
# 526 "/usr/include/x86_64-linux-gnu/c++/10/bits/c++config.h" 2 3
# 42 "/usr/include/c++/10/cstring" 2 3
# 1 "/usr/include/string.h" 1 3 4
# 26 "/usr/include/string.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/libc-header-start.h" 1 3 4
# 27 "/usr/include/string.h" 2 3 4
extern "C" {
# 1 "/usr/lib/gcc/x86_64-linux-gnu/10/include/stddef.h" 1 3 4
# 34 "/usr/include/string.h" 2 3 4
# 43 "/usr/include/string.h" 3 4
extern void *memcpy (void *__restrict __dest, const void *__restrict __src,
size_t __n) throw () __attribute__ ((__nonnull__ (1, 2)));
extern void *memmove (void *__dest, const void *__src, size_t __n)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern void *memccpy (void *__restrict __dest, const void *__restrict __src,
int __c, size_t __n)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern void *memset (void *__s, int __c, size_t __n) throw () __attribute__ ((__nonnull__ (1)));
extern int memcmp (const void *__s1, const void *__s2, size_t __n)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
extern "C++"
{
extern void *memchr (void *__s, int __c, size_t __n)
throw () __asm ("memchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
extern const void *memchr (const void *__s, int __c, size_t __n)
throw () __asm ("memchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) void *
memchr (void *__s, int __c, size_t __n) throw ()
{
return __builtin_memchr (__s, __c, __n);
}
extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) const void *
memchr (const void *__s, int __c, size_t __n) throw ()
{
return __builtin_memchr (__s, __c, __n);
}
}
# 99 "/usr/include/string.h" 3 4
extern "C++" void *rawmemchr (void *__s, int __c)
throw () __asm ("rawmemchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
extern "C++" const void *rawmemchr (const void *__s, int __c)
throw () __asm ("rawmemchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
extern "C++" void *memrchr (void *__s, int __c, size_t __n)
throw () __asm ("memrchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
extern "C++" const void *memrchr (const void *__s, int __c, size_t __n)
throw () __asm ("memrchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
# 122 "/usr/include/string.h" 3 4
extern char *strcpy (char *__restrict __dest, const char *__restrict __src)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern char *strncpy (char *__restrict __dest,
const char *__restrict __src, size_t __n)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern char *strcat (char *__restrict __dest, const char *__restrict __src)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern char *strncat (char *__restrict __dest, const char *__restrict __src,
size_t __n) throw () __attribute__ ((__nonnull__ (1, 2)));
extern int strcmp (const char *__s1, const char *__s2)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
extern int strncmp (const char *__s1, const char *__s2, size_t __n)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
extern int strcoll (const char *__s1, const char *__s2)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
extern size_t strxfrm (char *__restrict __dest,
const char *__restrict __src, size_t __n)
throw () __attribute__ ((__nonnull__ (2)));
extern int strcoll_l (const char *__s1, const char *__s2, locale_t __l)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2, 3)));
extern size_t strxfrm_l (char *__dest, const char *__src, size_t __n,
locale_t __l) throw () __attribute__ ((__nonnull__ (2, 4)));
extern char *strdup (const char *__s)
throw () __attribute__ ((__malloc__)) __attribute__ ((__nonnull__ (1)));
extern char *strndup (const char *__string, size_t __n)
throw () __attribute__ ((__malloc__)) __attribute__ ((__nonnull__ (1)));
# 204 "/usr/include/string.h" 3 4
extern "C++"
{
extern char *strchr (char *__s, int __c)
throw () __asm ("strchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
extern const char *strchr (const char *__s, int __c)
throw () __asm ("strchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) char *
strchr (char *__s, int __c) throw ()
{
return __builtin_strchr (__s, __c);
}
extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) const char *
strchr (const char *__s, int __c) throw ()
{
return __builtin_strchr (__s, __c);
}
}
extern "C++"
{
extern char *strrchr (char *__s, int __c)
throw () __asm ("strrchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
extern const char *strrchr (const char *__s, int __c)
throw () __asm ("strrchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) char *
strrchr (char *__s, int __c) throw ()
{
return __builtin_strrchr (__s, __c);
}
extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) const char *
strrchr (const char *__s, int __c) throw ()
{
return __builtin_strrchr (__s, __c);
}
}
# 261 "/usr/include/string.h" 3 4
extern "C++" char *strchrnul (char *__s, int __c)
throw () __asm ("strchrnul") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
extern "C++" const char *strchrnul (const char *__s, int __c)
throw () __asm ("strchrnul") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
# 273 "/usr/include/string.h" 3 4
extern size_t strcspn (const char *__s, const char *__reject)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
extern size_t strspn (const char *__s, const char *__accept)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
extern "C++"
{
extern char *strpbrk (char *__s, const char *__accept)
throw () __asm ("strpbrk") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
extern const char *strpbrk (const char *__s, const char *__accept)
throw () __asm ("strpbrk") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) char *
strpbrk (char *__s, const char *__accept) throw ()
{
return __builtin_strpbrk (__s, __accept);
}
extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) const char *
strpbrk (const char *__s, const char *__accept) throw ()
{
return __builtin_strpbrk (__s, __accept);
}
}
extern "C++"
{
extern char *strstr (char *__haystack, const char *__needle)
throw () __asm ("strstr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
extern const char *strstr (const char *__haystack, const char *__needle)
throw () __asm ("strstr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) char *
strstr (char *__haystack, const char *__needle) throw ()
{
return __builtin_strstr (__haystack, __needle);
}
extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) const char *
strstr (const char *__haystack, const char *__needle) throw ()
{
return __builtin_strstr (__haystack, __needle);
}
}
extern char *strtok (char *__restrict __s, const char *__restrict __delim)
throw () __attribute__ ((__nonnull__ (2)));
extern char *__strtok_r (char *__restrict __s,
const char *__restrict __delim,
char **__restrict __save_ptr)
throw () __attribute__ ((__nonnull__ (2, 3)));
extern char *strtok_r (char *__restrict __s, const char *__restrict __delim,
char **__restrict __save_ptr)
throw () __attribute__ ((__nonnull__ (2, 3)));
extern "C++" char *strcasestr (char *__haystack, const char *__needle)
throw () __asm ("strcasestr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
extern "C++" const char *strcasestr (const char *__haystack,
const char *__needle)
throw () __asm ("strcasestr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
# 369 "/usr/include/string.h" 3 4
extern void *memmem (const void *__haystack, size_t __haystacklen,
const void *__needle, size_t __needlelen)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 3)));
extern void *__mempcpy (void *__restrict __dest,
const void *__restrict __src, size_t __n)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern void *mempcpy (void *__restrict __dest,
const void *__restrict __src, size_t __n)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern size_t strlen (const char *__s)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
extern size_t strnlen (const char *__string, size_t __maxlen)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
extern char *strerror (int __errnum) throw ();
# 421 "/usr/include/string.h" 3 4
extern char *strerror_r (int __errnum, char *__buf, size_t __buflen)
throw () __attribute__ ((__nonnull__ (2))) ;
extern char *strerror_l (int __errnum, locale_t __l) throw ();
# 1 "/usr/include/strings.h" 1 3 4
# 23 "/usr/include/strings.h" 3 4
# 1 "/usr/lib/gcc/x86_64-linux-gnu/10/include/stddef.h" 1 3 4
# 24 "/usr/include/strings.h" 2 3 4
extern "C" {
extern int bcmp (const void *__s1, const void *__s2, size_t __n)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
extern void bcopy (const void *__src, void *__dest, size_t __n)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern void bzero (void *__s, size_t __n) throw () __attribute__ ((__nonnull__ (1)));
extern "C++"
{
extern char *index (char *__s, int __c)
throw () __asm ("index") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
extern const char *index (const char *__s, int __c)
throw () __asm ("index") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) char *
index (char *__s, int __c) throw ()
{
return __builtin_index (__s, __c);
}
extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) const char *
index (const char *__s, int __c) throw ()
{
return __builtin_index (__s, __c);
}
}
extern "C++"
{
extern char *rindex (char *__s, int __c)
throw () __asm ("rindex") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
extern const char *rindex (const char *__s, int __c)
throw () __asm ("rindex") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) char *
rindex (char *__s, int __c) throw ()
{
return __builtin_rindex (__s, __c);
}
extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) const char *
rindex (const char *__s, int __c) throw ()
{
return __builtin_rindex (__s, __c);
}
}
# 104 "/usr/include/strings.h" 3 4
extern int ffs (int __i) throw () __attribute__ ((__const__));
extern int ffsl (long int __l) throw () __attribute__ ((__const__));
__extension__ extern int ffsll (long long int __ll)
throw () __attribute__ ((__const__));
extern int strcasecmp (const char *__s1, const char *__s2)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
extern int strncasecmp (const char *__s1, const char *__s2, size_t __n)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
extern int strcasecmp_l (const char *__s1, const char *__s2, locale_t __loc)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2, 3)));
extern int strncasecmp_l (const char *__s1, const char *__s2,
size_t __n, locale_t __loc)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2, 4)));
}
# 433 "/usr/include/string.h" 2 3 4
extern void explicit_bzero (void *__s, size_t __n) throw () __attribute__ ((__nonnull__ (1)));
extern char *strsep (char **__restrict __stringp,
const char *__restrict __delim)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern char *strsignal (int __sig) throw ();
extern char *__stpcpy (char *__restrict __dest, const char *__restrict __src)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern char *stpcpy (char *__restrict __dest, const char *__restrict __src)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern char *__stpncpy (char *__restrict __dest,
const char *__restrict __src, size_t __n)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern char *stpncpy (char *__restrict __dest,
const char *__restrict __src, size_t __n)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern int strverscmp (const char *__s1, const char *__s2)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
extern char *strfry (char *__string) throw () __attribute__ ((__nonnull__ (1)));
extern void *memfrob (void *__s, size_t __n) throw () __attribute__ ((__nonnull__ (1)));
extern "C++" char *basename (char *__filename)
throw () __asm ("basename") __attribute__ ((__nonnull__ (1)));
extern "C++" const char *basename (const char *__filename)
throw () __asm ("basename") __attribute__ ((__nonnull__ (1)));
# 499 "/usr/include/string.h" 3 4
}
# 43 "/usr/include/c++/10/cstring" 2 3
# 71 "/usr/include/c++/10/cstring" 3
extern "C++"
{
namespace std __attribute__ ((__visibility__ ("default")))
{
using ::memchr;
using ::memcmp;
using ::memcpy;
using ::memmove;
using ::memset;
using ::strcat;
using ::strcmp;
using ::strcoll;
using ::strcpy;
using ::strcspn;
using ::strerror;
using ::strlen;
using ::strncat;
using ::strncmp;
using ::strncpy;
using ::strspn;
using ::strtok;
using ::strxfrm;
using ::strchr;
using ::strpbrk;
using ::strrchr;
using ::strstr;
# 122 "/usr/include/c++/10/cstring" 3
}
}
# 236 "/home/giulianob/gcc_git_gnu/gcc/gcc/system.h" 2
# 1 "/usr/include/c++/10/new" 1 3
# 38 "/usr/include/c++/10/new" 3
# 39 "/usr/include/c++/10/new" 3
# 1 "/usr/include/c++/10/exception" 1 3
# 33 "/usr/include/c++/10/exception" 3
# 34 "/usr/include/c++/10/exception" 3
#pragma GCC visibility push(default)
# 1 "/usr/include/c++/10/bits/exception.h" 1 3
# 34 "/usr/include/c++/10/bits/exception.h" 3
# 35 "/usr/include/c++/10/bits/exception.h" 3
#pragma GCC visibility push(default)
extern "C++" {
namespace std
{
# 60 "/usr/include/c++/10/bits/exception.h" 3
class exception
{
public:
exception() noexcept { }
virtual ~exception() noexcept;
exception(const exception&) = default;
exception& operator=(const exception&) = default;
exception(exception&&) = default;
exception& operator=(exception&&) = default;
virtual const char*
what() const noexcept;
};
}
}
#pragma GCC visibility pop
# 39 "/usr/include/c++/10/exception" 2 3
extern "C++" {
namespace std
{
class bad_exception : public exception
{
public:
bad_exception() noexcept { }
virtual ~bad_exception() noexcept;
virtual const char*
what() const noexcept;
};
typedef void (*terminate_handler) ();
typedef void (*unexpected_handler) ();
terminate_handler set_terminate(terminate_handler) noexcept;
terminate_handler get_terminate() noexcept;
void terminate() noexcept __attribute__ ((__noreturn__));
unexpected_handler set_unexpected(unexpected_handler) noexcept;
unexpected_handler get_unexpected() noexcept;
void unexpected() __attribute__ ((__noreturn__));
# 105 "/usr/include/c++/10/exception" 3
bool uncaught_exception() noexcept __attribute__ ((__pure__));
int uncaught_exceptions() noexcept __attribute__ ((__pure__));
}
namespace __gnu_cxx
{
# 137 "/usr/include/c++/10/exception" 3
void __verbose_terminate_handler();
}
}
#pragma GCC visibility pop
# 1 "/usr/include/c++/10/bits/exception_ptr.h" 1 3
# 34 "/usr/include/c++/10/bits/exception_ptr.h" 3
#pragma GCC visibility push(default)
# 1 "/usr/include/c++/10/bits/exception_defines.h" 1 3
# 38 "/usr/include/c++/10/bits/exception_ptr.h" 2 3
# 1 "/usr/include/c++/10/bits/cxxabi_init_exception.h" 1 3
# 34 "/usr/include/c++/10/bits/cxxabi_init_exception.h" 3
# 35 "/usr/include/c++/10/bits/cxxabi_init_exception.h" 3
#pragma GCC visibility push(default)
# 1 "/usr/lib/gcc/x86_64-linux-gnu/10/include/stddef.h" 1 3 4
# 39 "/usr/include/c++/10/bits/cxxabi_init_exception.h" 2 3
# 50 "/usr/include/c++/10/bits/cxxabi_init_exception.h" 3
namespace std
{
class type_info;
}
namespace __cxxabiv1
{
struct __cxa_refcounted_exception;
extern "C"
{
void*
__cxa_allocate_exception(size_t) noexcept;
void
__cxa_free_exception(void*) noexcept;
__cxa_refcounted_exception*
__cxa_init_primary_exception(void *object, std::type_info *tinfo,
void ( *dest) (void *)) noexcept;
}
}
#pragma GCC visibility pop
# 39 "/usr/include/c++/10/bits/exception_ptr.h" 2 3
# 1 "/usr/include/c++/10/typeinfo" 1 3
# 32 "/usr/include/c++/10/typeinfo" 3
# 33 "/usr/include/c++/10/typeinfo" 3
# 1 "/usr/include/c++/10/bits/hash_bytes.h" 1 3
# 33 "/usr/include/c++/10/bits/hash_bytes.h" 3
# 34 "/usr/include/c++/10/bits/hash_bytes.h" 3
namespace std
{
size_t
_Hash_bytes(const void* __ptr, size_t __len, size_t __seed);
size_t
_Fnv_hash_bytes(const void* __ptr, size_t __len, size_t __seed);
}
# 37 "/usr/include/c++/10/typeinfo" 2 3
#pragma GCC visibility push(default)
extern "C++" {
namespace __cxxabiv1
{
class __class_type_info;
}
# 80 "/usr/include/c++/10/typeinfo" 3
namespace std
{
class type_info
{
public:
virtual ~type_info();
const char* name() const noexcept
{ return __name[0] == '*' ? __name + 1 : __name; }
# 115 "/usr/include/c++/10/typeinfo" 3
bool before(const type_info& __arg) const noexcept
{ return (__name[0] == '*' && __arg.__name[0] == '*')
? __name < __arg.__name
: __builtin_strcmp (__name, __arg.__name) < 0; }
bool operator==(const type_info& __arg) const noexcept
{
return ((__name == __arg.__name)
|| (__name[0] != '*' &&
__builtin_strcmp (__name, __arg.__name) == 0));
}
# 138 "/usr/include/c++/10/typeinfo" 3
bool operator!=(const type_info& __arg) const noexcept
{ return !operator==(__arg); }
size_t hash_code() const noexcept
{
return _Hash_bytes(name(), __builtin_strlen(name()),
static_cast<size_t>(0xc70f6907UL));
}
virtual bool __is_pointer_p() const;
virtual bool __is_function_p() const;
virtual bool __do_catch(const type_info *__thr_type, void **__thr_obj,
unsigned __outer) const;
virtual bool __do_upcast(const __cxxabiv1::__class_type_info *__target,
void **__obj_ptr) const;
protected:
const char *__name;
explicit type_info(const char *__n): __name(__n) { }
private:
type_info& operator=(const type_info&);
type_info(const type_info&);
};
class bad_cast : public exception
{
public:
bad_cast() noexcept { }
virtual ~bad_cast() noexcept;
virtual const char* what() const noexcept;
};
class bad_typeid : public exception
{
public:
bad_typeid () noexcept { }
virtual ~bad_typeid() noexcept;
virtual const char* what() const noexcept;
};
}
}
#pragma GCC visibility pop
# 40 "/usr/include/c++/10/bits/exception_ptr.h" 2 3
# 1 "/usr/include/c++/10/new" 1 3
# 41 "/usr/include/c++/10/bits/exception_ptr.h" 2 3
extern "C++" {
namespace std
{
class type_info;
namespace __exception_ptr
{
class exception_ptr;
}
using __exception_ptr::exception_ptr;
exception_ptr current_exception() noexcept;
template<typename _Ex>
exception_ptr make_exception_ptr(_Ex) noexcept;
void rethrow_exception(exception_ptr) __attribute__ ((__noreturn__));
namespace __exception_ptr
{
using std::rethrow_exception;
class exception_ptr
{
void* _M_exception_object;
explicit exception_ptr(void* __e) noexcept;
void _M_addref() noexcept;
void _M_release() noexcept;
void *_M_get() const noexcept __attribute__ ((__pure__));
friend exception_ptr std::current_exception() noexcept;
friend void std::rethrow_exception(exception_ptr);
template<typename _Ex>
friend exception_ptr std::make_exception_ptr(_Ex) noexcept;
public:
exception_ptr() noexcept;
exception_ptr(const exception_ptr&) noexcept;
exception_ptr(nullptr_t) noexcept
: _M_exception_object(0)
{ }
exception_ptr(exception_ptr&& __o) noexcept
: _M_exception_object(__o._M_exception_object)
{ __o._M_exception_object = 0; }
# 118 "/usr/include/c++/10/bits/exception_ptr.h" 3
exception_ptr&
operator=(const exception_ptr&) noexcept;
exception_ptr&
operator=(exception_ptr&& __o) noexcept
{
exception_ptr(static_cast<exception_ptr&&>(__o)).swap(*this);
return *this;
}
~exception_ptr() noexcept;
void
swap(exception_ptr&) noexcept;
# 145 "/usr/include/c++/10/bits/exception_ptr.h" 3
explicit operator bool() const
{ return _M_exception_object; }
friend bool
operator==(const exception_ptr&, const exception_ptr&)
noexcept __attribute__ ((__pure__));
const class std::type_info*
__cxa_exception_type() const noexcept
__attribute__ ((__pure__));
};
bool
operator==(const exception_ptr&, const exception_ptr&)
noexcept __attribute__ ((__pure__));
bool
operator!=(const exception_ptr&, const exception_ptr&)
noexcept __attribute__ ((__pure__));
inline void
swap(exception_ptr& __lhs, exception_ptr& __rhs)
{ __lhs.swap(__rhs); }
template<typename _Ex>
inline void
__dest_thunk(void* __x)
{ static_cast<_Ex*>(__x)->~_Ex(); }
}
template<typename _Ex>
exception_ptr
make_exception_ptr(_Ex __ex) noexcept
{
# 213 "/usr/include/c++/10/bits/exception_ptr.h" 3
return exception_ptr();
}
}
}
#pragma GCC visibility pop
# 148 "/usr/include/c++/10/exception" 2 3
# 1 "/usr/include/c++/10/bits/nested_exception.h" 1 3
# 33 "/usr/include/c++/10/bits/nested_exception.h" 3
#pragma GCC visibility push(default)
# 1 "/usr/include/c++/10/bits/move.h" 1 3
# 38 "/usr/include/c++/10/bits/move.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{
template<typename _Tp>
inline constexpr _Tp*
__addressof(_Tp& __r) noexcept
{ return __builtin_addressof(__r); }
}
# 1 "/usr/include/c++/10/type_traits" 1 3
# 32 "/usr/include/c++/10/type_traits" 3
# 33 "/usr/include/c++/10/type_traits" 3
namespace std __attribute__ ((__visibility__ ("default")))
{
# 56 "/usr/include/c++/10/type_traits" 3
template<typename _Tp, _Tp __v>
struct integral_constant
{
static constexpr _Tp value = __v;
typedef _Tp value_type;
typedef integral_constant<_Tp, __v> type;
constexpr operator value_type() const noexcept { return value; }
constexpr value_type operator()() const noexcept { return value; }
};
template<typename _Tp, _Tp __v>
constexpr _Tp integral_constant<_Tp, __v>::value;
typedef integral_constant<bool, true> true_type;
typedef integral_constant<bool, false> false_type;
template<bool __v>
using __bool_constant = integral_constant<bool, __v>;
# 91 "/usr/include/c++/10/type_traits" 3
template<bool, typename, typename>
struct conditional;
template <typename _Type>
struct __type_identity
{ using type = _Type; };
template<typename _Tp>
using __type_identity_t = typename __type_identity<_Tp>::type;
template<typename...>
struct __or_;
template<>
struct __or_<>
: public false_type
{ };
template<typename _B1>
struct __or_<_B1>
: public _B1
{ };
template<typename _B1, typename _B2>
struct __or_<_B1, _B2>
: public conditional<_B1::value, _B1, _B2>::type
{ };
template<typename _B1, typename _B2, typename _B3, typename... _Bn>
struct __or_<_B1, _B2, _B3, _Bn...>
: public conditional<_B1::value, _B1, __or_<_B2, _B3, _Bn...>>::type
{ };
template<typename...>
struct __and_;
template<>
struct __and_<>
: public true_type
{ };
template<typename _B1>
struct __and_<_B1>
: public _B1
{ };
template<typename _B1, typename _B2>
struct __and_<_B1, _B2>
: public conditional<_B1::value, _B2, _B1>::type
{ };
template<typename _B1, typename _B2, typename _B3, typename... _Bn>
struct __and_<_B1, _B2, _B3, _Bn...>
: public conditional<_B1::value, __and_<_B2, _B3, _Bn...>, _B1>::type
{ };
template<typename _Pp>
struct __not_
: public __bool_constant<!bool(_Pp::value)>
{ };
# 188 "/usr/include/c++/10/type_traits" 3
template<typename>
struct is_reference;
template<typename>
struct is_function;
template<typename>
struct is_void;
template<typename>
struct __is_array_unknown_bounds;
template <typename _Tp, size_t = sizeof(_Tp)>
constexpr true_type __is_complete_or_unbounded(__type_identity<_Tp>)
{ return {}; }
template <typename _TypeIdentity,
typename _NestedType = typename _TypeIdentity::type>
constexpr typename __or_<
is_reference<_NestedType>,
is_function<_NestedType>,
is_void<_NestedType>,
__is_array_unknown_bounds<_NestedType>
>::type __is_complete_or_unbounded(_TypeIdentity)
{ return {}; }
template<typename _Tp>
struct __success_type
{ typedef _Tp type; };
struct __failure_type
{ };
template<typename>
struct remove_cv;
template<typename _Tp>
using __remove_cv_t = typename remove_cv<_Tp>::type;
template<typename>
struct is_const;
template<typename>
struct __is_void_helper
: public false_type { };
template<>
struct __is_void_helper<void>
: public true_type { };
template<typename _Tp>
struct is_void
: public __is_void_helper<__remove_cv_t<_Tp>>::type
{ };
template<typename>
struct __is_integral_helper
: public false_type { };
template<>
struct __is_integral_helper<bool>
: public true_type { };
template<>
struct __is_integral_helper<char>
: public true_type { };
template<>
struct __is_integral_helper<signed char>
: public true_type { };
template<>
struct __is_integral_helper<unsigned char>
: public true_type { };
template<>
struct __is_integral_helper<wchar_t>
: public true_type { };
# 284 "/usr/include/c++/10/type_traits" 3
template<>
struct __is_integral_helper<char16_t>
: public true_type { };
template<>
struct __is_integral_helper<char32_t>
: public true_type { };
template<>
struct __is_integral_helper<short>
: public true_type { };
template<>
struct __is_integral_helper<unsigned short>
: public true_type { };
template<>
struct __is_integral_helper<int>
: public true_type { };
template<>
struct __is_integral_helper<unsigned int>
: public true_type { };
template<>
struct __is_integral_helper<long>
: public true_type { };
template<>
struct __is_integral_helper<unsigned long>
: public true_type { };
template<>
struct __is_integral_helper<long long>
: public true_type { };
template<>
struct __is_integral_helper<unsigned long long>
: public true_type { };
template<>
struct __is_integral_helper<__int128>
: public true_type { };
template<>
struct __is_integral_helper<unsigned __int128>
: public true_type { };
# 364 "/usr/include/c++/10/type_traits" 3
template<typename _Tp>
struct is_integral
: public __is_integral_helper<__remove_cv_t<_Tp>>::type
{ };
template<typename>
struct __is_floating_point_helper
: public false_type { };
template<>
struct __is_floating_point_helper<float>
: public true_type { };
template<>
struct __is_floating_point_helper<double>
: public true_type { };
template<>
struct __is_floating_point_helper<long double>
: public true_type { };
template<>
struct __is_floating_point_helper<__float128>
: public true_type { };
template<typename _Tp>
struct is_floating_point
: public __is_floating_point_helper<__remove_cv_t<_Tp>>::type
{ };
template<typename>
struct is_array
: public false_type { };
template<typename _Tp, std::size_t _Size>
struct is_array<_Tp[_Size]>
: public true_type { };
template<typename _Tp>
struct is_array<_Tp[]>
: public true_type { };
template<typename>
struct __is_pointer_helper
: public false_type { };
template<typename _Tp>
struct __is_pointer_helper<_Tp*>
: public true_type { };
template<typename _Tp>
struct is_pointer
: public __is_pointer_helper<__remove_cv_t<_Tp>>::type
{ };
template<typename>
struct is_lvalue_reference
: public false_type { };
template<typename _Tp>
struct is_lvalue_reference<_Tp&>
: public true_type { };
template<typename>
struct is_rvalue_reference
: public false_type { };
template<typename _Tp>
struct is_rvalue_reference<_Tp&&>
: public true_type { };
template<typename>
struct __is_member_object_pointer_helper
: public false_type { };
template<typename _Tp, typename _Cp>
struct __is_member_object_pointer_helper<_Tp _Cp::*>
: public __not_<is_function<_Tp>>::type { };
template<typename _Tp>
struct is_member_object_pointer
: public __is_member_object_pointer_helper<__remove_cv_t<_Tp>>::type
{ };
template<typename>
struct __is_member_function_pointer_helper
: public false_type { };
template<typename _Tp, typename _Cp>
struct __is_member_function_pointer_helper<_Tp _Cp::*>
: public is_function<_Tp>::type { };
template<typename _Tp>
struct is_member_function_pointer
: public __is_member_function_pointer_helper<__remove_cv_t<_Tp>>::type
{ };
template<typename _Tp>
struct is_enum
: public integral_constant<bool, __is_enum(_Tp)>
{ };
template<typename _Tp>
struct is_union
: public integral_constant<bool, __is_union(_Tp)>
{ };
template<typename _Tp>
struct is_class
: public integral_constant<bool, __is_class(_Tp)>
{ };
template<typename _Tp>
struct is_function
: public __bool_constant<!is_const<const _Tp>::value> { };
template<typename _Tp>
struct is_function<_Tp&>
: public false_type { };
template<typename _Tp>
struct is_function<_Tp&&>
: public false_type { };
template<typename>
struct __is_null_pointer_helper
: public false_type { };
template<>
struct __is_null_pointer_helper<std::nullptr_t>
: public true_type { };
template<typename _Tp>
struct is_null_pointer
: public __is_null_pointer_helper<__remove_cv_t<_Tp>>::type
{ };
template<typename _Tp>
struct __is_nullptr_t
: public is_null_pointer<_Tp>
{ } __attribute__ ((__deprecated__ ("use '" "std::is_null_pointer" "' instead")));
template<typename _Tp>
struct is_reference
: public __or_<is_lvalue_reference<_Tp>,
is_rvalue_reference<_Tp>>::type
{ };
template<typename _Tp>
struct is_arithmetic
: public __or_<is_integral<_Tp>, is_floating_point<_Tp>>::type
{ };
template<typename _Tp>
struct is_fundamental
: public __or_<is_arithmetic<_Tp>, is_void<_Tp>,
is_null_pointer<_Tp>>::type
{ };
template<typename _Tp>
struct is_object
: public __not_<__or_<is_function<_Tp>, is_reference<_Tp>,
is_void<_Tp>>>::type
{ };
template<typename>
struct is_member_pointer;
template<typename _Tp>
struct is_scalar
: public __or_<is_arithmetic<_Tp>, is_enum<_Tp>, is_pointer<_Tp>,
is_member_pointer<_Tp>, is_null_pointer<_Tp>>::type
{ };
template<typename _Tp>
struct is_compound
: public __not_<is_fundamental<_Tp>>::type { };
template<typename _Tp>
struct __is_member_pointer_helper
: public false_type { };
template<typename _Tp, typename _Cp>
struct __is_member_pointer_helper<_Tp _Cp::*>
: public true_type { };
template<typename _Tp>
struct is_member_pointer
: public __is_member_pointer_helper<__remove_cv_t<_Tp>>::type
{ };
template<typename, typename>
struct is_same;
template<typename _Tp, typename... _Types>
using __is_one_of = __or_<is_same<_Tp, _Types>...>;
template<typename _Tp>
using __is_signed_integer = __is_one_of<__remove_cv_t<_Tp>,
signed char, signed short, signed int, signed long,
signed long long
, signed __int128
# 604 "/usr/include/c++/10/type_traits" 3
>;
template<typename _Tp>
using __is_unsigned_integer = __is_one_of<__remove_cv_t<_Tp>,
unsigned char, unsigned short, unsigned int, unsigned long,
unsigned long long
, unsigned __int128
# 623 "/usr/include/c++/10/type_traits" 3
>;
template<typename _Tp>
using __is_standard_integer
= __or_<__is_signed_integer<_Tp>, __is_unsigned_integer<_Tp>>;
template<typename...> using __void_t = void;
template<typename _Tp, typename = void>
struct __is_referenceable
: public false_type
{ };
template<typename _Tp>
struct __is_referenceable<_Tp, __void_t<_Tp&>>
: public true_type
{ };
template<typename>
struct is_const
: public false_type { };
template<typename _Tp>
struct is_const<_Tp const>
: public true_type { };
template<typename>
struct is_volatile
: public false_type { };
template<typename _Tp>
struct is_volatile<_Tp volatile>
: public true_type { };
template<typename _Tp>
struct is_trivial
: public integral_constant<bool, __is_trivial(_Tp)>
{
static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
"template argument must be a complete class or an unbounded array");
};
template<typename _Tp>
struct is_trivially_copyable
: public integral_constant<bool, __is_trivially_copyable(_Tp)>
{
static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
"template argument must be a complete class or an unbounded array");
};
template<typename _Tp>
struct is_standard_layout
: public integral_constant<bool, __is_standard_layout(_Tp)>
{
static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
"template argument must be a complete class or an unbounded array");
};
template<typename _Tp>
struct
is_pod
: public integral_constant<bool, __is_pod(_Tp)>
{
static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
"template argument must be a complete class or an unbounded array");
};
template<typename _Tp>
struct is_literal_type
: public integral_constant<bool, __is_literal_type(_Tp)>
{
static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
"template argument must be a complete class or an unbounded array");
};
template<typename _Tp>
struct is_empty
: public integral_constant<bool, __is_empty(_Tp)>
{ };
template<typename _Tp>
struct is_polymorphic
: public integral_constant<bool, __is_polymorphic(_Tp)>
{ };
template<typename _Tp>
struct is_final
: public integral_constant<bool, __is_final(_Tp)>
{ };
template<typename _Tp>
struct is_abstract
: public integral_constant<bool, __is_abstract(_Tp)>
{ };
template<typename _Tp,
bool = is_arithmetic<_Tp>::value>
struct __is_signed_helper
: public false_type { };
template<typename _Tp>
struct __is_signed_helper<_Tp, true>
: public integral_constant<bool, _Tp(-1) < _Tp(0)>
{ };
template<typename _Tp>
struct is_signed
: public __is_signed_helper<_Tp>::type
{ };
template<typename _Tp>
struct is_unsigned
: public __and_<is_arithmetic<_Tp>, __not_<is_signed<_Tp>>>
{ };
# 770 "/usr/include/c++/10/type_traits" 3
template<typename _Tp, typename _Up = _Tp&&>
_Up
__declval(int);
template<typename _Tp>
_Tp
__declval(long);
template<typename _Tp>
auto declval() noexcept -> decltype(__declval<_Tp>(0));
template<typename, unsigned = 0>
struct extent;
template<typename>
struct remove_all_extents;
template<typename _Tp>
struct __is_array_known_bounds
: public integral_constant<bool, (extent<_Tp>::value > 0)>
{ };
template<typename _Tp>
struct __is_array_unknown_bounds
: public __and_<is_array<_Tp>, __not_<extent<_Tp>>>
{ };
struct __do_is_destructible_impl
{
template<typename _Tp, typename = decltype(declval<_Tp&>().~_Tp())>
static true_type __test(int);
template<typename>
static false_type __test(...);
};
template<typename _Tp>
struct __is_destructible_impl
: public __do_is_destructible_impl
{
typedef decltype(__test<_Tp>(0)) type;
};
template<typename _Tp,
bool = __or_<is_void<_Tp>,
__is_array_unknown_bounds<_Tp>,
is_function<_Tp>>::value,
bool = __or_<is_reference<_Tp>, is_scalar<_Tp>>::value>
struct __is_destructible_safe;
template<typename _Tp>
struct __is_destructible_safe<_Tp, false, false>
: public __is_destructible_impl<typename
remove_all_extents<_Tp>::type>::type
{ };
template<typename _Tp>
struct __is_destructible_safe<_Tp, true, false>
: public false_type { };
template<typename _Tp>
struct __is_destructible_safe<_Tp, false, true>
: public true_type { };
template<typename _Tp>
struct is_destructible
: public __is_destructible_safe<_Tp>::type
{
static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
"template argument must be a complete class or an unbounded array");
};
struct __do_is_nt_destructible_impl
{
template<typename _Tp>
static __bool_constant<noexcept(declval<_Tp&>().~_Tp())>
__test(int);
template<typename>
static false_type __test(...);
};
template<typename _Tp>
struct __is_nt_destructible_impl
: public __do_is_nt_destructible_impl
{
typedef decltype(__test<_Tp>(0)) type;
};
template<typename _Tp,
bool = __or_<is_void<_Tp>,
__is_array_unknown_bounds<_Tp>,
is_function<_Tp>>::value,
bool = __or_<is_reference<_Tp>, is_scalar<_Tp>>::value>
struct __is_nt_destructible_safe;
template<typename _Tp>
struct __is_nt_destructible_safe<_Tp, false, false>
: public __is_nt_destructible_impl<typename
remove_all_extents<_Tp>::type>::type
{ };
template<typename _Tp>
struct __is_nt_destructible_safe<_Tp, true, false>
: public false_type { };
template<typename _Tp>
struct __is_nt_destructible_safe<_Tp, false, true>
: public true_type { };
template<typename _Tp>
struct is_nothrow_destructible
: public __is_nt_destructible_safe<_Tp>::type
{
static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
"template argument must be a complete class or an unbounded array");
};
template<typename _Tp, typename... _Args>
struct __is_constructible_impl
: public __bool_constant<__is_constructible(_Tp, _Args...)>
{ };
template<typename _Tp, typename... _Args>
struct is_constructible
: public __is_constructible_impl<_Tp, _Args...>
{
static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
"template argument must be a complete class or an unbounded array");
};
template<typename _Tp>
struct is_default_constructible
: public __is_constructible_impl<_Tp>::type
{
static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
"template argument must be a complete class or an unbounded array");
};
template<typename _Tp, bool = __is_referenceable<_Tp>::value>
struct __is_copy_constructible_impl;
template<typename _Tp>
struct __is_copy_constructible_impl<_Tp, false>
: public false_type { };
template<typename _Tp>
struct __is_copy_constructible_impl<_Tp, true>
: public __is_constructible_impl<_Tp, const _Tp&>
{ };
template<typename _Tp>
struct is_copy_constructible
: public __is_copy_constructible_impl<_Tp>
{
static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
"template argument must be a complete class or an unbounded array");
};
template<typename _Tp, bool = __is_referenceable<_Tp>::value>
struct __is_move_constructible_impl;
template<typename _Tp>
struct __is_move_constructible_impl<_Tp, false>
: public false_type { };
template<typename _Tp>
struct __is_move_constructible_impl<_Tp, true>
: public __is_constructible_impl<_Tp, _Tp&&>
{ };
template<typename _Tp>
struct is_move_constructible
: public __is_move_constructible_impl<_Tp>
{
static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
"template argument must be a complete class or an unbounded array");
};
template<bool, typename _Tp, typename... _Args>
struct __is_nt_constructible_impl
: public false_type
{ };
template<typename _Tp, typename... _Args>
struct __is_nt_constructible_impl<true, _Tp, _Args...>
: public __bool_constant<noexcept(_Tp(std::declval<_Args>()...))>
{ };
template<typename _Tp, typename _Arg>
struct __is_nt_constructible_impl<true, _Tp, _Arg>
: public __bool_constant<noexcept(static_cast<_Tp>(std::declval<_Arg>()))>
{ };
template<typename _Tp>
struct __is_nt_constructible_impl<true, _Tp>
: public __bool_constant<noexcept(_Tp())>
{ };
template<typename _Tp, size_t _Num>
struct __is_nt_constructible_impl<true, _Tp[_Num]>
: public __bool_constant<noexcept(typename remove_all_extents<_Tp>::type())>
{ };
# 1001 "/usr/include/c++/10/type_traits" 3
template<typename _Tp, typename... _Args>
using __is_nothrow_constructible_impl
= __is_nt_constructible_impl<__is_constructible(_Tp, _Args...),
_Tp, _Args...>;
template<typename _Tp, typename... _Args>
struct is_nothrow_constructible
: public __is_nothrow_constructible_impl<_Tp, _Args...>::type
{
static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
"template argument must be a complete class or an unbounded array");
};
template<typename _Tp>
struct is_nothrow_default_constructible
: public __is_nothrow_constructible_impl<_Tp>::type
{
static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
"template argument must be a complete class or an unbounded array");
};
template<typename _Tp, bool = __is_referenceable<_Tp>::value>
struct __is_nothrow_copy_constructible_impl;
template<typename _Tp>
struct __is_nothrow_copy_constructible_impl<_Tp, false>
: public false_type { };
template<typename _Tp>
struct __is_nothrow_copy_constructible_impl<_Tp, true>
: public __is_nothrow_constructible_impl<_Tp, const _Tp&>
{ };
template<typename _Tp>
struct is_nothrow_copy_constructible
: public __is_nothrow_copy_constructible_impl<_Tp>::type
{
static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
"template argument must be a complete class or an unbounded array");
};
template<typename _Tp, bool = __is_referenceable<_Tp>::value>
struct __is_nothrow_move_constructible_impl;
template<typename _Tp>
struct __is_nothrow_move_constructible_impl<_Tp, false>
: public false_type { };
template<typename _Tp>
struct __is_nothrow_move_constructible_impl<_Tp, true>
: public __is_nothrow_constructible_impl<_Tp, _Tp&&>
{ };
template<typename _Tp>
struct is_nothrow_move_constructible
: public __is_nothrow_move_constructible_impl<_Tp>::type
{
static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
"template argument must be a complete class or an unbounded array");
};
template<typename _Tp, typename _Up>
struct is_assignable
: public __bool_constant<__is_assignable(_Tp, _Up)>
{
static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
"template argument must be a complete class or an unbounded array");
};
template<typename _Tp, bool = __is_referenceable<_Tp>::value>
struct __is_copy_assignable_impl;
template<typename _Tp>
struct __is_copy_assignable_impl<_Tp, false>
: public false_type { };
template<typename _Tp>
struct __is_copy_assignable_impl<_Tp, true>
: public __bool_constant<__is_assignable(_Tp&, const _Tp&)>
{ };
template<typename _Tp>
struct is_copy_assignable
: public __is_copy_assignable_impl<_Tp>::type
{
static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
"template argument must be a complete class or an unbounded array");
};
template<typename _Tp, bool = __is_referenceable<_Tp>::value>
struct __is_move_assignable_impl;
template<typename _Tp>
struct __is_move_assignable_impl<_Tp, false>
: public false_type { };
template<typename _Tp>
struct __is_move_assignable_impl<_Tp, true>
: public __bool_constant<__is_assignable(_Tp&, _Tp&&)>
{ };
template<typename _Tp>
struct is_move_assignable
: public __is_move_assignable_impl<_Tp>::type
{
static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
"template argument must be a complete class or an unbounded array");
};
template<typename _Tp, typename _Up>
struct __is_nt_assignable_impl
: public integral_constant<bool, noexcept(declval<_Tp>() = declval<_Up>())>
{ };
template<typename _Tp, typename _Up>
struct __is_nothrow_assignable_impl
: public __and_<__bool_constant<__is_assignable(_Tp, _Up)>,
__is_nt_assignable_impl<_Tp, _Up>>
{ };
template<typename _Tp, typename _Up>
struct is_nothrow_assignable
: public __is_nothrow_assignable_impl<_Tp, _Up>
{
static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
"template argument must be a complete class or an unbounded array");
};
template<typename _Tp, bool = __is_referenceable<_Tp>::value>
struct __is_nt_copy_assignable_impl;
template<typename _Tp>
struct __is_nt_copy_assignable_impl<_Tp, false>
: public false_type { };
template<typename _Tp>
struct __is_nt_copy_assignable_impl<_Tp, true>
: public __is_nothrow_assignable_impl<_Tp&, const _Tp&>
{ };
template<typename _Tp>
struct is_nothrow_copy_assignable
: public __is_nt_copy_assignable_impl<_Tp>
{
static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
"template argument must be a complete class or an unbounded array");
};
template<typename _Tp, bool = __is_referenceable<_Tp>::value>
struct __is_nt_move_assignable_impl;
template<typename _Tp>
struct __is_nt_move_assignable_impl<_Tp, false>
: public false_type { };
template<typename _Tp>
struct __is_nt_move_assignable_impl<_Tp, true>
: public __is_nothrow_assignable_impl<_Tp&, _Tp&&>
{ };
template<typename _Tp>
struct is_nothrow_move_assignable
: public __is_nt_move_assignable_impl<_Tp>
{
static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
"template argument must be a complete class or an unbounded array");
};
template<typename _Tp, typename... _Args>
struct is_trivially_constructible
: public __bool_constant<__is_trivially_constructible(_Tp, _Args...)>
{
static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
"template argument must be a complete class or an unbounded array");
};
template<typename _Tp>
struct is_trivially_default_constructible
: public __bool_constant<__is_trivially_constructible(_Tp)>
{
static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
"template argument must be a complete class or an unbounded array");
};
struct __do_is_implicitly_default_constructible_impl
{
template <typename _Tp>
static void __helper(const _Tp&);
template <typename _Tp>
static true_type __test(const _Tp&,
decltype(__helper<const _Tp&>({}))* = 0);
static false_type __test(...);
};
template<typename _Tp>
struct __is_implicitly_default_constructible_impl
: public __do_is_implicitly_default_constructible_impl
{
typedef decltype(__test(declval<_Tp>())) type;
};
template<typename _Tp>
struct __is_implicitly_default_constructible_safe
: public __is_implicitly_default_constructible_impl<_Tp>::type
{ };
template <typename _Tp>
struct __is_implicitly_default_constructible
: public __and_<__is_constructible_impl<_Tp>,
__is_implicitly_default_constructible_safe<_Tp>>
{ };
template<typename _Tp, bool = __is_referenceable<_Tp>::value>
struct __is_trivially_copy_constructible_impl;
template<typename _Tp>
struct __is_trivially_copy_constructible_impl<_Tp, false>
: public false_type { };
template<typename _Tp>
struct __is_trivially_copy_constructible_impl<_Tp, true>
: public __and_<__is_copy_constructible_impl<_Tp>,
integral_constant<bool,
__is_trivially_constructible(_Tp, const _Tp&)>>
{ };
template<typename _Tp>
struct is_trivially_copy_constructible
: public __is_trivially_copy_constructible_impl<_Tp>
{
static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
"template argument must be a complete class or an unbounded array");
};
template<typename _Tp, bool = __is_referenceable<_Tp>::value>
struct __is_trivially_move_constructible_impl;
template<typename _Tp>
struct __is_trivially_move_constructible_impl<_Tp, false>
: public false_type { };
template<typename _Tp>
struct __is_trivially_move_constructible_impl<_Tp, true>
: public __and_<__is_move_constructible_impl<_Tp>,
integral_constant<bool,
__is_trivially_constructible(_Tp, _Tp&&)>>
{ };
template<typename _Tp>
struct is_trivially_move_constructible
: public __is_trivially_move_constructible_impl<_Tp>
{
static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
"template argument must be a complete class or an unbounded array");
};
template<typename _Tp, typename _Up>
struct is_trivially_assignable
: public __bool_constant<__is_trivially_assignable(_Tp, _Up)>
{
static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
"template argument must be a complete class or an unbounded array");
};
template<typename _Tp, bool = __is_referenceable<_Tp>::value>
struct __is_trivially_copy_assignable_impl;
template<typename _Tp>
struct __is_trivially_copy_assignable_impl<_Tp, false>
: public false_type { };
template<typename _Tp>
struct __is_trivially_copy_assignable_impl<_Tp, true>
: public __bool_constant<__is_trivially_assignable(_Tp&, const _Tp&)>
{ };
template<typename _Tp>
struct is_trivially_copy_assignable
: public __is_trivially_copy_assignable_impl<_Tp>
{
static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
"template argument must be a complete class or an unbounded array");
};
template<typename _Tp, bool = __is_referenceable<_Tp>::value>
struct __is_trivially_move_assignable_impl;
template<typename _Tp>
struct __is_trivially_move_assignable_impl<_Tp, false>
: public false_type { };
template<typename _Tp>
struct __is_trivially_move_assignable_impl<_Tp, true>
: public __bool_constant<__is_trivially_assignable(_Tp&, _Tp&&)>
{ };
template<typename _Tp>
struct is_trivially_move_assignable
: public __is_trivially_move_assignable_impl<_Tp>
{
static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
"template argument must be a complete class or an unbounded array");
};
template<typename _Tp>
struct is_trivially_destructible
: public __and_<__is_destructible_safe<_Tp>,
__bool_constant<__has_trivial_destructor(_Tp)>>
{
static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
"template argument must be a complete class or an unbounded array");
};
template<typename _Tp>
struct has_virtual_destructor
: public integral_constant<bool, __has_virtual_destructor(_Tp)>
{
static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
"template argument must be a complete class or an unbounded array");
};
template<typename _Tp>
struct alignment_of
: public integral_constant<std::size_t, alignof(_Tp)>
{
static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
"template argument must be a complete class or an unbounded array");
};
template<typename>
struct rank
: public integral_constant<std::size_t, 0> { };
template<typename _Tp, std::size_t _Size>
struct rank<_Tp[_Size]>
: public integral_constant<std::size_t, 1 + rank<_Tp>::value> { };
template<typename _Tp>
struct rank<_Tp[]>
: public integral_constant<std::size_t, 1 + rank<_Tp>::value> { };
template<typename, unsigned _Uint>
struct extent
: public integral_constant<std::size_t, 0> { };
template<typename _Tp, unsigned _Uint, std::size_t _Size>
struct extent<_Tp[_Size], _Uint>
: public integral_constant<std::size_t,
_Uint == 0 ? _Size : extent<_Tp,
_Uint - 1>::value>
{ };
template<typename _Tp, unsigned _Uint>
struct extent<_Tp[], _Uint>
: public integral_constant<std::size_t,
_Uint == 0 ? 0 : extent<_Tp,
_Uint - 1>::value>
{ };
template<typename _Tp, typename _Up>
struct is_same
: public integral_constant<bool, __is_same_as(_Tp, _Up)>
{ };
# 1410 "/usr/include/c++/10/type_traits" 3
template<typename _Base, typename _Derived>
struct is_base_of
: public integral_constant<bool, __is_base_of(_Base, _Derived)>
{ };
template<typename _From, typename _To,
bool = __or_<is_void<_From>, is_function<_To>,
is_array<_To>>::value>
struct __is_convertible_helper
{
typedef typename is_void<_To>::type type;
};
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wctor-dtor-privacy"
template<typename _From, typename _To>
class __is_convertible_helper<_From, _To, false>
{
template<typename _To1>
static void __test_aux(_To1) noexcept;
template<typename _From1, typename _To1,
typename = decltype(__test_aux<_To1>(std::declval<_From1>()))>
static true_type
__test(int);
template<typename, typename>
static false_type
__test(...);
public:
typedef decltype(__test<_From, _To>(0)) type;
};
#pragma GCC diagnostic pop
template<typename _From, typename _To>
struct is_convertible
: public __is_convertible_helper<_From, _To>::type
{ };
template<typename _ToElementType, typename _FromElementType>
using __is_array_convertible
= is_convertible<_FromElementType(*)[], _ToElementType(*)[]>;
template<typename _From, typename _To,
bool = __or_<is_void<_From>, is_function<_To>,
is_array<_To>>::value>
struct __is_nt_convertible_helper
: is_void<_To>
{ };
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wctor-dtor-privacy"
template<typename _From, typename _To>
class __is_nt_convertible_helper<_From, _To, false>
{
template<typename _To1>
static void __test_aux(_To1) noexcept;
template<typename _From1, typename _To1>
static
__bool_constant<noexcept(__test_aux<_To1>(std::declval<_From1>()))>
__test(int);
template<typename, typename>
static false_type
__test(...);
public:
using type = decltype(__test<_From, _To>(0));
};
#pragma GCC diagnostic pop
template<typename _From, typename _To>
struct __is_nothrow_convertible
: public __is_nt_convertible_helper<_From, _To>::type
{ };
# 1508 "/usr/include/c++/10/type_traits" 3
template<typename _Tp>
struct remove_const
{ typedef _Tp type; };
template<typename _Tp>
struct remove_const<_Tp const>
{ typedef _Tp type; };
template<typename _Tp>
struct remove_volatile
{ typedef _Tp type; };
template<typename _Tp>
struct remove_volatile<_Tp volatile>
{ typedef _Tp type; };
template<typename _Tp>
struct remove_cv
{ using type = _Tp; };
template<typename _Tp>
struct remove_cv<const _Tp>
{ using type = _Tp; };
template<typename _Tp>
struct remove_cv<volatile _Tp>
{ using type = _Tp; };
template<typename _Tp>
struct remove_cv<const volatile _Tp>
{ using type = _Tp; };
template<typename _Tp>
struct add_const
{ typedef _Tp const type; };
template<typename _Tp>
struct add_volatile
{ typedef _Tp volatile type; };
template<typename _Tp>
struct add_cv
{
typedef typename
add_const<typename add_volatile<_Tp>::type>::type type;
};
template<typename _Tp>
using remove_const_t = typename remove_const<_Tp>::type;
template<typename _Tp>
using remove_volatile_t = typename remove_volatile<_Tp>::type;
template<typename _Tp>
using remove_cv_t = typename remove_cv<_Tp>::type;
template<typename _Tp>
using add_const_t = typename add_const<_Tp>::type;
template<typename _Tp>
using add_volatile_t = typename add_volatile<_Tp>::type;
template<typename _Tp>
using add_cv_t = typename add_cv<_Tp>::type;
template<typename _Tp>
struct remove_reference
{ typedef _Tp type; };
template<typename _Tp>
struct remove_reference<_Tp&>
{ typedef _Tp type; };
template<typename _Tp>
struct remove_reference<_Tp&&>
{ typedef _Tp type; };
template<typename _Tp, bool = __is_referenceable<_Tp>::value>
struct __add_lvalue_reference_helper
{ typedef _Tp type; };
template<typename _Tp>
struct __add_lvalue_reference_helper<_Tp, true>
{ typedef _Tp& type; };
template<typename _Tp>
struct add_lvalue_reference
: public __add_lvalue_reference_helper<_Tp>
{ };
template<typename _Tp, bool = __is_referenceable<_Tp>::value>
struct __add_rvalue_reference_helper
{ typedef _Tp type; };
template<typename _Tp>
struct __add_rvalue_reference_helper<_Tp, true>
{ typedef _Tp&& type; };
template<typename _Tp>
struct add_rvalue_reference
: public __add_rvalue_reference_helper<_Tp>
{ };
template<typename _Tp>
using remove_reference_t = typename remove_reference<_Tp>::type;
template<typename _Tp>
using add_lvalue_reference_t = typename add_lvalue_reference<_Tp>::type;
template<typename _Tp>
using add_rvalue_reference_t = typename add_rvalue_reference<_Tp>::type;
template<typename _Unqualified, bool _IsConst, bool _IsVol>
struct __cv_selector;
template<typename _Unqualified>
struct __cv_selector<_Unqualified, false, false>
{ typedef _Unqualified __type; };
template<typename _Unqualified>
struct __cv_selector<_Unqualified, false, true>
{ typedef volatile _Unqualified __type; };
template<typename _Unqualified>
struct __cv_selector<_Unqualified, true, false>
{ typedef const _Unqualified __type; };
template<typename _Unqualified>
struct __cv_selector<_Unqualified, true, true>
{ typedef const volatile _Unqualified __type; };
template<typename _Qualified, typename _Unqualified,
bool _IsConst = is_const<_Qualified>::value,
bool _IsVol = is_volatile<_Qualified>::value>
class __match_cv_qualifiers
{
typedef __cv_selector<_Unqualified, _IsConst, _IsVol> __match;
public:
typedef typename __match::__type __type;
};
template<typename _Tp>
struct __make_unsigned
{ typedef _Tp __type; };
template<>
struct __make_unsigned<char>
{ typedef unsigned char __type; };
template<>
struct __make_unsigned<signed char>
{ typedef unsigned char __type; };
template<>
struct __make_unsigned<short>
{ typedef unsigned short __type; };
template<>
struct __make_unsigned<int>
{ typedef unsigned int __type; };
template<>
struct __make_unsigned<long>
{ typedef unsigned long __type; };
template<>
struct __make_unsigned<long long>
{ typedef unsigned long long __type; };
template<>
struct __make_unsigned<__int128>
{ typedef unsigned __int128 __type; };
# 1730 "/usr/include/c++/10/type_traits" 3
template<typename _Tp,
bool _IsInt = is_integral<_Tp>::value,
bool _IsEnum = is_enum<_Tp>::value>
class __make_unsigned_selector;
template<typename _Tp>
class __make_unsigned_selector<_Tp, true, false>
{
using __unsigned_type
= typename __make_unsigned<__remove_cv_t<_Tp>>::__type;
public:
using __type
= typename __match_cv_qualifiers<_Tp, __unsigned_type>::__type;
};
class __make_unsigned_selector_base
{
protected:
template<typename...> struct _List { };
template<typename _Tp, typename... _Up>
struct _List<_Tp, _Up...> : _List<_Up...>
{ static constexpr size_t __size = sizeof(_Tp); };
template<size_t _Sz, typename _Tp, bool = (_Sz <= _Tp::__size)>
struct __select;
template<size_t _Sz, typename _Uint, typename... _UInts>
struct __select<_Sz, _List<_Uint, _UInts...>, true>
{ using __type = _Uint; };
template<size_t _Sz, typename _Uint, typename... _UInts>
struct __select<_Sz, _List<_Uint, _UInts...>, false>
: __select<_Sz, _List<_UInts...>>
{ };
};
template<typename _Tp>
class __make_unsigned_selector<_Tp, false, true>
: __make_unsigned_selector_base
{
using _UInts = _List<unsigned char, unsigned short, unsigned int,
unsigned long, unsigned long long>;
using __unsigned_type = typename __select<sizeof(_Tp), _UInts>::__type;
public:
using __type
= typename __match_cv_qualifiers<_Tp, __unsigned_type>::__type;
};
template<>
struct __make_unsigned<wchar_t>
{
using __type
= typename __make_unsigned_selector<wchar_t, false, true>::__type;
};
# 1806 "/usr/include/c++/10/type_traits" 3
template<>
struct __make_unsigned<char16_t>
{
using __type
= typename __make_unsigned_selector<char16_t, false, true>::__type;
};
template<>
struct __make_unsigned<char32_t>
{
using __type
= typename __make_unsigned_selector<char32_t, false, true>::__type;
};
template<typename _Tp>
struct make_unsigned
{ typedef typename __make_unsigned_selector<_Tp>::__type type; };
template<>
struct make_unsigned<bool>;
template<typename _Tp>
struct __make_signed
{ typedef _Tp __type; };
template<>
struct __make_signed<char>
{ typedef signed char __type; };
template<>
struct __make_signed<unsigned char>
{ typedef signed char __type; };
template<>
struct __make_signed<unsigned short>
{ typedef signed short __type; };
template<>
struct __make_signed<unsigned int>
{ typedef signed int __type; };
template<>
struct __make_signed<unsigned long>
{ typedef signed long __type; };
template<>
struct __make_signed<unsigned long long>
{ typedef signed long long __type; };
template<>
struct __make_signed<unsigned __int128>
{ typedef __int128 __type; };
# 1884 "/usr/include/c++/10/type_traits" 3
template<typename _Tp,
bool _IsInt = is_integral<_Tp>::value,
bool _IsEnum = is_enum<_Tp>::value>
class __make_signed_selector;
template<typename _Tp>
class __make_signed_selector<_Tp, true, false>
{
using __signed_type
= typename __make_signed<__remove_cv_t<_Tp>>::__type;
public:
using __type
= typename __match_cv_qualifiers<_Tp, __signed_type>::__type;
};
template<typename _Tp>
class __make_signed_selector<_Tp, false, true>
{
typedef typename __make_unsigned_selector<_Tp>::__type __unsigned_type;
public:
typedef typename __make_signed_selector<__unsigned_type>::__type __type;
};
template<>
struct __make_signed<wchar_t>
{
using __type
= typename __make_signed_selector<wchar_t, false, true>::__type;
};
# 1932 "/usr/include/c++/10/type_traits" 3
template<>
struct __make_signed<char16_t>
{
using __type
= typename __make_signed_selector<char16_t, false, true>::__type;
};
template<>
struct __make_signed<char32_t>
{
using __type
= typename __make_signed_selector<char32_t, false, true>::__type;
};
template<typename _Tp>
struct make_signed
{ typedef typename __make_signed_selector<_Tp>::__type type; };
template<>
struct make_signed<bool>;
template<typename _Tp>
using make_signed_t = typename make_signed<_Tp>::type;
template<typename _Tp>
using make_unsigned_t = typename make_unsigned<_Tp>::type;
template<typename _Tp>
struct remove_extent
{ typedef _Tp type; };
template<typename _Tp, std::size_t _Size>
struct remove_extent<_Tp[_Size]>
{ typedef _Tp type; };
template<typename _Tp>
struct remove_extent<_Tp[]>
{ typedef _Tp type; };
template<typename _Tp>
struct remove_all_extents
{ typedef _Tp type; };
template<typename _Tp, std::size_t _Size>
struct remove_all_extents<_Tp[_Size]>
{ typedef typename remove_all_extents<_Tp>::type type; };
template<typename _Tp>
struct remove_all_extents<_Tp[]>
{ typedef typename remove_all_extents<_Tp>::type type; };
template<typename _Tp>
using remove_extent_t = typename remove_extent<_Tp>::type;
template<typename _Tp>
using remove_all_extents_t = typename remove_all_extents<_Tp>::type;
template<typename _Tp, typename>
struct __remove_pointer_helper
{ typedef _Tp type; };
template<typename _Tp, typename _Up>
struct __remove_pointer_helper<_Tp, _Up*>
{ typedef _Up type; };
template<typename _Tp>
struct remove_pointer
: public __remove_pointer_helper<_Tp, __remove_cv_t<_Tp>>
{ };
template<typename _Tp, bool = __or_<__is_referenceable<_Tp>,
is_void<_Tp>>::value>
struct __add_pointer_helper
{ typedef _Tp type; };
template<typename _Tp>
struct __add_pointer_helper<_Tp, true>
{ typedef typename remove_reference<_Tp>::type* type; };
template<typename _Tp>
struct add_pointer
: public __add_pointer_helper<_Tp>
{ };
template<typename _Tp>
using remove_pointer_t = typename remove_pointer<_Tp>::type;
template<typename _Tp>
using add_pointer_t = typename add_pointer<_Tp>::type;
template<std::size_t _Len>
struct __aligned_storage_msa
{
union __type
{
unsigned char __data[_Len];
struct __attribute__((__aligned__)) { } __align;
};
};
# 2067 "/usr/include/c++/10/type_traits" 3
template<std::size_t _Len, std::size_t _Align =
__alignof__(typename __aligned_storage_msa<_Len>::__type)>
struct aligned_storage
{
union type
{
unsigned char __data[_Len];
struct __attribute__((__aligned__((_Align)))) { } __align;
};
};
template <typename... _Types>
struct __strictest_alignment
{
static const size_t _S_alignment = 0;
static const size_t _S_size = 0;
};
template <typename _Tp, typename... _Types>
struct __strictest_alignment<_Tp, _Types...>
{
static const size_t _S_alignment =
alignof(_Tp) > __strictest_alignment<_Types...>::_S_alignment
? alignof(_Tp) : __strictest_alignment<_Types...>::_S_alignment;
static const size_t _S_size =
sizeof(_Tp) > __strictest_alignment<_Types...>::_S_size
? sizeof(_Tp) : __strictest_alignment<_Types...>::_S_size;
};
# 2106 "/usr/include/c++/10/type_traits" 3
template <size_t _Len, typename... _Types>
struct aligned_union
{
private:
static_assert(sizeof...(_Types) != 0, "At least one type is required");
using __strictest = __strictest_alignment<_Types...>;
static const size_t _S_len = _Len > __strictest::_S_size
? _Len : __strictest::_S_size;
public:
static const size_t alignment_value = __strictest::_S_alignment;
typedef typename aligned_storage<_S_len, alignment_value>::type type;
};
template <size_t _Len, typename... _Types>
const size_t aligned_union<_Len, _Types...>::alignment_value;
template<typename _Up,
bool _IsArray = is_array<_Up>::value,
bool _IsFunction = is_function<_Up>::value>
struct __decay_selector;
template<typename _Up>
struct __decay_selector<_Up, false, false>
{ typedef __remove_cv_t<_Up> __type; };
template<typename _Up>
struct __decay_selector<_Up, true, false>
{ typedef typename remove_extent<_Up>::type* __type; };
template<typename _Up>
struct __decay_selector<_Up, false, true>
{ typedef typename add_pointer<_Up>::type __type; };
template<typename _Tp>
class decay
{
typedef typename remove_reference<_Tp>::type __remove_type;
public:
typedef typename __decay_selector<__remove_type>::__type type;
};
template<typename _Tp>
using __decay_t = typename decay<_Tp>::type;
template<typename _Tp>
class reference_wrapper;
template<typename _Tp>
struct __strip_reference_wrapper
{
typedef _Tp __type;
};
template<typename _Tp>
struct __strip_reference_wrapper<reference_wrapper<_Tp> >
{
typedef _Tp& __type;
};
template<typename _Tp>
using __decay_and_strip = __strip_reference_wrapper<__decay_t<_Tp>>;
template<bool, typename _Tp = void>
struct enable_if
{ };
template<typename _Tp>
struct enable_if<true, _Tp>
{ typedef _Tp type; };
template<bool _Cond, typename _Tp = void>
using __enable_if_t = typename enable_if<_Cond, _Tp>::type;
template<typename... _Cond>
using _Require = __enable_if_t<__and_<_Cond...>::value>;
template<bool _Cond, typename _Iftrue, typename _Iffalse>
struct conditional
{ typedef _Iftrue type; };
template<typename _Iftrue, typename _Iffalse>
struct conditional<false, _Iftrue, _Iffalse>
{ typedef _Iffalse type; };
template<typename _Tp>
using __remove_cvref_t
= typename remove_cv<typename remove_reference<_Tp>::type>::type;
template<typename... _Tp>
struct common_type;
struct __do_common_type_impl
{
template<typename _Tp, typename _Up>
using __cond_t
= decltype(true ? std::declval<_Tp>() : std::declval<_Up>());
template<typename _Tp, typename _Up>
static __success_type<__decay_t<__cond_t<_Tp, _Up>>>
_S_test(int);
# 2239 "/usr/include/c++/10/type_traits" 3
template<typename, typename>
static __failure_type
_S_test_2(...);
template<typename _Tp, typename _Up>
static decltype(_S_test_2<_Tp, _Up>(0))
_S_test(...);
};
template<>
struct common_type<>
{ };
template<typename _Tp0>
struct common_type<_Tp0>
: public common_type<_Tp0, _Tp0>
{ };
template<typename _Tp1, typename _Tp2,
typename _Dp1 = __decay_t<_Tp1>, typename _Dp2 = __decay_t<_Tp2>>
struct __common_type_impl
{
using type = common_type<_Dp1, _Dp2>;
};
template<typename _Tp1, typename _Tp2>
struct __common_type_impl<_Tp1, _Tp2, _Tp1, _Tp2>
: private __do_common_type_impl
{
using type = decltype(_S_test<_Tp1, _Tp2>(0));
};
template<typename _Tp1, typename _Tp2>
struct common_type<_Tp1, _Tp2>
: public __common_type_impl<_Tp1, _Tp2>::type
{ };
template<typename...>
struct __common_type_pack
{ };
template<typename, typename, typename = void>
struct __common_type_fold;
template<typename _Tp1, typename _Tp2, typename... _Rp>
struct common_type<_Tp1, _Tp2, _Rp...>
: public __common_type_fold<common_type<_Tp1, _Tp2>,
__common_type_pack<_Rp...>>
{ };
template<typename _CTp, typename... _Rp>
struct __common_type_fold<_CTp, __common_type_pack<_Rp...>,
__void_t<typename _CTp::type>>
: public common_type<typename _CTp::type, _Rp...>
{ };
template<typename _CTp, typename _Rp>
struct __common_type_fold<_CTp, _Rp, void>
{ };
template<typename _Tp, bool = is_enum<_Tp>::value>
struct __underlying_type_impl
{
using type = __underlying_type(_Tp);
};
template<typename _Tp>
struct __underlying_type_impl<_Tp, false>
{ };
template<typename _Tp>
struct underlying_type
: public __underlying_type_impl<_Tp>
{ };
template<typename _Tp>
struct __declval_protector
{
static const bool __stop = false;
};
template<typename _Tp>
auto declval() noexcept -> decltype(__declval<_Tp>(0))
{
static_assert(__declval_protector<_Tp>::__stop,
"declval() must not be used!");
return __declval<_Tp>(0);
}
template<typename _Signature>
class result_of;
struct __invoke_memfun_ref { };
struct __invoke_memfun_deref { };
struct __invoke_memobj_ref { };
struct __invoke_memobj_deref { };
struct __invoke_other { };
template<typename _Tp, typename _Tag>
struct __result_of_success : __success_type<_Tp>
{ using __invoke_type = _Tag; };
struct __result_of_memfun_ref_impl
{
template<typename _Fp, typename _Tp1, typename... _Args>
static __result_of_success<decltype(
(std::declval<_Tp1>().*std::declval<_Fp>())(std::declval<_Args>()...)
), __invoke_memfun_ref> _S_test(int);
template<typename...>
static __failure_type _S_test(...);
};
template<typename _MemPtr, typename _Arg, typename... _Args>
struct __result_of_memfun_ref
: private __result_of_memfun_ref_impl
{
typedef decltype(_S_test<_MemPtr, _Arg, _Args...>(0)) type;
};
struct __result_of_memfun_deref_impl
{
template<typename _Fp, typename _Tp1, typename... _Args>
static __result_of_success<decltype(
((*std::declval<_Tp1>()).*std::declval<_Fp>())(std::declval<_Args>()...)
), __invoke_memfun_deref> _S_test(int);
template<typename...>
static __failure_type _S_test(...);
};
template<typename _MemPtr, typename _Arg, typename... _Args>
struct __result_of_memfun_deref
: private __result_of_memfun_deref_impl
{
typedef decltype(_S_test<_MemPtr, _Arg, _Args...>(0)) type;
};
struct __result_of_memobj_ref_impl
{
template<typename _Fp, typename _Tp1>
static __result_of_success<decltype(
std::declval<_Tp1>().*std::declval<_Fp>()
), __invoke_memobj_ref> _S_test(int);
template<typename, typename>
static __failure_type _S_test(...);
};
template<typename _MemPtr, typename _Arg>
struct __result_of_memobj_ref
: private __result_of_memobj_ref_impl
{
typedef decltype(_S_test<_MemPtr, _Arg>(0)) type;
};
struct __result_of_memobj_deref_impl
{
template<typename _Fp, typename _Tp1>
static __result_of_success<decltype(
(*std::declval<_Tp1>()).*std::declval<_Fp>()
), __invoke_memobj_deref> _S_test(int);
template<typename, typename>
static __failure_type _S_test(...);
};
template<typename _MemPtr, typename _Arg>
struct __result_of_memobj_deref
: private __result_of_memobj_deref_impl
{
typedef decltype(_S_test<_MemPtr, _Arg>(0)) type;
};
template<typename _MemPtr, typename _Arg>
struct __result_of_memobj;
template<typename _Res, typename _Class, typename _Arg>
struct __result_of_memobj<_Res _Class::*, _Arg>
{
typedef __remove_cvref_t<_Arg> _Argval;
typedef _Res _Class::* _MemPtr;
typedef typename conditional<__or_<is_same<_Argval, _Class>,
is_base_of<_Class, _Argval>>::value,
__result_of_memobj_ref<_MemPtr, _Arg>,
__result_of_memobj_deref<_MemPtr, _Arg>
>::type::type type;
};
template<typename _MemPtr, typename _Arg, typename... _Args>
struct __result_of_memfun;
template<typename _Res, typename _Class, typename _Arg, typename... _Args>
struct __result_of_memfun<_Res _Class::*, _Arg, _Args...>
{
typedef typename remove_reference<_Arg>::type _Argval;
typedef _Res _Class::* _MemPtr;
typedef typename conditional<is_base_of<_Class, _Argval>::value,
__result_of_memfun_ref<_MemPtr, _Arg, _Args...>,
__result_of_memfun_deref<_MemPtr, _Arg, _Args...>
>::type::type type;
};
template<typename _Tp, typename _Up = __remove_cvref_t<_Tp>>
struct __inv_unwrap
{
using type = _Tp;
};
template<typename _Tp, typename _Up>
struct __inv_unwrap<_Tp, reference_wrapper<_Up>>
{
using type = _Up&;
};
template<bool, bool, typename _Functor, typename... _ArgTypes>
struct __result_of_impl
{
typedef __failure_type type;
};
template<typename _MemPtr, typename _Arg>
struct __result_of_impl<true, false, _MemPtr, _Arg>
: public __result_of_memobj<__decay_t<_MemPtr>,
typename __inv_unwrap<_Arg>::type>
{ };
template<typename _MemPtr, typename _Arg, typename... _Args>
struct __result_of_impl<false, true, _MemPtr, _Arg, _Args...>
: public __result_of_memfun<__decay_t<_MemPtr>,
typename __inv_unwrap<_Arg>::type, _Args...>
{ };
struct __result_of_other_impl
{
template<typename _Fn, typename... _Args>
static __result_of_success<decltype(
std::declval<_Fn>()(std::declval<_Args>()...)
), __invoke_other> _S_test(int);
template<typename...>
static __failure_type _S_test(...);
};
template<typename _Functor, typename... _ArgTypes>
struct __result_of_impl<false, false, _Functor, _ArgTypes...>
: private __result_of_other_impl
{
typedef decltype(_S_test<_Functor, _ArgTypes...>(0)) type;
};
template<typename _Functor, typename... _ArgTypes>
struct __invoke_result
: public __result_of_impl<
is_member_object_pointer<
typename remove_reference<_Functor>::type
>::value,
is_member_function_pointer<
typename remove_reference<_Functor>::type
>::value,
_Functor, _ArgTypes...
>::type
{ };
template<typename _Functor, typename... _ArgTypes>
struct result_of<_Functor(_ArgTypes...)>
: public __invoke_result<_Functor, _ArgTypes...>
{ };
template<size_t _Len, size_t _Align =
__alignof__(typename __aligned_storage_msa<_Len>::__type)>
using aligned_storage_t = typename aligned_storage<_Len, _Align>::type;
template <size_t _Len, typename... _Types>
using aligned_union_t = typename aligned_union<_Len, _Types...>::type;
template<typename _Tp>
using decay_t = typename decay<_Tp>::type;
template<bool _Cond, typename _Tp = void>
using enable_if_t = typename enable_if<_Cond, _Tp>::type;
template<bool _Cond, typename _Iftrue, typename _Iffalse>
using conditional_t = typename conditional<_Cond, _Iftrue, _Iffalse>::type;
template<typename... _Tp>
using common_type_t = typename common_type<_Tp...>::type;
template<typename _Tp>
using underlying_type_t = typename underlying_type<_Tp>::type;
template<typename _Tp>
using result_of_t = typename result_of<_Tp>::type;
template<typename...> using void_t = void;
template<typename _Default, typename _AlwaysVoid,
template<typename...> class _Op, typename... _Args>
struct __detector
{
using value_t = false_type;
using type = _Default;
};
template<typename _Default, template<typename...> class _Op,
typename... _Args>
struct __detector<_Default, __void_t<_Op<_Args...>>, _Op, _Args...>
{
using value_t = true_type;
using type = _Op<_Args...>;
};
template<typename _Default, template<typename...> class _Op,
typename... _Args>
using __detected_or = __detector<_Default, void, _Op, _Args...>;
template<typename _Default, template<typename...> class _Op,
typename... _Args>
using __detected_or_t
= typename __detected_or<_Default, _Op, _Args...>::type;
# 2624 "/usr/include/c++/10/type_traits" 3
template <typename _Tp>
struct __is_swappable;
template <typename _Tp>
struct __is_nothrow_swappable;
template<typename... _Elements>
class tuple;
template<typename>
struct __is_tuple_like_impl : false_type
{ };
template<typename... _Tps>
struct __is_tuple_like_impl<tuple<_Tps...>> : true_type
{ };
template<typename _Tp>
struct __is_tuple_like
: public __is_tuple_like_impl<__remove_cvref_t<_Tp>>::type
{ };
template<typename _Tp>
inline
_Require<__not_<__is_tuple_like<_Tp>>,
is_move_constructible<_Tp>,
is_move_assignable<_Tp>>
swap(_Tp&, _Tp&)
noexcept(__and_<is_nothrow_move_constructible<_Tp>,
is_nothrow_move_assignable<_Tp>>::value);
template<typename _Tp, size_t _Nm>
inline
__enable_if_t<__is_swappable<_Tp>::value>
swap(_Tp (&__a)[_Nm], _Tp (&__b)[_Nm])
noexcept(__is_nothrow_swappable<_Tp>::value);
namespace __swappable_details {
using std::swap;
struct __do_is_swappable_impl
{
template<typename _Tp, typename
= decltype(swap(std::declval<_Tp&>(), std::declval<_Tp&>()))>
static true_type __test(int);
template<typename>
static false_type __test(...);
};
struct __do_is_nothrow_swappable_impl
{
template<typename _Tp>
static __bool_constant<
noexcept(swap(std::declval<_Tp&>(), std::declval<_Tp&>()))
> __test(int);
template<typename>
static false_type __test(...);
};
}
template<typename _Tp>
struct __is_swappable_impl
: public __swappable_details::__do_is_swappable_impl
{
typedef decltype(__test<_Tp>(0)) type;
};
template<typename _Tp>
struct __is_nothrow_swappable_impl
: public __swappable_details::__do_is_nothrow_swappable_impl
{
typedef decltype(__test<_Tp>(0)) type;
};
template<typename _Tp>
struct __is_swappable
: public __is_swappable_impl<_Tp>::type
{ };
template<typename _Tp>
struct __is_nothrow_swappable
: public __is_nothrow_swappable_impl<_Tp>::type
{ };
template<typename _Tp>
struct is_swappable
: public __is_swappable_impl<_Tp>::type
{
static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
"template argument must be a complete class or an unbounded array");
};
template<typename _Tp>
struct is_nothrow_swappable
: public __is_nothrow_swappable_impl<_Tp>::type
{
static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
"template argument must be a complete class or an unbounded array");
};
template<typename _Tp>
constexpr bool is_swappable_v =
is_swappable<_Tp>::value;
template<typename _Tp>
constexpr bool is_nothrow_swappable_v =
is_nothrow_swappable<_Tp>::value;
namespace __swappable_with_details {
using std::swap;
struct __do_is_swappable_with_impl
{
template<typename _Tp, typename _Up, typename
= decltype(swap(std::declval<_Tp>(), std::declval<_Up>())),
typename
= decltype(swap(std::declval<_Up>(), std::declval<_Tp>()))>
static true_type __test(int);
template<typename, typename>
static false_type __test(...);
};
struct __do_is_nothrow_swappable_with_impl
{
template<typename _Tp, typename _Up>
static __bool_constant<
noexcept(swap(std::declval<_Tp>(), std::declval<_Up>()))
&&
noexcept(swap(std::declval<_Up>(), std::declval<_Tp>()))
> __test(int);
template<typename, typename>
static false_type __test(...);
};
}
template<typename _Tp, typename _Up>
struct __is_swappable_with_impl
: public __swappable_with_details::__do_is_swappable_with_impl
{
typedef decltype(__test<_Tp, _Up>(0)) type;
};
template<typename _Tp>
struct __is_swappable_with_impl<_Tp&, _Tp&>
: public __swappable_details::__do_is_swappable_impl
{
typedef decltype(__test<_Tp&>(0)) type;
};
template<typename _Tp, typename _Up>
struct __is_nothrow_swappable_with_impl
: public __swappable_with_details::__do_is_nothrow_swappable_with_impl
{
typedef decltype(__test<_Tp, _Up>(0)) type;
};
template<typename _Tp>
struct __is_nothrow_swappable_with_impl<_Tp&, _Tp&>
: public __swappable_details::__do_is_nothrow_swappable_impl
{
typedef decltype(__test<_Tp&>(0)) type;
};
template<typename _Tp, typename _Up>
struct is_swappable_with
: public __is_swappable_with_impl<_Tp, _Up>::type
{ };
template<typename _Tp, typename _Up>
struct is_nothrow_swappable_with
: public __is_nothrow_swappable_with_impl<_Tp, _Up>::type
{ };
template<typename _Tp, typename _Up>
constexpr bool is_swappable_with_v =
is_swappable_with<_Tp, _Up>::value;
template<typename _Tp, typename _Up>
constexpr bool is_nothrow_swappable_with_v =
is_nothrow_swappable_with<_Tp, _Up>::value;
template<typename _Result, typename _Ret,
bool = is_void<_Ret>::value, typename = void>
struct __is_invocable_impl : false_type { };
template<typename _Result, typename _Ret>
struct __is_invocable_impl<_Result, _Ret,
true,
__void_t<typename _Result::type>>
: true_type
{ };
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wctor-dtor-privacy"
template<typename _Result, typename _Ret>
struct __is_invocable_impl<_Result, _Ret,
false,
__void_t<typename _Result::type>>
{
private:
static typename _Result::type _S_get();
template<typename _Tp>
static void _S_conv(_Tp);
template<typename _Tp, typename = decltype(_S_conv<_Tp>(_S_get()))>
static true_type
_S_test(int);
template<typename _Tp>
static false_type
_S_test(...);
public:
using type = decltype(_S_test<_Ret>(1));
};
#pragma GCC diagnostic pop
template<typename _Fn, typename... _ArgTypes>
struct __is_invocable
: __is_invocable_impl<__invoke_result<_Fn, _ArgTypes...>, void>::type
{ };
template<typename _Fn, typename _Tp, typename... _Args>
constexpr bool __call_is_nt(__invoke_memfun_ref)
{
using _Up = typename __inv_unwrap<_Tp>::type;
return noexcept((std::declval<_Up>().*std::declval<_Fn>())(
std::declval<_Args>()...));
}
template<typename _Fn, typename _Tp, typename... _Args>
constexpr bool __call_is_nt(__invoke_memfun_deref)
{
return noexcept(((*std::declval<_Tp>()).*std::declval<_Fn>())(
std::declval<_Args>()...));
}
template<typename _Fn, typename _Tp>
constexpr bool __call_is_nt(__invoke_memobj_ref)
{
using _Up = typename __inv_unwrap<_Tp>::type;
return noexcept(std::declval<_Up>().*std::declval<_Fn>());
}
template<typename _Fn, typename _Tp>
constexpr bool __call_is_nt(__invoke_memobj_deref)
{
return noexcept((*std::declval<_Tp>()).*std::declval<_Fn>());
}
template<typename _Fn, typename... _Args>
constexpr bool __call_is_nt(__invoke_other)
{
return noexcept(std::declval<_Fn>()(std::declval<_Args>()...));
}
template<typename _Result, typename _Fn, typename... _Args>
struct __call_is_nothrow
: __bool_constant<
std::__call_is_nt<_Fn, _Args...>(typename _Result::__invoke_type{})
>
{ };
template<typename _Fn, typename... _Args>
using __call_is_nothrow_
= __call_is_nothrow<__invoke_result<_Fn, _Args...>, _Fn, _Args...>;
template<typename _Fn, typename... _Args>
struct __is_nothrow_invocable
: __and_<__is_invocable<_Fn, _Args...>,
__call_is_nothrow_<_Fn, _Args...>>::type
{ };
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wctor-dtor-privacy"
struct __nonesuchbase {};
struct __nonesuch : private __nonesuchbase {
~__nonesuch() = delete;
__nonesuch(__nonesuch const&) = delete;
void operator=(__nonesuch const&) = delete;
};
#pragma GCC diagnostic pop
# 3455 "/usr/include/c++/10/type_traits" 3
}
# 58 "/usr/include/c++/10/bits/move.h" 2 3
namespace std __attribute__ ((__visibility__ ("default")))
{
# 74 "/usr/include/c++/10/bits/move.h" 3
template<typename _Tp>
constexpr _Tp&&
forward(typename std::remove_reference<_Tp>::type& __t) noexcept
{ return static_cast<_Tp&&>(__t); }
template<typename _Tp>
constexpr _Tp&&
forward(typename std::remove_reference<_Tp>::type&& __t) noexcept
{
static_assert(!std::is_lvalue_reference<_Tp>::value, "template argument"
" substituting _Tp is an lvalue reference type");
return static_cast<_Tp&&>(__t);
}
template<typename _Tp>
constexpr typename std::remove_reference<_Tp>::type&&
move(_Tp&& __t) noexcept
{ return static_cast<typename std::remove_reference<_Tp>::type&&>(__t); }
template<typename _Tp>
struct __move_if_noexcept_cond
: public __and_<__not_<is_nothrow_move_constructible<_Tp>>,
is_copy_constructible<_Tp>>::type { };
# 118 "/usr/include/c++/10/bits/move.h" 3
template<typename _Tp>
constexpr typename
conditional<__move_if_noexcept_cond<_Tp>::value, const _Tp&, _Tp&&>::type
move_if_noexcept(_Tp& __x) noexcept
{ return std::move(__x); }
# 138 "/usr/include/c++/10/bits/move.h" 3
template<typename _Tp>
inline _Tp*
addressof(_Tp& __r) noexcept
{ return std::__addressof(__r); }
template<typename _Tp>
const _Tp* addressof(const _Tp&&) = delete;
template <typename _Tp, typename _Up = _Tp>
inline _Tp
__exchange(_Tp& __obj, _Up&& __new_val)
{
_Tp __old_val = std::move(__obj);
__obj = std::forward<_Up>(__new_val);
return __old_val;
}
# 179 "/usr/include/c++/10/bits/move.h" 3
template<typename _Tp>
inline
typename enable_if<__and_<__not_<__is_tuple_like<_Tp>>,
is_move_constructible<_Tp>,
is_move_assignable<_Tp>>::value>::type
swap(_Tp& __a, _Tp& __b)
noexcept(__and_<is_nothrow_move_constructible<_Tp>, is_nothrow_move_assignable<_Tp>>::value)
{
_Tp __tmp = std::move(__a);
__a = std::move(__b);
__b = std::move(__tmp);
}
template<typename _Tp, size_t _Nm>
inline
typename enable_if<__is_swappable<_Tp>::value>::type
swap(_Tp (&__a)[_Nm], _Tp (&__b)[_Nm])
noexcept(__is_nothrow_swappable<_Tp>::value)
{
for (size_t __n = 0; __n < _Nm; ++__n)
swap(__a[__n], __b[__n]);
}
}
# 41 "/usr/include/c++/10/bits/nested_exception.h" 2 3
extern "C++" {
namespace std
{
class nested_exception
{
exception_ptr _M_ptr;
public:
nested_exception() noexcept : _M_ptr(current_exception()) { }
nested_exception(const nested_exception&) noexcept = default;
nested_exception& operator=(const nested_exception&) noexcept = default;
virtual ~nested_exception() noexcept;
[[noreturn]]
void
rethrow_nested() const
{
if (_M_ptr)
rethrow_exception(_M_ptr);
std::terminate();
}
exception_ptr
nested_ptr() const noexcept
{ return _M_ptr; }
};
template<typename _Except>
struct _Nested_exception : public _Except, public nested_exception
{
explicit _Nested_exception(const _Except& __ex)
: _Except(__ex)
{ }
explicit _Nested_exception(_Except&& __ex)
: _Except(static_cast<_Except&&>(__ex))
{ }
};
template<typename _Tp>
[[noreturn]]
inline void
__throw_with_nested_impl(_Tp&& __t, true_type)
{
using _Up = typename remove_reference<_Tp>::type;
throw _Nested_exception<_Up>{std::forward<_Tp>(__t)};
}
template<typename _Tp>
[[noreturn]]
inline void
__throw_with_nested_impl(_Tp&& __t, false_type)
{ throw std::forward<_Tp>(__t); }
template<typename _Tp>
[[noreturn]]
inline void
throw_with_nested(_Tp&& __t)
{
using _Up = typename decay<_Tp>::type;
using _CopyConstructible
= __and_<is_copy_constructible<_Up>, is_move_constructible<_Up>>;
static_assert(_CopyConstructible::value,
"throw_with_nested argument must be CopyConstructible");
using __nest = __and_<is_class<_Up>, __bool_constant<!__is_final(_Up)>,
__not_<is_base_of<nested_exception, _Up>>>;
std::__throw_with_nested_impl(std::forward<_Tp>(__t), __nest{});
}
template<typename _Tp>
using __rethrow_if_nested_cond = typename enable_if<
__and_<is_polymorphic<_Tp>,
__or_<__not_<is_base_of<nested_exception, _Tp>>,
is_convertible<_Tp*, nested_exception*>>>::value
>::type;
template<typename _Ex>
inline __rethrow_if_nested_cond<_Ex>
__rethrow_if_nested_impl(const _Ex* __ptr)
{
if (auto __ne_ptr = dynamic_cast<const nested_exception*>(__ptr))
__ne_ptr->rethrow_nested();
}
inline void
__rethrow_if_nested_impl(const void*)
{ }
template<typename _Ex>
inline void
rethrow_if_nested(const _Ex& __ex)
{ std::__rethrow_if_nested_impl(std::__addressof(__ex)); }
}
}
#pragma GCC visibility pop
# 149 "/usr/include/c++/10/exception" 2 3
# 42 "/usr/include/c++/10/new" 2 3
#pragma GCC visibility push(default)
extern "C++" {
namespace std
{
class bad_alloc : public exception
{
public:
bad_alloc() throw() { }
bad_alloc(const bad_alloc&) = default;
bad_alloc& operator=(const bad_alloc&) = default;
virtual ~bad_alloc() throw();
virtual const char* what() const throw();
};
class bad_array_new_length : public bad_alloc
{
public:
bad_array_new_length() throw() { }
virtual ~bad_array_new_length() throw();
virtual const char* what() const throw();
};
struct nothrow_t
{
explicit nothrow_t() = default;
};
extern const nothrow_t nothrow;
typedef void (*new_handler)();
new_handler set_new_handler(new_handler) throw();
new_handler get_new_handler() noexcept;
}
# 126 "/usr/include/c++/10/new" 3
void* operator new(std::size_t)
__attribute__((__externally_visible__));
void* operator new[](std::size_t)
__attribute__((__externally_visible__));
void operator delete(void*) noexcept
__attribute__((__externally_visible__));
void operator delete[](void*) noexcept
__attribute__((__externally_visible__));
void operator delete(void*, std::size_t) noexcept
__attribute__((__externally_visible__));
void operator delete[](void*, std::size_t) noexcept
__attribute__((__externally_visible__));
void* operator new(std::size_t, const std::nothrow_t&) noexcept
__attribute__((__externally_visible__, __malloc__));
void* operator new[](std::size_t, const std::nothrow_t&) noexcept
__attribute__((__externally_visible__, __malloc__));
void operator delete(void*, const std::nothrow_t&) noexcept
__attribute__((__externally_visible__));
void operator delete[](void*, const std::nothrow_t&) noexcept
__attribute__((__externally_visible__));
# 174 "/usr/include/c++/10/new" 3
inline void* operator new(std::size_t, void* __p) noexcept
{ return __p; }
inline void* operator new[](std::size_t, void* __p) noexcept
{ return __p; }
inline void operator delete (void*, void*) noexcept { }
inline void operator delete[](void*, void*) noexcept { }
}
# 230 "/usr/include/c++/10/new" 3
#pragma GCC visibility pop
# 237 "/home/giulianob/gcc_git_gnu/gcc/gcc/system.h" 2
# 1 "/usr/include/c++/10/utility" 1 3
# 58 "/usr/include/c++/10/utility" 3
# 59 "/usr/include/c++/10/utility" 3
# 69 "/usr/include/c++/10/utility" 3
# 1 "/usr/include/c++/10/bits/stl_relops.h" 1 3
# 67 "/usr/include/c++/10/bits/stl_relops.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{
namespace rel_ops
{
# 85 "/usr/include/c++/10/bits/stl_relops.h" 3
template <class _Tp>
inline bool
operator!=(const _Tp& __x, const _Tp& __y)
{ return !(__x == __y); }
# 98 "/usr/include/c++/10/bits/stl_relops.h" 3
template <class _Tp>
inline bool
operator>(const _Tp& __x, const _Tp& __y)
{ return __y < __x; }
# 111 "/usr/include/c++/10/bits/stl_relops.h" 3
template <class _Tp>
inline bool
operator<=(const _Tp& __x, const _Tp& __y)
{ return !(__y < __x); }
# 124 "/usr/include/c++/10/bits/stl_relops.h" 3
template <class _Tp>
inline bool
operator>=(const _Tp& __x, const _Tp& __y)
{ return !(__x < __y); }
}
}
# 70 "/usr/include/c++/10/utility" 2 3
# 1 "/usr/include/c++/10/bits/stl_pair.h" 1 3
# 69 "/usr/include/c++/10/bits/stl_pair.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{
# 80 "/usr/include/c++/10/bits/stl_pair.h" 3
struct piecewise_construct_t { explicit piecewise_construct_t() = default; };
constexpr piecewise_construct_t piecewise_construct =
piecewise_construct_t();
template<typename...>
class tuple;
template<std::size_t...>
struct _Index_tuple;
template <bool, typename _T1, typename _T2>
struct _PCC
{
template <typename _U1, typename _U2>
static constexpr bool _ConstructiblePair()
{
return __and_<is_constructible<_T1, const _U1&>,
is_constructible<_T2, const _U2&>>::value;
}
template <typename _U1, typename _U2>
static constexpr bool _ImplicitlyConvertiblePair()
{
return __and_<is_convertible<const _U1&, _T1>,
is_convertible<const _U2&, _T2>>::value;
}
template <typename _U1, typename _U2>
static constexpr bool _MoveConstructiblePair()
{
return __and_<is_constructible<_T1, _U1&&>,
is_constructible<_T2, _U2&&>>::value;
}
template <typename _U1, typename _U2>
static constexpr bool _ImplicitlyMoveConvertiblePair()
{
return __and_<is_convertible<_U1&&, _T1>,
is_convertible<_U2&&, _T2>>::value;
}
template <bool __implicit, typename _U1, typename _U2>
static constexpr bool _CopyMovePair()
{
using __do_converts = __and_<is_convertible<const _U1&, _T1>,
is_convertible<_U2&&, _T2>>;
using __converts = typename conditional<__implicit,
__do_converts,
__not_<__do_converts>>::type;
return __and_<is_constructible<_T1, const _U1&>,
is_constructible<_T2, _U2&&>,
__converts
>::value;
}
template <bool __implicit, typename _U1, typename _U2>
static constexpr bool _MoveCopyPair()
{
using __do_converts = __and_<is_convertible<_U1&&, _T1>,
is_convertible<const _U2&, _T2>>;
using __converts = typename conditional<__implicit,
__do_converts,
__not_<__do_converts>>::type;
return __and_<is_constructible<_T1, _U1&&>,
is_constructible<_T2, const _U2&&>,
__converts
>::value;
}
};
template <typename _T1, typename _T2>
struct _PCC<false, _T1, _T2>
{
template <typename _U1, typename _U2>
static constexpr bool _ConstructiblePair()
{
return false;
}
template <typename _U1, typename _U2>
static constexpr bool _ImplicitlyConvertiblePair()
{
return false;
}
template <typename _U1, typename _U2>
static constexpr bool _MoveConstructiblePair()
{
return false;
}
template <typename _U1, typename _U2>
static constexpr bool _ImplicitlyMoveConvertiblePair()
{
return false;
}
};
template<typename _U1, typename _U2> class __pair_base
{
template<typename _T1, typename _T2> friend struct pair;
__pair_base() = default;
~__pair_base() = default;
__pair_base(const __pair_base&) = default;
__pair_base& operator=(const __pair_base&) = delete;
};
# 210 "/usr/include/c++/10/bits/stl_pair.h" 3
template<typename _T1, typename _T2>
struct pair
: private __pair_base<_T1, _T2>
{
typedef _T1 first_type;
typedef _T2 second_type;
_T1 first;
_T2 second;
template <typename _U1 = _T1,
typename _U2 = _T2,
typename enable_if<__and_<
__is_implicitly_default_constructible<_U1>,
__is_implicitly_default_constructible<_U2>>
::value, bool>::type = true>
constexpr pair()
: first(), second() { }
template <typename _U1 = _T1,
typename _U2 = _T2,
typename enable_if<__and_<
is_default_constructible<_U1>,
is_default_constructible<_U2>,
__not_<
__and_<__is_implicitly_default_constructible<_U1>,
__is_implicitly_default_constructible<_U2>>>>
::value, bool>::type = false>
explicit constexpr pair()
: first(), second() { }
# 256 "/usr/include/c++/10/bits/stl_pair.h" 3
using _PCCP = _PCC<true, _T1, _T2>;
template<typename _U1 = _T1, typename _U2=_T2, typename
enable_if<_PCCP::template
_ConstructiblePair<_U1, _U2>()
&& _PCCP::template
_ImplicitlyConvertiblePair<_U1, _U2>(),
bool>::type=true>
constexpr pair(const _T1& __a, const _T2& __b)
: first(__a), second(__b) { }
template<typename _U1 = _T1, typename _U2=_T2, typename
enable_if<_PCCP::template
_ConstructiblePair<_U1, _U2>()
&& !_PCCP::template
_ImplicitlyConvertiblePair<_U1, _U2>(),
bool>::type=false>
explicit constexpr pair(const _T1& __a, const _T2& __b)
: first(__a), second(__b) { }
# 288 "/usr/include/c++/10/bits/stl_pair.h" 3
template <typename _U1, typename _U2>
using _PCCFP = _PCC<!is_same<_T1, _U1>::value
|| !is_same<_T2, _U2>::value,
_T1, _T2>;
template<typename _U1, typename _U2, typename
enable_if<_PCCFP<_U1, _U2>::template
_ConstructiblePair<_U1, _U2>()
&& _PCCFP<_U1, _U2>::template
_ImplicitlyConvertiblePair<_U1, _U2>(),
bool>::type=true>
constexpr pair(const pair<_U1, _U2>& __p)
: first(__p.first), second(__p.second) { }
template<typename _U1, typename _U2, typename
enable_if<_PCCFP<_U1, _U2>::template
_ConstructiblePair<_U1, _U2>()
&& !_PCCFP<_U1, _U2>::template
_ImplicitlyConvertiblePair<_U1, _U2>(),
bool>::type=false>
explicit constexpr pair(const pair<_U1, _U2>& __p)
: first(__p.first), second(__p.second) { }
constexpr pair(const pair&) = default;
constexpr pair(pair&&) = default;
template<typename _U1, typename
enable_if<_PCCP::template
_MoveCopyPair<true, _U1, _T2>(),
bool>::type=true>
constexpr pair(_U1&& __x, const _T2& __y)
: first(std::forward<_U1>(__x)), second(__y) { }
template<typename _U1, typename
enable_if<_PCCP::template
_MoveCopyPair<false, _U1, _T2>(),
bool>::type=false>
explicit constexpr pair(_U1&& __x, const _T2& __y)
: first(std::forward<_U1>(__x)), second(__y) { }
template<typename _U2, typename
enable_if<_PCCP::template
_CopyMovePair<true, _T1, _U2>(),
bool>::type=true>
constexpr pair(const _T1& __x, _U2&& __y)
: first(__x), second(std::forward<_U2>(__y)) { }
template<typename _U2, typename
enable_if<_PCCP::template
_CopyMovePair<false, _T1, _U2>(),
bool>::type=false>
explicit pair(const _T1& __x, _U2&& __y)
: first(__x), second(std::forward<_U2>(__y)) { }
template<typename _U1, typename _U2, typename
enable_if<_PCCP::template
_MoveConstructiblePair<_U1, _U2>()
&& _PCCP::template
_ImplicitlyMoveConvertiblePair<_U1, _U2>(),
bool>::type=true>
constexpr pair(_U1&& __x, _U2&& __y)
: first(std::forward<_U1>(__x)), second(std::forward<_U2>(__y)) { }
template<typename _U1, typename _U2, typename
enable_if<_PCCP::template
_MoveConstructiblePair<_U1, _U2>()
&& !_PCCP::template
_ImplicitlyMoveConvertiblePair<_U1, _U2>(),
bool>::type=false>
explicit constexpr pair(_U1&& __x, _U2&& __y)
: first(std::forward<_U1>(__x)), second(std::forward<_U2>(__y)) { }
template<typename _U1, typename _U2, typename
enable_if<_PCCFP<_U1, _U2>::template
_MoveConstructiblePair<_U1, _U2>()
&& _PCCFP<_U1, _U2>::template
_ImplicitlyMoveConvertiblePair<_U1, _U2>(),
bool>::type=true>
constexpr pair(pair<_U1, _U2>&& __p)
: first(std::forward<_U1>(__p.first)),
second(std::forward<_U2>(__p.second)) { }
template<typename _U1, typename _U2, typename
enable_if<_PCCFP<_U1, _U2>::template
_MoveConstructiblePair<_U1, _U2>()
&& !_PCCFP<_U1, _U2>::template
_ImplicitlyMoveConvertiblePair<_U1, _U2>(),
bool>::type=false>
explicit constexpr pair(pair<_U1, _U2>&& __p)
: first(std::forward<_U1>(__p.first)),
second(std::forward<_U2>(__p.second)) { }
template<typename... _Args1, typename... _Args2>
pair(piecewise_construct_t, tuple<_Args1...>, tuple<_Args2...>);
pair&
operator=(typename conditional<
__and_<is_copy_assignable<_T1>,
is_copy_assignable<_T2>>::value,
const pair&, const __nonesuch&>::type __p)
{
first = __p.first;
second = __p.second;
return *this;
}
pair&
operator=(typename conditional<
__and_<is_move_assignable<_T1>,
is_move_assignable<_T2>>::value,
pair&&, __nonesuch&&>::type __p)
noexcept(__and_<is_nothrow_move_assignable<_T1>,
is_nothrow_move_assignable<_T2>>::value)
{
first = std::forward<first_type>(__p.first);
second = std::forward<second_type>(__p.second);
return *this;
}
template<typename _U1, typename _U2>
typename enable_if<__and_<is_assignable<_T1&, const _U1&>,
is_assignable<_T2&, const _U2&>>::value,
pair&>::type
operator=(const pair<_U1, _U2>& __p)
{
first = __p.first;
second = __p.second;
return *this;
}
template<typename _U1, typename _U2>
typename enable_if<__and_<is_assignable<_T1&, _U1&&>,
is_assignable<_T2&, _U2&&>>::value,
pair&>::type
operator=(pair<_U1, _U2>&& __p)
{
first = std::forward<_U1>(__p.first);
second = std::forward<_U2>(__p.second);
return *this;
}
void
swap(pair& __p)
noexcept(__and_<__is_nothrow_swappable<_T1>,
__is_nothrow_swappable<_T2>>::value)
{
using std::swap;
swap(first, __p.first);
swap(second, __p.second);
}
private:
template<typename... _Args1, std::size_t... _Indexes1,
typename... _Args2, std::size_t... _Indexes2>
pair(tuple<_Args1...>&, tuple<_Args2...>&,
_Index_tuple<_Indexes1...>, _Index_tuple<_Indexes2...>);
};
# 464 "/usr/include/c++/10/bits/stl_pair.h" 3
template<typename _T1, typename _T2>
inline constexpr bool
operator==(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
{ return __x.first == __y.first && __x.second == __y.second; }
# 487 "/usr/include/c++/10/bits/stl_pair.h" 3
template<typename _T1, typename _T2>
inline constexpr bool
operator<(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
{ return __x.first < __y.first
|| (!(__y.first < __x.first) && __x.second < __y.second); }
template<typename _T1, typename _T2>
inline constexpr bool
operator!=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
{ return !(__x == __y); }
template<typename _T1, typename _T2>
inline constexpr bool
operator>(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
{ return __y < __x; }
template<typename _T1, typename _T2>
inline constexpr bool
operator<=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
{ return !(__y < __x); }
template<typename _T1, typename _T2>
inline constexpr bool
operator>=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
{ return !(__x < __y); }
# 524 "/usr/include/c++/10/bits/stl_pair.h" 3
template<typename _T1, typename _T2>
inline
typename enable_if<__and_<__is_swappable<_T1>,
__is_swappable<_T2>>::value>::type
swap(pair<_T1, _T2>& __x, pair<_T1, _T2>& __y)
noexcept(noexcept(__x.swap(__y)))
{ __x.swap(__y); }
template<typename _T1, typename _T2>
typename enable_if<!__and_<__is_swappable<_T1>,
__is_swappable<_T2>>::value>::type
swap(pair<_T1, _T2>&, pair<_T1, _T2>&) = delete;
# 564 "/usr/include/c++/10/bits/stl_pair.h" 3
template<typename _T1, typename _T2>
constexpr pair<typename __decay_and_strip<_T1>::__type,
typename __decay_and_strip<_T2>::__type>
make_pair(_T1&& __x, _T2&& __y)
{
typedef typename __decay_and_strip<_T1>::__type __ds_type1;
typedef typename __decay_and_strip<_T2>::__type __ds_type2;
typedef pair<__ds_type1, __ds_type2> __pair_type;
return __pair_type(std::forward<_T1>(__x), std::forward<_T2>(__y));
}
# 583 "/usr/include/c++/10/bits/stl_pair.h" 3
}
# 71 "/usr/include/c++/10/utility" 2 3
# 1 "/usr/include/c++/10/initializer_list" 1 3
# 33 "/usr/include/c++/10/initializer_list" 3
# 34 "/usr/include/c++/10/initializer_list" 3
#pragma GCC visibility push(default)
namespace std
{
template<class _E>
class initializer_list
{
public:
typedef _E value_type;
typedef const _E& reference;
typedef const _E& const_reference;
typedef size_t size_type;
typedef const _E* iterator;
typedef const _E* const_iterator;
private:
iterator _M_array;
size_type _M_len;
constexpr initializer_list(const_iterator __a, size_type __l)
: _M_array(__a), _M_len(__l) { }
public:
constexpr initializer_list() noexcept
: _M_array(0), _M_len(0) { }
constexpr size_type
size() const noexcept { return _M_len; }
constexpr const_iterator
begin() const noexcept { return _M_array; }
constexpr const_iterator
end() const noexcept { return begin() + size(); }
};
template<class _Tp>
constexpr const _Tp*
begin(initializer_list<_Tp> __ils) noexcept
{ return __ils.begin(); }
template<class _Tp>
constexpr const _Tp*
end(initializer_list<_Tp> __ils) noexcept
{ return __ils.end(); }
}
#pragma GCC visibility pop
# 77 "/usr/include/c++/10/utility" 2 3
namespace std __attribute__ ((__visibility__ ("default")))
{
template<typename _Tp>
struct tuple_size;
template<typename _Tp,
typename _Up = typename remove_cv<_Tp>::type,
typename = typename enable_if<is_same<_Tp, _Up>::value>::type,
size_t = tuple_size<_Tp>::value>
using __enable_if_has_tuple_size = _Tp;
template<typename _Tp>
struct tuple_size<const __enable_if_has_tuple_size<_Tp>>
: public tuple_size<_Tp> { };
template<typename _Tp>
struct tuple_size<volatile __enable_if_has_tuple_size<_Tp>>
: public tuple_size<_Tp> { };
template<typename _Tp>
struct tuple_size<const volatile __enable_if_has_tuple_size<_Tp>>
: public tuple_size<_Tp> { };
template<std::size_t __i, typename _Tp>
struct tuple_element;
template<std::size_t __i, typename _Tp>
using __tuple_element_t = typename tuple_element<__i, _Tp>::type;
template<std::size_t __i, typename _Tp>
struct tuple_element<__i, const _Tp>
{
typedef typename add_const<__tuple_element_t<__i, _Tp>>::type type;
};
template<std::size_t __i, typename _Tp>
struct tuple_element<__i, volatile _Tp>
{
typedef typename add_volatile<__tuple_element_t<__i, _Tp>>::type type;
};
template<std::size_t __i, typename _Tp>
struct tuple_element<__i, const volatile _Tp>
{
typedef typename add_cv<__tuple_element_t<__i, _Tp>>::type type;
};
template<std::size_t __i, typename _Tp>
using tuple_element_t = typename tuple_element<__i, _Tp>::type;
template<typename _T1, typename _T2>
struct __is_tuple_like_impl<std::pair<_T1, _T2>> : true_type
{ };
template<class _Tp1, class _Tp2>
struct tuple_size<std::pair<_Tp1, _Tp2>>
: public integral_constant<std::size_t, 2> { };
template<class _Tp1, class _Tp2>
struct tuple_element<0, std::pair<_Tp1, _Tp2>>
{ typedef _Tp1 type; };
template<class _Tp1, class _Tp2>
struct tuple_element<1, std::pair<_Tp1, _Tp2>>
{ typedef _Tp2 type; };
template<std::size_t _Int>
struct __pair_get;
template<>
struct __pair_get<0>
{
template<typename _Tp1, typename _Tp2>
static constexpr _Tp1&
__get(std::pair<_Tp1, _Tp2>& __pair) noexcept
{ return __pair.first; }
template<typename _Tp1, typename _Tp2>
static constexpr _Tp1&&
__move_get(std::pair<_Tp1, _Tp2>&& __pair) noexcept
{ return std::forward<_Tp1>(__pair.first); }
template<typename _Tp1, typename _Tp2>
static constexpr const _Tp1&
__const_get(const std::pair<_Tp1, _Tp2>& __pair) noexcept
{ return __pair.first; }
template<typename _Tp1, typename _Tp2>
static constexpr const _Tp1&&
__const_move_get(const std::pair<_Tp1, _Tp2>&& __pair) noexcept
{ return std::forward<const _Tp1>(__pair.first); }
};
template<>
struct __pair_get<1>
{
template<typename _Tp1, typename _Tp2>
static constexpr _Tp2&
__get(std::pair<_Tp1, _Tp2>& __pair) noexcept
{ return __pair.second; }
template<typename _Tp1, typename _Tp2>
static constexpr _Tp2&&
__move_get(std::pair<_Tp1, _Tp2>&& __pair) noexcept
{ return std::forward<_Tp2>(__pair.second); }
template<typename _Tp1, typename _Tp2>
static constexpr const _Tp2&
__const_get(const std::pair<_Tp1, _Tp2>& __pair) noexcept
{ return __pair.second; }
template<typename _Tp1, typename _Tp2>
static constexpr const _Tp2&&
__const_move_get(const std::pair<_Tp1, _Tp2>&& __pair) noexcept
{ return std::forward<const _Tp2>(__pair.second); }
};
template<std::size_t _Int, class _Tp1, class _Tp2>
constexpr typename tuple_element<_Int, std::pair<_Tp1, _Tp2>>::type&
get(std::pair<_Tp1, _Tp2>& __in) noexcept
{ return __pair_get<_Int>::__get(__in); }
template<std::size_t _Int, class _Tp1, class _Tp2>
constexpr typename tuple_element<_Int, std::pair<_Tp1, _Tp2>>::type&&
get(std::pair<_Tp1, _Tp2>&& __in) noexcept
{ return __pair_get<_Int>::__move_get(std::move(__in)); }
template<std::size_t _Int, class _Tp1, class _Tp2>
constexpr const typename tuple_element<_Int, std::pair<_Tp1, _Tp2>>::type&
get(const std::pair<_Tp1, _Tp2>& __in) noexcept
{ return __pair_get<_Int>::__const_get(__in); }
template<std::size_t _Int, class _Tp1, class _Tp2>
constexpr const typename tuple_element<_Int, std::pair<_Tp1, _Tp2>>::type&&
get(const std::pair<_Tp1, _Tp2>&& __in) noexcept
{ return __pair_get<_Int>::__const_move_get(std::move(__in)); }
template <typename _Tp, typename _Up>
constexpr _Tp&
get(pair<_Tp, _Up>& __p) noexcept
{ return __p.first; }
template <typename _Tp, typename _Up>
constexpr const _Tp&
get(const pair<_Tp, _Up>& __p) noexcept
{ return __p.first; }
template <typename _Tp, typename _Up>
constexpr _Tp&&
get(pair<_Tp, _Up>&& __p) noexcept
{ return std::move(__p.first); }
template <typename _Tp, typename _Up>
constexpr const _Tp&&
get(const pair<_Tp, _Up>&& __p) noexcept
{ return std::move(__p.first); }
template <typename _Tp, typename _Up>
constexpr _Tp&
get(pair<_Up, _Tp>& __p) noexcept
{ return __p.second; }
template <typename _Tp, typename _Up>
constexpr const _Tp&
get(const pair<_Up, _Tp>& __p) noexcept
{ return __p.second; }
template <typename _Tp, typename _Up>
constexpr _Tp&&
get(pair<_Up, _Tp>&& __p) noexcept
{ return std::move(__p.second); }
template <typename _Tp, typename _Up>
constexpr const _Tp&&
get(const pair<_Up, _Tp>&& __p) noexcept
{ return std::move(__p.second); }
template <typename _Tp, typename _Up = _Tp>
inline _Tp
exchange(_Tp& __obj, _Up&& __new_val)
{ return std::__exchange(__obj, std::forward<_Up>(__new_val)); }
template<size_t... _Indexes> struct _Index_tuple { };
# 307 "/usr/include/c++/10/utility" 3
template<size_t _Num>
struct _Build_index_tuple
{
using __type = _Index_tuple<__integer_pack(_Num)...>;
};
template<typename _Tp, _Tp... _Idx>
struct integer_sequence
{
typedef _Tp value_type;
static constexpr size_t size() noexcept { return sizeof...(_Idx); }
};
template<typename _Tp, _Tp _Num>
using make_integer_sequence
= integer_sequence<_Tp, __integer_pack(_Num)...>;
template<size_t... _Idx>
using index_sequence = integer_sequence<size_t, _Idx...>;
template<size_t _Num>
using make_index_sequence = make_integer_sequence<size_t, _Num>;
template<typename... _Types>
using index_sequence_for = make_index_sequence<sizeof...(_Types)>;
# 473 "/usr/include/c++/10/utility" 3
}
# 238 "/home/giulianob/gcc_git_gnu/gcc/gcc/system.h" 2
# 259 "/home/giulianob/gcc_git_gnu/gcc/gcc/system.h"
# 1 "/usr/include/c++/10/stdlib.h" 1 3
# 36 "/usr/include/c++/10/stdlib.h" 3
# 1 "/usr/include/c++/10/cstdlib" 1 3
# 39 "/usr/include/c++/10/cstdlib" 3
# 40 "/usr/include/c++/10/cstdlib" 3
# 75 "/usr/include/c++/10/cstdlib" 3
# 1 "/usr/include/stdlib.h" 1 3 4
# 25 "/usr/include/stdlib.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/libc-header-start.h" 1 3 4
# 26 "/usr/include/stdlib.h" 2 3 4
# 1 "/usr/lib/gcc/x86_64-linux-gnu/10/include/stddef.h" 1 3 4
# 32 "/usr/include/stdlib.h" 2 3 4
extern "C" {
# 1 "/usr/include/x86_64-linux-gnu/bits/waitflags.h" 1 3 4
# 52 "/usr/include/x86_64-linux-gnu/bits/waitflags.h" 3 4
typedef enum
{
P_ALL,
P_PID,
P_PGID
} idtype_t;
# 40 "/usr/include/stdlib.h" 2 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/waitstatus.h" 1 3 4
# 41 "/usr/include/stdlib.h" 2 3 4
# 55 "/usr/include/stdlib.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/floatn.h" 1 3 4
# 75 "/usr/include/x86_64-linux-gnu/bits/floatn.h" 3 4
typedef _Complex float __cfloat128 __attribute__ ((__mode__ (__TC__)));
# 87 "/usr/include/x86_64-linux-gnu/bits/floatn.h" 3 4
typedef __float128 _Float128;
# 120 "/usr/include/x86_64-linux-gnu/bits/floatn.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/floatn-common.h" 1 3 4
# 24 "/usr/include/x86_64-linux-gnu/bits/floatn-common.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/long-double.h" 1 3 4
# 25 "/usr/include/x86_64-linux-gnu/bits/floatn-common.h" 2 3 4
# 214 "/usr/include/x86_64-linux-gnu/bits/floatn-common.h" 3 4
typedef float _Float32;
# 251 "/usr/include/x86_64-linux-gnu/bits/floatn-common.h" 3 4
typedef double _Float64;
# 268 "/usr/include/x86_64-linux-gnu/bits/floatn-common.h" 3 4
typedef double _Float32x;
# 285 "/usr/include/x86_64-linux-gnu/bits/floatn-common.h" 3 4
typedef long double _Float64x;
# 121 "/usr/include/x86_64-linux-gnu/bits/floatn.h" 2 3 4
# 56 "/usr/include/stdlib.h" 2 3 4
typedef struct
{
int quot;
int rem;
} div_t;
typedef struct
{
long int quot;
long int rem;
} ldiv_t;
__extension__ typedef struct
{
long long int quot;
long long int rem;
} lldiv_t;
# 97 "/usr/include/stdlib.h" 3 4
extern size_t __ctype_get_mb_cur_max (void) throw () ;
extern double atof (const char *__nptr)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ;
extern int atoi (const char *__nptr)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ;
extern long int atol (const char *__nptr)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ;
__extension__ extern long long int atoll (const char *__nptr)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ;
extern double strtod (const char *__restrict __nptr,
char **__restrict __endptr)
throw () __attribute__ ((__nonnull__ (1)));
extern float strtof (const char *__restrict __nptr,
char **__restrict __endptr) throw () __attribute__ ((__nonnull__ (1)));
extern long double strtold (const char *__restrict __nptr,
char **__restrict __endptr)
throw () __attribute__ ((__nonnull__ (1)));
# 140 "/usr/include/stdlib.h" 3 4
extern _Float32 strtof32 (const char *__restrict __nptr,
char **__restrict __endptr)
throw () __attribute__ ((__nonnull__ (1)));
extern _Float64 strtof64 (const char *__restrict __nptr,
char **__restrict __endptr)
throw () __attribute__ ((__nonnull__ (1)));
extern _Float128 strtof128 (const char *__restrict __nptr,
char **__restrict __endptr)
throw () __attribute__ ((__nonnull__ (1)));
extern _Float32x strtof32x (const char *__restrict __nptr,
char **__restrict __endptr)
throw () __attribute__ ((__nonnull__ (1)));
extern _Float64x strtof64x (const char *__restrict __nptr,
char **__restrict __endptr)
throw () __attribute__ ((__nonnull__ (1)));
# 176 "/usr/include/stdlib.h" 3 4
extern long int strtol (const char *__restrict __nptr,
char **__restrict __endptr, int __base)
throw () __attribute__ ((__nonnull__ (1)));
extern unsigned long int strtoul (const char *__restrict __nptr,
char **__restrict __endptr, int __base)
throw () __attribute__ ((__nonnull__ (1)));
__extension__
extern long long int strtoq (const char *__restrict __nptr,
char **__restrict __endptr, int __base)
throw () __attribute__ ((__nonnull__ (1)));
__extension__
extern unsigned long long int strtouq (const char *__restrict __nptr,
char **__restrict __endptr, int __base)
throw () __attribute__ ((__nonnull__ (1)));
__extension__
extern long long int strtoll (const char *__restrict __nptr,
char **__restrict __endptr, int __base)
throw () __attribute__ ((__nonnull__ (1)));
__extension__
extern unsigned long long int strtoull (const char *__restrict __nptr,
char **__restrict __endptr, int __base)
throw () __attribute__ ((__nonnull__ (1)));
extern int strfromd (char *__dest, size_t __size, const char *__format,
double __f)
throw () __attribute__ ((__nonnull__ (3)));
extern int strfromf (char *__dest, size_t __size, const char *__format,
float __f)
throw () __attribute__ ((__nonnull__ (3)));
extern int strfroml (char *__dest, size_t __size, const char *__format,
long double __f)
throw () __attribute__ ((__nonnull__ (3)));
# 232 "/usr/include/stdlib.h" 3 4
extern int strfromf32 (char *__dest, size_t __size, const char * __format,
_Float32 __f)
throw () __attribute__ ((__nonnull__ (3)));
extern int strfromf64 (char *__dest, size_t __size, const char * __format,
_Float64 __f)
throw () __attribute__ ((__nonnull__ (3)));
extern int strfromf128 (char *__dest, size_t __size, const char * __format,
_Float128 __f)
throw () __attribute__ ((__nonnull__ (3)));
extern int strfromf32x (char *__dest, size_t __size, const char * __format,
_Float32x __f)
throw () __attribute__ ((__nonnull__ (3)));
extern int strfromf64x (char *__dest, size_t __size, const char * __format,
_Float64x __f)
throw () __attribute__ ((__nonnull__ (3)));
# 274 "/usr/include/stdlib.h" 3 4
extern long int strtol_l (const char *__restrict __nptr,
char **__restrict __endptr, int __base,
locale_t __loc) throw () __attribute__ ((__nonnull__ (1, 4)));
extern unsigned long int strtoul_l (const char *__restrict __nptr,
char **__restrict __endptr,
int __base, locale_t __loc)
throw () __attribute__ ((__nonnull__ (1, 4)));
__extension__
extern long long int strtoll_l (const char *__restrict __nptr,
char **__restrict __endptr, int __base,
locale_t __loc)
throw () __attribute__ ((__nonnull__ (1, 4)));
__extension__
extern unsigned long long int strtoull_l (const char *__restrict __nptr,
char **__restrict __endptr,
int __base, locale_t __loc)
throw () __attribute__ ((__nonnull__ (1, 4)));
extern double strtod_l (const char *__restrict __nptr,
char **__restrict __endptr, locale_t __loc)
throw () __attribute__ ((__nonnull__ (1, 3)));
extern float strtof_l (const char *__restrict __nptr,
char **__restrict __endptr, locale_t __loc)
throw () __attribute__ ((__nonnull__ (1, 3)));
extern long double strtold_l (const char *__restrict __nptr,
char **__restrict __endptr,
locale_t __loc)
throw () __attribute__ ((__nonnull__ (1, 3)));
# 316 "/usr/include/stdlib.h" 3 4
extern _Float32 strtof32_l (const char *__restrict __nptr,
char **__restrict __endptr,
locale_t __loc)
throw () __attribute__ ((__nonnull__ (1, 3)));
extern _Float64 strtof64_l (const char *__restrict __nptr,
char **__restrict __endptr,
locale_t __loc)
throw () __attribute__ ((__nonnull__ (1, 3)));
extern _Float128 strtof128_l (const char *__restrict __nptr,
char **__restrict __endptr,
locale_t __loc)
throw () __attribute__ ((__nonnull__ (1, 3)));
extern _Float32x strtof32x_l (const char *__restrict __nptr,
char **__restrict __endptr,
locale_t __loc)
throw () __attribute__ ((__nonnull__ (1, 3)));
extern _Float64x strtof64x_l (const char *__restrict __nptr,
char **__restrict __endptr,
locale_t __loc)
throw () __attribute__ ((__nonnull__ (1, 3)));
# 360 "/usr/include/stdlib.h" 3 4
extern __inline __attribute__ ((__gnu_inline__)) int
__attribute__ ((__leaf__)) atoi (const char *__nptr) throw ()
{
return (int) strtol (__nptr, (char **) __null, 10);
}
extern __inline __attribute__ ((__gnu_inline__)) long int
__attribute__ ((__leaf__)) atol (const char *__nptr) throw ()
{
return strtol (__nptr, (char **) __null, 10);
}
__extension__ extern __inline __attribute__ ((__gnu_inline__)) long long int
__attribute__ ((__leaf__)) atoll (const char *__nptr) throw ()
{
return strtoll (__nptr, (char **) __null, 10);
}
# 385 "/usr/include/stdlib.h" 3 4
extern char *l64a (long int __n) throw () ;
extern long int a64l (const char *__s)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ;
# 401 "/usr/include/stdlib.h" 3 4
extern long int random (void) throw ();
extern void srandom (unsigned int __seed) throw ();
extern char *initstate (unsigned int __seed, char *__statebuf,
size_t __statelen) throw () __attribute__ ((__nonnull__ (2)));
extern char *setstate (char *__statebuf) throw () __attribute__ ((__nonnull__ (1)));
struct random_data
{
int32_t *fptr;
int32_t *rptr;
int32_t *state;
int rand_type;
int rand_deg;
int rand_sep;
int32_t *end_ptr;
};
extern int random_r (struct random_data *__restrict __buf,
int32_t *__restrict __result) throw () __attribute__ ((__nonnull__ (1, 2)));
extern int srandom_r (unsigned int __seed, struct random_data *__buf)
throw () __attribute__ ((__nonnull__ (2)));
extern int initstate_r (unsigned int __seed, char *__restrict __statebuf,
size_t __statelen,
struct random_data *__restrict __buf)
throw () __attribute__ ((__nonnull__ (2, 4)));
extern int setstate_r (char *__restrict __statebuf,
struct random_data *__restrict __buf)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern int rand (void) throw ();
extern void srand (unsigned int __seed) throw ();
extern int rand_r (unsigned int *__seed) throw ();
extern double drand48 (void) throw ();
extern double erand48 (unsigned short int __xsubi[3]) throw () __attribute__ ((__nonnull__ (1)));
extern long int lrand48 (void) throw ();
extern long int nrand48 (unsigned short int __xsubi[3])
throw () __attribute__ ((__nonnull__ (1)));
extern long int mrand48 (void) throw ();
extern long int jrand48 (unsigned short int __xsubi[3])
throw () __attribute__ ((__nonnull__ (1)));
extern void srand48 (long int __seedval) throw ();
extern unsigned short int *seed48 (unsigned short int __seed16v[3])
throw () __attribute__ ((__nonnull__ (1)));
extern void lcong48 (unsigned short int __param[7]) throw () __attribute__ ((__nonnull__ (1)));
struct drand48_data
{
unsigned short int __x[3];
unsigned short int __old_x[3];
unsigned short int __c;
unsigned short int __init;
__extension__ unsigned long long int __a;
};
extern int drand48_r (struct drand48_data *__restrict __buffer,
double *__restrict __result) throw () __attribute__ ((__nonnull__ (1, 2)));
extern int erand48_r (unsigned short int __xsubi[3],
struct drand48_data *__restrict __buffer,
double *__restrict __result) throw () __attribute__ ((__nonnull__ (1, 2)));
extern int lrand48_r (struct drand48_data *__restrict __buffer,
long int *__restrict __result)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern int nrand48_r (unsigned short int __xsubi[3],
struct drand48_data *__restrict __buffer,
long int *__restrict __result)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern int mrand48_r (struct drand48_data *__restrict __buffer,
long int *__restrict __result)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern int jrand48_r (unsigned short int __xsubi[3],
struct drand48_data *__restrict __buffer,
long int *__restrict __result)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern int srand48_r (long int __seedval, struct drand48_data *__buffer)
throw () __attribute__ ((__nonnull__ (2)));
extern int seed48_r (unsigned short int __seed16v[3],
struct drand48_data *__buffer) throw () __attribute__ ((__nonnull__ (1, 2)));
extern int lcong48_r (unsigned short int __param[7],
struct drand48_data *__buffer)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern void *malloc (size_t __size) throw () __attribute__ ((__malloc__))
__attribute__ ((__alloc_size__ (1))) ;
extern void *calloc (size_t __nmemb, size_t __size)
throw () __attribute__ ((__malloc__)) __attribute__ ((__alloc_size__ (1, 2))) ;
extern void *realloc (void *__ptr, size_t __size)
throw () __attribute__ ((__warn_unused_result__)) __attribute__ ((__alloc_size__ (2)));
extern void *reallocarray (void *__ptr, size_t __nmemb, size_t __size)
throw () __attribute__ ((__warn_unused_result__))
__attribute__ ((__alloc_size__ (2, 3)));
extern void free (void *__ptr) throw ();
# 1 "/usr/include/alloca.h" 1 3 4
# 24 "/usr/include/alloca.h" 3 4
# 1 "/usr/lib/gcc/x86_64-linux-gnu/10/include/stddef.h" 1 3 4
# 25 "/usr/include/alloca.h" 2 3 4
extern "C" {
extern void *alloca (size_t __size) throw ();
}
# 569 "/usr/include/stdlib.h" 2 3 4
extern void *valloc (size_t __size) throw () __attribute__ ((__malloc__))
__attribute__ ((__alloc_size__ (1))) ;
extern int posix_memalign (void **__memptr, size_t __alignment, size_t __size)
throw () __attribute__ ((__nonnull__ (1))) ;
extern void *aligned_alloc (size_t __alignment, size_t __size)
throw () __attribute__ ((__malloc__)) __attribute__ ((__alloc_size__ (2))) ;
extern void abort (void) throw () __attribute__ ((__noreturn__));
extern int atexit (void (*__func) (void)) throw () __attribute__ ((__nonnull__ (1)));
extern "C++" int at_quick_exit (void (*__func) (void))
throw () __asm ("at_quick_exit") __attribute__ ((__nonnull__ (1)));
# 610 "/usr/include/stdlib.h" 3 4
extern int on_exit (void (*__func) (int __status, void *__arg), void *__arg)
throw () __attribute__ ((__nonnull__ (1)));
extern void exit (int __status) throw () __attribute__ ((__noreturn__));
extern void quick_exit (int __status) throw () __attribute__ ((__noreturn__));
extern void _Exit (int __status) throw () __attribute__ ((__noreturn__));
extern char *getenv (const char *__name) throw () __attribute__ ((__nonnull__ (1))) ;
extern char *secure_getenv (const char *__name)
throw () __attribute__ ((__nonnull__ (1))) ;
extern int putenv (char *__string) throw () __attribute__ ((__nonnull__ (1)));
extern int setenv (const char *__name, const char *__value, int __replace)
throw () __attribute__ ((__nonnull__ (2)));
extern int unsetenv (const char *__name) throw () __attribute__ ((__nonnull__ (1)));
extern int clearenv (void) throw ();
# 675 "/usr/include/stdlib.h" 3 4
extern char *mktemp (char *__template) throw () __attribute__ ((__nonnull__ (1)));
# 688 "/usr/include/stdlib.h" 3 4
extern int mkstemp (char *__template) __attribute__ ((__nonnull__ (1))) ;
# 698 "/usr/include/stdlib.h" 3 4
extern int mkstemp64 (char *__template) __attribute__ ((__nonnull__ (1))) ;
# 710 "/usr/include/stdlib.h" 3 4
extern int mkstemps (char *__template, int __suffixlen) __attribute__ ((__nonnull__ (1))) ;
# 720 "/usr/include/stdlib.h" 3 4
extern int mkstemps64 (char *__template, int __suffixlen)
__attribute__ ((__nonnull__ (1))) ;
# 731 "/usr/include/stdlib.h" 3 4
extern char *mkdtemp (char *__template) throw () __attribute__ ((__nonnull__ (1))) ;
# 742 "/usr/include/stdlib.h" 3 4
extern int mkostemp (char *__template, int __flags) __attribute__ ((__nonnull__ (1))) ;
# 752 "/usr/include/stdlib.h" 3 4
extern int mkostemp64 (char *__template, int __flags) __attribute__ ((__nonnull__ (1))) ;
# 762 "/usr/include/stdlib.h" 3 4
extern int mkostemps (char *__template, int __suffixlen, int __flags)
__attribute__ ((__nonnull__ (1))) ;
# 774 "/usr/include/stdlib.h" 3 4
extern int mkostemps64 (char *__template, int __suffixlen, int __flags)
__attribute__ ((__nonnull__ (1))) ;
# 784 "/usr/include/stdlib.h" 3 4
extern int system (const char *__command) ;
extern char *canonicalize_file_name (const char *__name)
throw () __attribute__ ((__nonnull__ (1))) ;
# 800 "/usr/include/stdlib.h" 3 4
extern char *realpath (const char *__restrict __name,
char *__restrict __resolved) throw () ;
typedef int (*__compar_fn_t) (const void *, const void *);
typedef __compar_fn_t comparison_fn_t;
typedef int (*__compar_d_fn_t) (const void *, const void *, void *);
extern void *bsearch (const void *__key, const void *__base,
size_t __nmemb, size_t __size, __compar_fn_t __compar)
__attribute__ ((__nonnull__ (1, 2, 5))) ;
# 1 "/usr/include/x86_64-linux-gnu/bits/stdlib-bsearch.h" 1 3 4
# 19 "/usr/include/x86_64-linux-gnu/bits/stdlib-bsearch.h" 3 4
extern __inline __attribute__ ((__gnu_inline__)) void *
bsearch (const void *__key, const void *__base, size_t __nmemb, size_t __size,
__compar_fn_t __compar)
{
size_t __l, __u, __idx;
const void *__p;
int __comparison;
__l = 0;
__u = __nmemb;
while (__l < __u)
{
__idx = (__l + __u) / 2;
__p = (void *) (((const char *) __base) + (__idx * __size));
__comparison = (*__compar) (__key, __p);
if (__comparison < 0)
__u = __idx;
else if (__comparison > 0)
__l = __idx + 1;
else
return (void *) __p;
}
return __null;
}
# 826 "/usr/include/stdlib.h" 2 3 4
extern void qsort (void *__base, size_t __nmemb, size_t __size,
__compar_fn_t __compar) __attribute__ ((__nonnull__ (1, 4)));
extern void qsort_r (void *__base, size_t __nmemb, size_t __size,
__compar_d_fn_t __compar, void *__arg)
__attribute__ ((__nonnull__ (1, 4)));
extern int abs (int __x) throw () __attribute__ ((__const__)) ;
extern long int labs (long int __x) throw () __attribute__ ((__const__)) ;
__extension__ extern long long int llabs (long long int __x)
throw () __attribute__ ((__const__)) ;
extern div_t div (int __numer, int __denom)
throw () __attribute__ ((__const__)) ;
extern ldiv_t ldiv (long int __numer, long int __denom)
throw () __attribute__ ((__const__)) ;
__extension__ extern lldiv_t lldiv (long long int __numer,
long long int __denom)
throw () __attribute__ ((__const__)) ;
# 872 "/usr/include/stdlib.h" 3 4
extern char *ecvt (double __value, int __ndigit, int *__restrict __decpt,
int *__restrict __sign) throw () __attribute__ ((__nonnull__ (3, 4))) ;
extern char *fcvt (double __value, int __ndigit, int *__restrict __decpt,
int *__restrict __sign) throw () __attribute__ ((__nonnull__ (3, 4))) ;
extern char *gcvt (double __value, int __ndigit, char *__buf)
throw () __attribute__ ((__nonnull__ (3))) ;
extern char *qecvt (long double __value, int __ndigit,
int *__restrict __decpt, int *__restrict __sign)
throw () __attribute__ ((__nonnull__ (3, 4))) ;
extern char *qfcvt (long double __value, int __ndigit,
int *__restrict __decpt, int *__restrict __sign)
throw () __attribute__ ((__nonnull__ (3, 4))) ;
extern char *qgcvt (long double __value, int __ndigit, char *__buf)
throw () __attribute__ ((__nonnull__ (3))) ;
extern int ecvt_r (double __value, int __ndigit, int *__restrict __decpt,
int *__restrict __sign, char *__restrict __buf,
size_t __len) throw () __attribute__ ((__nonnull__ (3, 4, 5)));
extern int fcvt_r (double __value, int __ndigit, int *__restrict __decpt,
int *__restrict __sign, char *__restrict __buf,
size_t __len) throw () __attribute__ ((__nonnull__ (3, 4, 5)));
extern int qecvt_r (long double __value, int __ndigit,
int *__restrict __decpt, int *__restrict __sign,
char *__restrict __buf, size_t __len)
throw () __attribute__ ((__nonnull__ (3, 4, 5)));
extern int qfcvt_r (long double __value, int __ndigit,
int *__restrict __decpt, int *__restrict __sign,
char *__restrict __buf, size_t __len)
throw () __attribute__ ((__nonnull__ (3, 4, 5)));
extern int mblen (const char *__s, size_t __n) throw ();
extern int mbtowc (wchar_t *__restrict __pwc,
const char *__restrict __s, size_t __n) throw ();
extern int wctomb (char *__s, wchar_t __wchar) throw ();
extern size_t mbstowcs (wchar_t *__restrict __pwcs,
const char *__restrict __s, size_t __n) throw ();
extern size_t wcstombs (char *__restrict __s,
const wchar_t *__restrict __pwcs, size_t __n)
throw ();
extern int rpmatch (const char *__response) throw () __attribute__ ((__nonnull__ (1))) ;
# 957 "/usr/include/stdlib.h" 3 4
extern int getsubopt (char **__restrict __optionp,
char *const *__restrict __tokens,
char **__restrict __valuep)
throw () __attribute__ ((__nonnull__ (1, 2, 3))) ;
extern int posix_openpt (int __oflag) ;
extern int grantpt (int __fd) throw ();
extern int unlockpt (int __fd) throw ();
extern char *ptsname (int __fd) throw () ;
extern int ptsname_r (int __fd, char *__buf, size_t __buflen)
throw () __attribute__ ((__nonnull__ (2)));
extern int getpt (void);
extern int getloadavg (double __loadavg[], int __nelem)
throw () __attribute__ ((__nonnull__ (1)));
# 1013 "/usr/include/stdlib.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/stdlib-float.h" 1 3 4
# 24 "/usr/include/x86_64-linux-gnu/bits/stdlib-float.h" 3 4
extern __inline __attribute__ ((__gnu_inline__)) double
__attribute__ ((__leaf__)) atof (const char *__nptr) throw ()
{
return strtod (__nptr, (char **) __null);
}
# 1014 "/usr/include/stdlib.h" 2 3 4
# 1023 "/usr/include/stdlib.h" 3 4
}
# 76 "/usr/include/c++/10/cstdlib" 2 3
# 1 "/usr/include/c++/10/bits/std_abs.h" 1 3
# 33 "/usr/include/c++/10/bits/std_abs.h" 3
# 34 "/usr/include/c++/10/bits/std_abs.h" 3
# 46 "/usr/include/c++/10/bits/std_abs.h" 3
extern "C++"
{
namespace std __attribute__ ((__visibility__ ("default")))
{
using ::abs;
inline long
abs(long __i) { return __builtin_labs(__i); }
inline long long
abs(long long __x) { return __builtin_llabs (__x); }
# 70 "/usr/include/c++/10/bits/std_abs.h" 3
inline constexpr double
abs(double __x)
{ return __builtin_fabs(__x); }
inline constexpr float
abs(float __x)
{ return __builtin_fabsf(__x); }
inline constexpr long double
abs(long double __x)
{ return __builtin_fabsl(__x); }
inline constexpr __int128
abs(__int128 __x) { return __x >= 0 ? __x : -__x; }
# 101 "/usr/include/c++/10/bits/std_abs.h" 3
inline constexpr
__float128
abs(__float128 __x)
{ return __x < 0 ? -__x : __x; }
}
}
# 78 "/usr/include/c++/10/cstdlib" 2 3
# 121 "/usr/include/c++/10/cstdlib" 3
extern "C++"
{
namespace std __attribute__ ((__visibility__ ("default")))
{
using ::div_t;
using ::ldiv_t;
using ::abort;
using ::atexit;
using ::at_quick_exit;
using ::atof;
using ::atoi;
using ::atol;
using ::bsearch;
using ::calloc;
using ::div;
using ::exit;
using ::free;
using ::getenv;
using ::labs;
using ::ldiv;
using ::malloc;
using ::mblen;
using ::mbstowcs;
using ::mbtowc;
using ::qsort;
using ::quick_exit;
using ::rand;
using ::realloc;
using ::srand;
using ::strtod;
using ::strtol;
using ::strtoul;
using ::system;
using ::wcstombs;
using ::wctomb;
inline ldiv_t
div(long __i, long __j) { return ldiv(__i, __j); }
}
# 195 "/usr/include/c++/10/cstdlib" 3
namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
{
using ::lldiv_t;
using ::_Exit;
using ::llabs;
inline lldiv_t
div(long long __n, long long __d)
{ lldiv_t __q; __q.quot = __n / __d; __q.rem = __n % __d; return __q; }
using ::lldiv;
# 227 "/usr/include/c++/10/cstdlib" 3
using ::atoll;
using ::strtoll;
using ::strtoull;
using ::strtof;
using ::strtold;
}
namespace std
{
using ::__gnu_cxx::lldiv_t;
using ::__gnu_cxx::_Exit;
using ::__gnu_cxx::llabs;
using ::__gnu_cxx::div;
using ::__gnu_cxx::lldiv;
using ::__gnu_cxx::atoll;
using ::__gnu_cxx::strtof;
using ::__gnu_cxx::strtoll;
using ::__gnu_cxx::strtoull;
using ::__gnu_cxx::strtold;
}
}
# 37 "/usr/include/c++/10/stdlib.h" 2 3
using std::abort;
using std::atexit;
using std::exit;
using std::at_quick_exit;
using std::quick_exit;
using std::div_t;
using std::ldiv_t;
using std::abs;
using std::atof;
using std::atoi;
using std::atol;
using std::bsearch;
using std::calloc;
using std::div;
using std::free;
using std::getenv;
using std::labs;
using std::ldiv;
using std::malloc;
using std::mblen;
using std::mbstowcs;
using std::mbtowc;
using std::qsort;
using std::rand;
using std::realloc;
using std::srand;
using std::strtod;
using std::strtol;
using std::strtoul;
using std::system;
using std::wcstombs;
using std::wctomb;
# 260 "/home/giulianob/gcc_git_gnu/gcc/gcc/system.h" 2
# 1 "/usr/include/c++/10/cstdlib" 1 3
# 39 "/usr/include/c++/10/cstdlib" 3
# 40 "/usr/include/c++/10/cstdlib" 3
# 268 "/home/giulianob/gcc_git_gnu/gcc/gcc/system.h" 2
# 295 "/home/giulianob/gcc_git_gnu/gcc/gcc/system.h"
# 1 "/usr/include/unistd.h" 1 3 4
# 27 "/usr/include/unistd.h" 3 4
extern "C" {
# 202 "/usr/include/unistd.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/posix_opt.h" 1 3 4
# 203 "/usr/include/unistd.h" 2 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/environments.h" 1 3 4
# 22 "/usr/include/x86_64-linux-gnu/bits/environments.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/wordsize.h" 1 3 4
# 23 "/usr/include/x86_64-linux-gnu/bits/environments.h" 2 3 4
# 207 "/usr/include/unistd.h" 2 3 4
# 226 "/usr/include/unistd.h" 3 4
# 1 "/usr/lib/gcc/x86_64-linux-gnu/10/include/stddef.h" 1 3 4
# 227 "/usr/include/unistd.h" 2 3 4
# 267 "/usr/include/unistd.h" 3 4
typedef __intptr_t intptr_t;
typedef __socklen_t socklen_t;
# 287 "/usr/include/unistd.h" 3 4
extern int access (const char *__name, int __type) throw () __attribute__ ((__nonnull__ (1)));
extern int euidaccess (const char *__name, int __type)
throw () __attribute__ ((__nonnull__ (1)));
extern int eaccess (const char *__name, int __type)
throw () __attribute__ ((__nonnull__ (1)));
extern int faccessat (int __fd, const char *__file, int __type, int __flag)
throw () __attribute__ ((__nonnull__ (2))) ;
# 334 "/usr/include/unistd.h" 3 4
extern __off_t lseek (int __fd, __off_t __offset, int __whence) throw ();
# 345 "/usr/include/unistd.h" 3 4
extern __off64_t lseek64 (int __fd, __off64_t __offset, int __whence)
throw ();
extern int close (int __fd);
extern ssize_t read (int __fd, void *__buf, size_t __nbytes) ;
extern ssize_t write (int __fd, const void *__buf, size_t __n) ;
# 376 "/usr/include/unistd.h" 3 4
extern ssize_t pread (int __fd, void *__buf, size_t __nbytes,
__off_t __offset) ;
extern ssize_t pwrite (int __fd, const void *__buf, size_t __n,
__off_t __offset) ;
# 404 "/usr/include/unistd.h" 3 4
extern ssize_t pread64 (int __fd, void *__buf, size_t __nbytes,
__off64_t __offset) ;
extern ssize_t pwrite64 (int __fd, const void *__buf, size_t __n,
__off64_t __offset) ;
extern int pipe (int __pipedes[2]) throw () ;
extern int pipe2 (int __pipedes[2], int __flags) throw () ;
# 432 "/usr/include/unistd.h" 3 4
extern unsigned int alarm (unsigned int __seconds) throw ();
# 444 "/usr/include/unistd.h" 3 4
extern unsigned int sleep (unsigned int __seconds);
extern __useconds_t ualarm (__useconds_t __value, __useconds_t __interval)
throw ();
extern int usleep (__useconds_t __useconds);
# 469 "/usr/include/unistd.h" 3 4
extern int pause (void);
extern int chown (const char *__file, __uid_t __owner, __gid_t __group)
throw () __attribute__ ((__nonnull__ (1))) ;
extern int fchown (int __fd, __uid_t __owner, __gid_t __group) throw () ;
extern int lchown (const char *__file, __uid_t __owner, __gid_t __group)
throw () __attribute__ ((__nonnull__ (1))) ;
extern int fchownat (int __fd, const char *__file, __uid_t __owner,
__gid_t __group, int __flag)
throw () __attribute__ ((__nonnull__ (2))) ;
extern int chdir (const char *__path) throw () __attribute__ ((__nonnull__ (1))) ;
extern int fchdir (int __fd) throw () ;
# 511 "/usr/include/unistd.h" 3 4
extern char *getcwd (char *__buf, size_t __size) throw () ;
extern char *get_current_dir_name (void) throw ();
extern char *getwd (char *__buf)
throw () __attribute__ ((__nonnull__ (1))) __attribute__ ((__deprecated__)) ;
extern int dup (int __fd) throw () ;
extern int dup2 (int __fd, int __fd2) throw ();
extern int dup3 (int __fd, int __fd2, int __flags) throw ();
extern char **__environ;
extern char **environ;
extern int execve (const char *__path, char *const __argv[],
char *const __envp[]) throw () __attribute__ ((__nonnull__ (1, 2)));
extern int fexecve (int __fd, char *const __argv[], char *const __envp[])
throw () __attribute__ ((__nonnull__ (2)));
extern int execv (const char *__path, char *const __argv[])
throw () __attribute__ ((__nonnull__ (1, 2)));
extern int execle (const char *__path, const char *__arg, ...)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern int execl (const char *__path, const char *__arg, ...)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern int execvp (const char *__file, char *const __argv[])
throw () __attribute__ ((__nonnull__ (1, 2)));
extern int execlp (const char *__file, const char *__arg, ...)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern int execvpe (const char *__file, char *const __argv[],
char *const __envp[])
throw () __attribute__ ((__nonnull__ (1, 2)));
extern int nice (int __inc) throw () ;
extern void _exit (int __status) __attribute__ ((__noreturn__));
# 1 "/usr/include/x86_64-linux-gnu/bits/confname.h" 1 3 4
# 24 "/usr/include/x86_64-linux-gnu/bits/confname.h" 3 4
enum
{
_PC_LINK_MAX,
_PC_MAX_CANON,
_PC_MAX_INPUT,
_PC_NAME_MAX,
_PC_PATH_MAX,
_PC_PIPE_BUF,
_PC_CHOWN_RESTRICTED,
_PC_NO_TRUNC,
_PC_VDISABLE,
_PC_SYNC_IO,
_PC_ASYNC_IO,
_PC_PRIO_IO,
_PC_SOCK_MAXBUF,
_PC_FILESIZEBITS,
_PC_REC_INCR_XFER_SIZE,
_PC_REC_MAX_XFER_SIZE,
_PC_REC_MIN_XFER_SIZE,
_PC_REC_XFER_ALIGN,
_PC_ALLOC_SIZE_MIN,
_PC_SYMLINK_MAX,
_PC_2_SYMLINKS
};
enum
{
_SC_ARG_MAX,
_SC_CHILD_MAX,
_SC_CLK_TCK,
_SC_NGROUPS_MAX,
_SC_OPEN_MAX,
_SC_STREAM_MAX,
_SC_TZNAME_MAX,
_SC_JOB_CONTROL,
_SC_SAVED_IDS,
_SC_REALTIME_SIGNALS,
_SC_PRIORITY_SCHEDULING,
_SC_TIMERS,
_SC_ASYNCHRONOUS_IO,
_SC_PRIORITIZED_IO,
_SC_SYNCHRONIZED_IO,
_SC_FSYNC,
_SC_MAPPED_FILES,
_SC_MEMLOCK,
_SC_MEMLOCK_RANGE,
_SC_MEMORY_PROTECTION,
_SC_MESSAGE_PASSING,
_SC_SEMAPHORES,
_SC_SHARED_MEMORY_OBJECTS,
_SC_AIO_LISTIO_MAX,
_SC_AIO_MAX,
_SC_AIO_PRIO_DELTA_MAX,
_SC_DELAYTIMER_MAX,
_SC_MQ_OPEN_MAX,
_SC_MQ_PRIO_MAX,
_SC_VERSION,
_SC_PAGESIZE,
_SC_RTSIG_MAX,
_SC_SEM_NSEMS_MAX,
_SC_SEM_VALUE_MAX,
_SC_SIGQUEUE_MAX,
_SC_TIMER_MAX,
_SC_BC_BASE_MAX,
_SC_BC_DIM_MAX,
_SC_BC_SCALE_MAX,
_SC_BC_STRING_MAX,
_SC_COLL_WEIGHTS_MAX,
_SC_EQUIV_CLASS_MAX,
_SC_EXPR_NEST_MAX,
_SC_LINE_MAX,
_SC_RE_DUP_MAX,
_SC_CHARCLASS_NAME_MAX,
_SC_2_VERSION,
_SC_2_C_BIND,
_SC_2_C_DEV,
_SC_2_FORT_DEV,
_SC_2_FORT_RUN,
_SC_2_SW_DEV,
_SC_2_LOCALEDEF,
_SC_PII,
_SC_PII_XTI,
_SC_PII_SOCKET,
_SC_PII_INTERNET,
_SC_PII_OSI,
_SC_POLL,
_SC_SELECT,
_SC_UIO_MAXIOV,
_SC_IOV_MAX = _SC_UIO_MAXIOV,
_SC_PII_INTERNET_STREAM,
_SC_PII_INTERNET_DGRAM,
_SC_PII_OSI_COTS,
_SC_PII_OSI_CLTS,
_SC_PII_OSI_M,
_SC_T_IOV_MAX,
_SC_THREADS,
_SC_THREAD_SAFE_FUNCTIONS,
_SC_GETGR_R_SIZE_MAX,
_SC_GETPW_R_SIZE_MAX,
_SC_LOGIN_NAME_MAX,
_SC_TTY_NAME_MAX,
_SC_THREAD_DESTRUCTOR_ITERATIONS,
_SC_THREAD_KEYS_MAX,
_SC_THREAD_STACK_MIN,
_SC_THREAD_THREADS_MAX,
_SC_THREAD_ATTR_STACKADDR,
_SC_THREAD_ATTR_STACKSIZE,
_SC_THREAD_PRIORITY_SCHEDULING,
_SC_THREAD_PRIO_INHERIT,
_SC_THREAD_PRIO_PROTECT,
_SC_THREAD_PROCESS_SHARED,
_SC_NPROCESSORS_CONF,
_SC_NPROCESSORS_ONLN,
_SC_PHYS_PAGES,
_SC_AVPHYS_PAGES,
_SC_ATEXIT_MAX,
_SC_PASS_MAX,
_SC_XOPEN_VERSION,
_SC_XOPEN_XCU_VERSION,
_SC_XOPEN_UNIX,
_SC_XOPEN_CRYPT,
_SC_XOPEN_ENH_I18N,
_SC_XOPEN_SHM,
_SC_2_CHAR_TERM,
_SC_2_C_VERSION,
_SC_2_UPE,
_SC_XOPEN_XPG2,
_SC_XOPEN_XPG3,
_SC_XOPEN_XPG4,
_SC_CHAR_BIT,
_SC_CHAR_MAX,
_SC_CHAR_MIN,
_SC_INT_MAX,
_SC_INT_MIN,
_SC_LONG_BIT,
_SC_WORD_BIT,
_SC_MB_LEN_MAX,
_SC_NZERO,
_SC_SSIZE_MAX,
_SC_SCHAR_MAX,
_SC_SCHAR_MIN,
_SC_SHRT_MAX,
_SC_SHRT_MIN,
_SC_UCHAR_MAX,
_SC_UINT_MAX,
_SC_ULONG_MAX,
_SC_USHRT_MAX,
_SC_NL_ARGMAX,
_SC_NL_LANGMAX,
_SC_NL_MSGMAX,
_SC_NL_NMAX,
_SC_NL_SETMAX,
_SC_NL_TEXTMAX,
_SC_XBS5_ILP32_OFF32,
_SC_XBS5_ILP32_OFFBIG,
_SC_XBS5_LP64_OFF64,
_SC_XBS5_LPBIG_OFFBIG,
_SC_XOPEN_LEGACY,
_SC_XOPEN_REALTIME,
_SC_XOPEN_REALTIME_THREADS,
_SC_ADVISORY_INFO,
_SC_BARRIERS,
_SC_BASE,
_SC_C_LANG_SUPPORT,
_SC_C_LANG_SUPPORT_R,
_SC_CLOCK_SELECTION,
_SC_CPUTIME,
_SC_THREAD_CPUTIME,
_SC_DEVICE_IO,
_SC_DEVICE_SPECIFIC,
_SC_DEVICE_SPECIFIC_R,
_SC_FD_MGMT,
_SC_FIFO,
_SC_PIPE,
_SC_FILE_ATTRIBUTES,
_SC_FILE_LOCKING,
_SC_FILE_SYSTEM,
_SC_MONOTONIC_CLOCK,
_SC_MULTI_PROCESS,
_SC_SINGLE_PROCESS,
_SC_NETWORKING,
_SC_READER_WRITER_LOCKS,
_SC_SPIN_LOCKS,
_SC_REGEXP,
_SC_REGEX_VERSION,
_SC_SHELL,
_SC_SIGNALS,
_SC_SPAWN,
_SC_SPORADIC_SERVER,
_SC_THREAD_SPORADIC_SERVER,
_SC_SYSTEM_DATABASE,
_SC_SYSTEM_DATABASE_R,
_SC_TIMEOUTS,
_SC_TYPED_MEMORY_OBJECTS,
_SC_USER_GROUPS,
_SC_USER_GROUPS_R,
_SC_2_PBS,
_SC_2_PBS_ACCOUNTING,
_SC_2_PBS_LOCATE,
_SC_2_PBS_MESSAGE,
_SC_2_PBS_TRACK,
_SC_SYMLOOP_MAX,
_SC_STREAMS,
_SC_2_PBS_CHECKPOINT,
_SC_V6_ILP32_OFF32,
_SC_V6_ILP32_OFFBIG,
_SC_V6_LP64_OFF64,
_SC_V6_LPBIG_OFFBIG,
_SC_HOST_NAME_MAX,
_SC_TRACE,
_SC_TRACE_EVENT_FILTER,
_SC_TRACE_INHERIT,
_SC_TRACE_LOG,
_SC_LEVEL1_ICACHE_SIZE,
_SC_LEVEL1_ICACHE_ASSOC,
_SC_LEVEL1_ICACHE_LINESIZE,
_SC_LEVEL1_DCACHE_SIZE,
_SC_LEVEL1_DCACHE_ASSOC,
_SC_LEVEL1_DCACHE_LINESIZE,
_SC_LEVEL2_CACHE_SIZE,
_SC_LEVEL2_CACHE_ASSOC,
_SC_LEVEL2_CACHE_LINESIZE,
_SC_LEVEL3_CACHE_SIZE,
_SC_LEVEL3_CACHE_ASSOC,
_SC_LEVEL3_CACHE_LINESIZE,
_SC_LEVEL4_CACHE_SIZE,
_SC_LEVEL4_CACHE_ASSOC,
_SC_LEVEL4_CACHE_LINESIZE,
_SC_IPV6 = _SC_LEVEL1_ICACHE_SIZE + 50,
_SC_RAW_SOCKETS,
_SC_V7_ILP32_OFF32,
_SC_V7_ILP32_OFFBIG,
_SC_V7_LP64_OFF64,
_SC_V7_LPBIG_OFFBIG,
_SC_SS_REPL_MAX,
_SC_TRACE_EVENT_NAME_MAX,
_SC_TRACE_NAME_MAX,
_SC_TRACE_SYS_MAX,
_SC_TRACE_USER_EVENT_MAX,
_SC_XOPEN_STREAMS,
_SC_THREAD_ROBUST_PRIO_INHERIT,
_SC_THREAD_ROBUST_PRIO_PROTECT
};
enum
{
_CS_PATH,
_CS_V6_WIDTH_RESTRICTED_ENVS,
_CS_GNU_LIBC_VERSION,
_CS_GNU_LIBPTHREAD_VERSION,
_CS_V5_WIDTH_RESTRICTED_ENVS,
_CS_V7_WIDTH_RESTRICTED_ENVS,
_CS_LFS_CFLAGS = 1000,
_CS_LFS_LDFLAGS,
_CS_LFS_LIBS,
_CS_LFS_LINTFLAGS,
_CS_LFS64_CFLAGS,
_CS_LFS64_LDFLAGS,
_CS_LFS64_LIBS,
_CS_LFS64_LINTFLAGS,
_CS_XBS5_ILP32_OFF32_CFLAGS = 1100,
_CS_XBS5_ILP32_OFF32_LDFLAGS,
_CS_XBS5_ILP32_OFF32_LIBS,
_CS_XBS5_ILP32_OFF32_LINTFLAGS,
_CS_XBS5_ILP32_OFFBIG_CFLAGS,
_CS_XBS5_ILP32_OFFBIG_LDFLAGS,
_CS_XBS5_ILP32_OFFBIG_LIBS,
_CS_XBS5_ILP32_OFFBIG_LINTFLAGS,
_CS_XBS5_LP64_OFF64_CFLAGS,
_CS_XBS5_LP64_OFF64_LDFLAGS,
_CS_XBS5_LP64_OFF64_LIBS,
_CS_XBS5_LP64_OFF64_LINTFLAGS,
_CS_XBS5_LPBIG_OFFBIG_CFLAGS,
_CS_XBS5_LPBIG_OFFBIG_LDFLAGS,
_CS_XBS5_LPBIG_OFFBIG_LIBS,
_CS_XBS5_LPBIG_OFFBIG_LINTFLAGS,
_CS_POSIX_V6_ILP32_OFF32_CFLAGS,
_CS_POSIX_V6_ILP32_OFF32_LDFLAGS,
_CS_POSIX_V6_ILP32_OFF32_LIBS,
_CS_POSIX_V6_ILP32_OFF32_LINTFLAGS,
_CS_POSIX_V6_ILP32_OFFBIG_CFLAGS,
_CS_POSIX_V6_ILP32_OFFBIG_LDFLAGS,
_CS_POSIX_V6_ILP32_OFFBIG_LIBS,
_CS_POSIX_V6_ILP32_OFFBIG_LINTFLAGS,
_CS_POSIX_V6_LP64_OFF64_CFLAGS,
_CS_POSIX_V6_LP64_OFF64_LDFLAGS,
_CS_POSIX_V6_LP64_OFF64_LIBS,
_CS_POSIX_V6_LP64_OFF64_LINTFLAGS,
_CS_POSIX_V6_LPBIG_OFFBIG_CFLAGS,
_CS_POSIX_V6_LPBIG_OFFBIG_LDFLAGS,
_CS_POSIX_V6_LPBIG_OFFBIG_LIBS,
_CS_POSIX_V6_LPBIG_OFFBIG_LINTFLAGS,
_CS_POSIX_V7_ILP32_OFF32_CFLAGS,
_CS_POSIX_V7_ILP32_OFF32_LDFLAGS,
_CS_POSIX_V7_ILP32_OFF32_LIBS,
_CS_POSIX_V7_ILP32_OFF32_LINTFLAGS,
_CS_POSIX_V7_ILP32_OFFBIG_CFLAGS,
_CS_POSIX_V7_ILP32_OFFBIG_LDFLAGS,
_CS_POSIX_V7_ILP32_OFFBIG_LIBS,
_CS_POSIX_V7_ILP32_OFFBIG_LINTFLAGS,
_CS_POSIX_V7_LP64_OFF64_CFLAGS,
_CS_POSIX_V7_LP64_OFF64_LDFLAGS,
_CS_POSIX_V7_LP64_OFF64_LIBS,
_CS_POSIX_V7_LP64_OFF64_LINTFLAGS,
_CS_POSIX_V7_LPBIG_OFFBIG_CFLAGS,
_CS_POSIX_V7_LPBIG_OFFBIG_LDFLAGS,
_CS_POSIX_V7_LPBIG_OFFBIG_LIBS,
_CS_POSIX_V7_LPBIG_OFFBIG_LINTFLAGS,
_CS_V6_ENV,
_CS_V7_ENV
};
# 610 "/usr/include/unistd.h" 2 3 4
extern long int pathconf (const char *__path, int __name)
throw () __attribute__ ((__nonnull__ (1)));
extern long int fpathconf (int __fd, int __name) throw ();
extern long int sysconf (int __name) throw ();
extern size_t confstr (int __name, char *__buf, size_t __len) throw ();
extern __pid_t getpid (void) throw ();
extern __pid_t getppid (void) throw ();
extern __pid_t getpgrp (void) throw ();
extern __pid_t __getpgid (__pid_t __pid) throw ();
extern __pid_t getpgid (__pid_t __pid) throw ();
extern int setpgid (__pid_t __pid, __pid_t __pgid) throw ();
# 660 "/usr/include/unistd.h" 3 4
extern int setpgrp (void) throw ();
extern __pid_t setsid (void) throw ();
extern __pid_t getsid (__pid_t __pid) throw ();
extern __uid_t getuid (void) throw ();
extern __uid_t geteuid (void) throw ();
extern __gid_t getgid (void) throw ();
extern __gid_t getegid (void) throw ();
extern int getgroups (int __size, __gid_t __list[]) throw () ;
extern int group_member (__gid_t __gid) throw ();
extern int setuid (__uid_t __uid) throw () ;
extern int setreuid (__uid_t __ruid, __uid_t __euid) throw () ;
extern int seteuid (__uid_t __uid) throw () ;
extern int setgid (__gid_t __gid) throw () ;
extern int setregid (__gid_t __rgid, __gid_t __egid) throw () ;
extern int setegid (__gid_t __gid) throw () ;
extern int getresuid (__uid_t *__ruid, __uid_t *__euid, __uid_t *__suid)
throw ();
extern int getresgid (__gid_t *__rgid, __gid_t *__egid, __gid_t *__sgid)
throw ();
extern int setresuid (__uid_t __ruid, __uid_t __euid, __uid_t __suid)
throw () ;
extern int setresgid (__gid_t __rgid, __gid_t __egid, __gid_t __sgid)
throw () ;
extern __pid_t fork (void) throw ();
extern __pid_t vfork (void) throw ();
extern char *ttyname (int __fd) throw ();
extern int ttyname_r (int __fd, char *__buf, size_t __buflen)
throw () __attribute__ ((__nonnull__ (2))) ;
extern int isatty (int __fd) throw ();
extern int ttyslot (void) throw ();
extern int link (const char *__from, const char *__to)
throw () __attribute__ ((__nonnull__ (1, 2))) ;
extern int linkat (int __fromfd, const char *__from, int __tofd,
const char *__to, int __flags)
throw () __attribute__ ((__nonnull__ (2, 4))) ;
extern int symlink (const char *__from, const char *__to)
throw () __attribute__ ((__nonnull__ (1, 2))) ;
extern ssize_t readlink (const char *__restrict __path,
char *__restrict __buf, size_t __len)
throw () __attribute__ ((__nonnull__ (1, 2))) ;
extern int symlinkat (const char *__from, int __tofd,
const char *__to) throw () __attribute__ ((__nonnull__ (1, 3))) ;
extern ssize_t readlinkat (int __fd, const char *__restrict __path,
char *__restrict __buf, size_t __len)
throw () __attribute__ ((__nonnull__ (2, 3))) ;
extern int unlink (const char *__name) throw () __attribute__ ((__nonnull__ (1)));
extern int unlinkat (int __fd, const char *__name, int __flag)
throw () __attribute__ ((__nonnull__ (2)));
extern int rmdir (const char *__path) throw () __attribute__ ((__nonnull__ (1)));
extern __pid_t tcgetpgrp (int __fd) throw ();
extern int tcsetpgrp (int __fd, __pid_t __pgrp_id) throw ();
extern char *getlogin (void);
extern int getlogin_r (char *__name, size_t __name_len) __attribute__ ((__nonnull__ (1)));
extern int setlogin (const char *__name) throw () __attribute__ ((__nonnull__ (1)));
# 1 "/usr/include/x86_64-linux-gnu/bits/getopt_posix.h" 1 3 4
# 27 "/usr/include/x86_64-linux-gnu/bits/getopt_posix.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/getopt_core.h" 1 3 4
# 28 "/usr/include/x86_64-linux-gnu/bits/getopt_core.h" 3 4
extern "C" {
extern char *optarg;
# 50 "/usr/include/x86_64-linux-gnu/bits/getopt_core.h" 3 4
extern int optind;
extern int opterr;
extern int optopt;
# 91 "/usr/include/x86_64-linux-gnu/bits/getopt_core.h" 3 4
extern int getopt (int ___argc, char *const *___argv, const char *__shortopts)
throw () __attribute__ ((__nonnull__ (2, 3)));
}
# 28 "/usr/include/x86_64-linux-gnu/bits/getopt_posix.h" 2 3 4
extern "C" {
# 49 "/usr/include/x86_64-linux-gnu/bits/getopt_posix.h" 3 4
}
# 870 "/usr/include/unistd.h" 2 3 4
extern int gethostname (char *__name, size_t __len) throw () __attribute__ ((__nonnull__ (1)));
extern int sethostname (const char *__name, size_t __len)
throw () __attribute__ ((__nonnull__ (1))) ;
extern int sethostid (long int __id) throw () ;
extern int getdomainname (char *__name, size_t __len)
throw () __attribute__ ((__nonnull__ (1))) ;
extern int setdomainname (const char *__name, size_t __len)
throw () __attribute__ ((__nonnull__ (1))) ;
extern int vhangup (void) throw ();
extern int revoke (const char *__file) throw () __attribute__ ((__nonnull__ (1))) ;
extern int profil (unsigned short int *__sample_buffer, size_t __size,
size_t __offset, unsigned int __scale)
throw () __attribute__ ((__nonnull__ (1)));
extern int acct (const char *__name) throw ();
extern char *getusershell (void) throw ();
extern void endusershell (void) throw ();
extern void setusershell (void) throw ();
extern int daemon (int __nochdir, int __noclose) throw () ;
extern int chroot (const char *__path) throw () __attribute__ ((__nonnull__ (1))) ;
extern char *getpass (const char *__prompt) __attribute__ ((__nonnull__ (1)));
extern int fsync (int __fd);
extern int syncfs (int __fd) throw ();
extern long int gethostid (void);
extern void sync (void) throw ();
extern int getpagesize (void) throw () __attribute__ ((__const__));
extern int getdtablesize (void) throw ();
# 991 "/usr/include/unistd.h" 3 4
extern int truncate (const char *__file, __off_t __length)
throw () __attribute__ ((__nonnull__ (1))) ;
# 1003 "/usr/include/unistd.h" 3 4
extern int truncate64 (const char *__file, __off64_t __length)
throw () __attribute__ ((__nonnull__ (1))) ;
# 1014 "/usr/include/unistd.h" 3 4
extern int ftruncate (int __fd, __off_t __length) throw () ;
# 1024 "/usr/include/unistd.h" 3 4
extern int ftruncate64 (int __fd, __off64_t __length) throw () ;
# 1035 "/usr/include/unistd.h" 3 4
extern int brk (void *__addr) throw () ;
extern void *sbrk (intptr_t __delta) throw ();
# 1056 "/usr/include/unistd.h" 3 4
extern long int syscall (long int __sysno, ...) throw ();
# 1079 "/usr/include/unistd.h" 3 4
extern int lockf (int __fd, int __cmd, __off_t __len) ;
# 1089 "/usr/include/unistd.h" 3 4
extern int lockf64 (int __fd, int __cmd, __off64_t __len) ;
# 1107 "/usr/include/unistd.h" 3 4
ssize_t copy_file_range (int __infd, __off64_t *__pinoff,
int __outfd, __off64_t *__poutoff,
size_t __length, unsigned int __flags);
extern int fdatasync (int __fildes);
# 1124 "/usr/include/unistd.h" 3 4
extern char *crypt (const char *__key, const char *__salt)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern void swab (const void *__restrict __from, void *__restrict __to,
ssize_t __n) throw () __attribute__ ((__nonnull__ (1, 2)));
# 1161 "/usr/include/unistd.h" 3 4
int getentropy (void *__buffer, size_t __length) ;
# 1170 "/usr/include/unistd.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/unistd_ext.h" 1 3 4
# 34 "/usr/include/x86_64-linux-gnu/bits/unistd_ext.h" 3 4
extern __pid_t gettid (void) throw ();
# 1171 "/usr/include/unistd.h" 2 3 4
}
# 296 "/home/giulianob/gcc_git_gnu/gcc/gcc/system.h" 2
# 1 "/usr/include/x86_64-linux-gnu/sys/param.h" 1 3 4
# 23 "/usr/include/x86_64-linux-gnu/sys/param.h" 3 4
# 1 "/usr/lib/gcc/x86_64-linux-gnu/10/include/stddef.h" 1 3 4
# 24 "/usr/include/x86_64-linux-gnu/sys/param.h" 2 3 4
# 1 "/usr/lib/gcc/x86_64-linux-gnu/10/include/limits.h" 1 3 4
# 34 "/usr/lib/gcc/x86_64-linux-gnu/10/include/limits.h" 3 4
# 1 "/usr/lib/gcc/x86_64-linux-gnu/10/include/syslimits.h" 1 3 4
# 1 "/usr/lib/gcc/x86_64-linux-gnu/10/include/limits.h" 1 3 4
# 195 "/usr/lib/gcc/x86_64-linux-gnu/10/include/limits.h" 3 4
# 1 "/usr/include/limits.h" 1 3 4
# 26 "/usr/include/limits.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/libc-header-start.h" 1 3 4
# 27 "/usr/include/limits.h" 2 3 4
# 183 "/usr/include/limits.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/posix1_lim.h" 1 3 4
# 27 "/usr/include/x86_64-linux-gnu/bits/posix1_lim.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/wordsize.h" 1 3 4
# 28 "/usr/include/x86_64-linux-gnu/bits/posix1_lim.h" 2 3 4
# 161 "/usr/include/x86_64-linux-gnu/bits/posix1_lim.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/local_lim.h" 1 3 4
# 38 "/usr/include/x86_64-linux-gnu/bits/local_lim.h" 3 4
# 1 "/usr/include/linux/limits.h" 1 3 4
# 39 "/usr/include/x86_64-linux-gnu/bits/local_lim.h" 2 3 4
# 162 "/usr/include/x86_64-linux-gnu/bits/posix1_lim.h" 2 3 4
# 184 "/usr/include/limits.h" 2 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/posix2_lim.h" 1 3 4
# 188 "/usr/include/limits.h" 2 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/xopen_lim.h" 1 3 4
# 64 "/usr/include/x86_64-linux-gnu/bits/xopen_lim.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/uio_lim.h" 1 3 4
# 65 "/usr/include/x86_64-linux-gnu/bits/xopen_lim.h" 2 3 4
# 192 "/usr/include/limits.h" 2 3 4
# 196 "/usr/lib/gcc/x86_64-linux-gnu/10/include/limits.h" 2 3 4
# 8 "/usr/lib/gcc/x86_64-linux-gnu/10/include/syslimits.h" 2 3 4
# 35 "/usr/lib/gcc/x86_64-linux-gnu/10/include/limits.h" 2 3 4
# 27 "/usr/include/x86_64-linux-gnu/sys/param.h" 2 3 4
# 1 "/usr/include/signal.h" 1 3 4
# 27 "/usr/include/signal.h" 3 4
extern "C" {
# 1 "/usr/include/x86_64-linux-gnu/bits/signum.h" 1 3 4
# 26 "/usr/include/x86_64-linux-gnu/bits/signum.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/signum-generic.h" 1 3 4
# 27 "/usr/include/x86_64-linux-gnu/bits/signum.h" 2 3 4
# 31 "/usr/include/signal.h" 2 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/types/sig_atomic_t.h" 1 3 4
typedef __sig_atomic_t sig_atomic_t;
# 33 "/usr/include/signal.h" 2 3 4
# 57 "/usr/include/signal.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/types/siginfo_t.h" 1 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/wordsize.h" 1 3 4
# 5 "/usr/include/x86_64-linux-gnu/bits/types/siginfo_t.h" 2 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/types/__sigval_t.h" 1 3 4
# 24 "/usr/include/x86_64-linux-gnu/bits/types/__sigval_t.h" 3 4
union sigval
{
int sival_int;
void *sival_ptr;
};
typedef union sigval __sigval_t;
# 7 "/usr/include/x86_64-linux-gnu/bits/types/siginfo_t.h" 2 3 4
# 16 "/usr/include/x86_64-linux-gnu/bits/types/siginfo_t.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/siginfo-arch.h" 1 3 4
# 17 "/usr/include/x86_64-linux-gnu/bits/types/siginfo_t.h" 2 3 4
# 36 "/usr/include/x86_64-linux-gnu/bits/types/siginfo_t.h" 3 4
typedef struct
{
int si_signo;
int si_errno;
int si_code;
int __pad0;
union
{
int _pad[((128 / sizeof (int)) - 4)];
struct
{
__pid_t si_pid;
__uid_t si_uid;
} _kill;
struct
{
int si_tid;
int si_overrun;
__sigval_t si_sigval;
} _timer;
struct
{
__pid_t si_pid;
__uid_t si_uid;
__sigval_t si_sigval;
} _rt;
struct
{
__pid_t si_pid;
__uid_t si_uid;
int si_status;
__clock_t si_utime;
__clock_t si_stime;
} _sigchld;
struct
{
void *si_addr;
short int si_addr_lsb;
union
{
struct
{
void *_lower;
void *_upper;
} _addr_bnd;
__uint32_t _pkey;
} _bounds;
} _sigfault;
struct
{
long int si_band;
int si_fd;
} _sigpoll;
struct
{
void *_call_addr;
int _syscall;
unsigned int _arch;
} _sigsys;
} _sifields;
} siginfo_t ;
# 58 "/usr/include/signal.h" 2 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/siginfo-consts.h" 1 3 4
# 35 "/usr/include/x86_64-linux-gnu/bits/siginfo-consts.h" 3 4
enum
{
SI_ASYNCNL = -60,
SI_DETHREAD = -7,
SI_TKILL,
SI_SIGIO,
SI_ASYNCIO,
SI_MESGQ,
SI_TIMER,
SI_QUEUE,
SI_USER,
SI_KERNEL = 0x80
# 66 "/usr/include/x86_64-linux-gnu/bits/siginfo-consts.h" 3 4
};
enum
{
ILL_ILLOPC = 1,
ILL_ILLOPN,
ILL_ILLADR,
ILL_ILLTRP,
ILL_PRVOPC,
ILL_PRVREG,
ILL_COPROC,
ILL_BADSTK,
ILL_BADIADDR
};
enum
{
FPE_INTDIV = 1,
FPE_INTOVF,
FPE_FLTDIV,
FPE_FLTOVF,
FPE_FLTUND,
FPE_FLTRES,
FPE_FLTINV,
FPE_FLTSUB,
FPE_FLTUNK = 14,
FPE_CONDTRAP
};
enum
{
SEGV_MAPERR = 1,
SEGV_ACCERR,
SEGV_BNDERR,
SEGV_PKUERR,
SEGV_ACCADI,
SEGV_ADIDERR,
SEGV_ADIPERR
};
enum
{
BUS_ADRALN = 1,
BUS_ADRERR,
BUS_OBJERR,
BUS_MCEERR_AR,
BUS_MCEERR_AO
};
enum
{
TRAP_BRKPT = 1,
TRAP_TRACE,
TRAP_BRANCH,
TRAP_HWBKPT,
TRAP_UNK
};
enum
{
CLD_EXITED = 1,
CLD_KILLED,
CLD_DUMPED,
CLD_TRAPPED,
CLD_STOPPED,
CLD_CONTINUED
};
enum
{
POLL_IN = 1,
POLL_OUT,
POLL_MSG,
POLL_ERR,
POLL_PRI,
POLL_HUP
};
# 1 "/usr/include/x86_64-linux-gnu/bits/siginfo-consts-arch.h" 1 3 4
# 210 "/usr/include/x86_64-linux-gnu/bits/siginfo-consts.h" 2 3 4
# 59 "/usr/include/signal.h" 2 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/types/sigval_t.h" 1 3 4
# 16 "/usr/include/x86_64-linux-gnu/bits/types/sigval_t.h" 3 4
typedef __sigval_t sigval_t;
# 63 "/usr/include/signal.h" 2 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/types/sigevent_t.h" 1 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/wordsize.h" 1 3 4
# 5 "/usr/include/x86_64-linux-gnu/bits/types/sigevent_t.h" 2 3 4
# 22 "/usr/include/x86_64-linux-gnu/bits/types/sigevent_t.h" 3 4
typedef struct sigevent
{
__sigval_t sigev_value;
int sigev_signo;
int sigev_notify;
union
{
int _pad[((64 / sizeof (int)) - 4)];
__pid_t _tid;
struct
{
void (*_function) (__sigval_t);
pthread_attr_t *_attribute;
} _sigev_thread;
} _sigev_un;
} sigevent_t;
# 67 "/usr/include/signal.h" 2 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/sigevent-consts.h" 1 3 4
# 27 "/usr/include/x86_64-linux-gnu/bits/sigevent-consts.h" 3 4
enum
{
SIGEV_SIGNAL = 0,
SIGEV_NONE,
SIGEV_THREAD,
SIGEV_THREAD_ID = 4
};
# 68 "/usr/include/signal.h" 2 3 4
typedef void (*__sighandler_t) (int);
extern __sighandler_t __sysv_signal (int __sig, __sighandler_t __handler)
throw ();
extern __sighandler_t sysv_signal (int __sig, __sighandler_t __handler)
throw ();
extern __sighandler_t signal (int __sig, __sighandler_t __handler)
throw ();
# 112 "/usr/include/signal.h" 3 4
extern int kill (__pid_t __pid, int __sig) throw ();
extern int killpg (__pid_t __pgrp, int __sig) throw ();
extern int raise (int __sig) throw ();
extern __sighandler_t ssignal (int __sig, __sighandler_t __handler)
throw ();
extern int gsignal (int __sig) throw ();
extern void psignal (int __sig, const char *__s);
extern void psiginfo (const siginfo_t *__pinfo, const char *__s);
# 151 "/usr/include/signal.h" 3 4
extern int sigpause (int __sig) __asm__ ("__xpg_sigpause");
# 170 "/usr/include/signal.h" 3 4
extern int sigblock (int __mask) throw () __attribute__ ((__deprecated__));
extern int sigsetmask (int __mask) throw () __attribute__ ((__deprecated__));
extern int siggetmask (void) throw () __attribute__ ((__deprecated__));
# 185 "/usr/include/signal.h" 3 4
typedef __sighandler_t sighandler_t;
typedef __sighandler_t sig_t;
extern int sigemptyset (sigset_t *__set) throw () __attribute__ ((__nonnull__ (1)));
extern int sigfillset (sigset_t *__set) throw () __attribute__ ((__nonnull__ (1)));
extern int sigaddset (sigset_t *__set, int __signo) throw () __attribute__ ((__nonnull__ (1)));
extern int sigdelset (sigset_t *__set, int __signo) throw () __attribute__ ((__nonnull__ (1)));
extern int sigismember (const sigset_t *__set, int __signo)
throw () __attribute__ ((__nonnull__ (1)));
extern int sigisemptyset (const sigset_t *__set) throw () __attribute__ ((__nonnull__ (1)));
extern int sigandset (sigset_t *__set, const sigset_t *__left,
const sigset_t *__right) throw () __attribute__ ((__nonnull__ (1, 2, 3)));
extern int sigorset (sigset_t *__set, const sigset_t *__left,
const sigset_t *__right) throw () __attribute__ ((__nonnull__ (1, 2, 3)));
# 1 "/usr/include/x86_64-linux-gnu/bits/sigaction.h" 1 3 4
# 27 "/usr/include/x86_64-linux-gnu/bits/sigaction.h" 3 4
struct sigaction
{
union
{
__sighandler_t sa_handler;
void (*sa_sigaction) (int, siginfo_t *, void *);
}
__sigaction_handler;
__sigset_t sa_mask;
int sa_flags;
void (*sa_restorer) (void);
};
# 227 "/usr/include/signal.h" 2 3 4
extern int sigprocmask (int __how, const sigset_t *__restrict __set,
sigset_t *__restrict __oset) throw ();
extern int sigsuspend (const sigset_t *__set) __attribute__ ((__nonnull__ (1)));
extern int sigaction (int __sig, const struct sigaction *__restrict __act,
struct sigaction *__restrict __oact) throw ();
extern int sigpending (sigset_t *__set) throw () __attribute__ ((__nonnull__ (1)));
extern int sigwait (const sigset_t *__restrict __set, int *__restrict __sig)
__attribute__ ((__nonnull__ (1, 2)));
extern int sigwaitinfo (const sigset_t *__restrict __set,
siginfo_t *__restrict __info) __attribute__ ((__nonnull__ (1)));
extern int sigtimedwait (const sigset_t *__restrict __set,
siginfo_t *__restrict __info,
const struct timespec *__restrict __timeout)
__attribute__ ((__nonnull__ (1)));
extern int sigqueue (__pid_t __pid, int __sig, const union sigval __val)
throw ();
# 286 "/usr/include/signal.h" 3 4
extern const char *const _sys_siglist[(64 + 1)];
extern const char *const sys_siglist[(64 + 1)];
# 1 "/usr/include/x86_64-linux-gnu/bits/sigcontext.h" 1 3 4
# 31 "/usr/include/x86_64-linux-gnu/bits/sigcontext.h" 3 4
struct _fpx_sw_bytes
{
__uint32_t magic1;
__uint32_t extended_size;
__uint64_t xstate_bv;
__uint32_t xstate_size;
__uint32_t __glibc_reserved1[7];
};
struct _fpreg
{
unsigned short significand[4];
unsigned short exponent;
};
struct _fpxreg
{
unsigned short significand[4];
unsigned short exponent;
unsigned short __glibc_reserved1[3];
};
struct _xmmreg
{
__uint32_t element[4];
};
# 123 "/usr/include/x86_64-linux-gnu/bits/sigcontext.h" 3 4
struct _fpstate
{
__uint16_t cwd;
__uint16_t swd;
__uint16_t ftw;
__uint16_t fop;
__uint64_t rip;
__uint64_t rdp;
__uint32_t mxcsr;
__uint32_t mxcr_mask;
struct _fpxreg _st[8];
struct _xmmreg _xmm[16];
__uint32_t __glibc_reserved1[24];
};
struct sigcontext
{
__uint64_t r8;
__uint64_t r9;
__uint64_t r10;
__uint64_t r11;
__uint64_t r12;
__uint64_t r13;
__uint64_t r14;
__uint64_t r15;
__uint64_t rdi;
__uint64_t rsi;
__uint64_t rbp;
__uint64_t rbx;
__uint64_t rdx;
__uint64_t rax;
__uint64_t rcx;
__uint64_t rsp;
__uint64_t rip;
__uint64_t eflags;
unsigned short cs;
unsigned short gs;
unsigned short fs;
unsigned short __pad0;
__uint64_t err;
__uint64_t trapno;
__uint64_t oldmask;
__uint64_t cr2;
__extension__ union
{
struct _fpstate * fpstate;
__uint64_t __fpstate_word;
};
__uint64_t __reserved1 [8];
};
struct _xsave_hdr
{
__uint64_t xstate_bv;
__uint64_t __glibc_reserved1[2];
__uint64_t __glibc_reserved2[5];
};
struct _ymmh_state
{
__uint32_t ymmh_space[64];
};
struct _xstate
{
struct _fpstate fpstate;
struct _xsave_hdr xstate_hdr;
struct _ymmh_state ymmh;
};
# 292 "/usr/include/signal.h" 2 3 4
extern int sigreturn (struct sigcontext *__scp) throw ();
# 1 "/usr/lib/gcc/x86_64-linux-gnu/10/include/stddef.h" 1 3 4
# 302 "/usr/include/signal.h" 2 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/types/stack_t.h" 1 3 4
# 23 "/usr/include/x86_64-linux-gnu/bits/types/stack_t.h" 3 4
# 1 "/usr/lib/gcc/x86_64-linux-gnu/10/include/stddef.h" 1 3 4
# 24 "/usr/include/x86_64-linux-gnu/bits/types/stack_t.h" 2 3 4
typedef struct
{
void *ss_sp;
int ss_flags;
size_t ss_size;
} stack_t;
# 304 "/usr/include/signal.h" 2 3 4
# 1 "/usr/include/x86_64-linux-gnu/sys/ucontext.h" 1 3 4
# 37 "/usr/include/x86_64-linux-gnu/sys/ucontext.h" 3 4
__extension__ typedef long long int greg_t;
# 46 "/usr/include/x86_64-linux-gnu/sys/ucontext.h" 3 4
typedef greg_t gregset_t[23];
enum
{
REG_R8 = 0,
REG_R9,
REG_R10,
REG_R11,
REG_R12,
REG_R13,
REG_R14,
REG_R15,
REG_RDI,
REG_RSI,
REG_RBP,
REG_RBX,
REG_RDX,
REG_RAX,
REG_RCX,
REG_RSP,
REG_RIP,
REG_EFL,
REG_CSGSFS,
REG_ERR,
REG_TRAPNO,
REG_OLDMASK,
REG_CR2
};
struct _libc_fpxreg
{
unsigned short int significand[4];
unsigned short int exponent;
unsigned short int __glibc_reserved1[3];
};
struct _libc_xmmreg
{
__uint32_t element[4];
};
struct _libc_fpstate
{
__uint16_t cwd;
__uint16_t swd;
__uint16_t ftw;
__uint16_t fop;
__uint64_t rip;
__uint64_t rdp;
__uint32_t mxcsr;
__uint32_t mxcr_mask;
struct _libc_fpxreg _st[8];
struct _libc_xmmreg _xmm[16];
__uint32_t __glibc_reserved1[24];
};
typedef struct _libc_fpstate *fpregset_t;
typedef struct
{
gregset_t gregs;
fpregset_t fpregs;
__extension__ unsigned long long __reserved1 [8];
} mcontext_t;
typedef struct ucontext_t
{
unsigned long int uc_flags;
struct ucontext_t *uc_link;
stack_t uc_stack;
mcontext_t uc_mcontext;
sigset_t uc_sigmask;
struct _libc_fpstate __fpregs_mem;
__extension__ unsigned long long int __ssp[4];
} ucontext_t;
# 307 "/usr/include/signal.h" 2 3 4
extern int siginterrupt (int __sig, int __interrupt) throw ();
# 1 "/usr/include/x86_64-linux-gnu/bits/sigstack.h" 1 3 4
# 317 "/usr/include/signal.h" 2 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/ss_flags.h" 1 3 4
# 27 "/usr/include/x86_64-linux-gnu/bits/ss_flags.h" 3 4
enum
{
SS_ONSTACK = 1,
SS_DISABLE
};
# 318 "/usr/include/signal.h" 2 3 4
extern int sigaltstack (const stack_t *__restrict __ss,
stack_t *__restrict __oss) throw ();
# 1 "/usr/include/x86_64-linux-gnu/bits/types/struct_sigstack.h" 1 3 4
# 23 "/usr/include/x86_64-linux-gnu/bits/types/struct_sigstack.h" 3 4
struct sigstack
{
void *ss_sp;
int ss_onstack;
};
# 328 "/usr/include/signal.h" 2 3 4
extern int sigstack (struct sigstack *__ss, struct sigstack *__oss)
throw () __attribute__ ((__deprecated__));
extern int sighold (int __sig) throw ();
extern int sigrelse (int __sig) throw ();
extern int sigignore (int __sig) throw ();
extern __sighandler_t sigset (int __sig, __sighandler_t __disp) throw ();
# 1 "/usr/include/x86_64-linux-gnu/bits/sigthread.h" 1 3 4
# 31 "/usr/include/x86_64-linux-gnu/bits/sigthread.h" 3 4
extern int pthread_sigmask (int __how,
const __sigset_t *__restrict __newmask,
__sigset_t *__restrict __oldmask)throw ();
extern int pthread_kill (pthread_t __threadid, int __signo) throw ();
extern int pthread_sigqueue (pthread_t __threadid, int __signo,
const union sigval __value) throw ();
# 360 "/usr/include/signal.h" 2 3 4
extern int __libc_current_sigrtmin (void) throw ();
extern int __libc_current_sigrtmax (void) throw ();
# 1 "/usr/include/x86_64-linux-gnu/bits/signal_ext.h" 1 3 4
# 29 "/usr/include/x86_64-linux-gnu/bits/signal_ext.h" 3 4
extern int tgkill (__pid_t __tgid, __pid_t __tid, int __signal);
# 375 "/usr/include/signal.h" 2 3 4
}
# 29 "/usr/include/x86_64-linux-gnu/sys/param.h" 2 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/param.h" 1 3 4
# 28 "/usr/include/x86_64-linux-gnu/bits/param.h" 3 4
# 1 "/usr/include/linux/param.h" 1 3 4
# 1 "/usr/include/x86_64-linux-gnu/asm/param.h" 1 3 4
# 1 "/usr/include/asm-generic/param.h" 1 3 4
# 2 "/usr/include/x86_64-linux-gnu/asm/param.h" 2 3 4
# 6 "/usr/include/linux/param.h" 2 3 4
# 29 "/usr/include/x86_64-linux-gnu/bits/param.h" 2 3 4
# 32 "/usr/include/x86_64-linux-gnu/sys/param.h" 2 3 4
# 300 "/home/giulianob/gcc_git_gnu/gcc/gcc/system.h" 2
# 1 "/usr/lib/gcc/x86_64-linux-gnu/10/include/limits.h" 1 3 4
# 307 "/home/giulianob/gcc_git_gnu/gcc/gcc/system.h" 2
# 337 "/home/giulianob/gcc_git_gnu/gcc/gcc/system.h"
# 1 "/usr/include/x86_64-linux-gnu/sys/time.h" 1 3 4
# 34 "/usr/include/x86_64-linux-gnu/sys/time.h" 3 4
extern "C" {
# 52 "/usr/include/x86_64-linux-gnu/sys/time.h" 3 4
struct timezone
{
int tz_minuteswest;
int tz_dsttime;
};
# 66 "/usr/include/x86_64-linux-gnu/sys/time.h" 3 4
extern int gettimeofday (struct timeval *__restrict __tv,
void *__restrict __tz) throw () __attribute__ ((__nonnull__ (1)));
extern int settimeofday (const struct timeval *__tv,
const struct timezone *__tz)
throw ();
extern int adjtime (const struct timeval *__delta,
struct timeval *__olddelta) throw ();
enum __itimer_which
{
ITIMER_REAL = 0,
ITIMER_VIRTUAL = 1,
ITIMER_PROF = 2
};
struct itimerval
{
struct timeval it_interval;
struct timeval it_value;
};
typedef int __itimer_which_t;
extern int getitimer (__itimer_which_t __which,
struct itimerval *__value) throw ();
extern int setitimer (__itimer_which_t __which,
const struct itimerval *__restrict __new,
struct itimerval *__restrict __old) throw ();
extern int utimes (const char *__file, const struct timeval __tvp[2])
throw () __attribute__ ((__nonnull__ (1)));
extern int lutimes (const char *__file, const struct timeval __tvp[2])
throw () __attribute__ ((__nonnull__ (1)));
extern int futimes (int __fd, const struct timeval __tvp[2]) throw ();
extern int futimesat (int __fd, const char *__file,
const struct timeval __tvp[2]) throw ();
# 187 "/usr/include/x86_64-linux-gnu/sys/time.h" 3 4
}
# 338 "/home/giulianob/gcc_git_gnu/gcc/gcc/system.h" 2
# 1 "/usr/include/time.h" 1 3 4
# 29 "/usr/include/time.h" 3 4
# 1 "/usr/lib/gcc/x86_64-linux-gnu/10/include/stddef.h" 1 3 4
# 30 "/usr/include/time.h" 2 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/time.h" 1 3 4
# 73 "/usr/include/x86_64-linux-gnu/bits/time.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/timex.h" 1 3 4
# 26 "/usr/include/x86_64-linux-gnu/bits/timex.h" 3 4
struct timex
{
unsigned int modes;
__syscall_slong_t offset;
__syscall_slong_t freq;
__syscall_slong_t maxerror;
__syscall_slong_t esterror;
int status;
__syscall_slong_t constant;
__syscall_slong_t precision;
__syscall_slong_t tolerance;
struct timeval time;
__syscall_slong_t tick;
__syscall_slong_t ppsfreq;
__syscall_slong_t jitter;
int shift;
__syscall_slong_t stabil;
__syscall_slong_t jitcnt;
__syscall_slong_t calcnt;
__syscall_slong_t errcnt;
__syscall_slong_t stbcnt;
int tai;
int :32; int :32; int :32; int :32;
int :32; int :32; int :32; int :32;
int :32; int :32; int :32;
};
# 74 "/usr/include/x86_64-linux-gnu/bits/time.h" 2 3 4
extern "C" {
extern int clock_adjtime (__clockid_t __clock_id, struct timex *__utx) throw ();
}
# 34 "/usr/include/time.h" 2 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/types/struct_tm.h" 1 3 4
struct tm
{
int tm_sec;
int tm_min;
int tm_hour;
int tm_mday;
int tm_mon;
int tm_year;
int tm_wday;
int tm_yday;
int tm_isdst;
long int tm_gmtoff;
const char *tm_zone;
};
# 40 "/usr/include/time.h" 2 3 4
# 48 "/usr/include/time.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/types/struct_itimerspec.h" 1 3 4
struct itimerspec
{
struct timespec it_interval;
struct timespec it_value;
};
# 49 "/usr/include/time.h" 2 3 4
struct sigevent;
# 68 "/usr/include/time.h" 3 4
extern "C" {
extern clock_t clock (void) throw ();
extern time_t time (time_t *__timer) throw ();
extern double difftime (time_t __time1, time_t __time0)
throw () __attribute__ ((__const__));
extern time_t mktime (struct tm *__tp) throw ();
extern size_t strftime (char *__restrict __s, size_t __maxsize,
const char *__restrict __format,
const struct tm *__restrict __tp) throw ();
extern char *strptime (const char *__restrict __s,
const char *__restrict __fmt, struct tm *__tp)
throw ();
extern size_t strftime_l (char *__restrict __s, size_t __maxsize,
const char *__restrict __format,
const struct tm *__restrict __tp,
locale_t __loc) throw ();
extern char *strptime_l (const char *__restrict __s,
const char *__restrict __fmt, struct tm *__tp,
locale_t __loc) throw ();
extern struct tm *gmtime (const time_t *__timer) throw ();
extern struct tm *localtime (const time_t *__timer) throw ();
extern struct tm *gmtime_r (const time_t *__restrict __timer,
struct tm *__restrict __tp) throw ();
extern struct tm *localtime_r (const time_t *__restrict __timer,
struct tm *__restrict __tp) throw ();
extern char *asctime (const struct tm *__tp) throw ();
extern char *ctime (const time_t *__timer) throw ();
extern char *asctime_r (const struct tm *__restrict __tp,
char *__restrict __buf) throw ();
extern char *ctime_r (const time_t *__restrict __timer,
char *__restrict __buf) throw ();
extern char *__tzname[2];
extern int __daylight;
extern long int __timezone;
extern char *tzname[2];
extern void tzset (void) throw ();
extern int daylight;
extern long int timezone;
# 190 "/usr/include/time.h" 3 4
extern time_t timegm (struct tm *__tp) throw ();
extern time_t timelocal (struct tm *__tp) throw ();
extern int dysize (int __year) throw () __attribute__ ((__const__));
# 205 "/usr/include/time.h" 3 4
extern int nanosleep (const struct timespec *__requested_time,
struct timespec *__remaining);
extern int clock_getres (clockid_t __clock_id, struct timespec *__res) throw ();
extern int clock_gettime (clockid_t __clock_id, struct timespec *__tp) throw ();
extern int clock_settime (clockid_t __clock_id, const struct timespec *__tp)
throw ();
extern int clock_nanosleep (clockid_t __clock_id, int __flags,
const struct timespec *__req,
struct timespec *__rem);
extern int clock_getcpuclockid (pid_t __pid, clockid_t *__clock_id) throw ();
extern int timer_create (clockid_t __clock_id,
struct sigevent *__restrict __evp,
timer_t *__restrict __timerid) throw ();
extern int timer_delete (timer_t __timerid) throw ();
extern int timer_settime (timer_t __timerid, int __flags,
const struct itimerspec *__restrict __value,
struct itimerspec *__restrict __ovalue) throw ();
extern int timer_gettime (timer_t __timerid, struct itimerspec *__value)
throw ();
extern int timer_getoverrun (timer_t __timerid) throw ();
extern int timespec_get (struct timespec *__ts, int __base)
throw () __attribute__ ((__nonnull__ (1)));
# 274 "/usr/include/time.h" 3 4
extern int getdate_err;
# 283 "/usr/include/time.h" 3 4
extern struct tm *getdate (const char *__string);
# 297 "/usr/include/time.h" 3 4
extern int getdate_r (const char *__restrict __string,
struct tm *__restrict __resbufp);
}
# 339 "/home/giulianob/gcc_git_gnu/gcc/gcc/system.h" 2
# 350 "/home/giulianob/gcc_git_gnu/gcc/gcc/system.h"
# 1 "/usr/include/fcntl.h" 1 3 4
# 28 "/usr/include/fcntl.h" 3 4
extern "C" {
# 1 "/usr/include/x86_64-linux-gnu/bits/fcntl.h" 1 3 4
# 35 "/usr/include/x86_64-linux-gnu/bits/fcntl.h" 3 4
struct flock
{
short int l_type;
short int l_whence;
__off_t l_start;
__off_t l_len;
__pid_t l_pid;
};
struct flock64
{
short int l_type;
short int l_whence;
__off64_t l_start;
__off64_t l_len;
__pid_t l_pid;
};
# 1 "/usr/include/x86_64-linux-gnu/bits/fcntl-linux.h" 1 3 4
# 38 "/usr/include/x86_64-linux-gnu/bits/fcntl-linux.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/types/struct_iovec.h" 1 3 4
# 23 "/usr/include/x86_64-linux-gnu/bits/types/struct_iovec.h" 3 4
# 1 "/usr/lib/gcc/x86_64-linux-gnu/10/include/stddef.h" 1 3 4
# 24 "/usr/include/x86_64-linux-gnu/bits/types/struct_iovec.h" 2 3 4
struct iovec
{
void *iov_base;
size_t iov_len;
};
# 39 "/usr/include/x86_64-linux-gnu/bits/fcntl-linux.h" 2 3 4
# 265 "/usr/include/x86_64-linux-gnu/bits/fcntl-linux.h" 3 4
enum __pid_type
{
F_OWNER_TID = 0,
F_OWNER_PID,
F_OWNER_PGRP,
F_OWNER_GID = F_OWNER_PGRP
};
struct f_owner_ex
{
enum __pid_type type;
__pid_t pid;
};
# 353 "/usr/include/x86_64-linux-gnu/bits/fcntl-linux.h" 3 4
# 1 "/usr/include/linux/falloc.h" 1 3 4
# 354 "/usr/include/x86_64-linux-gnu/bits/fcntl-linux.h" 2 3 4
struct file_handle
{
unsigned int handle_bytes;
int handle_type;
unsigned char f_handle[0];
};
# 392 "/usr/include/x86_64-linux-gnu/bits/fcntl-linux.h" 3 4
extern "C" {
extern __ssize_t readahead (int __fd, __off64_t __offset, size_t __count)
throw ();
extern int sync_file_range (int __fd, __off64_t __offset, __off64_t __count,
unsigned int __flags);
extern __ssize_t vmsplice (int __fdout, const struct iovec *__iov,
size_t __count, unsigned int __flags);
extern __ssize_t splice (int __fdin, __off64_t *__offin, int __fdout,
__off64_t *__offout, size_t __len,
unsigned int __flags);
extern __ssize_t tee (int __fdin, int __fdout, size_t __len,
unsigned int __flags);
extern int fallocate (int __fd, int __mode, __off_t __offset, __off_t __len);
# 447 "/usr/include/x86_64-linux-gnu/bits/fcntl-linux.h" 3 4
extern int fallocate64 (int __fd, int __mode, __off64_t __offset,
__off64_t __len);
extern int name_to_handle_at (int __dfd, const char *__name,
struct file_handle *__handle, int *__mnt_id,
int __flags) throw ();
extern int open_by_handle_at (int __mountdirfd, struct file_handle *__handle,
int __flags);
}
# 62 "/usr/include/x86_64-linux-gnu/bits/fcntl.h" 2 3 4
# 36 "/usr/include/fcntl.h" 2 3 4
# 78 "/usr/include/fcntl.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/stat.h" 1 3 4
# 46 "/usr/include/x86_64-linux-gnu/bits/stat.h" 3 4
struct stat
{
__dev_t st_dev;
__ino_t st_ino;
__nlink_t st_nlink;
__mode_t st_mode;
__uid_t st_uid;
__gid_t st_gid;
int __pad0;
__dev_t st_rdev;
__off_t st_size;
__blksize_t st_blksize;
__blkcnt_t st_blocks;
# 91 "/usr/include/x86_64-linux-gnu/bits/stat.h" 3 4
struct timespec st_atim;
struct timespec st_mtim;
struct timespec st_ctim;
# 106 "/usr/include/x86_64-linux-gnu/bits/stat.h" 3 4
__syscall_slong_t __glibc_reserved[3];
# 115 "/usr/include/x86_64-linux-gnu/bits/stat.h" 3 4
};
struct stat64
{
__dev_t st_dev;
__ino64_t st_ino;
__nlink_t st_nlink;
__mode_t st_mode;
__uid_t st_uid;
__gid_t st_gid;
int __pad0;
__dev_t st_rdev;
__off_t st_size;
__blksize_t st_blksize;
__blkcnt64_t st_blocks;
struct timespec st_atim;
struct timespec st_mtim;
struct timespec st_ctim;
# 164 "/usr/include/x86_64-linux-gnu/bits/stat.h" 3 4
__syscall_slong_t __glibc_reserved[3];
};
# 79 "/usr/include/fcntl.h" 2 3 4
# 148 "/usr/include/fcntl.h" 3 4
extern int fcntl (int __fd, int __cmd, ...);
# 157 "/usr/include/fcntl.h" 3 4
extern int fcntl64 (int __fd, int __cmd, ...);
# 168 "/usr/include/fcntl.h" 3 4
extern int open (const char *__file, int __oflag, ...) __attribute__ ((__nonnull__ (1)));
# 178 "/usr/include/fcntl.h" 3 4
extern int open64 (const char *__file, int __oflag, ...) __attribute__ ((__nonnull__ (1)));
# 192 "/usr/include/fcntl.h" 3 4
extern int openat (int __fd, const char *__file, int __oflag, ...)
__attribute__ ((__nonnull__ (2)));
# 203 "/usr/include/fcntl.h" 3 4
extern int openat64 (int __fd, const char *__file, int __oflag, ...)
__attribute__ ((__nonnull__ (2)));
# 214 "/usr/include/fcntl.h" 3 4
extern int creat (const char *__file, mode_t __mode) __attribute__ ((__nonnull__ (1)));
# 224 "/usr/include/fcntl.h" 3 4
extern int creat64 (const char *__file, mode_t __mode) __attribute__ ((__nonnull__ (1)));
# 260 "/usr/include/fcntl.h" 3 4
extern int posix_fadvise (int __fd, off_t __offset, off_t __len,
int __advise) throw ();
# 272 "/usr/include/fcntl.h" 3 4
extern int posix_fadvise64 (int __fd, off64_t __offset, off64_t __len,
int __advise) throw ();
# 282 "/usr/include/fcntl.h" 3 4
extern int posix_fallocate (int __fd, off_t __offset, off_t __len);
# 293 "/usr/include/fcntl.h" 3 4
extern int posix_fallocate64 (int __fd, off64_t __offset, off64_t __len);
# 304 "/usr/include/fcntl.h" 3 4
}
# 351 "/home/giulianob/gcc_git_gnu/gcc/gcc/system.h" 2
# 397 "/home/giulianob/gcc_git_gnu/gcc/gcc/system.h"
# 1 "/usr/include/x86_64-linux-gnu/sys/wait.h" 1 3 4
# 27 "/usr/include/x86_64-linux-gnu/sys/wait.h" 3 4
extern "C" {
# 77 "/usr/include/x86_64-linux-gnu/sys/wait.h" 3 4
extern __pid_t wait (int *__stat_loc);
# 100 "/usr/include/x86_64-linux-gnu/sys/wait.h" 3 4
extern __pid_t waitpid (__pid_t __pid, int *__stat_loc, int __options);
# 121 "/usr/include/x86_64-linux-gnu/sys/wait.h" 3 4
extern int waitid (idtype_t __idtype, __id_t __id, siginfo_t *__infop,
int __options);
struct rusage;
extern __pid_t wait3 (int *__stat_loc, int __options,
struct rusage * __usage) throw ();
extern __pid_t wait4 (__pid_t __pid, int *__stat_loc, int __options,
struct rusage *__usage) throw ();
}
# 398 "/home/giulianob/gcc_git_gnu/gcc/gcc/system.h" 2
# 428 "/home/giulianob/gcc_git_gnu/gcc/gcc/system.h"
# 1 "/usr/include/x86_64-linux-gnu/sys/mman.h" 1 3 4
# 25 "/usr/include/x86_64-linux-gnu/sys/mman.h" 3 4
# 1 "/usr/lib/gcc/x86_64-linux-gnu/10/include/stddef.h" 1 3 4
# 26 "/usr/include/x86_64-linux-gnu/sys/mman.h" 2 3 4
# 41 "/usr/include/x86_64-linux-gnu/sys/mman.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/mman.h" 1 3 4
# 31 "/usr/include/x86_64-linux-gnu/bits/mman.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/mman-map-flags-generic.h" 1 3 4
# 32 "/usr/include/x86_64-linux-gnu/bits/mman.h" 2 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/mman-linux.h" 1 3 4
# 113 "/usr/include/x86_64-linux-gnu/bits/mman-linux.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/mman-shared.h" 1 3 4
# 46 "/usr/include/x86_64-linux-gnu/bits/mman-shared.h" 3 4
extern "C" {
int memfd_create (const char *__name, unsigned int __flags) throw ();
int mlock2 (const void *__addr, size_t __length, unsigned int __flags) throw ();
int pkey_alloc (unsigned int __flags, unsigned int __access_rights) throw ();
int pkey_set (int __key, unsigned int __access_rights) throw ();
int pkey_get (int __key) throw ();
int pkey_free (int __key) throw ();
int pkey_mprotect (void *__addr, size_t __len, int __prot, int __pkey) throw ();
}
# 114 "/usr/include/x86_64-linux-gnu/bits/mman-linux.h" 2 3 4
# 35 "/usr/include/x86_64-linux-gnu/bits/mman.h" 2 3 4
# 42 "/usr/include/x86_64-linux-gnu/sys/mman.h" 2 3 4
extern "C" {
# 57 "/usr/include/x86_64-linux-gnu/sys/mman.h" 3 4
extern void *mmap (void *__addr, size_t __len, int __prot,
int __flags, int __fd, __off_t __offset) throw ();
# 70 "/usr/include/x86_64-linux-gnu/sys/mman.h" 3 4
extern void *mmap64 (void *__addr, size_t __len, int __prot,
int __flags, int __fd, __off64_t __offset) throw ();
extern int munmap (void *__addr, size_t __len) throw ();
extern int mprotect (void *__addr, size_t __len, int __prot) throw ();
extern int msync (void *__addr, size_t __len, int __flags);
extern int madvise (void *__addr, size_t __len, int __advice) throw ();
extern int posix_madvise (void *__addr, size_t __len, int __advice) throw ();
extern int mlock (const void *__addr, size_t __len) throw ();
extern int munlock (const void *__addr, size_t __len) throw ();
extern int mlockall (int __flags) throw ();
extern int munlockall (void) throw ();
extern int mincore (void *__start, size_t __len, unsigned char *__vec)
throw ();
# 133 "/usr/include/x86_64-linux-gnu/sys/mman.h" 3 4
extern void *mremap (void *__addr, size_t __old_len, size_t __new_len,
int __flags, ...) throw ();
extern int remap_file_pages (void *__start, size_t __size, int __prot,
size_t __pgoff, int __flags) throw ();
extern int shm_open (const char *__name, int __oflag, mode_t __mode);
extern int shm_unlink (const char *__name);
}
# 429 "/home/giulianob/gcc_git_gnu/gcc/gcc/system.h" 2
# 440 "/home/giulianob/gcc_git_gnu/gcc/gcc/system.h"
# 1 "/usr/include/x86_64-linux-gnu/sys/resource.h" 1 3 4
# 24 "/usr/include/x86_64-linux-gnu/sys/resource.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/resource.h" 1 3 4
# 31 "/usr/include/x86_64-linux-gnu/bits/resource.h" 3 4
enum __rlimit_resource
{
RLIMIT_CPU = 0,
RLIMIT_FSIZE = 1,
RLIMIT_DATA = 2,
RLIMIT_STACK = 3,
RLIMIT_CORE = 4,
__RLIMIT_RSS = 5,
RLIMIT_NOFILE = 7,
__RLIMIT_OFILE = RLIMIT_NOFILE,
RLIMIT_AS = 9,
__RLIMIT_NPROC = 6,
__RLIMIT_MEMLOCK = 8,
__RLIMIT_LOCKS = 10,
__RLIMIT_SIGPENDING = 11,
__RLIMIT_MSGQUEUE = 12,
__RLIMIT_NICE = 13,
__RLIMIT_RTPRIO = 14,
__RLIMIT_RTTIME = 15,
__RLIMIT_NLIMITS = 16,
__RLIM_NLIMITS = __RLIMIT_NLIMITS
};
# 131 "/usr/include/x86_64-linux-gnu/bits/resource.h" 3 4
typedef __rlim_t rlim_t;
typedef __rlim64_t rlim64_t;
struct rlimit
{
rlim_t rlim_cur;
rlim_t rlim_max;
};
struct rlimit64
{
rlim64_t rlim_cur;
rlim64_t rlim_max;
};
enum __rusage_who
{
RUSAGE_SELF = 0,
RUSAGE_CHILDREN = -1
,
RUSAGE_THREAD = 1
};
# 1 "/usr/include/x86_64-linux-gnu/bits/types/struct_rusage.h" 1 3 4
# 33 "/usr/include/x86_64-linux-gnu/bits/types/struct_rusage.h" 3 4
struct rusage
{
struct timeval ru_utime;
struct timeval ru_stime;
__extension__ union
{
long int ru_maxrss;
__syscall_slong_t __ru_maxrss_word;
};
__extension__ union
{
long int ru_ixrss;
__syscall_slong_t __ru_ixrss_word;
};
__extension__ union
{
long int ru_idrss;
__syscall_slong_t __ru_idrss_word;
};
__extension__ union
{
long int ru_isrss;
__syscall_slong_t __ru_isrss_word;
};
__extension__ union
{
long int ru_minflt;
__syscall_slong_t __ru_minflt_word;
};
__extension__ union
{
long int ru_majflt;
__syscall_slong_t __ru_majflt_word;
};
__extension__ union
{
long int ru_nswap;
__syscall_slong_t __ru_nswap_word;
};
__extension__ union
{
long int ru_inblock;
__syscall_slong_t __ru_inblock_word;
};
__extension__ union
{
long int ru_oublock;
__syscall_slong_t __ru_oublock_word;
};
__extension__ union
{
long int ru_msgsnd;
__syscall_slong_t __ru_msgsnd_word;
};
__extension__ union
{
long int ru_msgrcv;
__syscall_slong_t __ru_msgrcv_word;
};
__extension__ union
{
long int ru_nsignals;
__syscall_slong_t __ru_nsignals_word;
};
__extension__ union
{
long int ru_nvcsw;
__syscall_slong_t __ru_nvcsw_word;
};
__extension__ union
{
long int ru_nivcsw;
__syscall_slong_t __ru_nivcsw_word;
};
};
# 180 "/usr/include/x86_64-linux-gnu/bits/resource.h" 2 3 4
enum __priority_which
{
PRIO_PROCESS = 0,
PRIO_PGRP = 1,
PRIO_USER = 2
};
extern "C" {
extern int prlimit (__pid_t __pid, enum __rlimit_resource __resource,
const struct rlimit *__new_limit,
struct rlimit *__old_limit) throw ();
# 217 "/usr/include/x86_64-linux-gnu/bits/resource.h" 3 4
extern int prlimit64 (__pid_t __pid, enum __rlimit_resource __resource,
const struct rlimit64 *__new_limit,
struct rlimit64 *__old_limit) throw ();
}
# 25 "/usr/include/x86_64-linux-gnu/sys/resource.h" 2 3 4
extern "C" {
# 42 "/usr/include/x86_64-linux-gnu/sys/resource.h" 3 4
typedef int __rlimit_resource_t;
typedef int __rusage_who_t;
typedef int __priority_which_t;
extern int getrlimit (__rlimit_resource_t __resource,
struct rlimit *__rlimits) throw ();
# 61 "/usr/include/x86_64-linux-gnu/sys/resource.h" 3 4
extern int getrlimit64 (__rlimit_resource_t __resource,
struct rlimit64 *__rlimits) throw ();
extern int setrlimit (__rlimit_resource_t __resource,
const struct rlimit *__rlimits) throw ();
# 81 "/usr/include/x86_64-linux-gnu/sys/resource.h" 3 4
extern int setrlimit64 (__rlimit_resource_t __resource,
const struct rlimit64 *__rlimits) throw ();
extern int getrusage (__rusage_who_t __who, struct rusage *__usage) throw ();
extern int getpriority (__priority_which_t __which, id_t __who) throw ();
extern int setpriority (__priority_which_t __which, id_t __who, int __prio)
throw ();
}
# 441 "/home/giulianob/gcc_git_gnu/gcc/gcc/system.h" 2
# 1 "/usr/include/x86_64-linux-gnu/sys/times.h" 1 3 4
# 29 "/usr/include/x86_64-linux-gnu/sys/times.h" 3 4
extern "C" {
struct tms
{
clock_t tms_utime;
clock_t tms_stime;
clock_t tms_cutime;
clock_t tms_cstime;
};
extern clock_t times (struct tms *__buffer) throw ();
}
# 445 "/home/giulianob/gcc_git_gnu/gcc/gcc/system.h" 2
# 453 "/home/giulianob/gcc_git_gnu/gcc/gcc/system.h"
# 453 "/home/giulianob/gcc_git_gnu/gcc/gcc/system.h"
extern "C" {
# 521 "/home/giulianob/gcc_git_gnu/gcc/gcc/system.h"
}
# 1 "/usr/lib/gcc/x86_64-linux-gnu/10/include/stdint.h" 1 3 4
# 9 "/usr/lib/gcc/x86_64-linux-gnu/10/include/stdint.h" 3 4
# 1 "/usr/include/stdint.h" 1 3 4
# 26 "/usr/include/stdint.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/libc-header-start.h" 1 3 4
# 27 "/usr/include/stdint.h" 2 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/wchar.h" 1 3 4
# 29 "/usr/include/stdint.h" 2 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/wordsize.h" 1 3 4
# 30 "/usr/include/stdint.h" 2 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/stdint-uintn.h" 1 3 4
# 24 "/usr/include/x86_64-linux-gnu/bits/stdint-uintn.h" 3 4
# 24 "/usr/include/x86_64-linux-gnu/bits/stdint-uintn.h" 3 4
typedef __uint8_t uint8_t;
typedef __uint16_t uint16_t;
typedef __uint32_t uint32_t;
typedef __uint64_t uint64_t;
# 38 "/usr/include/stdint.h" 2 3 4
typedef __int_least8_t int_least8_t;
typedef __int_least16_t int_least16_t;
typedef __int_least32_t int_least32_t;
typedef __int_least64_t int_least64_t;
typedef __uint_least8_t uint_least8_t;
typedef __uint_least16_t uint_least16_t;
typedef __uint_least32_t uint_least32_t;
typedef __uint_least64_t uint_least64_t;
typedef signed char int_fast8_t;
typedef long int int_fast16_t;
typedef long int int_fast32_t;
typedef long int int_fast64_t;
# 71 "/usr/include/stdint.h" 3 4
typedef unsigned char uint_fast8_t;
typedef unsigned long int uint_fast16_t;
typedef unsigned long int uint_fast32_t;
typedef unsigned long int uint_fast64_t;
# 90 "/usr/include/stdint.h" 3 4
typedef unsigned long int uintptr_t;
# 101 "/usr/include/stdint.h" 3 4
typedef __intmax_t intmax_t;
typedef __uintmax_t uintmax_t;
# 10 "/usr/lib/gcc/x86_64-linux-gnu/10/include/stdint.h" 2 3 4
# 526 "/home/giulianob/gcc_git_gnu/gcc/gcc/system.h" 2
# 1 "/usr/include/inttypes.h" 1 3 4
# 266 "/usr/include/inttypes.h" 3 4
extern "C" {
typedef struct
{
long int quot;
long int rem;
} imaxdiv_t;
# 290 "/usr/include/inttypes.h" 3 4
extern intmax_t imaxabs (intmax_t __n) throw () __attribute__ ((__const__));
extern imaxdiv_t imaxdiv (intmax_t __numer, intmax_t __denom)
throw () __attribute__ ((__const__));
extern intmax_t strtoimax (const char *__restrict __nptr,
char **__restrict __endptr, int __base) throw ();
extern uintmax_t strtoumax (const char *__restrict __nptr,
char ** __restrict __endptr, int __base) throw ();
extern intmax_t wcstoimax (const wchar_t *__restrict __nptr,
wchar_t **__restrict __endptr, int __base)
throw ();
extern uintmax_t wcstoumax (const wchar_t *__restrict __nptr,
wchar_t ** __restrict __endptr, int __base)
throw ();
extern long int __strtol_internal (const char *__restrict __nptr,
char **__restrict __endptr,
int __base, int __group)
throw () __attribute__ ((__nonnull__ (1))) ;
extern __inline __attribute__ ((__gnu_inline__)) intmax_t
__attribute__ ((__leaf__)) strtoimax (const char *__restrict nptr, char **__restrict endptr, int base) throw ()
{
return __strtol_internal (nptr, endptr, base, 0);
}
extern unsigned long int __strtoul_internal (const char *__restrict __nptr,
char ** __restrict __endptr,
int __base, int __group)
throw () __attribute__ ((__nonnull__ (1))) ;
extern __inline __attribute__ ((__gnu_inline__)) uintmax_t
__attribute__ ((__leaf__)) strtoumax (const char *__restrict nptr, char **__restrict endptr, int base) throw ()
{
return __strtoul_internal (nptr, endptr, base, 0);
}
extern long int __wcstol_internal (const wchar_t * __restrict __nptr,
wchar_t **__restrict __endptr,
int __base, int __group)
throw () __attribute__ ((__nonnull__ (1))) ;
extern __inline __attribute__ ((__gnu_inline__)) intmax_t
__attribute__ ((__leaf__)) wcstoimax (const wchar_t *__restrict nptr, wchar_t **__restrict endptr, int base) throw ()
{
return __wcstol_internal (nptr, endptr, base, 0);
}
extern unsigned long int __wcstoul_internal (const wchar_t *
__restrict __nptr,
wchar_t **
__restrict __endptr,
int __base, int __group)
throw () __attribute__ ((__nonnull__ (1))) ;
extern __inline __attribute__ ((__gnu_inline__)) uintmax_t
__attribute__ ((__leaf__)) wcstoumax (const wchar_t *__restrict nptr, wchar_t **__restrict endptr, int base) throw ()
{
return __wcstoul_internal (nptr, endptr, base, 0);
}
# 432 "/usr/include/inttypes.h" 3 4
}
# 530 "/home/giulianob/gcc_git_gnu/gcc/gcc/system.h" 2
# 533 "/home/giulianob/gcc_git_gnu/gcc/gcc/system.h"
extern "C" {
# 576 "/home/giulianob/gcc_git_gnu/gcc/gcc/system.h"
}
# 599 "/home/giulianob/gcc_git_gnu/gcc/gcc/system.h"
# 1 "/usr/include/x86_64-linux-gnu/sys/stat.h" 1 3 4
# 99 "/usr/include/x86_64-linux-gnu/sys/stat.h" 3 4
# 99 "/usr/include/x86_64-linux-gnu/sys/stat.h" 3 4
extern "C" {
# 1 "/usr/include/x86_64-linux-gnu/bits/stat.h" 1 3 4
# 102 "/usr/include/x86_64-linux-gnu/sys/stat.h" 2 3 4
# 205 "/usr/include/x86_64-linux-gnu/sys/stat.h" 3 4
extern int stat (const char *__restrict __file,
struct stat *__restrict __buf) throw () __attribute__ ((__nonnull__ (1, 2)));
extern int fstat (int __fd, struct stat *__buf) throw () __attribute__ ((__nonnull__ (2)));
# 224 "/usr/include/x86_64-linux-gnu/sys/stat.h" 3 4
extern int stat64 (const char *__restrict __file,
struct stat64 *__restrict __buf) throw () __attribute__ ((__nonnull__ (1, 2)));
extern int fstat64 (int __fd, struct stat64 *__buf) throw () __attribute__ ((__nonnull__ (2)));
extern int fstatat (int __fd, const char *__restrict __file,
struct stat *__restrict __buf, int __flag)
throw () __attribute__ ((__nonnull__ (2, 3)));
# 249 "/usr/include/x86_64-linux-gnu/sys/stat.h" 3 4
extern int fstatat64 (int __fd, const char *__restrict __file,
struct stat64 *__restrict __buf, int __flag)
throw () __attribute__ ((__nonnull__ (2, 3)));
extern int lstat (const char *__restrict __file,
struct stat *__restrict __buf) throw () __attribute__ ((__nonnull__ (1, 2)));
# 272 "/usr/include/x86_64-linux-gnu/sys/stat.h" 3 4
extern int lstat64 (const char *__restrict __file,
struct stat64 *__restrict __buf)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern int chmod (const char *__file, __mode_t __mode)
throw () __attribute__ ((__nonnull__ (1)));
extern int lchmod (const char *__file, __mode_t __mode)
throw () __attribute__ ((__nonnull__ (1)));
extern int fchmod (int __fd, __mode_t __mode) throw ();
extern int fchmodat (int __fd, const char *__file, __mode_t __mode,
int __flag)
throw () __attribute__ ((__nonnull__ (2))) ;
extern __mode_t umask (__mode_t __mask) throw ();
extern __mode_t getumask (void) throw ();
extern int mkdir (const char *__path, __mode_t __mode)
throw () __attribute__ ((__nonnull__ (1)));
extern int mkdirat (int __fd, const char *__path, __mode_t __mode)
throw () __attribute__ ((__nonnull__ (2)));
extern int mknod (const char *__path, __mode_t __mode, __dev_t __dev)
throw () __attribute__ ((__nonnull__ (1)));
extern int mknodat (int __fd, const char *__path, __mode_t __mode,
__dev_t __dev) throw () __attribute__ ((__nonnull__ (2)));
extern int mkfifo (const char *__path, __mode_t __mode)
throw () __attribute__ ((__nonnull__ (1)));
extern int mkfifoat (int __fd, const char *__path, __mode_t __mode)
throw () __attribute__ ((__nonnull__ (2)));
extern int utimensat (int __fd, const char *__path,
const struct timespec __times[2],
int __flags)
throw () __attribute__ ((__nonnull__ (2)));
extern int futimens (int __fd, const struct timespec __times[2]) throw ();
# 395 "/usr/include/x86_64-linux-gnu/sys/stat.h" 3 4
extern int __fxstat (int __ver, int __fildes, struct stat *__stat_buf)
throw () __attribute__ ((__nonnull__ (3)));
extern int __xstat (int __ver, const char *__filename,
struct stat *__stat_buf) throw () __attribute__ ((__nonnull__ (2, 3)));
extern int __lxstat (int __ver, const char *__filename,
struct stat *__stat_buf) throw () __attribute__ ((__nonnull__ (2, 3)));
extern int __fxstatat (int __ver, int __fildes, const char *__filename,
struct stat *__stat_buf, int __flag)
throw () __attribute__ ((__nonnull__ (3, 4)));
# 428 "/usr/include/x86_64-linux-gnu/sys/stat.h" 3 4
extern int __fxstat64 (int __ver, int __fildes, struct stat64 *__stat_buf)
throw () __attribute__ ((__nonnull__ (3)));
extern int __xstat64 (int __ver, const char *__filename,
struct stat64 *__stat_buf) throw () __attribute__ ((__nonnull__ (2, 3)));
extern int __lxstat64 (int __ver, const char *__filename,
struct stat64 *__stat_buf) throw () __attribute__ ((__nonnull__ (2, 3)));
extern int __fxstatat64 (int __ver, int __fildes, const char *__filename,
struct stat64 *__stat_buf, int __flag)
throw () __attribute__ ((__nonnull__ (3, 4)));
extern int __xmknod (int __ver, const char *__path, __mode_t __mode,
__dev_t *__dev) throw () __attribute__ ((__nonnull__ (2, 4)));
extern int __xmknodat (int __ver, int __fd, const char *__path,
__mode_t __mode, __dev_t *__dev)
throw () __attribute__ ((__nonnull__ (3, 5)));
# 1 "/usr/include/x86_64-linux-gnu/bits/statx.h" 1 3 4
# 31 "/usr/include/x86_64-linux-gnu/bits/statx.h" 3 4
# 1 "/usr/include/linux/stat.h" 1 3 4
# 1 "/usr/include/linux/types.h" 1 3 4
# 1 "/usr/include/x86_64-linux-gnu/asm/types.h" 1 3 4
# 1 "/usr/include/asm-generic/types.h" 1 3 4
# 1 "/usr/include/asm-generic/int-ll64.h" 1 3 4
# 12 "/usr/include/asm-generic/int-ll64.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/asm/bitsperlong.h" 1 3 4
# 11 "/usr/include/x86_64-linux-gnu/asm/bitsperlong.h" 3 4
# 1 "/usr/include/asm-generic/bitsperlong.h" 1 3 4
# 12 "/usr/include/x86_64-linux-gnu/asm/bitsperlong.h" 2 3 4
# 13 "/usr/include/asm-generic/int-ll64.h" 2 3 4
typedef __signed__ char __s8;
typedef unsigned char __u8;
typedef __signed__ short __s16;
typedef unsigned short __u16;
typedef __signed__ int __s32;
typedef unsigned int __u32;
__extension__ typedef __signed__ long long __s64;
__extension__ typedef unsigned long long __u64;
# 8 "/usr/include/asm-generic/types.h" 2 3 4
# 2 "/usr/include/x86_64-linux-gnu/asm/types.h" 2 3 4
# 6 "/usr/include/linux/types.h" 2 3 4
# 1 "/usr/include/linux/posix_types.h" 1 3 4
# 1 "/usr/include/linux/stddef.h" 1 3 4
# 6 "/usr/include/linux/posix_types.h" 2 3 4
# 25 "/usr/include/linux/posix_types.h" 3 4
typedef struct {
unsigned long fds_bits[1024 / (8 * sizeof(long))];
} __kernel_fd_set;
typedef void (*__kernel_sighandler_t)(int);
typedef int __kernel_key_t;
typedef int __kernel_mqd_t;
# 1 "/usr/include/x86_64-linux-gnu/asm/posix_types.h" 1 3 4
# 1 "/usr/include/x86_64-linux-gnu/asm/posix_types_64.h" 1 3 4
# 11 "/usr/include/x86_64-linux-gnu/asm/posix_types_64.h" 3 4
typedef unsigned short __kernel_old_uid_t;
typedef unsigned short __kernel_old_gid_t;
typedef unsigned long __kernel_old_dev_t;
# 1 "/usr/include/asm-generic/posix_types.h" 1 3 4
# 15 "/usr/include/asm-generic/posix_types.h" 3 4
typedef long __kernel_long_t;
typedef unsigned long __kernel_ulong_t;
typedef __kernel_ulong_t __kernel_ino_t;
typedef unsigned int __kernel_mode_t;
typedef int __kernel_pid_t;
typedef int __kernel_ipc_pid_t;
typedef unsigned int __kernel_uid_t;
typedef unsigned int __kernel_gid_t;
typedef __kernel_long_t __kernel_suseconds_t;
typedef int __kernel_daddr_t;
typedef unsigned int __kernel_uid32_t;
typedef unsigned int __kernel_gid32_t;
# 72 "/usr/include/asm-generic/posix_types.h" 3 4
typedef __kernel_ulong_t __kernel_size_t;
typedef __kernel_long_t __kernel_ssize_t;
typedef __kernel_long_t __kernel_ptrdiff_t;
typedef struct {
int val[2];
} __kernel_fsid_t;
typedef __kernel_long_t __kernel_off_t;
typedef long long __kernel_loff_t;
typedef __kernel_long_t __kernel_old_time_t;
typedef __kernel_long_t __kernel_time_t;
typedef long long __kernel_time64_t;
typedef __kernel_long_t __kernel_clock_t;
typedef int __kernel_timer_t;
typedef int __kernel_clockid_t;
typedef char * __kernel_caddr_t;
typedef unsigned short __kernel_uid16_t;
typedef unsigned short __kernel_gid16_t;
# 19 "/usr/include/x86_64-linux-gnu/asm/posix_types_64.h" 2 3 4
# 8 "/usr/include/x86_64-linux-gnu/asm/posix_types.h" 2 3 4
# 37 "/usr/include/linux/posix_types.h" 2 3 4
# 10 "/usr/include/linux/types.h" 2 3 4
# 24 "/usr/include/linux/types.h" 3 4
typedef __u16 __le16;
typedef __u16 __be16;
typedef __u32 __le32;
typedef __u32 __be32;
typedef __u64 __le64;
typedef __u64 __be64;
typedef __u16 __sum16;
typedef __u32 __wsum;
# 47 "/usr/include/linux/types.h" 3 4
typedef unsigned __poll_t;
# 6 "/usr/include/linux/stat.h" 2 3 4
# 56 "/usr/include/linux/stat.h" 3 4
struct statx_timestamp {
__s64 tv_sec;
__u32 tv_nsec;
__s32 __reserved;
};
# 99 "/usr/include/linux/stat.h" 3 4
struct statx {
__u32 stx_mask;
__u32 stx_blksize;
__u64 stx_attributes;
__u32 stx_nlink;
__u32 stx_uid;
__u32 stx_gid;
__u16 stx_mode;
__u16 __spare0[1];
__u64 stx_ino;
__u64 stx_size;
__u64 stx_blocks;
__u64 stx_attributes_mask;
struct statx_timestamp stx_atime;
struct statx_timestamp stx_btime;
struct statx_timestamp stx_ctime;
struct statx_timestamp stx_mtime;
__u32 stx_rdev_major;
__u32 stx_rdev_minor;
__u32 stx_dev_major;
__u32 stx_dev_minor;
__u64 __spare2[14];
};
# 32 "/usr/include/x86_64-linux-gnu/bits/statx.h" 2 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/statx-generic.h" 1 3 4
# 25 "/usr/include/x86_64-linux-gnu/bits/statx-generic.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/types/struct_statx_timestamp.h" 1 3 4
# 26 "/usr/include/x86_64-linux-gnu/bits/statx-generic.h" 2 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/types/struct_statx.h" 1 3 4
# 27 "/usr/include/x86_64-linux-gnu/bits/statx-generic.h" 2 3 4
# 53 "/usr/include/x86_64-linux-gnu/bits/statx-generic.h" 3 4
extern "C" {
int statx (int __dirfd, const char *__restrict __path, int __flags,
unsigned int __mask, struct statx *__restrict __buf)
throw () __attribute__ ((__nonnull__ (2, 5)));
}
# 40 "/usr/include/x86_64-linux-gnu/bits/statx.h" 2 3 4
# 447 "/usr/include/x86_64-linux-gnu/sys/stat.h" 2 3 4
extern __inline __attribute__ ((__gnu_inline__)) int
__attribute__ ((__leaf__)) stat (const char *__path, struct stat *__statbuf) throw ()
{
return __xstat (1, __path, __statbuf);
}
extern __inline __attribute__ ((__gnu_inline__)) int
__attribute__ ((__leaf__)) lstat (const char *__path, struct stat *__statbuf) throw ()
{
return __lxstat (1, __path, __statbuf);
}
extern __inline __attribute__ ((__gnu_inline__)) int
__attribute__ ((__leaf__)) fstat (int __fd, struct stat *__statbuf) throw ()
{
return __fxstat (1, __fd, __statbuf);
}
extern __inline __attribute__ ((__gnu_inline__)) int
__attribute__ ((__leaf__)) fstatat (int __fd, const char *__filename, struct stat *__statbuf, int __flag) throw ()
{
return __fxstatat (1, __fd, __filename, __statbuf, __flag);
}
extern __inline __attribute__ ((__gnu_inline__)) int
__attribute__ ((__leaf__)) mknod (const char *__path, __mode_t __mode, __dev_t __dev) throw ()
{
return __xmknod (0, __path, __mode, &__dev);
}
extern __inline __attribute__ ((__gnu_inline__)) int
__attribute__ ((__leaf__)) mknodat (int __fd, const char *__path, __mode_t __mode, __dev_t __dev) throw ()
{
return __xmknodat (0, __fd, __path, __mode, &__dev);
}
extern __inline __attribute__ ((__gnu_inline__)) int
__attribute__ ((__leaf__)) stat64 (const char *__path, struct stat64 *__statbuf) throw ()
{
return __xstat64 (1, __path, __statbuf);
}
extern __inline __attribute__ ((__gnu_inline__)) int
__attribute__ ((__leaf__)) lstat64 (const char *__path, struct stat64 *__statbuf) throw ()
{
return __lxstat64 (1, __path, __statbuf);
}
extern __inline __attribute__ ((__gnu_inline__)) int
__attribute__ ((__leaf__)) fstat64 (int __fd, struct stat64 *__statbuf) throw ()
{
return __fxstat64 (1, __fd, __statbuf);
}
extern __inline __attribute__ ((__gnu_inline__)) int
__attribute__ ((__leaf__)) fstatat64 (int __fd, const char *__filename, struct stat64 *__statbuf, int __flag) throw ()
{
return __fxstatat64 (1, __fd, __filename, __statbuf, __flag);
}
}
# 600 "/home/giulianob/gcc_git_gnu/gcc/gcc/system.h" 2
# 671 "/home/giulianob/gcc_git_gnu/gcc/gcc/system.h"
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/../include/filenames.h" 1
# 29 "/home/giulianob/gcc_git_gnu/gcc/gcc/../include/filenames.h"
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/../include/hashtab.h" 1
# 36 "/home/giulianob/gcc_git_gnu/gcc/gcc/../include/hashtab.h"
# 36 "/home/giulianob/gcc_git_gnu/gcc/gcc/../include/hashtab.h"
extern "C" {
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/../include/ansidecl.h" 1
# 40 "/home/giulianob/gcc_git_gnu/gcc/gcc/../include/hashtab.h" 2
typedef unsigned int hashval_t;
typedef hashval_t (*htab_hash) (const void *);
typedef int (*htab_eq) (const void *, const void *);
typedef void (*htab_del) (void *);
typedef int (*htab_trav) (void **, void *);
typedef void *(*htab_alloc) (size_t, size_t);
typedef void (*htab_free) (void *);
typedef void *(*htab_alloc_with_arg) (void *, size_t, size_t);
typedef void (*htab_free_with_arg) (void *, void *);
# 95 "/home/giulianob/gcc_git_gnu/gcc/gcc/../include/hashtab.h"
struct htab {
htab_hash hash_f;
htab_eq eq_f;
htab_del del_f;
void **entries;
size_t size;
size_t n_elements;
size_t n_deleted;
unsigned int searches;
unsigned int collisions;
htab_alloc alloc_f;
htab_free free_f;
void *alloc_arg;
htab_alloc_with_arg alloc_with_arg_f;
htab_free_with_arg free_with_arg_f;
unsigned int size_prime_index;
};
typedef struct htab *htab_t;
enum insert_option {NO_INSERT, INSERT};
extern htab_t htab_create_alloc (size_t, htab_hash,
htab_eq, htab_del,
htab_alloc, htab_free);
extern htab_t htab_create_alloc_ex (size_t, htab_hash,
htab_eq, htab_del,
void *, htab_alloc_with_arg,
htab_free_with_arg);
extern htab_t htab_create_typed_alloc (size_t, htab_hash, htab_eq, htab_del,
htab_alloc, htab_alloc, htab_free);
extern htab_t htab_create (size_t, htab_hash, htab_eq, htab_del);
extern htab_t htab_try_create (size_t, htab_hash, htab_eq, htab_del);
extern void htab_set_functions_ex (htab_t, htab_hash,
htab_eq, htab_del,
void *, htab_alloc_with_arg,
htab_free_with_arg);
extern void htab_delete (htab_t);
extern void htab_empty (htab_t);
extern void * htab_find (htab_t, const void *);
extern void ** htab_find_slot (htab_t, const void *, enum insert_option);
extern void * htab_find_with_hash (htab_t, const void *, hashval_t);
extern void ** htab_find_slot_with_hash (htab_t, const void *,
hashval_t, enum insert_option);
extern void htab_clear_slot (htab_t, void **);
extern void htab_remove_elt (htab_t, const void *);
extern void htab_remove_elt_with_hash (htab_t, const void *, hashval_t);
extern void htab_traverse (htab_t, htab_trav, void *);
extern void htab_traverse_noresize (htab_t, htab_trav, void *);
extern size_t htab_size (htab_t);
extern size_t htab_elements (htab_t);
extern double htab_collisions (htab_t);
extern htab_hash htab_hash_pointer;
extern htab_eq htab_eq_pointer;
extern hashval_t htab_hash_string (const void *);
extern hashval_t iterative_hash (const void *, size_t, hashval_t);
}
# 30 "/home/giulianob/gcc_git_gnu/gcc/gcc/../include/filenames.h" 2
extern "C" {
# 84 "/home/giulianob/gcc_git_gnu/gcc/gcc/../include/filenames.h"
extern int filename_cmp (const char *s1, const char *s2);
extern int filename_ncmp (const char *s1, const char *s2,
size_t n);
extern hashval_t filename_hash (const void *s);
extern int filename_eq (const void *s1, const void *s2);
extern int canonical_filename_eq (const char *a, const char *b);
}
# 672 "/home/giulianob/gcc_git_gnu/gcc/gcc/system.h" 2
# 683 "/home/giulianob/gcc_git_gnu/gcc/gcc/system.h"
# 1 "/usr/include/dlfcn.h" 1 3 4
# 24 "/usr/include/dlfcn.h" 3 4
# 1 "/usr/lib/gcc/x86_64-linux-gnu/10/include/stddef.h" 1 3 4
# 25 "/usr/include/dlfcn.h" 2 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/dlfcn.h" 1 3 4
# 57 "/usr/include/x86_64-linux-gnu/bits/dlfcn.h" 3 4
# 57 "/usr/include/x86_64-linux-gnu/bits/dlfcn.h" 3 4
extern "C" {
extern void _dl_mcount_wrapper_check (void *__selfpc) throw ();
}
# 28 "/usr/include/dlfcn.h" 2 3 4
# 44 "/usr/include/dlfcn.h" 3 4
typedef long int Lmid_t;
extern "C" {
extern void *dlopen (const char *__file, int __mode) throw ();
extern int dlclose (void *__handle) throw () __attribute__ ((__nonnull__ (1)));
extern void *dlsym (void *__restrict __handle,
const char *__restrict __name) throw () __attribute__ ((__nonnull__ (2)));
extern void *dlmopen (Lmid_t __nsid, const char *__file, int __mode) throw ();
extern void *dlvsym (void *__restrict __handle,
const char *__restrict __name,
const char *__restrict __version)
throw () __attribute__ ((__nonnull__ (2, 3)));
extern char *dlerror (void) throw ();
typedef struct
{
const char *dli_fname;
void *dli_fbase;
const char *dli_sname;
void *dli_saddr;
} Dl_info;
extern int dladdr (const void *__address, Dl_info *__info)
throw () __attribute__ ((__nonnull__ (2)));
extern int dladdr1 (const void *__address, Dl_info *__info,
void **__extra_info, int __flags) throw () __attribute__ ((__nonnull__ (2)));
enum
{
RTLD_DL_SYMENT = 1,
RTLD_DL_LINKMAP = 2
};
extern int dlinfo (void *__restrict __handle,
int __request, void *__restrict __arg)
throw () __attribute__ ((__nonnull__ (1, 3)));
enum
{
RTLD_DI_LMID = 1,
RTLD_DI_LINKMAP = 2,
RTLD_DI_CONFIGADDR = 3,
RTLD_DI_SERINFO = 4,
RTLD_DI_SERINFOSIZE = 5,
RTLD_DI_ORIGIN = 6,
RTLD_DI_PROFILENAME = 7,
RTLD_DI_PROFILEOUT = 8,
RTLD_DI_TLS_MODID = 9,
RTLD_DI_TLS_DATA = 10,
RTLD_DI_MAX = 10
};
typedef struct
{
char *dls_name;
unsigned int dls_flags;
} Dl_serpath;
typedef struct
{
size_t dls_size;
unsigned int dls_cnt;
__extension__ union
{
Dl_serpath dls_serpath[0];
Dl_serpath __dls_serpath_pad[1];
};
} Dl_serinfo;
}
# 684 "/home/giulianob/gcc_git_gnu/gcc/gcc/system.h" 2
# 1 "/usr/include/x86_64-linux-gnu/gmp.h" 1 3 4
# 34 "/usr/include/x86_64-linux-gnu/gmp.h" 3 4
# 1 "/usr/include/c++/10/iosfwd" 1 3 4
# 36 "/usr/include/c++/10/iosfwd" 3 4
# 37 "/usr/include/c++/10/iosfwd" 3
# 1 "/usr/include/c++/10/bits/stringfwd.h" 1 3
# 37 "/usr/include/c++/10/bits/stringfwd.h" 3
# 38 "/usr/include/c++/10/bits/stringfwd.h" 3
# 1 "/usr/include/c++/10/bits/memoryfwd.h" 1 3
# 46 "/usr/include/c++/10/bits/memoryfwd.h" 3
# 47 "/usr/include/c++/10/bits/memoryfwd.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{
# 63 "/usr/include/c++/10/bits/memoryfwd.h" 3
template<typename>
class allocator;
template<>
class allocator<void>;
template<typename, typename>
struct uses_allocator;
}
# 41 "/usr/include/c++/10/bits/stringfwd.h" 2 3
namespace std __attribute__ ((__visibility__ ("default")))
{
template<class _CharT>
struct char_traits;
template<> struct char_traits<char>;
template<> struct char_traits<wchar_t>;
template<> struct char_traits<char16_t>;
template<> struct char_traits<char32_t>;
namespace __cxx11 {
template<typename _CharT, typename _Traits = char_traits<_CharT>,
typename _Alloc = allocator<_CharT> >
class basic_string;
}
typedef basic_string<char> string;
typedef basic_string<wchar_t> wstring;
# 93 "/usr/include/c++/10/bits/stringfwd.h" 3
typedef basic_string<char16_t> u16string;
typedef basic_string<char32_t> u32string;
}
# 40 "/usr/include/c++/10/iosfwd" 2 3
# 1 "/usr/include/c++/10/bits/postypes.h" 1 3
# 38 "/usr/include/c++/10/bits/postypes.h" 3
# 39 "/usr/include/c++/10/bits/postypes.h" 3
# 1 "/usr/include/c++/10/cwchar" 1 3
# 39 "/usr/include/c++/10/cwchar" 3
# 40 "/usr/include/c++/10/cwchar" 3
# 1 "/usr/include/wchar.h" 1 3 4
# 27 "/usr/include/wchar.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/libc-header-start.h" 1 3 4
# 28 "/usr/include/wchar.h" 2 3 4
# 1 "/usr/lib/gcc/x86_64-linux-gnu/10/include/stddef.h" 1 3 4
# 36 "/usr/include/wchar.h" 2 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/types/wint_t.h" 1 3 4
# 20 "/usr/include/x86_64-linux-gnu/bits/types/wint_t.h" 3 4
typedef unsigned int wint_t;
# 42 "/usr/include/wchar.h" 2 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/types/mbstate_t.h" 1 3 4
typedef __mbstate_t mbstate_t;
# 43 "/usr/include/wchar.h" 2 3 4
# 79 "/usr/include/wchar.h" 3 4
extern "C" {
struct tm;
extern wchar_t *wcscpy (wchar_t *__restrict __dest,
const wchar_t *__restrict __src)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern wchar_t *wcsncpy (wchar_t *__restrict __dest,
const wchar_t *__restrict __src, size_t __n)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern wchar_t *wcscat (wchar_t *__restrict __dest,
const wchar_t *__restrict __src)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern wchar_t *wcsncat (wchar_t *__restrict __dest,
const wchar_t *__restrict __src, size_t __n)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern int wcscmp (const wchar_t *__s1, const wchar_t *__s2)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
extern int wcsncmp (const wchar_t *__s1, const wchar_t *__s2, size_t __n)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
extern int wcscasecmp (const wchar_t *__s1, const wchar_t *__s2) throw ();
extern int wcsncasecmp (const wchar_t *__s1, const wchar_t *__s2,
size_t __n) throw ();
extern int wcscasecmp_l (const wchar_t *__s1, const wchar_t *__s2,
locale_t __loc) throw ();
extern int wcsncasecmp_l (const wchar_t *__s1, const wchar_t *__s2,
size_t __n, locale_t __loc) throw ();
extern int wcscoll (const wchar_t *__s1, const wchar_t *__s2) throw ();
extern size_t wcsxfrm (wchar_t *__restrict __s1,
const wchar_t *__restrict __s2, size_t __n) throw ();
extern int wcscoll_l (const wchar_t *__s1, const wchar_t *__s2,
locale_t __loc) throw ();
extern size_t wcsxfrm_l (wchar_t *__s1, const wchar_t *__s2,
size_t __n, locale_t __loc) throw ();
extern wchar_t *wcsdup (const wchar_t *__s) throw () __attribute__ ((__malloc__));
extern "C++" wchar_t *wcschr (wchar_t *__wcs, wchar_t __wc)
throw () __asm ("wcschr") __attribute__ ((__pure__));
extern "C++" const wchar_t *wcschr (const wchar_t *__wcs, wchar_t __wc)
throw () __asm ("wcschr") __attribute__ ((__pure__));
extern "C++" wchar_t *wcsrchr (wchar_t *__wcs, wchar_t __wc)
throw () __asm ("wcsrchr") __attribute__ ((__pure__));
extern "C++" const wchar_t *wcsrchr (const wchar_t *__wcs, wchar_t __wc)
throw () __asm ("wcsrchr") __attribute__ ((__pure__));
# 181 "/usr/include/wchar.h" 3 4
extern wchar_t *wcschrnul (const wchar_t *__s, wchar_t __wc)
throw () __attribute__ ((__pure__));
extern size_t wcscspn (const wchar_t *__wcs, const wchar_t *__reject)
throw () __attribute__ ((__pure__));
extern size_t wcsspn (const wchar_t *__wcs, const wchar_t *__accept)
throw () __attribute__ ((__pure__));
extern "C++" wchar_t *wcspbrk (wchar_t *__wcs, const wchar_t *__accept)
throw () __asm ("wcspbrk") __attribute__ ((__pure__));
extern "C++" const wchar_t *wcspbrk (const wchar_t *__wcs,
const wchar_t *__accept)
throw () __asm ("wcspbrk") __attribute__ ((__pure__));
extern "C++" wchar_t *wcsstr (wchar_t *__haystack, const wchar_t *__needle)
throw () __asm ("wcsstr") __attribute__ ((__pure__));
extern "C++" const wchar_t *wcsstr (const wchar_t *__haystack,
const wchar_t *__needle)
throw () __asm ("wcsstr") __attribute__ ((__pure__));
extern wchar_t *wcstok (wchar_t *__restrict __s,
const wchar_t *__restrict __delim,
wchar_t **__restrict __ptr) throw ();
extern size_t wcslen (const wchar_t *__s) throw () __attribute__ ((__pure__));
extern "C++" wchar_t *wcswcs (wchar_t *__haystack, const wchar_t *__needle)
throw () __asm ("wcswcs") __attribute__ ((__pure__));
extern "C++" const wchar_t *wcswcs (const wchar_t *__haystack,
const wchar_t *__needle)
throw () __asm ("wcswcs") __attribute__ ((__pure__));
# 240 "/usr/include/wchar.h" 3 4
extern size_t wcsnlen (const wchar_t *__s, size_t __maxlen)
throw () __attribute__ ((__pure__));
extern "C++" wchar_t *wmemchr (wchar_t *__s, wchar_t __c, size_t __n)
throw () __asm ("wmemchr") __attribute__ ((__pure__));
extern "C++" const wchar_t *wmemchr (const wchar_t *__s, wchar_t __c,
size_t __n)
throw () __asm ("wmemchr") __attribute__ ((__pure__));
extern int wmemcmp (const wchar_t *__s1, const wchar_t *__s2, size_t __n)
throw () __attribute__ ((__pure__));
extern wchar_t *wmemcpy (wchar_t *__restrict __s1,
const wchar_t *__restrict __s2, size_t __n) throw ();
extern wchar_t *wmemmove (wchar_t *__s1, const wchar_t *__s2, size_t __n)
throw ();
extern wchar_t *wmemset (wchar_t *__s, wchar_t __c, size_t __n) throw ();
extern wchar_t *wmempcpy (wchar_t *__restrict __s1,
const wchar_t *__restrict __s2, size_t __n)
throw ();
extern wint_t btowc (int __c) throw ();
extern int wctob (wint_t __c) throw ();
extern int mbsinit (const mbstate_t *__ps) throw () __attribute__ ((__pure__));
extern size_t mbrtowc (wchar_t *__restrict __pwc,
const char *__restrict __s, size_t __n,
mbstate_t *__restrict __p) throw ();
extern size_t wcrtomb (char *__restrict __s, wchar_t __wc,
mbstate_t *__restrict __ps) throw ();
extern size_t __mbrlen (const char *__restrict __s, size_t __n,
mbstate_t *__restrict __ps) throw ();
extern size_t mbrlen (const char *__restrict __s, size_t __n,
mbstate_t *__restrict __ps) throw ();
extern wint_t __btowc_alias (int __c) __asm ("btowc");
extern __inline __attribute__ ((__gnu_inline__)) wint_t
__attribute__ ((__leaf__)) btowc (int __c) throw ()
{ return (__builtin_constant_p (__c) && __c >= '\0' && __c <= '\x7f'
? (wint_t) __c : __btowc_alias (__c)); }
extern int __wctob_alias (wint_t __c) __asm ("wctob");
extern __inline __attribute__ ((__gnu_inline__)) int
__attribute__ ((__leaf__)) wctob (wint_t __wc) throw ()
{ return (__builtin_constant_p (__wc) && __wc >= L'\0' && __wc <= L'\x7f'
? (int) __wc : __wctob_alias (__wc)); }
extern __inline __attribute__ ((__gnu_inline__)) size_t
__attribute__ ((__leaf__)) mbrlen (const char *__restrict __s, size_t __n, mbstate_t *__restrict __ps) throw ()
{ return (__ps != __null
? mbrtowc (__null, __s, __n, __ps) : __mbrlen (__s, __n, __null)); }
extern size_t mbsrtowcs (wchar_t *__restrict __dst,
const char **__restrict __src, size_t __len,
mbstate_t *__restrict __ps) throw ();
extern size_t wcsrtombs (char *__restrict __dst,
const wchar_t **__restrict __src, size_t __len,
mbstate_t *__restrict __ps) throw ();
extern size_t mbsnrtowcs (wchar_t *__restrict __dst,
const char **__restrict __src, size_t __nmc,
size_t __len, mbstate_t *__restrict __ps) throw ();
extern size_t wcsnrtombs (char *__restrict __dst,
const wchar_t **__restrict __src,
size_t __nwc, size_t __len,
mbstate_t *__restrict __ps) throw ();
extern int wcwidth (wchar_t __c) throw ();
extern int wcswidth (const wchar_t *__s, size_t __n) throw ();
extern double wcstod (const wchar_t *__restrict __nptr,
wchar_t **__restrict __endptr) throw ();
extern float wcstof (const wchar_t *__restrict __nptr,
wchar_t **__restrict __endptr) throw ();
extern long double wcstold (const wchar_t *__restrict __nptr,
wchar_t **__restrict __endptr) throw ();
# 396 "/usr/include/wchar.h" 3 4
extern _Float32 wcstof32 (const wchar_t *__restrict __nptr,
wchar_t **__restrict __endptr) throw ();
extern _Float64 wcstof64 (const wchar_t *__restrict __nptr,
wchar_t **__restrict __endptr) throw ();
extern _Float128 wcstof128 (const wchar_t *__restrict __nptr,
wchar_t **__restrict __endptr) throw ();
extern _Float32x wcstof32x (const wchar_t *__restrict __nptr,
wchar_t **__restrict __endptr) throw ();
extern _Float64x wcstof64x (const wchar_t *__restrict __nptr,
wchar_t **__restrict __endptr) throw ();
# 428 "/usr/include/wchar.h" 3 4
extern long int wcstol (const wchar_t *__restrict __nptr,
wchar_t **__restrict __endptr, int __base) throw ();
extern unsigned long int wcstoul (const wchar_t *__restrict __nptr,
wchar_t **__restrict __endptr, int __base)
throw ();
__extension__
extern long long int wcstoll (const wchar_t *__restrict __nptr,
wchar_t **__restrict __endptr, int __base)
throw ();
__extension__
extern unsigned long long int wcstoull (const wchar_t *__restrict __nptr,
wchar_t **__restrict __endptr,
int __base) throw ();
__extension__
extern long long int wcstoq (const wchar_t *__restrict __nptr,
wchar_t **__restrict __endptr, int __base)
throw ();
__extension__
extern unsigned long long int wcstouq (const wchar_t *__restrict __nptr,
wchar_t **__restrict __endptr,
int __base) throw ();
extern long int wcstol_l (const wchar_t *__restrict __nptr,
wchar_t **__restrict __endptr, int __base,
locale_t __loc) throw ();
extern unsigned long int wcstoul_l (const wchar_t *__restrict __nptr,
wchar_t **__restrict __endptr,
int __base, locale_t __loc) throw ();
__extension__
extern long long int wcstoll_l (const wchar_t *__restrict __nptr,
wchar_t **__restrict __endptr,
int __base, locale_t __loc) throw ();
__extension__
extern unsigned long long int wcstoull_l (const wchar_t *__restrict __nptr,
wchar_t **__restrict __endptr,
int __base, locale_t __loc)
throw ();
extern double wcstod_l (const wchar_t *__restrict __nptr,
wchar_t **__restrict __endptr, locale_t __loc)
throw ();
extern float wcstof_l (const wchar_t *__restrict __nptr,
wchar_t **__restrict __endptr, locale_t __loc)
throw ();
extern long double wcstold_l (const wchar_t *__restrict __nptr,
wchar_t **__restrict __endptr,
locale_t __loc) throw ();
# 511 "/usr/include/wchar.h" 3 4
extern _Float32 wcstof32_l (const wchar_t *__restrict __nptr,
wchar_t **__restrict __endptr,
locale_t __loc) throw ();
extern _Float64 wcstof64_l (const wchar_t *__restrict __nptr,
wchar_t **__restrict __endptr,
locale_t __loc) throw ();
extern _Float128 wcstof128_l (const wchar_t *__restrict __nptr,
wchar_t **__restrict __endptr,
locale_t __loc) throw ();
extern _Float32x wcstof32x_l (const wchar_t *__restrict __nptr,
wchar_t **__restrict __endptr,
locale_t __loc) throw ();
extern _Float64x wcstof64x_l (const wchar_t *__restrict __nptr,
wchar_t **__restrict __endptr,
locale_t __loc) throw ();
# 551 "/usr/include/wchar.h" 3 4
extern wchar_t *wcpcpy (wchar_t *__restrict __dest,
const wchar_t *__restrict __src) throw ();
extern wchar_t *wcpncpy (wchar_t *__restrict __dest,
const wchar_t *__restrict __src, size_t __n)
throw ();
# 567 "/usr/include/wchar.h" 3 4
extern __FILE *open_wmemstream (wchar_t **__bufloc, size_t *__sizeloc) throw ();
extern int fwide (__FILE *__fp, int __mode) throw ();
extern int fwprintf (__FILE *__restrict __stream,
const wchar_t *__restrict __format, ...)
;
extern int wprintf (const wchar_t *__restrict __format, ...)
;
extern int swprintf (wchar_t *__restrict __s, size_t __n,
const wchar_t *__restrict __format, ...)
throw () ;
extern int vfwprintf (__FILE *__restrict __s,
const wchar_t *__restrict __format,
__gnuc_va_list __arg)
;
extern int vwprintf (const wchar_t *__restrict __format,
__gnuc_va_list __arg)
;
extern int vswprintf (wchar_t *__restrict __s, size_t __n,
const wchar_t *__restrict __format,
__gnuc_va_list __arg)
throw () ;
extern int fwscanf (__FILE *__restrict __stream,
const wchar_t *__restrict __format, ...)
;
extern int wscanf (const wchar_t *__restrict __format, ...)
;
extern int swscanf (const wchar_t *__restrict __s,
const wchar_t *__restrict __format, ...)
throw () ;
extern int fwscanf (__FILE *__restrict __stream, const wchar_t *__restrict __format, ...) __asm__ ("" "__isoc99_fwscanf")
;
extern int wscanf (const wchar_t *__restrict __format, ...) __asm__ ("" "__isoc99_wscanf")
;
extern int swscanf (const wchar_t *__restrict __s, const wchar_t *__restrict __format, ...) throw () __asm__ ("" "__isoc99_swscanf")
;
# 671 "/usr/include/wchar.h" 3 4
extern int vfwscanf (__FILE *__restrict __s,
const wchar_t *__restrict __format,
__gnuc_va_list __arg)
;
extern int vwscanf (const wchar_t *__restrict __format,
__gnuc_va_list __arg)
;
extern int vswscanf (const wchar_t *__restrict __s,
const wchar_t *__restrict __format,
__gnuc_va_list __arg)
throw () ;
extern int vfwscanf (__FILE *__restrict __s, const wchar_t *__restrict __format, __gnuc_va_list __arg) __asm__ ("" "__isoc99_vfwscanf")
;
extern int vwscanf (const wchar_t *__restrict __format, __gnuc_va_list __arg) __asm__ ("" "__isoc99_vwscanf")
;
extern int vswscanf (const wchar_t *__restrict __s, const wchar_t *__restrict __format, __gnuc_va_list __arg) throw () __asm__ ("" "__isoc99_vswscanf")
;
# 726 "/usr/include/wchar.h" 3 4
extern wint_t fgetwc (__FILE *__stream);
extern wint_t getwc (__FILE *__stream);
extern wint_t getwchar (void);
extern wint_t fputwc (wchar_t __wc, __FILE *__stream);
extern wint_t putwc (wchar_t __wc, __FILE *__stream);
extern wint_t putwchar (wchar_t __wc);
extern wchar_t *fgetws (wchar_t *__restrict __ws, int __n,
__FILE *__restrict __stream);
extern int fputws (const wchar_t *__restrict __ws,
__FILE *__restrict __stream);
extern wint_t ungetwc (wint_t __wc, __FILE *__stream);
# 781 "/usr/include/wchar.h" 3 4
extern wint_t getwc_unlocked (__FILE *__stream);
extern wint_t getwchar_unlocked (void);
extern wint_t fgetwc_unlocked (__FILE *__stream);
extern wint_t fputwc_unlocked (wchar_t __wc, __FILE *__stream);
# 807 "/usr/include/wchar.h" 3 4
extern wint_t putwc_unlocked (wchar_t __wc, __FILE *__stream);
extern wint_t putwchar_unlocked (wchar_t __wc);
# 817 "/usr/include/wchar.h" 3 4
extern wchar_t *fgetws_unlocked (wchar_t *__restrict __ws, int __n,
__FILE *__restrict __stream);
extern int fputws_unlocked (const wchar_t *__restrict __ws,
__FILE *__restrict __stream);
extern size_t wcsftime (wchar_t *__restrict __s, size_t __maxsize,
const wchar_t *__restrict __format,
const struct tm *__restrict __tp) throw ();
extern size_t wcsftime_l (wchar_t *__restrict __s, size_t __maxsize,
const wchar_t *__restrict __format,
const struct tm *__restrict __tp,
locale_t __loc) throw ();
# 856 "/usr/include/wchar.h" 3 4
}
# 45 "/usr/include/c++/10/cwchar" 2 3
# 62 "/usr/include/c++/10/cwchar" 3
namespace std
{
using ::mbstate_t;
}
# 135 "/usr/include/c++/10/cwchar" 3
extern "C++"
{
namespace std __attribute__ ((__visibility__ ("default")))
{
using ::wint_t;
using ::btowc;
using ::fgetwc;
using ::fgetws;
using ::fputwc;
using ::fputws;
using ::fwide;
using ::fwprintf;
using ::fwscanf;
using ::getwc;
using ::getwchar;
using ::mbrlen;
using ::mbrtowc;
using ::mbsinit;
using ::mbsrtowcs;
using ::putwc;
using ::putwchar;
using ::swprintf;
using ::swscanf;
using ::ungetwc;
using ::vfwprintf;
using ::vfwscanf;
using ::vswprintf;
using ::vswscanf;
using ::vwprintf;
using ::vwscanf;
using ::wcrtomb;
using ::wcscat;
using ::wcscmp;
using ::wcscoll;
using ::wcscpy;
using ::wcscspn;
using ::wcsftime;
using ::wcslen;
using ::wcsncat;
using ::wcsncmp;
using ::wcsncpy;
using ::wcsrtombs;
using ::wcsspn;
using ::wcstod;
using ::wcstof;
using ::wcstok;
using ::wcstol;
using ::wcstoul;
using ::wcsxfrm;
using ::wctob;
using ::wmemcmp;
using ::wmemcpy;
using ::wmemmove;
using ::wmemset;
using ::wprintf;
using ::wscanf;
using ::wcschr;
using ::wcspbrk;
using ::wcsrchr;
using ::wcsstr;
using ::wmemchr;
# 234 "/usr/include/c++/10/cwchar" 3
}
}
namespace __gnu_cxx
{
using ::wcstold;
# 260 "/usr/include/c++/10/cwchar" 3
using ::wcstoll;
using ::wcstoull;
}
namespace std
{
using ::__gnu_cxx::wcstold;
using ::__gnu_cxx::wcstoll;
using ::__gnu_cxx::wcstoull;
}
# 280 "/usr/include/c++/10/cwchar" 3
namespace std
{
using std::wcstof;
using std::vfwscanf;
using std::vswscanf;
using std::vwscanf;
using std::wcstold;
using std::wcstoll;
using std::wcstoull;
}
# 41 "/usr/include/c++/10/bits/postypes.h" 2 3
# 68 "/usr/include/c++/10/bits/postypes.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{
# 88 "/usr/include/c++/10/bits/postypes.h" 3
typedef long streamoff;
# 98 "/usr/include/c++/10/bits/postypes.h" 3
typedef ptrdiff_t streamsize;
# 111 "/usr/include/c++/10/bits/postypes.h" 3
template<typename _StateT>
class fpos
{
private:
streamoff _M_off;
_StateT _M_state;
public:
fpos()
: _M_off(0), _M_state() { }
# 133 "/usr/include/c++/10/bits/postypes.h" 3
fpos(streamoff __off)
: _M_off(__off), _M_state() { }
fpos(const fpos&) = default;
fpos& operator=(const fpos&) = default;
~fpos() = default;
operator streamoff() const { return _M_off; }
void
state(_StateT __st)
{ _M_state = __st; }
_StateT
state() const
{ return _M_state; }
fpos&
operator+=(streamoff __off)
{
_M_off += __off;
return *this;
}
fpos&
operator-=(streamoff __off)
{
_M_off -= __off;
return *this;
}
fpos
operator+(streamoff __off) const
{
fpos __pos(*this);
__pos += __off;
return __pos;
}
fpos
operator-(streamoff __off) const
{
fpos __pos(*this);
__pos -= __off;
return __pos;
}
streamoff
operator-(const fpos& __other) const
{ return _M_off - __other._M_off; }
};
template<typename _StateT>
inline bool
operator==(const fpos<_StateT>& __lhs, const fpos<_StateT>& __rhs)
{ return streamoff(__lhs) == streamoff(__rhs); }
template<typename _StateT>
inline bool
operator!=(const fpos<_StateT>& __lhs, const fpos<_StateT>& __rhs)
{ return streamoff(__lhs) != streamoff(__rhs); }
typedef fpos<mbstate_t> streampos;
typedef fpos<mbstate_t> wstreampos;
# 245 "/usr/include/c++/10/bits/postypes.h" 3
typedef fpos<mbstate_t> u16streampos;
typedef fpos<mbstate_t> u32streampos;
}
# 41 "/usr/include/c++/10/iosfwd" 2 3
namespace std __attribute__ ((__visibility__ ("default")))
{
# 74 "/usr/include/c++/10/iosfwd" 3
class ios_base;
template<typename _CharT, typename _Traits = char_traits<_CharT> >
class basic_ios;
template<typename _CharT, typename _Traits = char_traits<_CharT> >
class basic_streambuf;
template<typename _CharT, typename _Traits = char_traits<_CharT> >
class basic_istream;
template<typename _CharT, typename _Traits = char_traits<_CharT> >
class basic_ostream;
template<typename _CharT, typename _Traits = char_traits<_CharT> >
class basic_iostream;
namespace __cxx11 {
template<typename _CharT, typename _Traits = char_traits<_CharT>,
typename _Alloc = allocator<_CharT> >
class basic_stringbuf;
template<typename _CharT, typename _Traits = char_traits<_CharT>,
typename _Alloc = allocator<_CharT> >
class basic_istringstream;
template<typename _CharT, typename _Traits = char_traits<_CharT>,
typename _Alloc = allocator<_CharT> >
class basic_ostringstream;
template<typename _CharT, typename _Traits = char_traits<_CharT>,
typename _Alloc = allocator<_CharT> >
class basic_stringstream;
}
template<typename _CharT, typename _Traits = char_traits<_CharT> >
class basic_filebuf;
template<typename _CharT, typename _Traits = char_traits<_CharT> >
class basic_ifstream;
template<typename _CharT, typename _Traits = char_traits<_CharT> >
class basic_ofstream;
template<typename _CharT, typename _Traits = char_traits<_CharT> >
class basic_fstream;
template<typename _CharT, typename _Traits = char_traits<_CharT> >
class istreambuf_iterator;
template<typename _CharT, typename _Traits = char_traits<_CharT> >
class ostreambuf_iterator;
typedef basic_ios<char> ios;
typedef basic_streambuf<char> streambuf;
typedef basic_istream<char> istream;
typedef basic_ostream<char> ostream;
typedef basic_iostream<char> iostream;
typedef basic_stringbuf<char> stringbuf;
typedef basic_istringstream<char> istringstream;
typedef basic_ostringstream<char> ostringstream;
typedef basic_stringstream<char> stringstream;
typedef basic_filebuf<char> filebuf;
typedef basic_ifstream<char> ifstream;
typedef basic_ofstream<char> ofstream;
typedef basic_fstream<char> fstream;
typedef basic_ios<wchar_t> wios;
typedef basic_streambuf<wchar_t> wstreambuf;
typedef basic_istream<wchar_t> wistream;
typedef basic_ostream<wchar_t> wostream;
typedef basic_iostream<wchar_t> wiostream;
typedef basic_stringbuf<wchar_t> wstringbuf;
typedef basic_istringstream<wchar_t> wistringstream;
typedef basic_ostringstream<wchar_t> wostringstream;
typedef basic_stringstream<wchar_t> wstringstream;
typedef basic_filebuf<wchar_t> wfilebuf;
typedef basic_ifstream<wchar_t> wifstream;
typedef basic_ofstream<wchar_t> wofstream;
typedef basic_fstream<wchar_t> wfstream;
}
# 35 "/usr/include/x86_64-linux-gnu/gmp.h" 2 3 4
# 1 "/usr/include/c++/10/cstdio" 1 3 4
# 39 "/usr/include/c++/10/cstdio" 3 4
# 40 "/usr/include/c++/10/cstdio" 3
# 96 "/usr/include/c++/10/cstdio" 3
namespace std
{
using ::FILE;
using ::fpos_t;
using ::clearerr;
using ::fclose;
using ::feof;
using ::ferror;
using ::fflush;
using ::fgetc;
using ::fgetpos;
using ::fgets;
using ::fopen;
using ::fprintf;
using ::fputc;
using ::fputs;
using ::fread;
using ::freopen;
using ::fscanf;
using ::fseek;
using ::fsetpos;
using ::ftell;
using ::fwrite;
using ::getc;
using ::getchar;
using ::perror;
using ::printf;
using ::putc;
using ::putchar;
using ::puts;
using ::remove;
using ::rename;
using ::rewind;
using ::scanf;
using ::setbuf;
using ::setvbuf;
using ::sprintf;
using ::sscanf;
using ::tmpfile;
using ::tmpnam;
using ::ungetc;
using ::vfprintf;
using ::vprintf;
using ::vsprintf;
}
# 157 "/usr/include/c++/10/cstdio" 3
namespace __gnu_cxx
{
# 175 "/usr/include/c++/10/cstdio" 3
using ::snprintf;
using ::vfscanf;
using ::vscanf;
using ::vsnprintf;
using ::vsscanf;
}
namespace std
{
using ::__gnu_cxx::snprintf;
using ::__gnu_cxx::vfscanf;
using ::__gnu_cxx::vscanf;
using ::__gnu_cxx::vsnprintf;
using ::__gnu_cxx::vsscanf;
}
# 36 "/usr/include/x86_64-linux-gnu/gmp.h" 2 3 4
# 55 "/usr/include/x86_64-linux-gnu/gmp.h" 3 4
# 1 "/usr/lib/gcc/x86_64-linux-gnu/10/include/stddef.h" 1 3 4
# 56 "/usr/include/x86_64-linux-gnu/gmp.h" 2 3 4
# 1 "/usr/lib/gcc/x86_64-linux-gnu/10/include/limits.h" 1 3 4
# 57 "/usr/include/x86_64-linux-gnu/gmp.h" 2 3 4
# 141 "/usr/include/x86_64-linux-gnu/gmp.h" 3 4
typedef unsigned long int mp_limb_t;
typedef long int mp_limb_signed_t;
typedef unsigned long int mp_bitcnt_t;
typedef struct
{
int _mp_alloc;
int _mp_size;
mp_limb_t *_mp_d;
} __mpz_struct;
typedef __mpz_struct MP_INT;
typedef __mpz_struct mpz_t[1];
typedef mp_limb_t * mp_ptr;
typedef const mp_limb_t * mp_srcptr;
typedef long int mp_size_t;
typedef long int mp_exp_t;
typedef struct
{
__mpz_struct _mp_num;
__mpz_struct _mp_den;
} __mpq_struct;
typedef __mpq_struct MP_RAT;
typedef __mpq_struct mpq_t[1];
typedef struct
{
int _mp_prec;
int _mp_size;
mp_exp_t _mp_exp;
mp_limb_t *_mp_d;
} __mpf_struct;
typedef __mpf_struct mpf_t[1];
typedef enum
{
GMP_RAND_ALG_DEFAULT = 0,
GMP_RAND_ALG_LC = GMP_RAND_ALG_DEFAULT
} gmp_randalg_t;
typedef struct
{
mpz_t _mp_seed;
gmp_randalg_t _mp_alg;
union {
void *_mp_lc;
} _mp_algdata;
} __gmp_randstate_struct;
typedef __gmp_randstate_struct gmp_randstate_t[1];
typedef const __mpz_struct *mpz_srcptr;
typedef __mpz_struct *mpz_ptr;
typedef const __mpf_struct *mpf_srcptr;
typedef __mpf_struct *mpf_ptr;
typedef const __mpq_struct *mpq_srcptr;
typedef __mpq_struct *mpq_ptr;
# 472 "/usr/include/x86_64-linux-gnu/gmp.h" 3 4
extern "C" {
using std::FILE;
void __gmp_set_memory_functions (void *(*) (size_t),
void *(*) (void *, size_t, size_t),
void (*) (void *, size_t)) noexcept;
void __gmp_get_memory_functions (void *(**) (size_t),
void *(**) (void *, size_t, size_t),
void (**) (void *, size_t)) noexcept;
extern const int __gmp_bits_per_limb;
extern int __gmp_errno;
extern const char * const __gmp_version;
void __gmp_randinit (gmp_randstate_t, gmp_randalg_t, ...);
void __gmp_randinit_default (gmp_randstate_t);
void __gmp_randinit_lc_2exp (gmp_randstate_t, mpz_srcptr, unsigned long int, mp_bitcnt_t);
int __gmp_randinit_lc_2exp_size (gmp_randstate_t, mp_bitcnt_t);
void __gmp_randinit_mt (gmp_randstate_t);
void __gmp_randinit_set (gmp_randstate_t, const __gmp_randstate_struct *);
void __gmp_randseed (gmp_randstate_t, mpz_srcptr);
void __gmp_randseed_ui (gmp_randstate_t, unsigned long int);
void __gmp_randclear (gmp_randstate_t);
unsigned long __gmp_urandomb_ui (gmp_randstate_t, unsigned long);
unsigned long __gmp_urandomm_ui (gmp_randstate_t, unsigned long);
int __gmp_asprintf (char **, const char *, ...);
int __gmp_fprintf (FILE *, const char *, ...);
# 554 "/usr/include/x86_64-linux-gnu/gmp.h" 3 4
int __gmp_printf (const char *, ...);
int __gmp_snprintf (char *, size_t, const char *, ...);
int __gmp_sprintf (char *, const char *, ...);
int __gmp_vasprintf (char **, const char *, va_list);
int __gmp_vfprintf (FILE *, const char *, va_list);
int __gmp_vprintf (const char *, va_list);
int __gmp_vsnprintf (char *, size_t, const char *, va_list);
int __gmp_vsprintf (char *, const char *, va_list);
int __gmp_fscanf (FILE *, const char *, ...);
int __gmp_scanf (const char *, ...);
int __gmp_sscanf (const char *, const char *, ...);
int __gmp_vfscanf (FILE *, const char *, va_list);
int __gmp_vscanf (const char *, va_list);
int __gmp_vsscanf (const char *, const char *, va_list);
void *__gmpz_realloc (mpz_ptr, mp_size_t);
void __gmpz_abs (mpz_ptr, mpz_srcptr);
void __gmpz_add (mpz_ptr, mpz_srcptr, mpz_srcptr);
void __gmpz_add_ui (mpz_ptr, mpz_srcptr, unsigned long int);
void __gmpz_addmul (mpz_ptr, mpz_srcptr, mpz_srcptr);
void __gmpz_addmul_ui (mpz_ptr, mpz_srcptr, unsigned long int);
void __gmpz_and (mpz_ptr, mpz_srcptr, mpz_srcptr);
void __gmpz_array_init (mpz_ptr, mp_size_t, mp_size_t);
void __gmpz_bin_ui (mpz_ptr, mpz_srcptr, unsigned long int);
void __gmpz_bin_uiui (mpz_ptr, unsigned long int, unsigned long int);
void __gmpz_cdiv_q (mpz_ptr, mpz_srcptr, mpz_srcptr);
void __gmpz_cdiv_q_2exp (mpz_ptr, mpz_srcptr, mp_bitcnt_t);
unsigned long int __gmpz_cdiv_q_ui (mpz_ptr, mpz_srcptr, unsigned long int);
void __gmpz_cdiv_qr (mpz_ptr, mpz_ptr, mpz_srcptr, mpz_srcptr);
unsigned long int __gmpz_cdiv_qr_ui (mpz_ptr, mpz_ptr, mpz_srcptr, unsigned long int);
void __gmpz_cdiv_r (mpz_ptr, mpz_srcptr, mpz_srcptr);
void __gmpz_cdiv_r_2exp (mpz_ptr, mpz_srcptr, mp_bitcnt_t);
unsigned long int __gmpz_cdiv_r_ui (mpz_ptr, mpz_srcptr, unsigned long int);
unsigned long int __gmpz_cdiv_ui (mpz_srcptr, unsigned long int) __attribute__ ((__pure__));
void __gmpz_clear (mpz_ptr);
void __gmpz_clears (mpz_ptr, ...);
void __gmpz_clrbit (mpz_ptr, mp_bitcnt_t);
int __gmpz_cmp (mpz_srcptr, mpz_srcptr) noexcept __attribute__ ((__pure__));
int __gmpz_cmp_d (mpz_srcptr, double) __attribute__ ((__pure__));
int __gmpz_cmp_si (mpz_srcptr, signed long int) noexcept __attribute__ ((__pure__));
int __gmpz_cmp_ui (mpz_srcptr, unsigned long int) noexcept __attribute__ ((__pure__));
int __gmpz_cmpabs (mpz_srcptr, mpz_srcptr) noexcept __attribute__ ((__pure__));
int __gmpz_cmpabs_d (mpz_srcptr, double) __attribute__ ((__pure__));
int __gmpz_cmpabs_ui (mpz_srcptr, unsigned long int) noexcept __attribute__ ((__pure__));
void __gmpz_com (mpz_ptr, mpz_srcptr);
void __gmpz_combit (mpz_ptr, mp_bitcnt_t);
int __gmpz_congruent_p (mpz_srcptr, mpz_srcptr, mpz_srcptr) __attribute__ ((__pure__));
int __gmpz_congruent_2exp_p (mpz_srcptr, mpz_srcptr, mp_bitcnt_t) noexcept __attribute__ ((__pure__));
int __gmpz_congruent_ui_p (mpz_srcptr, unsigned long, unsigned long) __attribute__ ((__pure__));
void __gmpz_divexact (mpz_ptr, mpz_srcptr, mpz_srcptr);
void __gmpz_divexact_ui (mpz_ptr, mpz_srcptr, unsigned long);
int __gmpz_divisible_p (mpz_srcptr, mpz_srcptr) __attribute__ ((__pure__));
int __gmpz_divisible_ui_p (mpz_srcptr, unsigned long) __attribute__ ((__pure__));
int __gmpz_divisible_2exp_p (mpz_srcptr, mp_bitcnt_t) noexcept __attribute__ ((__pure__));
void __gmpz_dump (mpz_srcptr);
void *__gmpz_export (void *, size_t *, int, size_t, int, size_t, mpz_srcptr);
void __gmpz_fac_ui (mpz_ptr, unsigned long int);
void __gmpz_2fac_ui (mpz_ptr, unsigned long int);
void __gmpz_mfac_uiui (mpz_ptr, unsigned long int, unsigned long int);
void __gmpz_primorial_ui (mpz_ptr, unsigned long int);
void __gmpz_fdiv_q (mpz_ptr, mpz_srcptr, mpz_srcptr);
void __gmpz_fdiv_q_2exp (mpz_ptr, mpz_srcptr, mp_bitcnt_t);
unsigned long int __gmpz_fdiv_q_ui (mpz_ptr, mpz_srcptr, unsigned long int);
void __gmpz_fdiv_qr (mpz_ptr, mpz_ptr, mpz_srcptr, mpz_srcptr);
unsigned long int __gmpz_fdiv_qr_ui (mpz_ptr, mpz_ptr, mpz_srcptr, unsigned long int);
void __gmpz_fdiv_r (mpz_ptr, mpz_srcptr, mpz_srcptr);
void __gmpz_fdiv_r_2exp (mpz_ptr, mpz_srcptr, mp_bitcnt_t);
unsigned long int __gmpz_fdiv_r_ui (mpz_ptr, mpz_srcptr, unsigned long int);
unsigned long int __gmpz_fdiv_ui (mpz_srcptr, unsigned long int) __attribute__ ((__pure__));
void __gmpz_fib_ui (mpz_ptr, unsigned long int);
void __gmpz_fib2_ui (mpz_ptr, mpz_ptr, unsigned long int);
int __gmpz_fits_sint_p (mpz_srcptr) noexcept __attribute__ ((__pure__));
int __gmpz_fits_slong_p (mpz_srcptr) noexcept __attribute__ ((__pure__));
int __gmpz_fits_sshort_p (mpz_srcptr) noexcept __attribute__ ((__pure__));
int __gmpz_fits_uint_p (mpz_srcptr) noexcept __attribute__ ((__pure__));
int __gmpz_fits_ulong_p (mpz_srcptr) noexcept __attribute__ ((__pure__));
int __gmpz_fits_ushort_p (mpz_srcptr) noexcept __attribute__ ((__pure__));
void __gmpz_gcd (mpz_ptr, mpz_srcptr, mpz_srcptr);
unsigned long int __gmpz_gcd_ui (mpz_ptr, mpz_srcptr, unsigned long int);
void __gmpz_gcdext (mpz_ptr, mpz_ptr, mpz_ptr, mpz_srcptr, mpz_srcptr);
double __gmpz_get_d (mpz_srcptr) __attribute__ ((__pure__));
double __gmpz_get_d_2exp (signed long int *, mpz_srcptr);
long int __gmpz_get_si (mpz_srcptr) noexcept __attribute__ ((__pure__));
char *__gmpz_get_str (char *, int, mpz_srcptr);
unsigned long int __gmpz_get_ui (mpz_srcptr) noexcept __attribute__ ((__pure__));
mp_limb_t __gmpz_getlimbn (mpz_srcptr, mp_size_t) noexcept __attribute__ ((__pure__));
mp_bitcnt_t __gmpz_hamdist (mpz_srcptr, mpz_srcptr) noexcept __attribute__ ((__pure__));
void __gmpz_import (mpz_ptr, size_t, int, size_t, int, size_t, const void *);
void __gmpz_init (mpz_ptr) noexcept;
void __gmpz_init2 (mpz_ptr, mp_bitcnt_t);
void __gmpz_inits (mpz_ptr, ...) noexcept;
void __gmpz_init_set (mpz_ptr, mpz_srcptr);
void __gmpz_init_set_d (mpz_ptr, double);
void __gmpz_init_set_si (mpz_ptr, signed long int);
int __gmpz_init_set_str (mpz_ptr, const char *, int);
void __gmpz_init_set_ui (mpz_ptr, unsigned long int);
size_t __gmpz_inp_raw (mpz_ptr, FILE *);
size_t __gmpz_inp_str (mpz_ptr, FILE *, int);
int __gmpz_invert (mpz_ptr, mpz_srcptr, mpz_srcptr);
void __gmpz_ior (mpz_ptr, mpz_srcptr, mpz_srcptr);
int __gmpz_jacobi (mpz_srcptr, mpz_srcptr) __attribute__ ((__pure__));
int __gmpz_kronecker_si (mpz_srcptr, long) __attribute__ ((__pure__));
int __gmpz_kronecker_ui (mpz_srcptr, unsigned long) __attribute__ ((__pure__));
int __gmpz_si_kronecker (long, mpz_srcptr) __attribute__ ((__pure__));
int __gmpz_ui_kronecker (unsigned long, mpz_srcptr) __attribute__ ((__pure__));
void __gmpz_lcm (mpz_ptr, mpz_srcptr, mpz_srcptr);
void __gmpz_lcm_ui (mpz_ptr, mpz_srcptr, unsigned long);
void __gmpz_lucnum_ui (mpz_ptr, unsigned long int);
void __gmpz_lucnum2_ui (mpz_ptr, mpz_ptr, unsigned long int);
int __gmpz_millerrabin (mpz_srcptr, int) __attribute__ ((__pure__));
void __gmpz_mod (mpz_ptr, mpz_srcptr, mpz_srcptr);
void __gmpz_mul (mpz_ptr, mpz_srcptr, mpz_srcptr);
void __gmpz_mul_2exp (mpz_ptr, mpz_srcptr, mp_bitcnt_t);
void __gmpz_mul_si (mpz_ptr, mpz_srcptr, long int);
void __gmpz_mul_ui (mpz_ptr, mpz_srcptr, unsigned long int);
void __gmpz_neg (mpz_ptr, mpz_srcptr);
void __gmpz_nextprime (mpz_ptr, mpz_srcptr);
size_t __gmpz_out_raw (FILE *, mpz_srcptr);
size_t __gmpz_out_str (FILE *, int, mpz_srcptr);
int __gmpz_perfect_power_p (mpz_srcptr) __attribute__ ((__pure__));
int __gmpz_perfect_square_p (mpz_srcptr) __attribute__ ((__pure__));
mp_bitcnt_t __gmpz_popcount (mpz_srcptr) noexcept __attribute__ ((__pure__));
void __gmpz_pow_ui (mpz_ptr, mpz_srcptr, unsigned long int);
void __gmpz_powm (mpz_ptr, mpz_srcptr, mpz_srcptr, mpz_srcptr);
void __gmpz_powm_sec (mpz_ptr, mpz_srcptr, mpz_srcptr, mpz_srcptr);
void __gmpz_powm_ui (mpz_ptr, mpz_srcptr, unsigned long int, mpz_srcptr);
int __gmpz_probab_prime_p (mpz_srcptr, int) __attribute__ ((__pure__));
void __gmpz_random (mpz_ptr, mp_size_t);
void __gmpz_random2 (mpz_ptr, mp_size_t);
void __gmpz_realloc2 (mpz_ptr, mp_bitcnt_t);
mp_bitcnt_t __gmpz_remove (mpz_ptr, mpz_srcptr, mpz_srcptr);
int __gmpz_root (mpz_ptr, mpz_srcptr, unsigned long int);
void __gmpz_rootrem (mpz_ptr, mpz_ptr, mpz_srcptr, unsigned long int);
void __gmpz_rrandomb (mpz_ptr, gmp_randstate_t, mp_bitcnt_t);
mp_bitcnt_t __gmpz_scan0 (mpz_srcptr, mp_bitcnt_t) noexcept __attribute__ ((__pure__));
mp_bitcnt_t __gmpz_scan1 (mpz_srcptr, mp_bitcnt_t) noexcept __attribute__ ((__pure__));
void __gmpz_set (mpz_ptr, mpz_srcptr);
void __gmpz_set_d (mpz_ptr, double);
void __gmpz_set_f (mpz_ptr, mpf_srcptr);
void __gmpz_set_q (mpz_ptr, mpq_srcptr);
void __gmpz_set_si (mpz_ptr, signed long int);
int __gmpz_set_str (mpz_ptr, const char *, int);
void __gmpz_set_ui (mpz_ptr, unsigned long int);
void __gmpz_setbit (mpz_ptr, mp_bitcnt_t);
size_t __gmpz_size (mpz_srcptr) noexcept __attribute__ ((__pure__));
size_t __gmpz_sizeinbase (mpz_srcptr, int) noexcept __attribute__ ((__pure__));
void __gmpz_sqrt (mpz_ptr, mpz_srcptr);
void __gmpz_sqrtrem (mpz_ptr, mpz_ptr, mpz_srcptr);
void __gmpz_sub (mpz_ptr, mpz_srcptr, mpz_srcptr);
void __gmpz_sub_ui (mpz_ptr, mpz_srcptr, unsigned long int);
void __gmpz_ui_sub (mpz_ptr, unsigned long int, mpz_srcptr);
void __gmpz_submul (mpz_ptr, mpz_srcptr, mpz_srcptr);
void __gmpz_submul_ui (mpz_ptr, mpz_srcptr, unsigned long int);
void __gmpz_swap (mpz_ptr, mpz_ptr) noexcept;
unsigned long int __gmpz_tdiv_ui (mpz_srcptr, unsigned long int) __attribute__ ((__pure__));
void __gmpz_tdiv_q (mpz_ptr, mpz_srcptr, mpz_srcptr);
void __gmpz_tdiv_q_2exp (mpz_ptr, mpz_srcptr, mp_bitcnt_t);
unsigned long int __gmpz_tdiv_q_ui (mpz_ptr, mpz_srcptr, unsigned long int);
void __gmpz_tdiv_qr (mpz_ptr, mpz_ptr, mpz_srcptr, mpz_srcptr);
unsigned long int __gmpz_tdiv_qr_ui (mpz_ptr, mpz_ptr, mpz_srcptr, unsigned long int);
void __gmpz_tdiv_r (mpz_ptr, mpz_srcptr, mpz_srcptr);
void __gmpz_tdiv_r_2exp (mpz_ptr, mpz_srcptr, mp_bitcnt_t);
unsigned long int __gmpz_tdiv_r_ui (mpz_ptr, mpz_srcptr, unsigned long int);
int __gmpz_tstbit (mpz_srcptr, mp_bitcnt_t) noexcept __attribute__ ((__pure__));
void __gmpz_ui_pow_ui (mpz_ptr, unsigned long int, unsigned long int);
void __gmpz_urandomb (mpz_ptr, gmp_randstate_t, mp_bitcnt_t);
void __gmpz_urandomm (mpz_ptr, gmp_randstate_t, mpz_srcptr);
void __gmpz_xor (mpz_ptr, mpz_srcptr, mpz_srcptr);
mp_srcptr __gmpz_limbs_read (mpz_srcptr);
mp_ptr __gmpz_limbs_write (mpz_ptr, mp_size_t);
mp_ptr __gmpz_limbs_modify (mpz_ptr, mp_size_t);
void __gmpz_limbs_finish (mpz_ptr, mp_size_t);
mpz_srcptr __gmpz_roinit_n (mpz_ptr, mp_srcptr, mp_size_t);
void __gmpq_abs (mpq_ptr, mpq_srcptr);
void __gmpq_add (mpq_ptr, mpq_srcptr, mpq_srcptr);
void __gmpq_canonicalize (mpq_ptr);
void __gmpq_clear (mpq_ptr);
void __gmpq_clears (mpq_ptr, ...);
int __gmpq_cmp (mpq_srcptr, mpq_srcptr) __attribute__ ((__pure__));
int __gmpq_cmp_si (mpq_srcptr, long, unsigned long) __attribute__ ((__pure__));
int __gmpq_cmp_ui (mpq_srcptr, unsigned long int, unsigned long int) __attribute__ ((__pure__));
int __gmpq_cmp_z (mpq_srcptr, mpz_srcptr) __attribute__ ((__pure__));
void __gmpq_div (mpq_ptr, mpq_srcptr, mpq_srcptr);
void __gmpq_div_2exp (mpq_ptr, mpq_srcptr, mp_bitcnt_t);
int __gmpq_equal (mpq_srcptr, mpq_srcptr) noexcept __attribute__ ((__pure__));
void __gmpq_get_num (mpz_ptr, mpq_srcptr);
void __gmpq_get_den (mpz_ptr, mpq_srcptr);
double __gmpq_get_d (mpq_srcptr) __attribute__ ((__pure__));
char *__gmpq_get_str (char *, int, mpq_srcptr);
void __gmpq_init (mpq_ptr);
void __gmpq_inits (mpq_ptr, ...);
size_t __gmpq_inp_str (mpq_ptr, FILE *, int);
void __gmpq_inv (mpq_ptr, mpq_srcptr);
void __gmpq_mul (mpq_ptr, mpq_srcptr, mpq_srcptr);
void __gmpq_mul_2exp (mpq_ptr, mpq_srcptr, mp_bitcnt_t);
void __gmpq_neg (mpq_ptr, mpq_srcptr);
size_t __gmpq_out_str (FILE *, int, mpq_srcptr);
void __gmpq_set (mpq_ptr, mpq_srcptr);
void __gmpq_set_d (mpq_ptr, double);
void __gmpq_set_den (mpq_ptr, mpz_srcptr);
void __gmpq_set_f (mpq_ptr, mpf_srcptr);
void __gmpq_set_num (mpq_ptr, mpz_srcptr);
void __gmpq_set_si (mpq_ptr, signed long int, unsigned long int);
int __gmpq_set_str (mpq_ptr, const char *, int);
void __gmpq_set_ui (mpq_ptr, unsigned long int, unsigned long int);
void __gmpq_set_z (mpq_ptr, mpz_srcptr);
void __gmpq_sub (mpq_ptr, mpq_srcptr, mpq_srcptr);
void __gmpq_swap (mpq_ptr, mpq_ptr) noexcept;
void __gmpf_abs (mpf_ptr, mpf_srcptr);
void __gmpf_add (mpf_ptr, mpf_srcptr, mpf_srcptr);
void __gmpf_add_ui (mpf_ptr, mpf_srcptr, unsigned long int);
void __gmpf_ceil (mpf_ptr, mpf_srcptr);
void __gmpf_clear (mpf_ptr);
void __gmpf_clears (mpf_ptr, ...);
int __gmpf_cmp (mpf_srcptr, mpf_srcptr) noexcept __attribute__ ((__pure__));
int __gmpf_cmp_z (mpf_srcptr, mpz_srcptr) noexcept __attribute__ ((__pure__));
int __gmpf_cmp_d (mpf_srcptr, double) __attribute__ ((__pure__));
int __gmpf_cmp_si (mpf_srcptr, signed long int) noexcept __attribute__ ((__pure__));
int __gmpf_cmp_ui (mpf_srcptr, unsigned long int) noexcept __attribute__ ((__pure__));
void __gmpf_div (mpf_ptr, mpf_srcptr, mpf_srcptr);
void __gmpf_div_2exp (mpf_ptr, mpf_srcptr, mp_bitcnt_t);
void __gmpf_div_ui (mpf_ptr, mpf_srcptr, unsigned long int);
void __gmpf_dump (mpf_srcptr);
int __gmpf_eq (mpf_srcptr, mpf_srcptr, mp_bitcnt_t) __attribute__ ((__pure__));
int __gmpf_fits_sint_p (mpf_srcptr) noexcept __attribute__ ((__pure__));
int __gmpf_fits_slong_p (mpf_srcptr) noexcept __attribute__ ((__pure__));
int __gmpf_fits_sshort_p (mpf_srcptr) noexcept __attribute__ ((__pure__));
int __gmpf_fits_uint_p (mpf_srcptr) noexcept __attribute__ ((__pure__));
int __gmpf_fits_ulong_p (mpf_srcptr) noexcept __attribute__ ((__pure__));
int __gmpf_fits_ushort_p (mpf_srcptr) noexcept __attribute__ ((__pure__));
void __gmpf_floor (mpf_ptr, mpf_srcptr);
double __gmpf_get_d (mpf_srcptr) __attribute__ ((__pure__));
double __gmpf_get_d_2exp (signed long int *, mpf_srcptr);
mp_bitcnt_t __gmpf_get_default_prec (void) noexcept __attribute__ ((__pure__));
mp_bitcnt_t __gmpf_get_prec (mpf_srcptr) noexcept __attribute__ ((__pure__));
long __gmpf_get_si (mpf_srcptr) noexcept __attribute__ ((__pure__));
char *__gmpf_get_str (char *, mp_exp_t *, int, size_t, mpf_srcptr);
unsigned long __gmpf_get_ui (mpf_srcptr) noexcept __attribute__ ((__pure__));
void __gmpf_init (mpf_ptr);
void __gmpf_init2 (mpf_ptr, mp_bitcnt_t);
void __gmpf_inits (mpf_ptr, ...);
void __gmpf_init_set (mpf_ptr, mpf_srcptr);
void __gmpf_init_set_d (mpf_ptr, double);
void __gmpf_init_set_si (mpf_ptr, signed long int);
int __gmpf_init_set_str (mpf_ptr, const char *, int);
void __gmpf_init_set_ui (mpf_ptr, unsigned long int);
size_t __gmpf_inp_str (mpf_ptr, FILE *, int);
int __gmpf_integer_p (mpf_srcptr) noexcept __attribute__ ((__pure__));
void __gmpf_mul (mpf_ptr, mpf_srcptr, mpf_srcptr);
void __gmpf_mul_2exp (mpf_ptr, mpf_srcptr, mp_bitcnt_t);
void __gmpf_mul_ui (mpf_ptr, mpf_srcptr, unsigned long int);
void __gmpf_neg (mpf_ptr, mpf_srcptr);
size_t __gmpf_out_str (FILE *, int, size_t, mpf_srcptr);
void __gmpf_pow_ui (mpf_ptr, mpf_srcptr, unsigned long int);
void __gmpf_random2 (mpf_ptr, mp_size_t, mp_exp_t);
void __gmpf_reldiff (mpf_ptr, mpf_srcptr, mpf_srcptr);
void __gmpf_set (mpf_ptr, mpf_srcptr);
void __gmpf_set_d (mpf_ptr, double);
void __gmpf_set_default_prec (mp_bitcnt_t) noexcept;
void __gmpf_set_prec (mpf_ptr, mp_bitcnt_t);
void __gmpf_set_prec_raw (mpf_ptr, mp_bitcnt_t) noexcept;
void __gmpf_set_q (mpf_ptr, mpq_srcptr);
void __gmpf_set_si (mpf_ptr, signed long int);
int __gmpf_set_str (mpf_ptr, const char *, int);
void __gmpf_set_ui (mpf_ptr, unsigned long int);
void __gmpf_set_z (mpf_ptr, mpz_srcptr);
size_t __gmpf_size (mpf_srcptr) noexcept __attribute__ ((__pure__));
void __gmpf_sqrt (mpf_ptr, mpf_srcptr);
void __gmpf_sqrt_ui (mpf_ptr, unsigned long int);
void __gmpf_sub (mpf_ptr, mpf_srcptr, mpf_srcptr);
void __gmpf_sub_ui (mpf_ptr, mpf_srcptr, unsigned long int);
void __gmpf_swap (mpf_ptr, mpf_ptr) noexcept;
void __gmpf_trunc (mpf_ptr, mpf_srcptr);
void __gmpf_ui_div (mpf_ptr, unsigned long int, mpf_srcptr);
void __gmpf_ui_sub (mpf_ptr, unsigned long int, mpf_srcptr);
void __gmpf_urandomb (mpf_t, gmp_randstate_t, mp_bitcnt_t);
# 1465 "/usr/include/x86_64-linux-gnu/gmp.h" 3 4
mp_limb_t __gmpn_add (mp_ptr, mp_srcptr, mp_size_t, mp_srcptr, mp_size_t);
mp_limb_t __gmpn_add_1 (mp_ptr, mp_srcptr, mp_size_t, mp_limb_t) noexcept;
mp_limb_t __gmpn_add_n (mp_ptr, mp_srcptr, mp_srcptr, mp_size_t);
mp_limb_t __gmpn_addmul_1 (mp_ptr, mp_srcptr, mp_size_t, mp_limb_t);
int __gmpn_cmp (mp_srcptr, mp_srcptr, mp_size_t) noexcept __attribute__ ((__pure__));
int __gmpn_zero_p (mp_srcptr, mp_size_t) noexcept __attribute__ ((__pure__));
void __gmpn_divexact_1 (mp_ptr, mp_srcptr, mp_size_t, mp_limb_t);
mp_limb_t __gmpn_divexact_by3c (mp_ptr, mp_srcptr, mp_size_t, mp_limb_t);
mp_limb_t __gmpn_divrem (mp_ptr, mp_size_t, mp_ptr, mp_size_t, mp_srcptr, mp_size_t);
mp_limb_t __gmpn_divrem_1 (mp_ptr, mp_size_t, mp_srcptr, mp_size_t, mp_limb_t);
mp_limb_t __gmpn_divrem_2 (mp_ptr, mp_size_t, mp_ptr, mp_size_t, mp_srcptr);
mp_limb_t __gmpn_div_qr_1 (mp_ptr, mp_limb_t *, mp_srcptr, mp_size_t, mp_limb_t);
mp_limb_t __gmpn_div_qr_2 (mp_ptr, mp_ptr, mp_srcptr, mp_size_t, mp_srcptr);
mp_size_t __gmpn_gcd (mp_ptr, mp_ptr, mp_size_t, mp_ptr, mp_size_t);
mp_limb_t __gmpn_gcd_11 (mp_limb_t, mp_limb_t) __attribute__ ((__pure__));
mp_limb_t __gmpn_gcd_1 (mp_srcptr, mp_size_t, mp_limb_t) __attribute__ ((__pure__));
mp_limb_t __gmpn_gcdext_1 (mp_limb_signed_t *, mp_limb_signed_t *, mp_limb_t, mp_limb_t);
mp_size_t __gmpn_gcdext (mp_ptr, mp_ptr, mp_size_t *, mp_ptr, mp_size_t, mp_ptr, mp_size_t);
size_t __gmpn_get_str (unsigned char *, int, mp_ptr, mp_size_t);
mp_bitcnt_t __gmpn_hamdist (mp_srcptr, mp_srcptr, mp_size_t) noexcept __attribute__ ((__pure__));
mp_limb_t __gmpn_lshift (mp_ptr, mp_srcptr, mp_size_t, unsigned int);
mp_limb_t __gmpn_mod_1 (mp_srcptr, mp_size_t, mp_limb_t) __attribute__ ((__pure__));
mp_limb_t __gmpn_mul (mp_ptr, mp_srcptr, mp_size_t, mp_srcptr, mp_size_t);
mp_limb_t __gmpn_mul_1 (mp_ptr, mp_srcptr, mp_size_t, mp_limb_t);
void __gmpn_mul_n (mp_ptr, mp_srcptr, mp_srcptr, mp_size_t);
void __gmpn_sqr (mp_ptr, mp_srcptr, mp_size_t);
mp_limb_t __gmpn_neg (mp_ptr, mp_srcptr, mp_size_t);
void __gmpn_com (mp_ptr, mp_srcptr, mp_size_t);
int __gmpn_perfect_square_p (mp_srcptr, mp_size_t) __attribute__ ((__pure__));
int __gmpn_perfect_power_p (mp_srcptr, mp_size_t) __attribute__ ((__pure__));
mp_bitcnt_t __gmpn_popcount (mp_srcptr, mp_size_t) noexcept __attribute__ ((__pure__));
mp_size_t __gmpn_pow_1 (mp_ptr, mp_srcptr, mp_size_t, mp_limb_t, mp_ptr);
mp_limb_t __gmpn_preinv_mod_1 (mp_srcptr, mp_size_t, mp_limb_t, mp_limb_t) __attribute__ ((__pure__));
void __gmpn_random (mp_ptr, mp_size_t);
void __gmpn_random2 (mp_ptr, mp_size_t);
mp_limb_t __gmpn_rshift (mp_ptr, mp_srcptr, mp_size_t, unsigned int);
mp_bitcnt_t __gmpn_scan0 (mp_srcptr, mp_bitcnt_t) __attribute__ ((__pure__));
mp_bitcnt_t __gmpn_scan1 (mp_srcptr, mp_bitcnt_t) __attribute__ ((__pure__));
mp_size_t __gmpn_set_str (mp_ptr, const unsigned char *, size_t, int);
size_t __gmpn_sizeinbase (mp_srcptr, mp_size_t, int);
mp_size_t __gmpn_sqrtrem (mp_ptr, mp_ptr, mp_srcptr, mp_size_t);
mp_limb_t __gmpn_sub (mp_ptr, mp_srcptr, mp_size_t, mp_srcptr, mp_size_t);
mp_limb_t __gmpn_sub_1 (mp_ptr, mp_srcptr, mp_size_t, mp_limb_t) noexcept;
mp_limb_t __gmpn_sub_n (mp_ptr, mp_srcptr, mp_srcptr, mp_size_t);
mp_limb_t __gmpn_submul_1 (mp_ptr, mp_srcptr, mp_size_t, mp_limb_t);
void __gmpn_tdiv_qr (mp_ptr, mp_ptr, mp_size_t, mp_srcptr, mp_size_t, mp_srcptr, mp_size_t);
void __gmpn_and_n (mp_ptr, mp_srcptr, mp_srcptr, mp_size_t);
void __gmpn_andn_n (mp_ptr, mp_srcptr, mp_srcptr, mp_size_t);
void __gmpn_nand_n (mp_ptr, mp_srcptr, mp_srcptr, mp_size_t);
void __gmpn_ior_n (mp_ptr, mp_srcptr, mp_srcptr, mp_size_t);
void __gmpn_iorn_n (mp_ptr, mp_srcptr, mp_srcptr, mp_size_t);
void __gmpn_nior_n (mp_ptr, mp_srcptr, mp_srcptr, mp_size_t);
void __gmpn_xor_n (mp_ptr, mp_srcptr, mp_srcptr, mp_size_t);
void __gmpn_xnor_n (mp_ptr, mp_srcptr, mp_srcptr, mp_size_t);
void __gmpn_copyi (mp_ptr, mp_srcptr, mp_size_t);
void __gmpn_copyd (mp_ptr, mp_srcptr, mp_size_t);
void __gmpn_zero (mp_ptr, mp_size_t);
mp_limb_t __gmpn_cnd_add_n (mp_limb_t, mp_ptr, mp_srcptr, mp_srcptr, mp_size_t);
mp_limb_t __gmpn_cnd_sub_n (mp_limb_t, mp_ptr, mp_srcptr, mp_srcptr, mp_size_t);
mp_limb_t __gmpn_sec_add_1 (mp_ptr, mp_srcptr, mp_size_t, mp_limb_t, mp_ptr);
mp_size_t __gmpn_sec_add_1_itch (mp_size_t) __attribute__ ((__pure__));
mp_limb_t __gmpn_sec_sub_1 (mp_ptr, mp_srcptr, mp_size_t, mp_limb_t, mp_ptr);
mp_size_t __gmpn_sec_sub_1_itch (mp_size_t) __attribute__ ((__pure__));
void __gmpn_cnd_swap (mp_limb_t, volatile mp_limb_t *, volatile mp_limb_t *, mp_size_t);
void __gmpn_sec_mul (mp_ptr, mp_srcptr, mp_size_t, mp_srcptr, mp_size_t, mp_ptr);
mp_size_t __gmpn_sec_mul_itch (mp_size_t, mp_size_t) __attribute__ ((__pure__));
void __gmpn_sec_sqr (mp_ptr, mp_srcptr, mp_size_t, mp_ptr);
mp_size_t __gmpn_sec_sqr_itch (mp_size_t) __attribute__ ((__pure__));
void __gmpn_sec_powm (mp_ptr, mp_srcptr, mp_size_t, mp_srcptr, mp_bitcnt_t, mp_srcptr, mp_size_t, mp_ptr);
mp_size_t __gmpn_sec_powm_itch (mp_size_t, mp_bitcnt_t, mp_size_t) __attribute__ ((__pure__));
void __gmpn_sec_tabselect (volatile mp_limb_t *, volatile const mp_limb_t *, mp_size_t, mp_size_t, mp_size_t);
mp_limb_t __gmpn_sec_div_qr (mp_ptr, mp_ptr, mp_size_t, mp_srcptr, mp_size_t, mp_ptr);
mp_size_t __gmpn_sec_div_qr_itch (mp_size_t, mp_size_t) __attribute__ ((__pure__));
void __gmpn_sec_div_r (mp_ptr, mp_size_t, mp_srcptr, mp_size_t, mp_ptr);
mp_size_t __gmpn_sec_div_r_itch (mp_size_t, mp_size_t) __attribute__ ((__pure__));
int __gmpn_sec_invert (mp_ptr, mp_ptr, mp_srcptr, mp_size_t, mp_bitcnt_t, mp_ptr);
mp_size_t __gmpn_sec_invert_itch (mp_size_t) __attribute__ ((__pure__));
# 1714 "/usr/include/x86_64-linux-gnu/gmp.h" 3 4
extern __inline__ __attribute__ ((__gnu_inline__)) void
__gmpz_abs (mpz_ptr __gmp_w, mpz_srcptr __gmp_u)
{
if (__gmp_w != __gmp_u)
__gmpz_set (__gmp_w, __gmp_u);
__gmp_w->_mp_size = ((__gmp_w->_mp_size) >= 0 ? (__gmp_w->_mp_size) : -(__gmp_w->_mp_size));
}
# 1738 "/usr/include/x86_64-linux-gnu/gmp.h" 3 4
extern __inline__ __attribute__ ((__gnu_inline__))
int
__gmpz_fits_uint_p (mpz_srcptr __gmp_z) noexcept
{
mp_size_t __gmp_n = __gmp_z->_mp_size; mp_ptr __gmp_p = __gmp_z->_mp_d; return (__gmp_n == 0 || (__gmp_n == 1 && __gmp_p[0] <= (0x7fffffff * 2U + 1U)));;
}
extern __inline__ __attribute__ ((__gnu_inline__))
int
__gmpz_fits_ulong_p (mpz_srcptr __gmp_z) noexcept
{
mp_size_t __gmp_n = __gmp_z->_mp_size; mp_ptr __gmp_p = __gmp_z->_mp_d; return (__gmp_n == 0 || (__gmp_n == 1 && __gmp_p[0] <= (0x7fffffffffffffffL * 2UL + 1UL)));;
}
extern __inline__ __attribute__ ((__gnu_inline__))
int
__gmpz_fits_ushort_p (mpz_srcptr __gmp_z) noexcept
{
mp_size_t __gmp_n = __gmp_z->_mp_size; mp_ptr __gmp_p = __gmp_z->_mp_d; return (__gmp_n == 0 || (__gmp_n == 1 && __gmp_p[0] <= (0x7fff * 2 + 1)));;
}
extern __inline__ __attribute__ ((__gnu_inline__))
unsigned long
__gmpz_get_ui (mpz_srcptr __gmp_z) noexcept
{
mp_ptr __gmp_p = __gmp_z->_mp_d;
mp_size_t __gmp_n = __gmp_z->_mp_size;
mp_limb_t __gmp_l = __gmp_p[0];
return (__gmp_n != 0 ? __gmp_l : 0);
# 1794 "/usr/include/x86_64-linux-gnu/gmp.h" 3 4
}
extern __inline__ __attribute__ ((__gnu_inline__))
mp_limb_t
__gmpz_getlimbn (mpz_srcptr __gmp_z, mp_size_t __gmp_n) noexcept
{
mp_limb_t __gmp_result = 0;
if (__builtin_expect ((__gmp_n >= 0 && __gmp_n < ((__gmp_z->_mp_size) >= 0 ? (__gmp_z->_mp_size) : -(__gmp_z->_mp_size))) != 0, 1))
__gmp_result = __gmp_z->_mp_d[__gmp_n];
return __gmp_result;
}
extern __inline__ __attribute__ ((__gnu_inline__)) void
__gmpz_neg (mpz_ptr __gmp_w, mpz_srcptr __gmp_u)
{
if (__gmp_w != __gmp_u)
__gmpz_set (__gmp_w, __gmp_u);
__gmp_w->_mp_size = - __gmp_w->_mp_size;
}
extern __inline__ __attribute__ ((__gnu_inline__))
int
__gmpz_perfect_square_p (mpz_srcptr __gmp_a)
{
mp_size_t __gmp_asize;
int __gmp_result;
__gmp_asize = __gmp_a->_mp_size;
__gmp_result = (__gmp_asize >= 0);
if (__builtin_expect ((__gmp_asize > 0) != 0, 1))
__gmp_result = __gmpn_perfect_square_p (__gmp_a->_mp_d, __gmp_asize);
return __gmp_result;
}
extern __inline__ __attribute__ ((__gnu_inline__))
mp_bitcnt_t
__gmpz_popcount (mpz_srcptr __gmp_u) noexcept
{
mp_size_t __gmp_usize;
mp_bitcnt_t __gmp_result;
__gmp_usize = __gmp_u->_mp_size;
__gmp_result = (__gmp_usize < 0 ? ~ (static_cast<mp_bitcnt_t> (0)) : (static_cast<mp_bitcnt_t> (0)));
if (__builtin_expect ((__gmp_usize > 0) != 0, 1))
__gmp_result = __gmpn_popcount (__gmp_u->_mp_d, __gmp_usize);
return __gmp_result;
}
extern __inline__ __attribute__ ((__gnu_inline__))
void
__gmpz_set_q (mpz_ptr __gmp_w, mpq_srcptr __gmp_u)
{
__gmpz_tdiv_q (__gmp_w, (&((__gmp_u)->_mp_num)), (&((__gmp_u)->_mp_den)));
}
extern __inline__ __attribute__ ((__gnu_inline__))
size_t
__gmpz_size (mpz_srcptr __gmp_z) noexcept
{
return ((__gmp_z->_mp_size) >= 0 ? (__gmp_z->_mp_size) : -(__gmp_z->_mp_size));
}
extern __inline__ __attribute__ ((__gnu_inline__)) void
__gmpq_abs (mpq_ptr __gmp_w, mpq_srcptr __gmp_u)
{
if (__gmp_w != __gmp_u)
__gmpq_set (__gmp_w, __gmp_u);
__gmp_w->_mp_num._mp_size = ((__gmp_w->_mp_num._mp_size) >= 0 ? (__gmp_w->_mp_num._mp_size) : -(__gmp_w->_mp_num._mp_size));
}
extern __inline__ __attribute__ ((__gnu_inline__)) void
__gmpq_neg (mpq_ptr __gmp_w, mpq_srcptr __gmp_u)
{
if (__gmp_w != __gmp_u)
__gmpq_set (__gmp_w, __gmp_u);
__gmp_w->_mp_num._mp_size = - __gmp_w->_mp_num._mp_size;
}
# 2136 "/usr/include/x86_64-linux-gnu/gmp.h" 3 4
extern __inline__ __attribute__ ((__gnu_inline__))
mp_limb_t
__gmpn_add (mp_ptr __gmp_wp, mp_srcptr __gmp_xp, mp_size_t __gmp_xsize, mp_srcptr __gmp_yp, mp_size_t __gmp_ysize)
{
mp_limb_t __gmp_c;
do { mp_size_t __gmp_i; mp_limb_t __gmp_x; __gmp_i = (__gmp_ysize); if (__gmp_i != 0) { if (__gmpn_add_n (__gmp_wp, __gmp_xp, __gmp_yp, __gmp_i)) { do { if (__gmp_i >= (__gmp_xsize)) { (__gmp_c) = 1; goto __gmp_done; } __gmp_x = (__gmp_xp)[__gmp_i]; } while ((((__gmp_wp)[__gmp_i++] = (__gmp_x + 1) & ((~ (static_cast<mp_limb_t> (0))) >> 0)) == 0)); } } if ((__gmp_wp) != (__gmp_xp)) do { mp_size_t __gmp_j; ; for (__gmp_j = (__gmp_i); __gmp_j < (__gmp_xsize); __gmp_j++) (__gmp_wp)[__gmp_j] = (__gmp_xp)[__gmp_j]; } while (0); (__gmp_c) = 0; __gmp_done: ; } while (0);
return __gmp_c;
}
extern __inline__ __attribute__ ((__gnu_inline__))
mp_limb_t
__gmpn_add_1 (mp_ptr __gmp_dst, mp_srcptr __gmp_src, mp_size_t __gmp_size, mp_limb_t __gmp_n) noexcept
{
mp_limb_t __gmp_c;
do { mp_size_t __gmp_i; mp_limb_t __gmp_x, __gmp_r; __gmp_x = (__gmp_src)[0]; __gmp_r = __gmp_x + (__gmp_n); (__gmp_dst)[0] = __gmp_r; if (((__gmp_r) < ((__gmp_n)))) { (__gmp_c) = 1; for (__gmp_i = 1; __gmp_i < (__gmp_size);) { __gmp_x = (__gmp_src)[__gmp_i]; __gmp_r = __gmp_x + 1; (__gmp_dst)[__gmp_i] = __gmp_r; ++__gmp_i; if (!((__gmp_r) < (1))) { if ((__gmp_src) != (__gmp_dst)) do { mp_size_t __gmp_j; ; for (__gmp_j = (__gmp_i); __gmp_j < (__gmp_size); __gmp_j++) (__gmp_dst)[__gmp_j] = (__gmp_src)[__gmp_j]; } while (0); (__gmp_c) = 0; break; } } } else { if ((__gmp_src) != (__gmp_dst)) do { mp_size_t __gmp_j; ; for (__gmp_j = (1); __gmp_j < (__gmp_size); __gmp_j++) (__gmp_dst)[__gmp_j] = (__gmp_src)[__gmp_j]; } while (0); (__gmp_c) = 0; } } while (0);
return __gmp_c;
}
extern __inline__ __attribute__ ((__gnu_inline__))
int
__gmpn_cmp (mp_srcptr __gmp_xp, mp_srcptr __gmp_yp, mp_size_t __gmp_size) noexcept
{
int __gmp_result;
do { mp_size_t __gmp_i; mp_limb_t __gmp_x, __gmp_y; (__gmp_result) = 0; __gmp_i = (__gmp_size); while (--__gmp_i >= 0) { __gmp_x = (__gmp_xp)[__gmp_i]; __gmp_y = (__gmp_yp)[__gmp_i]; if (__gmp_x != __gmp_y) { (__gmp_result) = (__gmp_x > __gmp_y ? 1 : -1); break; } } } while (0);
return __gmp_result;
}
extern __inline__ __attribute__ ((__gnu_inline__))
int
__gmpn_zero_p (mp_srcptr __gmp_p, mp_size_t __gmp_n) noexcept
{
do {
if (__gmp_p[--__gmp_n] != 0)
return 0;
} while (__gmp_n != 0);
return 1;
}
extern __inline__ __attribute__ ((__gnu_inline__))
mp_limb_t
__gmpn_sub (mp_ptr __gmp_wp, mp_srcptr __gmp_xp, mp_size_t __gmp_xsize, mp_srcptr __gmp_yp, mp_size_t __gmp_ysize)
{
mp_limb_t __gmp_c;
do { mp_size_t __gmp_i; mp_limb_t __gmp_x; __gmp_i = (__gmp_ysize); if (__gmp_i != 0) { if (__gmpn_sub_n (__gmp_wp, __gmp_xp, __gmp_yp, __gmp_i)) { do { if (__gmp_i >= (__gmp_xsize)) { (__gmp_c) = 1; goto __gmp_done; } __gmp_x = (__gmp_xp)[__gmp_i]; } while ((((__gmp_wp)[__gmp_i++] = (__gmp_x - 1) & ((~ (static_cast<mp_limb_t> (0))) >> 0)), __gmp_x == 0)); } } if ((__gmp_wp) != (__gmp_xp)) do { mp_size_t __gmp_j; ; for (__gmp_j = (__gmp_i); __gmp_j < (__gmp_xsize); __gmp_j++) (__gmp_wp)[__gmp_j] = (__gmp_xp)[__gmp_j]; } while (0); (__gmp_c) = 0; __gmp_done: ; } while (0);
return __gmp_c;
}
extern __inline__ __attribute__ ((__gnu_inline__))
mp_limb_t
__gmpn_sub_1 (mp_ptr __gmp_dst, mp_srcptr __gmp_src, mp_size_t __gmp_size, mp_limb_t __gmp_n) noexcept
{
mp_limb_t __gmp_c;
do { mp_size_t __gmp_i; mp_limb_t __gmp_x, __gmp_r; __gmp_x = (__gmp_src)[0]; __gmp_r = __gmp_x - (__gmp_n); (__gmp_dst)[0] = __gmp_r; if (((__gmp_x) < ((__gmp_n)))) { (__gmp_c) = 1; for (__gmp_i = 1; __gmp_i < (__gmp_size);) { __gmp_x = (__gmp_src)[__gmp_i]; __gmp_r = __gmp_x - 1; (__gmp_dst)[__gmp_i] = __gmp_r; ++__gmp_i; if (!((__gmp_x) < (1))) { if ((__gmp_src) != (__gmp_dst)) do { mp_size_t __gmp_j; ; for (__gmp_j = (__gmp_i); __gmp_j < (__gmp_size); __gmp_j++) (__gmp_dst)[__gmp_j] = (__gmp_src)[__gmp_j]; } while (0); (__gmp_c) = 0; break; } } } else { if ((__gmp_src) != (__gmp_dst)) do { mp_size_t __gmp_j; ; for (__gmp_j = (1); __gmp_j < (__gmp_size); __gmp_j++) (__gmp_dst)[__gmp_j] = (__gmp_src)[__gmp_j]; } while (0); (__gmp_c) = 0; } } while (0);
return __gmp_c;
}
extern __inline__ __attribute__ ((__gnu_inline__))
mp_limb_t
__gmpn_neg (mp_ptr __gmp_rp, mp_srcptr __gmp_up, mp_size_t __gmp_n)
{
while (*__gmp_up == 0)
{
*__gmp_rp = 0;
if (!--__gmp_n)
return 0;
++__gmp_up; ++__gmp_rp;
}
*__gmp_rp = (- *__gmp_up) & ((~ (static_cast<mp_limb_t> (0))) >> 0);
if (--__gmp_n)
__gmpn_com (++__gmp_rp, ++__gmp_up, __gmp_n);
return 1;
}
}
# 2285 "/usr/include/x86_64-linux-gnu/gmp.h" 3 4
std::ostream& operator<< (std::ostream &, mpz_srcptr);
std::ostream& operator<< (std::ostream &, mpq_srcptr);
std::ostream& operator<< (std::ostream &, mpf_srcptr);
std::istream& operator>> (std::istream &, mpz_ptr);
std::istream& operator>> (std::istream &, mpq_ptr);
std::istream& operator>> (std::istream &, mpf_ptr);
# 2316 "/usr/include/x86_64-linux-gnu/gmp.h" 3 4
enum
{
GMP_ERROR_NONE = 0,
GMP_ERROR_UNSUPPORTED_ARGUMENT = 1,
GMP_ERROR_DIVISION_BY_ZERO = 2,
GMP_ERROR_SQRT_OF_NEGATIVE = 4,
GMP_ERROR_INVALID_ARGUMENT = 8
};
# 689 "/home/giulianob/gcc_git_gnu/gcc/gcc/system.h" 2
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/../include/libiberty.h" 1
# 39 "/home/giulianob/gcc_git_gnu/gcc/gcc/../include/libiberty.h"
# 39 "/home/giulianob/gcc_git_gnu/gcc/gcc/../include/libiberty.h"
extern "C" {
# 1 "/usr/lib/gcc/x86_64-linux-gnu/10/include/stddef.h" 1 3 4
# 46 "/home/giulianob/gcc_git_gnu/gcc/gcc/../include/libiberty.h" 2
# 55 "/home/giulianob/gcc_git_gnu/gcc/gcc/../include/libiberty.h"
extern void unlock_stream (FILE *);
extern void unlock_std_streams (void);
extern FILE *fopen_unlocked (const char *, const char *);
extern FILE *fdopen_unlocked (int, const char *);
extern FILE *freopen_unlocked (const char *, const char *, FILE *);
extern char **buildargv (const char *) __attribute__ ((__malloc__));
extern void freeargv (char **);
extern char **dupargv (char * const *) __attribute__ ((__malloc__));
extern void expandargv (int *, char ***);
extern int writeargv (char * const *, FILE *);
extern int countargv (char * const *);
# 123 "/home/giulianob/gcc_git_gnu/gcc/gcc/../include/libiberty.h"
extern const char *lbasename (const char *) __attribute__ ((__returns_nonnull__)) __attribute__ ((__nonnull__ (1)));
extern const char *dos_lbasename (const char *) __attribute__ ((__returns_nonnull__)) __attribute__ ((__nonnull__ (1)));
extern const char *unix_lbasename (const char *) __attribute__ ((__returns_nonnull__)) __attribute__ ((__nonnull__ (1)));
extern char *lrealpath (const char *);
extern int is_valid_fd (int fd);
extern char *concat (const char *, ...) __attribute__ ((__malloc__)) __attribute__ ((__returns_nonnull__)) __attribute__ ((__sentinel__));
# 157 "/home/giulianob/gcc_git_gnu/gcc/gcc/../include/libiberty.h"
extern char *reconcat (char *, const char *, ...) __attribute__ ((__malloc__)) __attribute__ ((__returns_nonnull__)) __attribute__ ((__sentinel__));
extern unsigned long concat_length (const char *, ...) __attribute__ ((__sentinel__));
extern char *concat_copy (char *, const char *, ...) __attribute__ ((__returns_nonnull__)) __attribute__ ((__nonnull__ (1))) __attribute__ ((__sentinel__));
extern char *concat_copy2 (const char *, ...) __attribute__ ((__returns_nonnull__)) __attribute__ ((__sentinel__));
extern char *libiberty_concat_ptr;
# 193 "/home/giulianob/gcc_git_gnu/gcc/gcc/../include/libiberty.h"
extern int fdmatch (int fd1, int fd2);
# 205 "/home/giulianob/gcc_git_gnu/gcc/gcc/../include/libiberty.h"
extern char * getpwd (void);
# 218 "/home/giulianob/gcc_git_gnu/gcc/gcc/../include/libiberty.h"
extern long get_run_time (void);
extern char *make_relative_prefix (const char *, const char *,
const char *) __attribute__ ((__malloc__));
extern char *make_relative_prefix_ignore_links (const char *, const char *,
const char *) __attribute__ ((__malloc__));
extern const char *choose_tmpdir (void) __attribute__ ((__returns_nonnull__));
extern char *choose_temp_base (void) __attribute__ ((__malloc__)) __attribute__ ((__returns_nonnull__));
extern char *make_temp_file (const char *) __attribute__ ((__malloc__));
extern char *make_temp_file_with_prefix (const char *, const char *) __attribute__ ((__malloc__));
extern int unlink_if_ordinary (const char *);
extern const char *spaces (int count);
extern int errno_max (void);
extern const char *strerrno (int);
extern int strtoerrno (const char *);
extern char *xstrerror (int) __attribute__ ((__returns_nonnull__));
extern int signo_max (void);
# 292 "/home/giulianob/gcc_git_gnu/gcc/gcc/../include/libiberty.h"
extern const char *strsigno (int);
extern int strtosigno (const char *);
extern int xatexit (void (*fn) (void));
extern void xexit (int status) __attribute__ ((__noreturn__));
extern void xmalloc_set_program_name (const char *);
extern void xmalloc_failed (size_t) __attribute__ ((__noreturn__));
extern void *xmalloc (size_t) __attribute__ ((__malloc__)) __attribute__ ((__returns_nonnull__)) __attribute__ ((alloc_size (1))) __attribute__ ((warn_unused_result));
extern void *xrealloc (void *, size_t) __attribute__ ((__returns_nonnull__)) __attribute__ ((alloc_size (2))) __attribute__ ((warn_unused_result));
extern void *xcalloc (size_t, size_t) __attribute__ ((__malloc__)) __attribute__ ((__returns_nonnull__)) __attribute__ ((alloc_size (1, 2))) __attribute__ ((warn_unused_result));
extern char *xstrdup (const char *) __attribute__ ((__malloc__)) __attribute__ ((__returns_nonnull__)) __attribute__ ((warn_unused_result));
extern char *xstrndup (const char *, size_t) __attribute__ ((__malloc__)) __attribute__ ((__returns_nonnull__)) __attribute__ ((warn_unused_result));
extern void *xmemdup (const void *, size_t, size_t) __attribute__ ((__malloc__)) __attribute__ ((__returns_nonnull__)) __attribute__ ((warn_unused_result));
extern double physmem_total (void);
extern double physmem_available (void);
extern unsigned int xcrc32 (const unsigned char *, int, unsigned int);
# 391 "/home/giulianob/gcc_git_gnu/gcc/gcc/../include/libiberty.h"
extern const unsigned char _hex_value[256];
extern void hex_init (void);
# 428 "/home/giulianob/gcc_git_gnu/gcc/gcc/../include/libiberty.h"
extern struct pex_obj *pex_init (int flags, const char *pname,
const char *tempbase) __attribute__ ((__returns_nonnull__));
# 528 "/home/giulianob/gcc_git_gnu/gcc/gcc/../include/libiberty.h"
extern const char *pex_run (struct pex_obj *obj, int flags,
const char *executable, char * const *argv,
const char *outname, const char *errname,
int *err);
# 543 "/home/giulianob/gcc_git_gnu/gcc/gcc/../include/libiberty.h"
extern const char *pex_run_in_environment (struct pex_obj *obj, int flags,
const char *executable,
char * const *argv,
char * const *env,
const char *outname,
const char *errname, int *err);
extern FILE *pex_input_file (struct pex_obj *obj, int flags,
const char *in_name);
extern FILE *pex_input_pipe (struct pex_obj *obj, int binary);
extern FILE *pex_read_output (struct pex_obj *, int binary);
extern FILE *pex_read_err (struct pex_obj *, int binary);
extern int pex_get_status (struct pex_obj *, int count, int *vector);
struct pex_time
{
unsigned long user_seconds;
unsigned long user_microseconds;
unsigned long system_seconds;
unsigned long system_microseconds;
};
extern int pex_get_times (struct pex_obj *, int count,
struct pex_time *vector);
extern void pex_free (struct pex_obj *);
# 618 "/home/giulianob/gcc_git_gnu/gcc/gcc/../include/libiberty.h"
extern const char *pex_one (int flags, const char *executable,
char * const *argv, const char *pname,
const char *outname, const char *errname,
int *status, int *err);
# 637 "/home/giulianob/gcc_git_gnu/gcc/gcc/../include/libiberty.h"
extern int pexecute (const char *, char * const *, const char *,
const char *, char **, char **, int);
extern int pwait (int, int *, int);
extern void *bsearch_r (const void *, const void *,
size_t, size_t,
int (*)(const void *, const void *, void *),
void *);
# 661 "/home/giulianob/gcc_git_gnu/gcc/gcc/../include/libiberty.h"
extern char *xasprintf (const char *, ...) __attribute__ ((__malloc__)) __attribute__ ((__format__ (__printf__, 1, 2))) __attribute__ ((__nonnull__ (1)));
# 673 "/home/giulianob/gcc_git_gnu/gcc/gcc/../include/libiberty.h"
extern char *xvasprintf (const char *, va_list) __attribute__ ((__malloc__)) __attribute__ ((__format__ (__printf__, 1, 0))) __attribute__ ((__nonnull__ (1)));
# 722 "/home/giulianob/gcc_git_gnu/gcc/gcc/../include/libiberty.h"
extern void setproctitle (const char *name, ...);
extern void stack_limit_increase (unsigned long);
# 735 "/home/giulianob/gcc_git_gnu/gcc/gcc/../include/libiberty.h"
extern void *C_alloca (size_t) __attribute__ ((__malloc__));
# 762 "/home/giulianob/gcc_git_gnu/gcc/gcc/../include/libiberty.h"
}
# 693 "/home/giulianob/gcc_git_gnu/gcc/gcc/system.h" 2
# 763 "/home/giulianob/gcc_git_gnu/gcc/gcc/system.h"
extern void fancy_abort (const char *, int, const char *)
__attribute__ ((__noreturn__)) __attribute__ ((__cold__));
# 894 "/home/giulianob/gcc_git_gnu/gcc/gcc/system.h"
# 963 "/home/giulianob/gcc_git_gnu/gcc/gcc/system.h"
# 1055 "/home/giulianob/gcc_git_gnu/gcc/gcc/system.h"
# 1073 "/home/giulianob/gcc_git_gnu/gcc/gcc/system.h"
# 1091 "/home/giulianob/gcc_git_gnu/gcc/gcc/system.h"
# 1107 "/home/giulianob/gcc_git_gnu/gcc/gcc/system.h"
# 1224 "/home/giulianob/gcc_git_gnu/gcc/gcc/system.h"
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/hwint.h" 1
# 77 "/home/giulianob/gcc_git_gnu/gcc/gcc/hwint.h"
typedef long __gcc_host_wide_int__;
# 141 "/home/giulianob/gcc_git_gnu/gcc/gcc/hwint.h"
static inline unsigned long
least_bit_hwi (unsigned long x)
{
return (x & -x);
}
static inline bool
pow2_or_zerop (unsigned long x)
{
return least_bit_hwi (x) == x;
}
static inline bool
pow2p_hwi (unsigned long x)
{
return x && pow2_or_zerop (x);
}
# 184 "/home/giulianob/gcc_git_gnu/gcc/gcc/hwint.h"
static inline int
clz_hwi (unsigned long x)
{
if (x == 0)
return 64;
return __builtin_clzl (x);
}
static inline int
ctz_hwi (unsigned long x)
{
if (x == 0)
return 64;
return __builtin_ctzl (x);
}
static inline int
ffs_hwi (unsigned long x)
{
return __builtin_ffsl (x);
}
static inline int
popcount_hwi (unsigned long x)
{
return __builtin_popcountl (x);
}
static inline int
floor_log2 (unsigned long x)
{
return 64 - 1 - clz_hwi (x);
}
static inline int
ceil_log2 (unsigned long x)
{
return x == 0 ? 0 : floor_log2 (x - 1) + 1;
}
static inline int
exact_log2 (unsigned long x)
{
return pow2p_hwi (x) ? ctz_hwi (x) : -1;
}
extern long abs_hwi (long);
extern unsigned long absu_hwi (long);
extern long gcd (long, long);
extern long pos_mul_hwi (long, long);
extern long mul_hwi (long, long);
extern long least_common_multiple (long, long);
static inline int
ctz_or_zero (unsigned long x)
{
return ffs_hwi (x) - 1;
}
static inline long
sext_hwi (long src, unsigned int prec)
{
if (prec == 64)
return src;
else
{
((void)(!(prec < 64) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/hwint.h", 291, __FUNCTION__), 0 : 0));
int shift = 64 - prec;
return ((long) ((unsigned long) src << shift)) >> shift;
}
# 304 "/home/giulianob/gcc_git_gnu/gcc/gcc/hwint.h"
}
static inline unsigned long
zext_hwi (unsigned long src, unsigned int prec)
{
if (prec == 64)
return src;
else
{
((void)(!(prec < 64) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/hwint.h", 314, __FUNCTION__), 0 : 0));
return src & ((1UL << prec) - 1);
}
}
inline long
abs_hwi (long x)
{
((void)(!(x != (long) (1UL << (64 - 1))) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/hwint.h", 324, __FUNCTION__), 0 : 0));
return x >= 0 ? x : -x;
}
inline unsigned long
absu_hwi (long x)
{
return x >= 0 ? (unsigned long)x : -(unsigned long)x;
}
# 1225 "/home/giulianob/gcc_git_gnu/gcc/gcc/system.h" 2
typedef int sort_r_cmp_fn (const void *, const void *, void *);
void qsort_chk (void *, size_t, size_t, sort_r_cmp_fn *, void *);
void gcc_sort_r (void *, size_t, size_t, sort_r_cmp_fn *, void *);
void gcc_qsort (void *, size_t, size_t, int (*)(const void *, const void *));
void gcc_stablesort (void *, size_t, size_t,
int (*)(const void *, const void *));
# 28 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 2
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/coretypes.h" 1
# 46 "/home/giulianob/gcc_git_gnu/gcc/gcc/coretypes.h"
typedef int64_t gcov_type;
typedef uint64_t gcov_type_unsigned;
struct bitmap_obstack;
class bitmap_head;
typedef class bitmap_head *bitmap;
typedef const class bitmap_head *const_bitmap;
struct simple_bitmap_def;
typedef struct simple_bitmap_def *sbitmap;
typedef const struct simple_bitmap_def *const_sbitmap;
struct rtx_def;
typedef struct rtx_def *rtx;
typedef const struct rtx_def *const_rtx;
class scalar_mode;
class scalar_int_mode;
class scalar_float_mode;
class complex_mode;
class fixed_size_mode;
template<typename> class opt_mode;
typedef opt_mode<scalar_mode> opt_scalar_mode;
typedef opt_mode<scalar_int_mode> opt_scalar_int_mode;
typedef opt_mode<scalar_float_mode> opt_scalar_float_mode;
template<typename> struct pod_mode;
typedef pod_mode<scalar_mode> scalar_mode_pod;
typedef pod_mode<scalar_int_mode> scalar_int_mode_pod;
typedef pod_mode<fixed_size_mode> fixed_size_mode_pod;
struct rtx_def;
struct rtx_expr_list;
struct rtx_insn_list;
struct rtx_sequence;
struct rtx_insn;
struct rtx_debug_insn;
struct rtx_nonjump_insn;
struct rtx_jump_insn;
struct rtx_call_insn;
struct rtx_jump_table_data;
struct rtx_barrier;
struct rtx_code_label;
struct rtx_note;
struct rtvec_def;
typedef struct rtvec_def *rtvec;
typedef const struct rtvec_def *const_rtvec;
struct hwivec_def;
typedef struct hwivec_def *hwivec;
typedef const struct hwivec_def *const_hwivec;
union tree_node;
typedef union tree_node *tree;
typedef const union tree_node *const_tree;
struct gimple;
typedef gimple *gimple_seq;
struct gimple_stmt_iterator;
struct gcond;
struct gdebug;
struct ggoto;
struct glabel;
struct gswitch;
struct gassign;
struct gasm;
struct gcall;
struct gtransaction;
struct greturn;
struct gbind;
struct gcatch;
struct geh_filter;
struct geh_mnt;
struct geh_else;
struct gresx;
struct geh_dispatch;
struct gphi;
struct gtry;
struct gomp_atomic_load;
struct gomp_atomic_store;
struct gomp_continue;
struct gomp_critical;
struct gomp_ordered;
struct gomp_for;
struct gomp_parallel;
struct gomp_task;
struct gomp_sections;
struct gomp_single;
struct gomp_target;
struct gomp_teams;
struct symtab_node;
struct cgraph_node;
struct varpool_node;
struct cgraph_edge;
union section;
typedef union section section;
struct gcc_options;
struct cl_target_option;
struct cl_optimization;
struct cl_option;
struct cl_decoded_option;
struct cl_option_handlers;
struct diagnostic_context;
class pretty_printer;
class diagnostic_event_id_t;
template<typename T> struct array_traits;
template<typename T, typename Traits = array_traits<T>,
bool has_constant_size = Traits::has_constant_size>
class bitmap_view;
typedef unsigned char addr_space_t;
enum ir_type {
IR_GIMPLE,
IR_RTL_CFGRTL,
IR_RTL_CFGLAYOUT
};
struct cpp_reader;
struct cpp_token;
enum tls_model {
TLS_MODEL_NONE,
TLS_MODEL_EMULATED,
TLS_MODEL_REAL,
TLS_MODEL_GLOBAL_DYNAMIC = TLS_MODEL_REAL,
TLS_MODEL_LOCAL_DYNAMIC,
TLS_MODEL_INITIAL_EXEC,
TLS_MODEL_LOCAL_EXEC
};
enum offload_abi {
OFFLOAD_ABI_UNSET,
OFFLOAD_ABI_LP64,
OFFLOAD_ABI_ILP32
};
enum profile_update {
PROFILE_UPDATE_SINGLE,
PROFILE_UPDATE_ATOMIC,
PROFILE_UPDATE_PREFER_ATOMIC
};
enum profile_reproducibility {
PROFILE_REPRODUCIBILITY_SERIAL,
PROFILE_REPRODUCIBILITY_PARALLEL_RUNS,
PROFILE_REPRODUCIBILITY_MULTITHREADED
};
enum unwind_info_type
{
UI_NONE,
UI_SJLJ,
UI_DWARF2,
UI_TARGET,
UI_SEH
};
enum node_frequency {
NODE_FREQUENCY_UNLIKELY_EXECUTED,
NODE_FREQUENCY_EXECUTED_ONCE,
NODE_FREQUENCY_NORMAL,
NODE_FREQUENCY_HOT
};
enum optimization_type {
OPTIMIZE_FOR_SPEED,
OPTIMIZE_FOR_BOTH,
OPTIMIZE_FOR_SIZE
};
enum pad_direction {
PAD_NONE,
PAD_UPWARD,
PAD_DOWNWARD
};
enum var_init_status
{
VAR_INIT_STATUS_UNKNOWN,
VAR_INIT_STATUS_UNINITIALIZED,
VAR_INIT_STATUS_INITIALIZED
};
enum warn_strict_overflow_code
{
WARN_STRICT_OVERFLOW_ALL = 1,
WARN_STRICT_OVERFLOW_CONDITIONAL = 2,
WARN_STRICT_OVERFLOW_COMPARISON = 3,
WARN_STRICT_OVERFLOW_MISC = 4,
WARN_STRICT_OVERFLOW_MAGNITUDE = 5
};
typedef int alias_set_type;
class edge_def;
typedef class edge_def *edge;
typedef const class edge_def *const_edge;
struct basic_block_def;
typedef struct basic_block_def *basic_block;
typedef const struct basic_block_def *const_basic_block;
# 343 "/home/giulianob/gcc_git_gnu/gcc/gcc/coretypes.h"
typedef int reg_class_t;
class rtl_opt_pass;
namespace gcc {
class context;
}
typedef std::pair <tree, tree> tree_pair;
typedef std::pair <const char *, int> string_int_pair;
template <typename ValueType>
struct kv_pair
{
const char *const name;
const ValueType value;
};
template<typename T>
struct iterator_range
{
public:
iterator_range (const T &begin, const T &end)
: m_begin (begin), m_end (end) {}
T begin () const { return m_begin; }
T end () const { return m_end; }
private:
T m_begin;
T m_end;
};
# 402 "/home/giulianob/gcc_git_gnu/gcc/gcc/coretypes.h"
enum function_class {
function_c94,
function_c99_misc,
function_c99_math_complex,
function_sincos,
function_c11_misc,
function_c2x_misc
};
enum symbol_visibility
{
VISIBILITY_DEFAULT,
VISIBILITY_PROTECTED,
VISIBILITY_HIDDEN,
VISIBILITY_INTERNAL
};
enum flt_eval_method
{
FLT_EVAL_METHOD_UNPREDICTABLE = -1,
FLT_EVAL_METHOD_PROMOTE_TO_FLOAT = 0,
FLT_EVAL_METHOD_PROMOTE_TO_DOUBLE = 1,
FLT_EVAL_METHOD_PROMOTE_TO_LONG_DOUBLE = 2,
FLT_EVAL_METHOD_PROMOTE_TO_FLOAT16 = 16
};
enum excess_precision_type
{
EXCESS_PRECISION_TYPE_IMPLICIT,
EXCESS_PRECISION_TYPE_STANDARD,
EXCESS_PRECISION_TYPE_FAST
};
typedef void (*gt_pointer_operator) (void *, void *);
typedef unsigned char uchar;
# 1 "./insn-modes.h" 1
enum machine_mode
{
E_VOIDmode,
E_BLKmode,
E_CCmode,
E_CCGCmode,
E_CCGOCmode,
E_CCNOmode,
E_CCGZmode,
E_CCAmode,
E_CCCmode,
E_CCOmode,
E_CCPmode,
E_CCSmode,
E_CCZmode,
E_CCFPmode,
E_BImode,
E_QImode,
E_HImode,
E_SImode,
E_DImode,
E_TImode,
E_OImode,
E_XImode,
E_P2QImode,
E_P2HImode,
E_POImode,
E_QQmode,
E_HQmode,
E_SQmode,
E_DQmode,
E_TQmode,
E_UQQmode,
E_UHQmode,
E_USQmode,
E_UDQmode,
E_UTQmode,
E_HAmode,
E_SAmode,
E_DAmode,
E_TAmode,
E_UHAmode,
E_USAmode,
E_UDAmode,
E_UTAmode,
E_SFmode,
E_DFmode,
E_XFmode,
E_TFmode,
E_SDmode,
E_DDmode,
E_TDmode,
E_CQImode,
E_CP2QImode,
E_CHImode,
E_CP2HImode,
E_CSImode,
E_CDImode,
E_CTImode,
E_CPOImode,
E_COImode,
E_CXImode,
E_SCmode,
E_DCmode,
E_XCmode,
E_TCmode,
E_V2QImode,
E_V4QImode,
E_V2HImode,
E_V1SImode,
E_V8QImode,
E_V4HImode,
E_V2SImode,
E_V1DImode,
E_V12QImode,
E_V6HImode,
E_V14QImode,
E_V16QImode,
E_V8HImode,
E_V4SImode,
E_V2DImode,
E_V1TImode,
E_V32QImode,
E_V16HImode,
E_V8SImode,
E_V4DImode,
E_V2TImode,
E_V64QImode,
E_V32HImode,
E_V16SImode,
E_V8DImode,
E_V4TImode,
E_V128QImode,
E_V64HImode,
E_V32SImode,
E_V16DImode,
E_V8TImode,
E_V64SImode,
E_V2SFmode,
E_V4SFmode,
E_V2DFmode,
E_V8SFmode,
E_V4DFmode,
E_V2TFmode,
E_V16SFmode,
E_V8DFmode,
E_V4TFmode,
E_V32SFmode,
E_V16DFmode,
E_V8TFmode,
E_V64SFmode,
E_V32DFmode,
E_V16TFmode,
MAX_MACHINE_MODE,
MIN_MODE_RANDOM = E_VOIDmode,
MAX_MODE_RANDOM = E_BLKmode,
MIN_MODE_CC = E_CCmode,
MAX_MODE_CC = E_CCFPmode,
MIN_MODE_INT = E_QImode,
MAX_MODE_INT = E_XImode,
MIN_MODE_PARTIAL_INT = E_P2QImode,
MAX_MODE_PARTIAL_INT = E_POImode,
MIN_MODE_FRACT = E_QQmode,
MAX_MODE_FRACT = E_TQmode,
MIN_MODE_UFRACT = E_UQQmode,
MAX_MODE_UFRACT = E_UTQmode,
MIN_MODE_ACCUM = E_HAmode,
MAX_MODE_ACCUM = E_TAmode,
MIN_MODE_UACCUM = E_UHAmode,
MAX_MODE_UACCUM = E_UTAmode,
MIN_MODE_FLOAT = E_SFmode,
MAX_MODE_FLOAT = E_TFmode,
MIN_MODE_DECIMAL_FLOAT = E_SDmode,
MAX_MODE_DECIMAL_FLOAT = E_TDmode,
MIN_MODE_COMPLEX_INT = E_CQImode,
MAX_MODE_COMPLEX_INT = E_CXImode,
MIN_MODE_COMPLEX_FLOAT = E_SCmode,
MAX_MODE_COMPLEX_FLOAT = E_TCmode,
MIN_MODE_VECTOR_BOOL = E_VOIDmode,
MAX_MODE_VECTOR_BOOL = E_VOIDmode,
MIN_MODE_VECTOR_INT = E_V2QImode,
MAX_MODE_VECTOR_INT = E_V64SImode,
MIN_MODE_VECTOR_FRACT = E_VOIDmode,
MAX_MODE_VECTOR_FRACT = E_VOIDmode,
MIN_MODE_VECTOR_UFRACT = E_VOIDmode,
MAX_MODE_VECTOR_UFRACT = E_VOIDmode,
MIN_MODE_VECTOR_ACCUM = E_VOIDmode,
MAX_MODE_VECTOR_ACCUM = E_VOIDmode,
MIN_MODE_VECTOR_UACCUM = E_VOIDmode,
MAX_MODE_VECTOR_UACCUM = E_VOIDmode,
MIN_MODE_VECTOR_FLOAT = E_V2SFmode,
MAX_MODE_VECTOR_FLOAT = E_V16TFmode,
NUM_MACHINE_MODES = MAX_MACHINE_MODE
};
# 450 "/home/giulianob/gcc_git_gnu/gcc/gcc/coretypes.h" 2
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/signop.h" 1
# 28 "/home/giulianob/gcc_git_gnu/gcc/gcc/signop.h"
enum signop {
SIGNED,
UNSIGNED
};
# 451 "/home/giulianob/gcc_git_gnu/gcc/gcc/coretypes.h" 2
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/wide-int.h" 1
# 314 "/home/giulianob/gcc_git_gnu/gcc/gcc/wide-int.h"
template <typename T> class generic_wide_int;
template <int N> class fixed_wide_int_storage;
class wide_int_storage;
typedef generic_wide_int <wide_int_storage> wide_int;
typedef generic_wide_int < fixed_wide_int_storage <((64 + 4 + 64 - 1) & ~(64 - 1))> > offset_int;
typedef generic_wide_int < fixed_wide_int_storage <(((160 + 64) / 64) * 64)> > widest_int;
typedef generic_wide_int < fixed_wide_int_storage <(((160 + 64) / 64) * 64) * 2> > widest2_int;
template <bool SE, bool HDP = true>
class wide_int_ref_storage;
typedef generic_wide_int <wide_int_ref_storage <false> > wide_int_ref;
# 348 "/home/giulianob/gcc_git_gnu/gcc/gcc/wide-int.h"
namespace wi
{
# 358 "/home/giulianob/gcc_git_gnu/gcc/gcc/wide-int.h"
enum overflow_type {
OVF_NONE = 0,
OVF_UNDERFLOW = -1,
OVF_OVERFLOW = 1,
OVF_UNKNOWN = 2
};
enum precision_type {
FLEXIBLE_PRECISION,
VAR_PRECISION,
CONST_PRECISION
};
# 403 "/home/giulianob/gcc_git_gnu/gcc/gcc/wide-int.h"
template <typename T> struct int_traits;
template <typename T1, typename T2,
enum precision_type P1 = int_traits <T1>::precision_type,
enum precision_type P2 = int_traits <T2>::precision_type>
struct binary_traits;
template <typename T1, typename T2>
struct binary_traits <T1, T2, FLEXIBLE_PRECISION, FLEXIBLE_PRECISION>
{
typedef widest_int result_type;
};
template <typename T1, typename T2>
struct binary_traits <T1, T2, FLEXIBLE_PRECISION, VAR_PRECISION>
{
typedef wide_int result_type;
typedef result_type operator_result;
typedef bool predicate_result;
};
template <typename T1, typename T2>
struct binary_traits <T1, T2, FLEXIBLE_PRECISION, CONST_PRECISION>
{
typedef generic_wide_int < fixed_wide_int_storage
<int_traits <T2>::precision> > result_type;
typedef result_type operator_result;
typedef bool predicate_result;
typedef result_type signed_shift_result_type;
typedef bool signed_predicate_result;
};
template <typename T1, typename T2>
struct binary_traits <T1, T2, VAR_PRECISION, FLEXIBLE_PRECISION>
{
typedef wide_int result_type;
typedef result_type operator_result;
typedef bool predicate_result;
};
template <typename T1, typename T2>
struct binary_traits <T1, T2, CONST_PRECISION, FLEXIBLE_PRECISION>
{
typedef generic_wide_int < fixed_wide_int_storage
<int_traits <T1>::precision> > result_type;
typedef result_type operator_result;
typedef bool predicate_result;
typedef result_type signed_shift_result_type;
typedef bool signed_predicate_result;
};
template <typename T1, typename T2>
struct binary_traits <T1, T2, CONST_PRECISION, CONST_PRECISION>
{
static_assert ((int_traits <T1>::precision == int_traits <T2>::precision), "int_traits <T1>::precision == int_traits <T2>::precision");
typedef generic_wide_int < fixed_wide_int_storage
<int_traits <T1>::precision> > result_type;
typedef result_type operator_result;
typedef bool predicate_result;
typedef result_type signed_shift_result_type;
typedef bool signed_predicate_result;
};
template <typename T1, typename T2>
struct binary_traits <T1, T2, VAR_PRECISION, VAR_PRECISION>
{
typedef wide_int result_type;
typedef result_type operator_result;
typedef bool predicate_result;
};
}
namespace wi
{
template <typename T>
unsigned int get_precision (const T &);
template <typename T1, typename T2>
unsigned int get_binary_precision (const T1 &, const T2 &);
template <typename T1, typename T2>
void copy (T1 &, const T2 &);
# 512 "/home/giulianob/gcc_git_gnu/gcc/gcc/wide-int.h"
template <typename T> bool fits_shwi_p (const T &);
template <typename T> bool fits_uhwi_p (const T &);
template <typename T> bool neg_p (const T &, signop = SIGNED);
template <typename T>
long sign_mask (const T &);
template <typename T1, typename T2> bool eq_p (const T1 &, const T2 &);
template <typename T1, typename T2> bool ne_p (const T1 &, const T2 &);
template <typename T1, typename T2> bool lt_p (const T1 &, const T2 &, signop);
template <typename T1, typename T2> bool lts_p (const T1 &, const T2 &);
template <typename T1, typename T2> bool ltu_p (const T1 &, const T2 &);
template <typename T1, typename T2> bool le_p (const T1 &, const T2 &, signop);
template <typename T1, typename T2> bool les_p (const T1 &, const T2 &);
template <typename T1, typename T2> bool leu_p (const T1 &, const T2 &);
template <typename T1, typename T2> bool gt_p (const T1 &, const T2 &, signop);
template <typename T1, typename T2> bool gts_p (const T1 &, const T2 &);
template <typename T1, typename T2> bool gtu_p (const T1 &, const T2 &);
template <typename T1, typename T2> bool ge_p (const T1 &, const T2 &, signop);
template <typename T1, typename T2> bool ges_p (const T1 &, const T2 &);
template <typename T1, typename T2> bool geu_p (const T1 &, const T2 &);
template <typename T1, typename T2>
int cmp (const T1 &, const T2 &, signop);
template <typename T1, typename T2>
int cmps (const T1 &, const T2 &);
template <typename T1, typename T2>
int cmpu (const T1 &, const T2 &);
template <typename T> typename wi::binary_traits <T, T>::result_type bit_not (const T &);
template <typename T> typename wi::binary_traits <T, T>::result_type neg (const T &);
template <typename T> typename wi::binary_traits <T, T>::result_type neg (const T &, overflow_type *);
template <typename T> typename wi::binary_traits <T, T>::result_type abs (const T &);
template <typename T> typename wi::binary_traits <T, T>::result_type ext (const T &, unsigned int, signop);
template <typename T> typename wi::binary_traits <T, T>::result_type sext (const T &, unsigned int);
template <typename T> typename wi::binary_traits <T, T>::result_type zext (const T &, unsigned int);
template <typename T> typename wi::binary_traits <T, T>::result_type set_bit (const T &, unsigned int);
template <typename T1, typename T2> typename wi::binary_traits <T1, T2>::result_type min (const T1 &, const T2 &, signop);
template <typename T1, typename T2> typename wi::binary_traits <T1, T2>::result_type smin (const T1 &, const T2 &);
template <typename T1, typename T2> typename wi::binary_traits <T1, T2>::result_type umin (const T1 &, const T2 &);
template <typename T1, typename T2> typename wi::binary_traits <T1, T2>::result_type max (const T1 &, const T2 &, signop);
template <typename T1, typename T2> typename wi::binary_traits <T1, T2>::result_type smax (const T1 &, const T2 &);
template <typename T1, typename T2> typename wi::binary_traits <T1, T2>::result_type umax (const T1 &, const T2 &);
template <typename T1, typename T2> typename wi::binary_traits <T1, T2>::result_type bit_and (const T1 &, const T2 &);
template <typename T1, typename T2> typename wi::binary_traits <T1, T2>::result_type bit_and_not (const T1 &, const T2 &);
template <typename T1, typename T2> typename wi::binary_traits <T1, T2>::result_type bit_or (const T1 &, const T2 &);
template <typename T1, typename T2> typename wi::binary_traits <T1, T2>::result_type bit_or_not (const T1 &, const T2 &);
template <typename T1, typename T2> typename wi::binary_traits <T1, T2>::result_type bit_xor (const T1 &, const T2 &);
template <typename T1, typename T2> typename wi::binary_traits <T1, T2>::result_type add (const T1 &, const T2 &);
template <typename T1, typename T2> typename wi::binary_traits <T1, T2>::result_type add (const T1 &, const T2 &, signop, overflow_type *);
template <typename T1, typename T2> typename wi::binary_traits <T1, T2>::result_type sub (const T1 &, const T2 &);
template <typename T1, typename T2> typename wi::binary_traits <T1, T2>::result_type sub (const T1 &, const T2 &, signop, overflow_type *);
template <typename T1, typename T2> typename wi::binary_traits <T1, T2>::result_type mul (const T1 &, const T2 &);
template <typename T1, typename T2> typename wi::binary_traits <T1, T2>::result_type mul (const T1 &, const T2 &, signop, overflow_type *);
template <typename T1, typename T2> typename wi::binary_traits <T1, T2>::result_type smul (const T1 &, const T2 &, overflow_type *);
template <typename T1, typename T2> typename wi::binary_traits <T1, T2>::result_type umul (const T1 &, const T2 &, overflow_type *);
template <typename T1, typename T2> typename wi::binary_traits <T1, T2>::result_type mul_high (const T1 &, const T2 &, signop);
template <typename T1, typename T2> typename wi::binary_traits <T1, T2>::result_type div_trunc (const T1 &, const T2 &, signop,
overflow_type * = 0);
template <typename T1, typename T2> typename wi::binary_traits <T1, T2>::result_type sdiv_trunc (const T1 &, const T2 &);
template <typename T1, typename T2> typename wi::binary_traits <T1, T2>::result_type udiv_trunc (const T1 &, const T2 &);
template <typename T1, typename T2> typename wi::binary_traits <T1, T2>::result_type div_floor (const T1 &, const T2 &, signop,
overflow_type * = 0);
template <typename T1, typename T2> typename wi::binary_traits <T1, T2>::result_type udiv_floor (const T1 &, const T2 &);
template <typename T1, typename T2> typename wi::binary_traits <T1, T2>::result_type sdiv_floor (const T1 &, const T2 &);
template <typename T1, typename T2> typename wi::binary_traits <T1, T2>::result_type div_ceil (const T1 &, const T2 &, signop,
overflow_type * = 0);
template <typename T1, typename T2> typename wi::binary_traits <T1, T2>::result_type udiv_ceil (const T1 &, const T2 &);
template <typename T1, typename T2> typename wi::binary_traits <T1, T2>::result_type div_round (const T1 &, const T2 &, signop,
overflow_type * = 0);
template <typename T1, typename T2> typename wi::binary_traits <T1, T2>::result_type divmod_trunc (const T1 &, const T2 &, signop,
typename wi::binary_traits <T1, T2>::result_type *);
template <typename T1, typename T2> typename wi::binary_traits <T1, T2>::result_type gcd (const T1 &, const T2 &, signop = UNSIGNED);
template <typename T1, typename T2> typename wi::binary_traits <T1, T2>::result_type mod_trunc (const T1 &, const T2 &, signop,
overflow_type * = 0);
template <typename T1, typename T2> typename wi::binary_traits <T1, T2>::result_type smod_trunc (const T1 &, const T2 &);
template <typename T1, typename T2> typename wi::binary_traits <T1, T2>::result_type umod_trunc (const T1 &, const T2 &);
template <typename T1, typename T2> typename wi::binary_traits <T1, T2>::result_type mod_floor (const T1 &, const T2 &, signop,
overflow_type * = 0);
template <typename T1, typename T2> typename wi::binary_traits <T1, T2>::result_type umod_floor (const T1 &, const T2 &);
template <typename T1, typename T2> typename wi::binary_traits <T1, T2>::result_type mod_ceil (const T1 &, const T2 &, signop,
overflow_type * = 0);
template <typename T1, typename T2> typename wi::binary_traits <T1, T2>::result_type mod_round (const T1 &, const T2 &, signop,
overflow_type * = 0);
template <typename T1, typename T2>
bool multiple_of_p (const T1 &, const T2 &, signop);
template <typename T1, typename T2>
bool multiple_of_p (const T1 &, const T2 &, signop,
typename wi::binary_traits <T1, T2>::result_type *);
template <typename T1, typename T2> typename wi::binary_traits <T1, T1>::result_type lshift (const T1 &, const T2 &);
template <typename T1, typename T2> typename wi::binary_traits <T1, T1>::result_type lrshift (const T1 &, const T2 &);
template <typename T1, typename T2> typename wi::binary_traits <T1, T1>::result_type arshift (const T1 &, const T2 &);
template <typename T1, typename T2> typename wi::binary_traits <T1, T1>::result_type rshift (const T1 &, const T2 &, signop sgn);
template <typename T1, typename T2> typename wi::binary_traits <T1, T1>::result_type lrotate (const T1 &, const T2 &, unsigned int = 0);
template <typename T1, typename T2> typename wi::binary_traits <T1, T1>::result_type rrotate (const T1 &, const T2 &, unsigned int = 0);
bool only_sign_bit_p (const wide_int_ref &, unsigned int);
bool only_sign_bit_p (const wide_int_ref &);
int clz (const wide_int_ref &);
int clrsb (const wide_int_ref &);
int ctz (const wide_int_ref &);
int exact_log2 (const wide_int_ref &);
int floor_log2 (const wide_int_ref &);
int ffs (const wide_int_ref &);
int popcount (const wide_int_ref &);
int parity (const wide_int_ref &);
template <typename T>
unsigned long extract_uhwi (const T &, unsigned int, unsigned int);
template <typename T>
unsigned int min_precision (const T &, signop);
static inline void accumulate_overflow (overflow_type &, overflow_type);
}
namespace wi
{
class storage_ref
{
public:
storage_ref () {}
storage_ref (const long *, unsigned int, unsigned int);
const long *val;
unsigned int len;
unsigned int precision;
unsigned int get_len () const;
unsigned int get_precision () const;
const long *get_val () const;
};
}
inline::wi::storage_ref::storage_ref (const long *val_in,
unsigned int len_in,
unsigned int precision_in)
: val (val_in), len (len_in), precision (precision_in)
{
}
inline unsigned int
wi::storage_ref::get_len () const
{
return len;
}
inline unsigned int
wi::storage_ref::get_precision () const
{
return precision;
}
inline const long *
wi::storage_ref::get_val () const
{
return val;
}
# 711 "/home/giulianob/gcc_git_gnu/gcc/gcc/wide-int.h"
template <typename storage>
class generic_wide_int : public storage
{
public:
generic_wide_int ();
template <typename T>
generic_wide_int (const T &);
template <typename T>
generic_wide_int (const T &, unsigned int);
long to_shwi (unsigned int) const;
long to_shwi () const;
unsigned long to_uhwi (unsigned int) const;
unsigned long to_uhwi () const;
long to_short_addr () const;
long sign_mask () const;
long elt (unsigned int) const;
long sext_elt (unsigned int) const;
unsigned long ulow () const;
unsigned long uhigh () const;
long slow () const;
long shigh () const;
template <typename T>
generic_wide_int &operator = (const T &);
# 754 "/home/giulianob/gcc_git_gnu/gcc/gcc/wide-int.h"
template <typename T> generic_wide_int &operator &= (const T &c) { return (*this = wi::bit_and (*this, c)); }
template <typename T> generic_wide_int &operator |= (const T &c) { return (*this = wi::bit_or (*this, c)); }
template <typename T> generic_wide_int &operator ^= (const T &c) { return (*this = wi::bit_xor (*this, c)); }
template <typename T> generic_wide_int &operator += (const T &c) { return (*this = wi::add (*this, c)); }
template <typename T> generic_wide_int &operator -= (const T &c) { return (*this = wi::sub (*this, c)); }
template <typename T> generic_wide_int &operator *= (const T &c) { return (*this = wi::mul (*this, c)); }
template <typename T> generic_wide_int &operator <<= (const T &c) { return (*this = wi::lshift (*this, c)); }
template <typename T> generic_wide_int &operator >>= (const T &c) { return (*this = *this >> c); }
generic_wide_int &operator ++ () { *this += 1; return *this; }
generic_wide_int &operator -- () { *this += -1; return *this; }
void dump () const;
static const bool is_sign_extended
= wi::int_traits <generic_wide_int <storage> >::is_sign_extended;
};
template <typename storage>
inline generic_wide_int <storage>::generic_wide_int () {}
template <typename storage>
template <typename T>
inline generic_wide_int <storage>::generic_wide_int (const T &x)
: storage (x)
{
}
template <typename storage>
template <typename T>
inline generic_wide_int <storage>::generic_wide_int (const T &x,
unsigned int precision)
: storage (x, precision)
{
}
template <typename storage>
inline long
generic_wide_int <storage>::to_shwi (unsigned int precision) const
{
if (precision < 64)
return sext_hwi (this->get_val ()[0], precision);
else
return this->get_val ()[0];
}
template <typename storage>
inline long
generic_wide_int <storage>::to_shwi () const
{
if (is_sign_extended)
return this->get_val ()[0];
else
return to_shwi (this->get_precision ());
}
template <typename storage>
inline unsigned long
generic_wide_int <storage>::to_uhwi (unsigned int precision) const
{
if (precision < 64)
return zext_hwi (this->get_val ()[0], precision);
else
return this->get_val ()[0];
}
template <typename storage>
inline unsigned long
generic_wide_int <storage>::to_uhwi () const
{
return to_uhwi (this->get_precision ());
}
template <typename storage>
inline long
generic_wide_int <storage>::to_short_addr () const
{
return this->get_val ()[0];
}
template <typename storage>
inline long
generic_wide_int <storage>::sign_mask () const
{
unsigned int len = this->get_len ();
((void)(!(len > 0) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/wide-int.h", 855, __FUNCTION__), 0 : 0));
unsigned long high = this->get_val ()[len - 1];
if (!is_sign_extended)
{
unsigned int precision = this->get_precision ();
int excess = len * 64 - precision;
if (excess > 0)
high <<= excess;
}
return (long) (high) < 0 ? -1 : 0;
}
template <typename storage>
inline long
generic_wide_int <storage>::slow () const
{
return this->get_val ()[0];
}
template <typename storage>
inline long
generic_wide_int <storage>::shigh () const
{
return this->get_val ()[this->get_len () - 1];
}
template <typename storage>
inline unsigned long
generic_wide_int <storage>::ulow () const
{
return this->get_val ()[0];
}
template <typename storage>
inline unsigned long
generic_wide_int <storage>::uhigh () const
{
return this->get_val ()[this->get_len () - 1];
}
template <typename storage>
inline long
generic_wide_int <storage>::elt (unsigned int i) const
{
if (i >= this->get_len ())
return sign_mask ();
else
return this->get_val ()[i];
}
template <typename storage>
inline long
generic_wide_int <storage>::sext_elt (unsigned int i) const
{
long elt_i = elt (i);
if (!is_sign_extended)
{
unsigned int precision = this->get_precision ();
unsigned int lsb = i * 64;
if (precision - lsb < 64)
elt_i = sext_hwi (elt_i, precision - lsb);
}
return elt_i;
}
template <typename storage>
template <typename T>
inline generic_wide_int <storage> &
generic_wide_int <storage>::operator = (const T &x)
{
storage::operator = (x);
return *this;
}
template <typename storage>
void
generic_wide_int <storage>::dump () const
{
unsigned int len = this->get_len ();
const long *val = this->get_val ();
unsigned int precision = this->get_precision ();
fprintf (
# 949 "/home/giulianob/gcc_git_gnu/gcc/gcc/wide-int.h" 3 4
stderr
# 949 "/home/giulianob/gcc_git_gnu/gcc/gcc/wide-int.h"
, "[");
if (len * 64 < precision)
fprintf (
# 951 "/home/giulianob/gcc_git_gnu/gcc/gcc/wide-int.h" 3 4
stderr
# 951 "/home/giulianob/gcc_git_gnu/gcc/gcc/wide-int.h"
, "...,");
for (unsigned int i = 0; i < len - 1; ++i)
fprintf (
# 953 "/home/giulianob/gcc_git_gnu/gcc/gcc/wide-int.h" 3 4
stderr
# 953 "/home/giulianob/gcc_git_gnu/gcc/gcc/wide-int.h"
, "%#"
# 953 "/home/giulianob/gcc_git_gnu/gcc/gcc/wide-int.h" 3 4
"l" "x"
# 953 "/home/giulianob/gcc_git_gnu/gcc/gcc/wide-int.h"
",", val[len - 1 - i]);
fprintf (
# 954 "/home/giulianob/gcc_git_gnu/gcc/gcc/wide-int.h" 3 4
stderr
# 954 "/home/giulianob/gcc_git_gnu/gcc/gcc/wide-int.h"
, "%#"
# 954 "/home/giulianob/gcc_git_gnu/gcc/gcc/wide-int.h" 3 4
"l" "x"
# 954 "/home/giulianob/gcc_git_gnu/gcc/gcc/wide-int.h"
"], precision = %d\n",
val[0], precision);
}
namespace wi
{
template <typename storage>
struct int_traits < generic_wide_int <storage> >
: public wi::int_traits <storage>
{
static unsigned int get_precision (const generic_wide_int <storage> &);
static wi::storage_ref decompose (long *, unsigned int,
const generic_wide_int <storage> &);
};
}
template <typename storage>
inline unsigned int
wi::int_traits < generic_wide_int <storage> >::
get_precision (const generic_wide_int <storage> &x)
{
return x.get_precision ();
}
template <typename storage>
inline wi::storage_ref
wi::int_traits < generic_wide_int <storage> >::
decompose (long *, unsigned int precision,
const generic_wide_int <storage> &x)
{
((void)(!(precision == x.get_precision ()) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/wide-int.h", 984, __FUNCTION__), 0 : 0));
return wi::storage_ref (x.get_val (), x.get_len (), precision);
}
template <bool SE, bool HDP>
class wide_int_ref_storage : public wi::storage_ref
{
private:
long scratch[2];
public:
wide_int_ref_storage () {}
wide_int_ref_storage (const wi::storage_ref &);
template <typename T>
wide_int_ref_storage (const T &);
template <typename T>
wide_int_ref_storage (const T &, unsigned int);
};
template <bool SE, bool HDP>
inline wide_int_ref_storage <SE, HDP>::
wide_int_ref_storage (const wi::storage_ref &x)
: storage_ref (x)
{}
template <bool SE, bool HDP>
template <typename T>
inline wide_int_ref_storage <SE, HDP>::wide_int_ref_storage (const T &x)
: storage_ref (wi::int_traits <T>::decompose (scratch,
wi::get_precision (x), x))
{
}
template <bool SE, bool HDP>
template <typename T>
inline wide_int_ref_storage <SE, HDP>::
wide_int_ref_storage (const T &x, unsigned int precision)
: storage_ref (wi::int_traits <T>::decompose (scratch, precision, x))
{
}
namespace wi
{
template <bool SE, bool HDP>
struct int_traits <wide_int_ref_storage <SE, HDP> >
{
static const enum precision_type precision_type = VAR_PRECISION;
static const bool host_dependent_precision = HDP;
static const bool is_sign_extended = SE;
};
}
namespace wi
{
unsigned int force_to_size (long *, const long *,
unsigned int, unsigned int, unsigned int,
signop sgn);
unsigned int from_array (long *, const long *,
unsigned int, unsigned int, bool = true);
}
class wide_int_storage
{
private:
long val[((160 + 64) / 64)];
unsigned int len;
unsigned int precision;
public:
wide_int_storage ();
template <typename T>
wide_int_storage (const T &);
unsigned int get_precision () const;
const long *get_val () const;
unsigned int get_len () const;
long *write_val ();
void set_len (unsigned int, bool = false);
template <typename T>
wide_int_storage &operator = (const T &);
static wide_int from (const wide_int_ref &, unsigned int, signop);
static wide_int from_array (const long *, unsigned int,
unsigned int, bool = true);
static wide_int create (unsigned int);
wide_int bswap () const;
};
namespace wi
{
template <>
struct int_traits <wide_int_storage>
{
static const enum precision_type precision_type = VAR_PRECISION;
static const bool host_dependent_precision = false;
static const bool is_sign_extended = true;
template <typename T1, typename T2>
static wide_int get_binary_result (const T1 &, const T2 &);
};
}
inline wide_int_storage::wide_int_storage () {}
template <typename T>
inline wide_int_storage::wide_int_storage (const T &x)
{
{ static_assert ((!wi::int_traits<T>::host_dependent_precision), "!wi::int_traits<T>::host_dependent_precision"); }
{ static_assert ((wi::int_traits<T>::precision_type != wi::CONST_PRECISION), "wi::int_traits<T>::precision_type != wi::CONST_PRECISION"); }
generic_wide_int <wide_int_ref_storage <wi::int_traits <T>::is_sign_extended, wi::int_traits <T>::host_dependent_precision> > xi (x);
precision = xi.precision;
wi::copy (*this, xi);
}
template <typename T>
inline wide_int_storage&
wide_int_storage::operator = (const T &x)
{
{ static_assert ((!wi::int_traits<T>::host_dependent_precision), "!wi::int_traits<T>::host_dependent_precision"); }
{ static_assert ((wi::int_traits<T>::precision_type != wi::CONST_PRECISION), "wi::int_traits<T>::precision_type != wi::CONST_PRECISION"); }
generic_wide_int <wide_int_ref_storage <wi::int_traits <T>::is_sign_extended, wi::int_traits <T>::host_dependent_precision> > xi (x);
precision = xi.precision;
wi::copy (*this, xi);
return *this;
}
inline unsigned int
wide_int_storage::get_precision () const
{
return precision;
}
inline const long *
wide_int_storage::get_val () const
{
return val;
}
inline unsigned int
wide_int_storage::get_len () const
{
return len;
}
inline long *
wide_int_storage::write_val ()
{
return val;
}
inline void
wide_int_storage::set_len (unsigned int l, bool is_sign_extended)
{
len = l;
if (!is_sign_extended && len * 64 > precision)
val[len - 1] = sext_hwi (val[len - 1],
precision % 64);
}
inline wide_int
wide_int_storage::from (const wide_int_ref &x, unsigned int precision,
signop sgn)
{
wide_int result = wide_int::create (precision);
result.set_len (wi::force_to_size (result.write_val (), x.val, x.len,
x.precision, precision, sgn));
return result;
}
inline wide_int
wide_int_storage::from_array (const long *val, unsigned int len,
unsigned int precision, bool need_canon_p)
{
wide_int result = wide_int::create (precision);
result.set_len (wi::from_array (result.write_val (), val, len, precision,
need_canon_p));
return result;
}
inline wide_int
wide_int_storage::create (unsigned int precision)
{
wide_int x;
x.precision = precision;
return x;
}
template <typename T1, typename T2>
inline wide_int
wi::int_traits <wide_int_storage>::get_binary_result (const T1 &x, const T2 &y)
{
static_assert ((wi::int_traits <T1>::precision_type != FLEXIBLE_PRECISION || wi::int_traits <T2>::precision_type != FLEXIBLE_PRECISION), "wi::int_traits <T1>::precision_type != FLEXIBLE_PRECISION || wi::int_traits <T2>::precision_type != FLEXIBLE_PRECISION")
;
if (wi::int_traits <T1>::precision_type == FLEXIBLE_PRECISION)
return wide_int::create (wi::get_precision (y));
else
return wide_int::create (wi::get_precision (x));
}
template <int N>
class fixed_wide_int_storage
{
private:
long val[(N + 64 + 1) / 64];
unsigned int len;
public:
fixed_wide_int_storage ();
template <typename T>
fixed_wide_int_storage (const T &);
unsigned int get_precision () const;
const long *get_val () const;
unsigned int get_len () const;
long *write_val ();
void set_len (unsigned int, bool = false);
static generic_wide_int < fixed_wide_int_storage <N> > from (const wide_int_ref &, signop);
static generic_wide_int < fixed_wide_int_storage <N> > from_array (const long *, unsigned int,
bool = true);
};
namespace wi
{
template <int N>
struct int_traits < fixed_wide_int_storage <N> >
{
static const enum precision_type precision_type = CONST_PRECISION;
static const bool host_dependent_precision = false;
static const bool is_sign_extended = true;
static const unsigned int precision = N;
template <typename T1, typename T2>
static generic_wide_int < fixed_wide_int_storage <N> > get_binary_result (const T1 &, const T2 &);
};
}
template <int N>
inline fixed_wide_int_storage <N>::fixed_wide_int_storage () {}
template <int N>
template <typename T>
inline fixed_wide_int_storage <N>::fixed_wide_int_storage (const T &x)
{
typename wi::binary_traits <T, generic_wide_int < fixed_wide_int_storage <N> > >::result_type *assertion __attribute__ ((__unused__));
wi::copy (*this, generic_wide_int <wide_int_ref_storage <wi::int_traits <T>::is_sign_extended, wi::int_traits <T>::host_dependent_precision> > (x, N));
}
template <int N>
inline unsigned int
fixed_wide_int_storage <N>::get_precision () const
{
return N;
}
template <int N>
inline const long *
fixed_wide_int_storage <N>::get_val () const
{
return val;
}
template <int N>
inline unsigned int
fixed_wide_int_storage <N>::get_len () const
{
return len;
}
template <int N>
inline long *
fixed_wide_int_storage <N>::write_val ()
{
return val;
}
template <int N>
inline void
fixed_wide_int_storage <N>::set_len (unsigned int l, bool)
{
len = l;
static_assert ((N % 64 == 0), "N % HOST_BITS_PER_WIDE_INT == 0");
}
template <int N>
inline generic_wide_int < fixed_wide_int_storage <N> >
fixed_wide_int_storage <N>::from (const wide_int_ref &x, signop sgn)
{
generic_wide_int < fixed_wide_int_storage <N> > result;
result.set_len (wi::force_to_size (result.write_val (), x.val, x.len,
x.precision, N, sgn));
return result;
}
template <int N>
inline generic_wide_int < fixed_wide_int_storage <N> >
fixed_wide_int_storage <N>::from_array (const long *val,
unsigned int len,
bool need_canon_p)
{
generic_wide_int < fixed_wide_int_storage <N> > result;
result.set_len (wi::from_array (result.write_val (), val, len,
N, need_canon_p));
return result;
}
template <int N>
template <typename T1, typename T2>
inline generic_wide_int < fixed_wide_int_storage <N> >
wi::int_traits < fixed_wide_int_storage <N> >::
get_binary_result (const T1 &, const T2 &)
{
return generic_wide_int < fixed_wide_int_storage <N> > ();
}
class trailing_wide_int_storage
{
private:
unsigned int m_precision;
unsigned char *m_len;
long *m_val;
public:
trailing_wide_int_storage (unsigned int, unsigned char *, long *);
unsigned int get_len () const;
unsigned int get_precision () const;
const long *get_val () const;
long *write_val ();
void set_len (unsigned int, bool = false);
template <typename T>
trailing_wide_int_storage &operator = (const T &);
};
typedef generic_wide_int <trailing_wide_int_storage> trailing_wide_int;
namespace wi
{
template <>
struct int_traits <trailing_wide_int_storage>
: public int_traits <wide_int_storage> {};
}
template <int N>
struct trailing_wide_ints
{
private:
unsigned short m_precision;
unsigned char m_max_len;
unsigned char m_len[N];
long m_val[1];
public:
typedef generic_wide_int <wide_int_ref_storage <wi::int_traits <trailing_wide_int_storage>::is_sign_extended, wi::int_traits <trailing_wide_int_storage>::host_dependent_precision> > const_reference;
void set_precision (unsigned int);
unsigned int get_precision () const { return m_precision; }
trailing_wide_int operator [] (unsigned int);
const_reference operator [] (unsigned int) const;
static size_t extra_size (unsigned int);
size_t extra_size () const { return extra_size (m_precision); }
};
inline trailing_wide_int_storage::
trailing_wide_int_storage (unsigned int precision, unsigned char *len,
long *val)
: m_precision (precision), m_len (len), m_val (val)
{
}
inline unsigned int
trailing_wide_int_storage::get_len () const
{
return *m_len;
}
inline unsigned int
trailing_wide_int_storage::get_precision () const
{
return m_precision;
}
inline const long *
trailing_wide_int_storage::get_val () const
{
return m_val;
}
inline long *
trailing_wide_int_storage::write_val ()
{
return m_val;
}
inline void
trailing_wide_int_storage::set_len (unsigned int len, bool is_sign_extended)
{
*m_len = len;
if (!is_sign_extended && len * 64 > m_precision)
m_val[len - 1] = sext_hwi (m_val[len - 1],
m_precision % 64);
}
template <typename T>
inline trailing_wide_int_storage &
trailing_wide_int_storage::operator = (const T &x)
{
generic_wide_int <wide_int_ref_storage <wi::int_traits <T>::is_sign_extended, wi::int_traits <T>::host_dependent_precision> > xi (x, m_precision);
wi::copy (*this, xi);
return *this;
}
template <int N>
inline void
trailing_wide_ints <N>::set_precision (unsigned int precision)
{
m_precision = precision;
m_max_len = ((precision + 64 - 1)
/ 64);
}
template <int N>
inline trailing_wide_int
trailing_wide_ints <N>::operator [] (unsigned int index)
{
return trailing_wide_int_storage (m_precision, &m_len[index],
&m_val[index * m_max_len]);
}
template <int N>
inline typename trailing_wide_ints <N>::const_reference
trailing_wide_ints <N>::operator [] (unsigned int index) const
{
return wi::storage_ref (&m_val[index * m_max_len],
m_len[index], m_precision);
}
template <int N>
inline size_t
trailing_wide_ints <N>::extra_size (unsigned int precision)
{
unsigned int max_len = ((precision + 64 - 1)
/ 64);
return (N * max_len - 1) * sizeof (long);
}
# 1503 "/home/giulianob/gcc_git_gnu/gcc/gcc/wide-int.h"
namespace wi
{
template <typename T, bool signed_p>
struct primitive_int_traits
{
static const enum precision_type precision_type = FLEXIBLE_PRECISION;
static const bool host_dependent_precision = true;
static const bool is_sign_extended = true;
static unsigned int get_precision (T);
static wi::storage_ref decompose (long *, unsigned int, T);
};
}
template <typename T, bool signed_p>
inline unsigned int
wi::primitive_int_traits <T, signed_p>::get_precision (T)
{
return sizeof (T) * 8;
}
template <typename T, bool signed_p>
inline wi::storage_ref
wi::primitive_int_traits <T, signed_p>::decompose (long *scratch,
unsigned int precision, T x)
{
scratch[0] = x;
if (signed_p || scratch[0] >= 0 || precision <= 64)
return wi::storage_ref (scratch, 1, precision);
scratch[1] = 0;
return wi::storage_ref (scratch, 2, precision);
}
namespace wi
{
template <>
struct int_traits <unsigned char>
: public primitive_int_traits <unsigned char, false> {};
template <>
struct int_traits <unsigned short>
: public primitive_int_traits <unsigned short, false> {};
template <>
struct int_traits <int>
: public primitive_int_traits <int, true> {};
template <>
struct int_traits <unsigned int>
: public primitive_int_traits <unsigned int, false> {};
template <>
struct int_traits <long>
: public primitive_int_traits <long, true> {};
template <>
struct int_traits <unsigned long>
: public primitive_int_traits <unsigned long, false> {};
template <>
struct int_traits <long long>
: public primitive_int_traits <long long, true> {};
template <>
struct int_traits <unsigned long long>
: public primitive_int_traits <unsigned long long, false> {};
}
namespace wi
{
class hwi_with_prec
{
public:
hwi_with_prec () {}
hwi_with_prec (long, unsigned int, signop);
long val;
unsigned int precision;
signop sgn;
};
hwi_with_prec shwi (long, unsigned int);
hwi_with_prec uhwi (unsigned long, unsigned int);
hwi_with_prec minus_one (unsigned int);
hwi_with_prec zero (unsigned int);
hwi_with_prec one (unsigned int);
hwi_with_prec two (unsigned int);
}
inline wi::hwi_with_prec::hwi_with_prec (long v, unsigned int p,
signop s)
: precision (p), sgn (s)
{
if (precision < 64)
val = sext_hwi (v, precision);
else
val = v;
}
inline wi::hwi_with_prec
wi::shwi (long val, unsigned int precision)
{
return hwi_with_prec (val, precision, SIGNED);
}
inline wi::hwi_with_prec
wi::uhwi (unsigned long val, unsigned int precision)
{
return hwi_with_prec (val, precision, UNSIGNED);
}
inline wi::hwi_with_prec
wi::minus_one (unsigned int precision)
{
return wi::shwi (-1, precision);
}
inline wi::hwi_with_prec
wi::zero (unsigned int precision)
{
return wi::shwi (0, precision);
}
inline wi::hwi_with_prec
wi::one (unsigned int precision)
{
return wi::shwi (1, precision);
}
inline wi::hwi_with_prec
wi::two (unsigned int precision)
{
return wi::shwi (2, precision);
}
namespace wi
{
template<typename T, precision_type = int_traits<T>::precision_type>
struct ints_for
{
static int zero (const T &) { return 0; }
};
template<typename T>
struct ints_for<T, VAR_PRECISION>
{
static hwi_with_prec zero (const T &);
};
}
template<typename T>
inline wi::hwi_with_prec
wi::ints_for<T, wi::VAR_PRECISION>::zero (const T &x)
{
return wi::zero (wi::get_precision (x));
}
namespace wi
{
template <>
struct int_traits <wi::hwi_with_prec>
{
static const enum precision_type precision_type = VAR_PRECISION;
static const bool host_dependent_precision = false;
static const bool is_sign_extended = true;
static unsigned int get_precision (const wi::hwi_with_prec &);
static wi::storage_ref decompose (long *, unsigned int,
const wi::hwi_with_prec &);
};
}
inline unsigned int
wi::int_traits <wi::hwi_with_prec>::get_precision (const wi::hwi_with_prec &x)
{
return x.precision;
}
inline wi::storage_ref
wi::int_traits <wi::hwi_with_prec>::
decompose (long *scratch, unsigned int precision,
const wi::hwi_with_prec &x)
{
((void)(!(precision == x.precision) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/wide-int.h", 1700, __FUNCTION__), 0 : 0));
scratch[0] = x.val;
if (x.sgn == SIGNED || x.val >= 0 || precision <= 64)
return wi::storage_ref (scratch, 1, precision);
scratch[1] = 0;
return wi::storage_ref (scratch, 2, precision);
}
namespace wi
{
bool eq_p_large (const long *, unsigned int,
const long *, unsigned int, unsigned int);
bool lts_p_large (const long *, unsigned int, unsigned int,
const long *, unsigned int);
bool ltu_p_large (const long *, unsigned int, unsigned int,
const long *, unsigned int);
int cmps_large (const long *, unsigned int, unsigned int,
const long *, unsigned int);
int cmpu_large (const long *, unsigned int, unsigned int,
const long *, unsigned int);
unsigned int sext_large (long *, const long *,
unsigned int,
unsigned int, unsigned int);
unsigned int zext_large (long *, const long *,
unsigned int,
unsigned int, unsigned int);
unsigned int set_bit_large (long *, const long *,
unsigned int, unsigned int, unsigned int);
unsigned int lshift_large (long *, const long *,
unsigned int, unsigned int, unsigned int);
unsigned int lrshift_large (long *, const long *,
unsigned int, unsigned int, unsigned int,
unsigned int);
unsigned int arshift_large (long *, const long *,
unsigned int, unsigned int, unsigned int,
unsigned int);
unsigned int and_large (long *, const long *, unsigned int,
const long *, unsigned int, unsigned int);
unsigned int and_not_large (long *, const long *,
unsigned int, const long *,
unsigned int, unsigned int);
unsigned int or_large (long *, const long *, unsigned int,
const long *, unsigned int, unsigned int);
unsigned int or_not_large (long *, const long *,
unsigned int, const long *,
unsigned int, unsigned int);
unsigned int xor_large (long *, const long *, unsigned int,
const long *, unsigned int, unsigned int);
unsigned int add_large (long *, const long *, unsigned int,
const long *, unsigned int, unsigned int,
signop, overflow_type *);
unsigned int sub_large (long *, const long *, unsigned int,
const long *, unsigned int, unsigned int,
signop, overflow_type *);
unsigned int mul_internal (long *, const long *,
unsigned int, const long *,
unsigned int, unsigned int, signop,
overflow_type *, bool);
unsigned int divmod_internal (long *, unsigned int *,
long *, const long *,
unsigned int, unsigned int,
const long *,
unsigned int, unsigned int,
signop, overflow_type *);
}
template <typename T>
inline unsigned int
wi::get_precision (const T &x)
{
return wi::int_traits <T>::get_precision (x);
}
template <typename T1, typename T2>
inline unsigned int
wi::get_binary_precision (const T1 &x, const T2 &y)
{
return get_precision (wi::int_traits <typename wi::binary_traits <T1, T2>::result_type>::
get_binary_result (x, y));
}
template <typename T1, typename T2>
inline void
wi::copy (T1 &x, const T2 &y)
{
long *xval = x.write_val ();
const long *yval = y.get_val ();
unsigned int len = y.get_len ();
unsigned int i = 0;
do
xval[i] = yval[i];
while (++i < len);
x.set_len (len, y.is_sign_extended);
}
template <typename T>
inline bool
wi::fits_shwi_p (const T &x)
{
generic_wide_int <wide_int_ref_storage <wi::int_traits <T>::is_sign_extended, wi::int_traits <T>::host_dependent_precision> > xi (x);
return xi.len == 1;
}
template <typename T>
inline bool
wi::fits_uhwi_p (const T &x)
{
generic_wide_int <wide_int_ref_storage <wi::int_traits <T>::is_sign_extended, wi::int_traits <T>::host_dependent_precision> > xi (x);
if (xi.precision <= 64)
return true;
if (xi.len == 1)
return xi.slow () >= 0;
return xi.len == 2 && xi.uhigh () == 0;
}
template <typename T>
inline bool
wi::neg_p (const T &x, signop sgn)
{
generic_wide_int <wide_int_ref_storage <wi::int_traits <T>::is_sign_extended, wi::int_traits <T>::host_dependent_precision> > xi (x);
if (sgn == UNSIGNED)
return false;
return xi.sign_mask () < 0;
}
template <typename T>
inline long
wi::sign_mask (const T &x)
{
generic_wide_int <wide_int_ref_storage <wi::int_traits <T>::is_sign_extended, wi::int_traits <T>::host_dependent_precision> > xi (x);
return xi.sign_mask ();
}
template <typename T1, typename T2>
inline bool
wi::eq_p (const T1 &x, const T2 &y)
{
unsigned int precision = get_binary_precision (x, y);
generic_wide_int <wide_int_ref_storage <wi::int_traits <T1>::is_sign_extended, wi::int_traits <T1>::host_dependent_precision> > xi (x, precision);
generic_wide_int <wide_int_ref_storage <wi::int_traits <T2>::is_sign_extended, wi::int_traits <T2>::host_dependent_precision> > yi (y, precision);
if (xi.is_sign_extended && yi.is_sign_extended)
{
if (xi.len != yi.len)
return false;
unsigned int i = 0;
do
if (xi.val[i] != yi.val[i])
return false;
while (++i != xi.len);
return true;
}
if (__builtin_expect (yi.len == 1, true))
{
if (xi.len != 1)
return false;
if ((__builtin_constant_p (yi.val[0] == 0) && (yi.val[0] == 0)))
return xi.val[0] == 0;
unsigned long diff = xi.val[0] ^ yi.val[0];
int excess = 64 - precision;
if (excess > 0)
diff <<= excess;
return diff == 0;
}
return eq_p_large (xi.val, xi.len, yi.val, yi.len, precision);
}
template <typename T1, typename T2>
inline bool
wi::ne_p (const T1 &x, const T2 &y)
{
return !eq_p (x, y);
}
template <typename T1, typename T2>
inline bool
wi::lts_p (const T1 &x, const T2 &y)
{
unsigned int precision = get_binary_precision (x, y);
generic_wide_int <wide_int_ref_storage <wi::int_traits <T1>::is_sign_extended, wi::int_traits <T1>::host_dependent_precision> > xi (x, precision);
generic_wide_int <wide_int_ref_storage <wi::int_traits <T2>::is_sign_extended, wi::int_traits <T2>::host_dependent_precision> > yi (y, precision);
if (wi::fits_shwi_p (yi))
{
if ((__builtin_constant_p (yi.val[0] == 0) && (yi.val[0] == 0)))
return neg_p (xi);
if (wi::fits_shwi_p (xi))
return xi.to_shwi () < yi.to_shwi ();
if (neg_p (xi))
return true;
return false;
}
if ((__builtin_constant_p (xi.len == 1) && (xi.len == 1)))
return !neg_p (yi);
return lts_p_large (xi.val, xi.len, precision, yi.val, yi.len);
}
template <typename T1, typename T2>
inline bool
wi::ltu_p (const T1 &x, const T2 &y)
{
unsigned int precision = get_binary_precision (x, y);
generic_wide_int <wide_int_ref_storage <wi::int_traits <T1>::is_sign_extended, wi::int_traits <T1>::host_dependent_precision> > xi (x, precision);
generic_wide_int <wide_int_ref_storage <wi::int_traits <T2>::is_sign_extended, wi::int_traits <T2>::host_dependent_precision> > yi (y, precision);
if ((__builtin_constant_p (yi.len == 1 && yi.val[0] >= 0) && (yi.len == 1 && yi.val[0] >= 0)))
return xi.len == 1 && xi.to_uhwi () < (unsigned long) yi.val[0];
if ((__builtin_constant_p (xi.len == 1 && xi.val[0] >= 0) && (xi.len == 1 && xi.val[0] >= 0)))
return yi.len != 1 || yi.to_uhwi () > (unsigned long) xi.val[0];
if (__builtin_expect (xi.len + yi.len == 2, true))
{
unsigned long xl = xi.to_uhwi ();
unsigned long yl = yi.to_uhwi ();
return xl < yl;
}
return ltu_p_large (xi.val, xi.len, precision, yi.val, yi.len);
}
template <typename T1, typename T2>
inline bool
wi::lt_p (const T1 &x, const T2 &y, signop sgn)
{
if (sgn == SIGNED)
return lts_p (x, y);
else
return ltu_p (x, y);
}
template <typename T1, typename T2>
inline bool
wi::les_p (const T1 &x, const T2 &y)
{
return !lts_p (y, x);
}
template <typename T1, typename T2>
inline bool
wi::leu_p (const T1 &x, const T2 &y)
{
return !ltu_p (y, x);
}
template <typename T1, typename T2>
inline bool
wi::le_p (const T1 &x, const T2 &y, signop sgn)
{
if (sgn == SIGNED)
return les_p (x, y);
else
return leu_p (x, y);
}
template <typename T1, typename T2>
inline bool
wi::gts_p (const T1 &x, const T2 &y)
{
return lts_p (y, x);
}
template <typename T1, typename T2>
inline bool
wi::gtu_p (const T1 &x, const T2 &y)
{
return ltu_p (y, x);
}
template <typename T1, typename T2>
inline bool
wi::gt_p (const T1 &x, const T2 &y, signop sgn)
{
if (sgn == SIGNED)
return gts_p (x, y);
else
return gtu_p (x, y);
}
template <typename T1, typename T2>
inline bool
wi::ges_p (const T1 &x, const T2 &y)
{
return !lts_p (x, y);
}
template <typename T1, typename T2>
inline bool
wi::geu_p (const T1 &x, const T2 &y)
{
return !ltu_p (x, y);
}
template <typename T1, typename T2>
inline bool
wi::ge_p (const T1 &x, const T2 &y, signop sgn)
{
if (sgn == SIGNED)
return ges_p (x, y);
else
return geu_p (x, y);
}
template <typename T1, typename T2>
inline int
wi::cmps (const T1 &x, const T2 &y)
{
unsigned int precision = get_binary_precision (x, y);
generic_wide_int <wide_int_ref_storage <wi::int_traits <T1>::is_sign_extended, wi::int_traits <T1>::host_dependent_precision> > xi (x, precision);
generic_wide_int <wide_int_ref_storage <wi::int_traits <T2>::is_sign_extended, wi::int_traits <T2>::host_dependent_precision> > yi (y, precision);
if (wi::fits_shwi_p (yi))
{
if ((__builtin_constant_p (yi.val[0] == 0) && (yi.val[0] == 0)))
return neg_p (xi) ? -1 : !(xi.len == 1 && xi.val[0] == 0);
if (wi::fits_shwi_p (xi))
{
long xl = xi.to_shwi ();
long yl = yi.to_shwi ();
return xl < yl ? -1 : xl > yl;
}
if (neg_p (xi))
return -1;
return 1;
}
if ((__builtin_constant_p (xi.len == 1) && (xi.len == 1)))
return neg_p (yi) ? 1 : -1;
return cmps_large (xi.val, xi.len, precision, yi.val, yi.len);
}
template <typename T1, typename T2>
inline int
wi::cmpu (const T1 &x, const T2 &y)
{
unsigned int precision = get_binary_precision (x, y);
generic_wide_int <wide_int_ref_storage <wi::int_traits <T1>::is_sign_extended, wi::int_traits <T1>::host_dependent_precision> > xi (x, precision);
generic_wide_int <wide_int_ref_storage <wi::int_traits <T2>::is_sign_extended, wi::int_traits <T2>::host_dependent_precision> > yi (y, precision);
if ((__builtin_constant_p (yi.len == 1 && yi.val[0] >= 0) && (yi.len == 1 && yi.val[0] >= 0)))
{
if (xi.len != 1)
return 1;
unsigned long xl = xi.to_uhwi ();
unsigned long yl = yi.val[0];
return xl < yl ? -1 : xl > yl;
}
if ((__builtin_constant_p (xi.len == 1 && xi.val[0] >= 0) && (xi.len == 1 && xi.val[0] >= 0)))
{
if (yi.len != 1)
return -1;
unsigned long xl = xi.val[0];
unsigned long yl = yi.to_uhwi ();
return xl < yl ? -1 : xl > yl;
}
if (__builtin_expect (xi.len + yi.len == 2, true))
{
unsigned long xl = xi.to_uhwi ();
unsigned long yl = yi.to_uhwi ();
return xl < yl ? -1 : xl > yl;
}
return cmpu_large (xi.val, xi.len, precision, yi.val, yi.len);
}
template <typename T1, typename T2>
inline int
wi::cmp (const T1 &x, const T2 &y, signop sgn)
{
if (sgn == SIGNED)
return cmps (x, y);
else
return cmpu (x, y);
}
template <typename T>
inline typename wi::binary_traits <T, T>::result_type
wi::bit_not (const T &x)
{
typename wi::binary_traits <T, T>::result_type result = wi::int_traits <typename wi::binary_traits <T, T>::result_type>::get_binary_result (x, x); long *val = result.write_val ();
generic_wide_int <wide_int_ref_storage <wi::int_traits <T>::is_sign_extended, wi::int_traits <T>::host_dependent_precision> > xi (x, get_precision (result));
for (unsigned int i = 0; i < xi.len; ++i)
val[i] = ~xi.val[i];
result.set_len (xi.len);
return result;
}
template <typename T>
inline typename wi::binary_traits <T, T>::result_type
wi::neg (const T &x)
{
return sub (0, x);
}
template <typename T>
inline typename wi::binary_traits <T, T>::result_type
wi::neg (const T &x, overflow_type *overflow)
{
*overflow = only_sign_bit_p (x) ? OVF_OVERFLOW : OVF_NONE;
return sub (0, x);
}
template <typename T>
inline typename wi::binary_traits <T, T>::result_type
wi::abs (const T &x)
{
return neg_p (x) ? neg (x) : typename wi::binary_traits <T, T>::result_type (x);
}
template <typename T>
inline typename wi::binary_traits <T, T>::result_type
wi::sext (const T &x, unsigned int offset)
{
typename wi::binary_traits <T, T>::result_type result = wi::int_traits <typename wi::binary_traits <T, T>::result_type>::get_binary_result (x, x); long *val = result.write_val ();
unsigned int precision = get_precision (result);
generic_wide_int <wide_int_ref_storage <wi::int_traits <T>::is_sign_extended, wi::int_traits <T>::host_dependent_precision> > xi (x, precision);
if (offset <= 64)
{
val[0] = sext_hwi (xi.ulow (), offset);
result.set_len (1, true);
}
else
result.set_len (sext_large (val, xi.val, xi.len, precision, offset));
return result;
}
template <typename T>
inline typename wi::binary_traits <T, T>::result_type
wi::zext (const T &x, unsigned int offset)
{
typename wi::binary_traits <T, T>::result_type result = wi::int_traits <typename wi::binary_traits <T, T>::result_type>::get_binary_result (x, x); long *val = result.write_val ();
unsigned int precision = get_precision (result);
generic_wide_int <wide_int_ref_storage <wi::int_traits <T>::is_sign_extended, wi::int_traits <T>::host_dependent_precision> > xi (x, precision);
if (offset >= precision)
{
wi::copy (result, xi);
return result;
}
if (offset < 64)
{
val[0] = zext_hwi (xi.ulow (), offset);
result.set_len (1, true);
}
else
result.set_len (zext_large (val, xi.val, xi.len, precision, offset), true);
return result;
}
template <typename T>
inline typename wi::binary_traits <T, T>::result_type
wi::ext (const T &x, unsigned int offset, signop sgn)
{
return sgn == SIGNED ? sext (x, offset) : zext (x, offset);
}
template <typename T>
inline typename wi::binary_traits <T, T>::result_type
wi::set_bit (const T &x, unsigned int bit)
{
typename wi::binary_traits <T, T>::result_type result = wi::int_traits <typename wi::binary_traits <T, T>::result_type>::get_binary_result (x, x); long *val = result.write_val ();
unsigned int precision = get_precision (result);
generic_wide_int <wide_int_ref_storage <wi::int_traits <T>::is_sign_extended, wi::int_traits <T>::host_dependent_precision> > xi (x, precision);
if (precision <= 64)
{
val[0] = xi.ulow () | (1UL << bit);
result.set_len (1);
}
else
result.set_len (set_bit_large (val, xi.val, xi.len, precision, bit));
return result;
}
template <typename T1, typename T2>
inline typename wi::binary_traits <T1, T2>::result_type
wi::min (const T1 &x, const T2 &y, signop sgn)
{
typename wi::binary_traits <T1, T2>::result_type result = wi::int_traits <typename wi::binary_traits <T1, T2>::result_type>::get_binary_result (x, y); long *val __attribute__ ((__unused__)) = result.write_val ();
unsigned int precision = get_precision (result);
if (wi::le_p (x, y, sgn))
wi::copy (result, generic_wide_int <wide_int_ref_storage <wi::int_traits <T1>::is_sign_extended, wi::int_traits <T1>::host_dependent_precision> > (x, precision));
else
wi::copy (result, generic_wide_int <wide_int_ref_storage <wi::int_traits <T2>::is_sign_extended, wi::int_traits <T2>::host_dependent_precision> > (y, precision));
return result;
}
template <typename T1, typename T2>
inline typename wi::binary_traits <T1, T2>::result_type
wi::smin (const T1 &x, const T2 &y)
{
return wi::min (x, y, SIGNED);
}
template <typename T1, typename T2>
inline typename wi::binary_traits <T1, T2>::result_type
wi::umin (const T1 &x, const T2 &y)
{
return wi::min (x, y, UNSIGNED);
}
template <typename T1, typename T2>
inline typename wi::binary_traits <T1, T2>::result_type
wi::max (const T1 &x, const T2 &y, signop sgn)
{
typename wi::binary_traits <T1, T2>::result_type result = wi::int_traits <typename wi::binary_traits <T1, T2>::result_type>::get_binary_result (x, y); long *val __attribute__ ((__unused__)) = result.write_val ();
unsigned int precision = get_precision (result);
if (wi::ge_p (x, y, sgn))
wi::copy (result, generic_wide_int <wide_int_ref_storage <wi::int_traits <T1>::is_sign_extended, wi::int_traits <T1>::host_dependent_precision> > (x, precision));
else
wi::copy (result, generic_wide_int <wide_int_ref_storage <wi::int_traits <T2>::is_sign_extended, wi::int_traits <T2>::host_dependent_precision> > (y, precision));
return result;
}
template <typename T1, typename T2>
inline typename wi::binary_traits <T1, T2>::result_type
wi::smax (const T1 &x, const T2 &y)
{
return wi::max (x, y, SIGNED);
}
template <typename T1, typename T2>
inline typename wi::binary_traits <T1, T2>::result_type
wi::umax (const T1 &x, const T2 &y)
{
return wi::max (x, y, UNSIGNED);
}
template <typename T1, typename T2>
inline typename wi::binary_traits <T1, T2>::result_type
wi::bit_and (const T1 &x, const T2 &y)
{
typename wi::binary_traits <T1, T2>::result_type result = wi::int_traits <typename wi::binary_traits <T1, T2>::result_type>::get_binary_result (x, y); long *val = result.write_val ();
unsigned int precision = get_precision (result);
generic_wide_int <wide_int_ref_storage <wi::int_traits <T1>::is_sign_extended, wi::int_traits <T1>::host_dependent_precision> > xi (x, precision);
generic_wide_int <wide_int_ref_storage <wi::int_traits <T2>::is_sign_extended, wi::int_traits <T2>::host_dependent_precision> > yi (y, precision);
bool is_sign_extended = xi.is_sign_extended && yi.is_sign_extended;
if (__builtin_expect (xi.len + yi.len == 2, true))
{
val[0] = xi.ulow () & yi.ulow ();
result.set_len (1, is_sign_extended);
}
else
result.set_len (and_large (val, xi.val, xi.len, yi.val, yi.len,
precision), is_sign_extended);
return result;
}
template <typename T1, typename T2>
inline typename wi::binary_traits <T1, T2>::result_type
wi::bit_and_not (const T1 &x, const T2 &y)
{
typename wi::binary_traits <T1, T2>::result_type result = wi::int_traits <typename wi::binary_traits <T1, T2>::result_type>::get_binary_result (x, y); long *val = result.write_val ();
unsigned int precision = get_precision (result);
generic_wide_int <wide_int_ref_storage <wi::int_traits <T1>::is_sign_extended, wi::int_traits <T1>::host_dependent_precision> > xi (x, precision);
generic_wide_int <wide_int_ref_storage <wi::int_traits <T2>::is_sign_extended, wi::int_traits <T2>::host_dependent_precision> > yi (y, precision);
bool is_sign_extended = xi.is_sign_extended && yi.is_sign_extended;
if (__builtin_expect (xi.len + yi.len == 2, true))
{
val[0] = xi.ulow () & ~yi.ulow ();
result.set_len (1, is_sign_extended);
}
else
result.set_len (and_not_large (val, xi.val, xi.len, yi.val, yi.len,
precision), is_sign_extended);
return result;
}
template <typename T1, typename T2>
inline typename wi::binary_traits <T1, T2>::result_type
wi::bit_or (const T1 &x, const T2 &y)
{
typename wi::binary_traits <T1, T2>::result_type result = wi::int_traits <typename wi::binary_traits <T1, T2>::result_type>::get_binary_result (x, y); long *val = result.write_val ();
unsigned int precision = get_precision (result);
generic_wide_int <wide_int_ref_storage <wi::int_traits <T1>::is_sign_extended, wi::int_traits <T1>::host_dependent_precision> > xi (x, precision);
generic_wide_int <wide_int_ref_storage <wi::int_traits <T2>::is_sign_extended, wi::int_traits <T2>::host_dependent_precision> > yi (y, precision);
bool is_sign_extended = xi.is_sign_extended && yi.is_sign_extended;
if (__builtin_expect (xi.len + yi.len == 2, true))
{
val[0] = xi.ulow () | yi.ulow ();
result.set_len (1, is_sign_extended);
}
else
result.set_len (or_large (val, xi.val, xi.len,
yi.val, yi.len, precision), is_sign_extended);
return result;
}
template <typename T1, typename T2>
inline typename wi::binary_traits <T1, T2>::result_type
wi::bit_or_not (const T1 &x, const T2 &y)
{
typename wi::binary_traits <T1, T2>::result_type result = wi::int_traits <typename wi::binary_traits <T1, T2>::result_type>::get_binary_result (x, y); long *val = result.write_val ();
unsigned int precision = get_precision (result);
generic_wide_int <wide_int_ref_storage <wi::int_traits <T1>::is_sign_extended, wi::int_traits <T1>::host_dependent_precision> > xi (x, precision);
generic_wide_int <wide_int_ref_storage <wi::int_traits <T2>::is_sign_extended, wi::int_traits <T2>::host_dependent_precision> > yi (y, precision);
bool is_sign_extended = xi.is_sign_extended && yi.is_sign_extended;
if (__builtin_expect (xi.len + yi.len == 2, true))
{
val[0] = xi.ulow () | ~yi.ulow ();
result.set_len (1, is_sign_extended);
}
else
result.set_len (or_not_large (val, xi.val, xi.len, yi.val, yi.len,
precision), is_sign_extended);
return result;
}
template <typename T1, typename T2>
inline typename wi::binary_traits <T1, T2>::result_type
wi::bit_xor (const T1 &x, const T2 &y)
{
typename wi::binary_traits <T1, T2>::result_type result = wi::int_traits <typename wi::binary_traits <T1, T2>::result_type>::get_binary_result (x, y); long *val = result.write_val ();
unsigned int precision = get_precision (result);
generic_wide_int <wide_int_ref_storage <wi::int_traits <T1>::is_sign_extended, wi::int_traits <T1>::host_dependent_precision> > xi (x, precision);
generic_wide_int <wide_int_ref_storage <wi::int_traits <T2>::is_sign_extended, wi::int_traits <T2>::host_dependent_precision> > yi (y, precision);
bool is_sign_extended = xi.is_sign_extended && yi.is_sign_extended;
if (__builtin_expect (xi.len + yi.len == 2, true))
{
val[0] = xi.ulow () ^ yi.ulow ();
result.set_len (1, is_sign_extended);
}
else
result.set_len (xor_large (val, xi.val, xi.len,
yi.val, yi.len, precision), is_sign_extended);
return result;
}
template <typename T1, typename T2>
inline typename wi::binary_traits <T1, T2>::result_type
wi::add (const T1 &x, const T2 &y)
{
typename wi::binary_traits <T1, T2>::result_type result = wi::int_traits <typename wi::binary_traits <T1, T2>::result_type>::get_binary_result (x, y); long *val = result.write_val ();
unsigned int precision = get_precision (result);
generic_wide_int <wide_int_ref_storage <wi::int_traits <T1>::is_sign_extended, wi::int_traits <T1>::host_dependent_precision> > xi (x, precision);
generic_wide_int <wide_int_ref_storage <wi::int_traits <T2>::is_sign_extended, wi::int_traits <T2>::host_dependent_precision> > yi (y, precision);
if (precision <= 64)
{
val[0] = xi.ulow () + yi.ulow ();
result.set_len (1);
}
# 2441 "/home/giulianob/gcc_git_gnu/gcc/gcc/wide-int.h"
else if ((__builtin_constant_p (precision > 64) && (precision > 64))
&& __builtin_expect (xi.len + yi.len == 2, true))
{
unsigned long xl = xi.ulow ();
unsigned long yl = yi.ulow ();
unsigned long resultl = xl + yl;
val[0] = resultl;
val[1] = (long) resultl < 0 ? 0 : -1;
result.set_len (1 + (((resultl ^ xl) & (resultl ^ yl))
>> (64 - 1)));
}
else
result.set_len (add_large (val, xi.val, xi.len,
yi.val, yi.len, precision,
UNSIGNED, 0));
return result;
}
template <typename T1, typename T2>
inline typename wi::binary_traits <T1, T2>::result_type
wi::add (const T1 &x, const T2 &y, signop sgn, overflow_type *overflow)
{
typename wi::binary_traits <T1, T2>::result_type result = wi::int_traits <typename wi::binary_traits <T1, T2>::result_type>::get_binary_result (x, y); long *val = result.write_val ();
unsigned int precision = get_precision (result);
generic_wide_int <wide_int_ref_storage <wi::int_traits <T1>::is_sign_extended, wi::int_traits <T1>::host_dependent_precision> > xi (x, precision);
generic_wide_int <wide_int_ref_storage <wi::int_traits <T2>::is_sign_extended, wi::int_traits <T2>::host_dependent_precision> > yi (y, precision);
if (precision <= 64)
{
unsigned long xl = xi.ulow ();
unsigned long yl = yi.ulow ();
unsigned long resultl = xl + yl;
if (sgn == SIGNED)
{
if ((((resultl ^ xl) & (resultl ^ yl))
>> (precision - 1)) & 1)
{
if (xl > resultl)
*overflow = OVF_UNDERFLOW;
else if (xl < resultl)
*overflow = OVF_OVERFLOW;
else
*overflow = OVF_NONE;
}
else
*overflow = OVF_NONE;
}
else
*overflow = ((resultl << (64 - precision))
< (xl << (64 - precision)))
? OVF_OVERFLOW : OVF_NONE;
val[0] = resultl;
result.set_len (1);
}
else
result.set_len (add_large (val, xi.val, xi.len,
yi.val, yi.len, precision,
sgn, overflow));
return result;
}
template <typename T1, typename T2>
inline typename wi::binary_traits <T1, T2>::result_type
wi::sub (const T1 &x, const T2 &y)
{
typename wi::binary_traits <T1, T2>::result_type result = wi::int_traits <typename wi::binary_traits <T1, T2>::result_type>::get_binary_result (x, y); long *val = result.write_val ();
unsigned int precision = get_precision (result);
generic_wide_int <wide_int_ref_storage <wi::int_traits <T1>::is_sign_extended, wi::int_traits <T1>::host_dependent_precision> > xi (x, precision);
generic_wide_int <wide_int_ref_storage <wi::int_traits <T2>::is_sign_extended, wi::int_traits <T2>::host_dependent_precision> > yi (y, precision);
if (precision <= 64)
{
val[0] = xi.ulow () - yi.ulow ();
result.set_len (1);
}
# 2527 "/home/giulianob/gcc_git_gnu/gcc/gcc/wide-int.h"
else if ((__builtin_constant_p (precision > 64) && (precision > 64))
&& __builtin_expect (xi.len + yi.len == 2, true))
{
unsigned long xl = xi.ulow ();
unsigned long yl = yi.ulow ();
unsigned long resultl = xl - yl;
val[0] = resultl;
val[1] = (long) resultl < 0 ? 0 : -1;
result.set_len (1 + (((resultl ^ xl) & (xl ^ yl))
>> (64 - 1)));
}
else
result.set_len (sub_large (val, xi.val, xi.len,
yi.val, yi.len, precision,
UNSIGNED, 0));
return result;
}
template <typename T1, typename T2>
inline typename wi::binary_traits <T1, T2>::result_type
wi::sub (const T1 &x, const T2 &y, signop sgn, overflow_type *overflow)
{
typename wi::binary_traits <T1, T2>::result_type result = wi::int_traits <typename wi::binary_traits <T1, T2>::result_type>::get_binary_result (x, y); long *val = result.write_val ();
unsigned int precision = get_precision (result);
generic_wide_int <wide_int_ref_storage <wi::int_traits <T1>::is_sign_extended, wi::int_traits <T1>::host_dependent_precision> > xi (x, precision);
generic_wide_int <wide_int_ref_storage <wi::int_traits <T2>::is_sign_extended, wi::int_traits <T2>::host_dependent_precision> > yi (y, precision);
if (precision <= 64)
{
unsigned long xl = xi.ulow ();
unsigned long yl = yi.ulow ();
unsigned long resultl = xl - yl;
if (sgn == SIGNED)
{
if ((((xl ^ yl) & (resultl ^ xl)) >> (precision - 1)) & 1)
{
if (xl > yl)
*overflow = OVF_UNDERFLOW;
else if (xl < yl)
*overflow = OVF_OVERFLOW;
else
*overflow = OVF_NONE;
}
else
*overflow = OVF_NONE;
}
else
*overflow = ((resultl << (64 - precision))
> (xl << (64 - precision)))
? OVF_UNDERFLOW : OVF_NONE;
val[0] = resultl;
result.set_len (1);
}
else
result.set_len (sub_large (val, xi.val, xi.len,
yi.val, yi.len, precision,
sgn, overflow));
return result;
}
template <typename T1, typename T2>
inline typename wi::binary_traits <T1, T2>::result_type
wi::mul (const T1 &x, const T2 &y)
{
typename wi::binary_traits <T1, T2>::result_type result = wi::int_traits <typename wi::binary_traits <T1, T2>::result_type>::get_binary_result (x, y); long *val = result.write_val ();
unsigned int precision = get_precision (result);
generic_wide_int <wide_int_ref_storage <wi::int_traits <T1>::is_sign_extended, wi::int_traits <T1>::host_dependent_precision> > xi (x, precision);
generic_wide_int <wide_int_ref_storage <wi::int_traits <T2>::is_sign_extended, wi::int_traits <T2>::host_dependent_precision> > yi (y, precision);
if (precision <= 64)
{
val[0] = xi.ulow () * yi.ulow ();
result.set_len (1);
}
else
result.set_len (mul_internal (val, xi.val, xi.len, yi.val, yi.len,
precision, UNSIGNED, 0, false));
return result;
}
template <typename T1, typename T2>
inline typename wi::binary_traits <T1, T2>::result_type
wi::mul (const T1 &x, const T2 &y, signop sgn, overflow_type *overflow)
{
typename wi::binary_traits <T1, T2>::result_type result = wi::int_traits <typename wi::binary_traits <T1, T2>::result_type>::get_binary_result (x, y); long *val = result.write_val ();
unsigned int precision = get_precision (result);
generic_wide_int <wide_int_ref_storage <wi::int_traits <T1>::is_sign_extended, wi::int_traits <T1>::host_dependent_precision> > xi (x, precision);
generic_wide_int <wide_int_ref_storage <wi::int_traits <T2>::is_sign_extended, wi::int_traits <T2>::host_dependent_precision> > yi (y, precision);
result.set_len (mul_internal (val, xi.val, xi.len,
yi.val, yi.len, precision,
sgn, overflow, false));
return result;
}
template <typename T1, typename T2>
inline typename wi::binary_traits <T1, T2>::result_type
wi::smul (const T1 &x, const T2 &y, overflow_type *overflow)
{
return mul (x, y, SIGNED, overflow);
}
template <typename T1, typename T2>
inline typename wi::binary_traits <T1, T2>::result_type
wi::umul (const T1 &x, const T2 &y, overflow_type *overflow)
{
return mul (x, y, UNSIGNED, overflow);
}
template <typename T1, typename T2>
inline typename wi::binary_traits <T1, T2>::result_type
wi::mul_high (const T1 &x, const T2 &y, signop sgn)
{
typename wi::binary_traits <T1, T2>::result_type result = wi::int_traits <typename wi::binary_traits <T1, T2>::result_type>::get_binary_result (x, y); long *val = result.write_val ();
unsigned int precision = get_precision (result);
generic_wide_int <wide_int_ref_storage <wi::int_traits <T1>::is_sign_extended, wi::int_traits <T1>::host_dependent_precision> > xi (x, precision);
generic_wide_int <wide_int_ref_storage <wi::int_traits <T2>::is_sign_extended, wi::int_traits <T2>::host_dependent_precision> > yi (y, precision);
result.set_len (mul_internal (val, xi.val, xi.len,
yi.val, yi.len, precision,
sgn, 0, true));
return result;
}
template <typename T1, typename T2>
inline typename wi::binary_traits <T1, T2>::result_type
wi::div_trunc (const T1 &x, const T2 &y, signop sgn, overflow_type *overflow)
{
typename wi::binary_traits <T1, T2>::result_type quotient = wi::int_traits <typename wi::binary_traits <T1, T2>::result_type>::get_binary_result (x, y); long *quotient_val = quotient.write_val ();
unsigned int precision = get_precision (quotient);
generic_wide_int <wide_int_ref_storage <wi::int_traits <T1>::is_sign_extended, wi::int_traits <T1>::host_dependent_precision> > xi (x, precision);
generic_wide_int <wide_int_ref_storage <wi::int_traits <T2>::is_sign_extended, wi::int_traits <T2>::host_dependent_precision> > yi (y);
quotient.set_len (divmod_internal (quotient_val, 0, 0, xi.val, xi.len,
precision,
yi.val, yi.len, yi.precision,
sgn, overflow));
return quotient;
}
template <typename T1, typename T2>
inline typename wi::binary_traits <T1, T2>::result_type
wi::sdiv_trunc (const T1 &x, const T2 &y)
{
return div_trunc (x, y, SIGNED);
}
template <typename T1, typename T2>
inline typename wi::binary_traits <T1, T2>::result_type
wi::udiv_trunc (const T1 &x, const T2 &y)
{
return div_trunc (x, y, UNSIGNED);
}
template <typename T1, typename T2>
inline typename wi::binary_traits <T1, T2>::result_type
wi::div_floor (const T1 &x, const T2 &y, signop sgn, overflow_type *overflow)
{
typename wi::binary_traits <T1, T2>::result_type quotient = wi::int_traits <typename wi::binary_traits <T1, T2>::result_type>::get_binary_result (x, y); long *quotient_val = quotient.write_val ();
typename wi::binary_traits <T1, T2>::result_type remainder = wi::int_traits <typename wi::binary_traits <T1, T2>::result_type>::get_binary_result (x, y); long *remainder_val = remainder.write_val ();
unsigned int precision = get_precision (quotient);
generic_wide_int <wide_int_ref_storage <wi::int_traits <T1>::is_sign_extended, wi::int_traits <T1>::host_dependent_precision> > xi (x, precision);
generic_wide_int <wide_int_ref_storage <wi::int_traits <T2>::is_sign_extended, wi::int_traits <T2>::host_dependent_precision> > yi (y);
unsigned int remainder_len;
quotient.set_len (divmod_internal (quotient_val,
&remainder_len, remainder_val,
xi.val, xi.len, precision,
yi.val, yi.len, yi.precision, sgn,
overflow));
remainder.set_len (remainder_len);
if (wi::neg_p (x, sgn) != wi::neg_p (y, sgn) && remainder != 0)
return quotient - 1;
return quotient;
}
template <typename T1, typename T2>
inline typename wi::binary_traits <T1, T2>::result_type
wi::sdiv_floor (const T1 &x, const T2 &y)
{
return div_floor (x, y, SIGNED);
}
template <typename T1, typename T2>
inline typename wi::binary_traits <T1, T2>::result_type
wi::udiv_floor (const T1 &x, const T2 &y)
{
return div_floor (x, y, UNSIGNED);
}
template <typename T1, typename T2>
inline typename wi::binary_traits <T1, T2>::result_type
wi::div_ceil (const T1 &x, const T2 &y, signop sgn, overflow_type *overflow)
{
typename wi::binary_traits <T1, T2>::result_type quotient = wi::int_traits <typename wi::binary_traits <T1, T2>::result_type>::get_binary_result (x, y); long *quotient_val = quotient.write_val ();
typename wi::binary_traits <T1, T2>::result_type remainder = wi::int_traits <typename wi::binary_traits <T1, T2>::result_type>::get_binary_result (x, y); long *remainder_val = remainder.write_val ();
unsigned int precision = get_precision (quotient);
generic_wide_int <wide_int_ref_storage <wi::int_traits <T1>::is_sign_extended, wi::int_traits <T1>::host_dependent_precision> > xi (x, precision);
generic_wide_int <wide_int_ref_storage <wi::int_traits <T2>::is_sign_extended, wi::int_traits <T2>::host_dependent_precision> > yi (y);
unsigned int remainder_len;
quotient.set_len (divmod_internal (quotient_val,
&remainder_len, remainder_val,
xi.val, xi.len, precision,
yi.val, yi.len, yi.precision, sgn,
overflow));
remainder.set_len (remainder_len);
if (wi::neg_p (x, sgn) == wi::neg_p (y, sgn) && remainder != 0)
return quotient + 1;
return quotient;
}
template <typename T1, typename T2>
inline typename wi::binary_traits <T1, T2>::result_type
wi::udiv_ceil (const T1 &x, const T2 &y)
{
return div_ceil (x, y, UNSIGNED);
}
template <typename T1, typename T2>
inline typename wi::binary_traits <T1, T2>::result_type
wi::div_round (const T1 &x, const T2 &y, signop sgn, overflow_type *overflow)
{
typename wi::binary_traits <T1, T2>::result_type quotient = wi::int_traits <typename wi::binary_traits <T1, T2>::result_type>::get_binary_result (x, y); long *quotient_val = quotient.write_val ();
typename wi::binary_traits <T1, T2>::result_type remainder = wi::int_traits <typename wi::binary_traits <T1, T2>::result_type>::get_binary_result (x, y); long *remainder_val = remainder.write_val ();
unsigned int precision = get_precision (quotient);
generic_wide_int <wide_int_ref_storage <wi::int_traits <T1>::is_sign_extended, wi::int_traits <T1>::host_dependent_precision> > xi (x, precision);
generic_wide_int <wide_int_ref_storage <wi::int_traits <T2>::is_sign_extended, wi::int_traits <T2>::host_dependent_precision> > yi (y);
unsigned int remainder_len;
quotient.set_len (divmod_internal (quotient_val,
&remainder_len, remainder_val,
xi.val, xi.len, precision,
yi.val, yi.len, yi.precision, sgn,
overflow));
remainder.set_len (remainder_len);
if (remainder != 0)
{
if (sgn == SIGNED)
{
typename wi::binary_traits <T1, T2>::result_type abs_remainder = wi::abs (remainder);
if (wi::geu_p (abs_remainder, wi::sub (wi::abs (y), abs_remainder)))
{
if (wi::neg_p (x, sgn) != wi::neg_p (y, sgn))
return quotient - 1;
else
return quotient + 1;
}
}
else
{
if (wi::geu_p (remainder, wi::sub (y, remainder)))
return quotient + 1;
}
}
return quotient;
}
template <typename T1, typename T2>
inline typename wi::binary_traits <T1, T2>::result_type
wi::divmod_trunc (const T1 &x, const T2 &y, signop sgn,
typename wi::binary_traits <T1, T2>::result_type *remainder_ptr)
{
typename wi::binary_traits <T1, T2>::result_type quotient = wi::int_traits <typename wi::binary_traits <T1, T2>::result_type>::get_binary_result (x, y); long *quotient_val = quotient.write_val ();
typename wi::binary_traits <T1, T2>::result_type remainder = wi::int_traits <typename wi::binary_traits <T1, T2>::result_type>::get_binary_result (x, y); long *remainder_val = remainder.write_val ();
unsigned int precision = get_precision (quotient);
generic_wide_int <wide_int_ref_storage <wi::int_traits <T1>::is_sign_extended, wi::int_traits <T1>::host_dependent_precision> > xi (x, precision);
generic_wide_int <wide_int_ref_storage <wi::int_traits <T2>::is_sign_extended, wi::int_traits <T2>::host_dependent_precision> > yi (y);
unsigned int remainder_len;
quotient.set_len (divmod_internal (quotient_val,
&remainder_len, remainder_val,
xi.val, xi.len, precision,
yi.val, yi.len, yi.precision, sgn, 0));
remainder.set_len (remainder_len);
*remainder_ptr = remainder;
return quotient;
}
template <typename T1, typename T2>
inline typename wi::binary_traits <T1, T2>::result_type
wi::gcd (const T1 &a, const T2 &b, signop sgn)
{
T1 x, y, z;
x = wi::abs (a);
y = wi::abs (b);
while (gt_p (x, 0, sgn))
{
z = mod_trunc (y, x, sgn);
y = x;
x = z;
}
return y;
}
template <typename T1, typename T2>
inline typename wi::binary_traits <T1, T2>::result_type
wi::mod_trunc (const T1 &x, const T2 &y, signop sgn, overflow_type *overflow)
{
typename wi::binary_traits <T1, T2>::result_type remainder = wi::int_traits <typename wi::binary_traits <T1, T2>::result_type>::get_binary_result (x, y); long *remainder_val = remainder.write_val ();
unsigned int precision = get_precision (remainder);
generic_wide_int <wide_int_ref_storage <wi::int_traits <T1>::is_sign_extended, wi::int_traits <T1>::host_dependent_precision> > xi (x, precision);
generic_wide_int <wide_int_ref_storage <wi::int_traits <T2>::is_sign_extended, wi::int_traits <T2>::host_dependent_precision> > yi (y);
unsigned int remainder_len;
divmod_internal (0, &remainder_len, remainder_val,
xi.val, xi.len, precision,
yi.val, yi.len, yi.precision, sgn, overflow);
remainder.set_len (remainder_len);
return remainder;
}
template <typename T1, typename T2>
inline typename wi::binary_traits <T1, T2>::result_type
wi::smod_trunc (const T1 &x, const T2 &y)
{
return mod_trunc (x, y, SIGNED);
}
template <typename T1, typename T2>
inline typename wi::binary_traits <T1, T2>::result_type
wi::umod_trunc (const T1 &x, const T2 &y)
{
return mod_trunc (x, y, UNSIGNED);
}
template <typename T1, typename T2>
inline typename wi::binary_traits <T1, T2>::result_type
wi::mod_floor (const T1 &x, const T2 &y, signop sgn, overflow_type *overflow)
{
typename wi::binary_traits <T1, T2>::result_type quotient = wi::int_traits <typename wi::binary_traits <T1, T2>::result_type>::get_binary_result (x, y); long *quotient_val = quotient.write_val ();
typename wi::binary_traits <T1, T2>::result_type remainder = wi::int_traits <typename wi::binary_traits <T1, T2>::result_type>::get_binary_result (x, y); long *remainder_val = remainder.write_val ();
unsigned int precision = get_precision (quotient);
generic_wide_int <wide_int_ref_storage <wi::int_traits <T1>::is_sign_extended, wi::int_traits <T1>::host_dependent_precision> > xi (x, precision);
generic_wide_int <wide_int_ref_storage <wi::int_traits <T2>::is_sign_extended, wi::int_traits <T2>::host_dependent_precision> > yi (y);
unsigned int remainder_len;
quotient.set_len (divmod_internal (quotient_val,
&remainder_len, remainder_val,
xi.val, xi.len, precision,
yi.val, yi.len, yi.precision, sgn,
overflow));
remainder.set_len (remainder_len);
if (wi::neg_p (x, sgn) != wi::neg_p (y, sgn) && remainder != 0)
return remainder + y;
return remainder;
}
template <typename T1, typename T2>
inline typename wi::binary_traits <T1, T2>::result_type
wi::umod_floor (const T1 &x, const T2 &y)
{
return mod_floor (x, y, UNSIGNED);
}
template <typename T1, typename T2>
inline typename wi::binary_traits <T1, T2>::result_type
wi::mod_ceil (const T1 &x, const T2 &y, signop sgn, overflow_type *overflow)
{
typename wi::binary_traits <T1, T2>::result_type quotient = wi::int_traits <typename wi::binary_traits <T1, T2>::result_type>::get_binary_result (x, y); long *quotient_val = quotient.write_val ();
typename wi::binary_traits <T1, T2>::result_type remainder = wi::int_traits <typename wi::binary_traits <T1, T2>::result_type>::get_binary_result (x, y); long *remainder_val = remainder.write_val ();
unsigned int precision = get_precision (quotient);
generic_wide_int <wide_int_ref_storage <wi::int_traits <T1>::is_sign_extended, wi::int_traits <T1>::host_dependent_precision> > xi (x, precision);
generic_wide_int <wide_int_ref_storage <wi::int_traits <T2>::is_sign_extended, wi::int_traits <T2>::host_dependent_precision> > yi (y);
unsigned int remainder_len;
quotient.set_len (divmod_internal (quotient_val,
&remainder_len, remainder_val,
xi.val, xi.len, precision,
yi.val, yi.len, yi.precision, sgn,
overflow));
remainder.set_len (remainder_len);
if (wi::neg_p (x, sgn) == wi::neg_p (y, sgn) && remainder != 0)
return remainder - y;
return remainder;
}
template <typename T1, typename T2>
inline typename wi::binary_traits <T1, T2>::result_type
wi::mod_round (const T1 &x, const T2 &y, signop sgn, overflow_type *overflow)
{
typename wi::binary_traits <T1, T2>::result_type quotient = wi::int_traits <typename wi::binary_traits <T1, T2>::result_type>::get_binary_result (x, y); long *quotient_val = quotient.write_val ();
typename wi::binary_traits <T1, T2>::result_type remainder = wi::int_traits <typename wi::binary_traits <T1, T2>::result_type>::get_binary_result (x, y); long *remainder_val = remainder.write_val ();
unsigned int precision = get_precision (quotient);
generic_wide_int <wide_int_ref_storage <wi::int_traits <T1>::is_sign_extended, wi::int_traits <T1>::host_dependent_precision> > xi (x, precision);
generic_wide_int <wide_int_ref_storage <wi::int_traits <T2>::is_sign_extended, wi::int_traits <T2>::host_dependent_precision> > yi (y);
unsigned int remainder_len;
quotient.set_len (divmod_internal (quotient_val,
&remainder_len, remainder_val,
xi.val, xi.len, precision,
yi.val, yi.len, yi.precision, sgn,
overflow));
remainder.set_len (remainder_len);
if (remainder != 0)
{
if (sgn == SIGNED)
{
typename wi::binary_traits <T1, T2>::result_type abs_remainder = wi::abs (remainder);
if (wi::geu_p (abs_remainder, wi::sub (wi::abs (y), abs_remainder)))
{
if (wi::neg_p (x, sgn) != wi::neg_p (y, sgn))
return remainder + y;
else
return remainder - y;
}
}
else
{
if (wi::geu_p (remainder, wi::sub (y, remainder)))
return remainder - y;
}
}
return remainder;
}
template <typename T1, typename T2>
inline bool
wi::multiple_of_p (const T1 &x, const T2 &y, signop sgn)
{
return wi::mod_trunc (x, y, sgn) == 0;
}
template <typename T1, typename T2>
inline bool
wi::multiple_of_p (const T1 &x, const T2 &y, signop sgn,
typename wi::binary_traits <T1, T2>::result_type *res)
{
typename wi::binary_traits <T1, T2>::result_type remainder;
typename wi::binary_traits <T1, T2>::result_type quotient
= divmod_trunc (x, y, sgn, &remainder);
if (remainder == 0)
{
*res = quotient;
return true;
}
return false;
}
template <typename T1, typename T2>
inline typename wi::binary_traits <T1, T1>::result_type
wi::lshift (const T1 &x, const T2 &y)
{
typename wi::binary_traits <T1, T1>::result_type result = wi::int_traits <typename wi::binary_traits <T1, T1>::result_type>::get_binary_result (x, x); long *val = result.write_val ();
unsigned int precision = get_precision (result);
generic_wide_int <wide_int_ref_storage <wi::int_traits <T1>::is_sign_extended, wi::int_traits <T1>::host_dependent_precision> > xi (x, precision);
generic_wide_int <wide_int_ref_storage <wi::int_traits <T2>::is_sign_extended, wi::int_traits <T2>::host_dependent_precision> > yi (y);
if (geu_p (yi, precision))
{
val[0] = 0;
result.set_len (1);
}
else
{
unsigned int shift = yi.to_uhwi ();
# 3054 "/home/giulianob/gcc_git_gnu/gcc/gcc/wide-int.h"
if ((__builtin_constant_p (xi.precision > 64) && (xi.precision > 64))
? ((__builtin_constant_p (shift < 64 - 1) && (shift < 64 - 1))
&& xi.len == 1
&& ((unsigned long) (xi.val[0]) - (unsigned long) (0) <= (unsigned long) ((~((long) (1UL << (64 - 1)))) >> shift) - (unsigned long) (0)))
: precision <= 64)
{
val[0] = xi.ulow () << shift;
result.set_len (1);
}
else
result.set_len (lshift_large (val, xi.val, xi.len,
precision, shift));
}
return result;
}
template <typename T1, typename T2>
inline typename wi::binary_traits <T1, T1>::result_type
wi::lrshift (const T1 &x, const T2 &y)
{
typename wi::binary_traits <T1, T1>::result_type result = wi::int_traits <typename wi::binary_traits <T1, T1>::result_type>::get_binary_result (x, x); long *val = result.write_val ();
generic_wide_int <wide_int_ref_storage <wi::int_traits <T1>::is_sign_extended, wi::int_traits <T1>::host_dependent_precision> > xi (x);
generic_wide_int <wide_int_ref_storage <wi::int_traits <T2>::is_sign_extended, wi::int_traits <T2>::host_dependent_precision> > yi (y);
if (geu_p (yi, xi.precision))
{
val[0] = 0;
result.set_len (1);
}
else
{
unsigned int shift = yi.to_uhwi ();
# 3098 "/home/giulianob/gcc_git_gnu/gcc/gcc/wide-int.h"
if ((__builtin_constant_p (xi.precision > 64) && (xi.precision > 64))
? (shift < 64
&& xi.len == 1
&& xi.val[0] >= 0)
: xi.precision <= 64)
{
val[0] = xi.to_uhwi () >> shift;
result.set_len (1);
}
else
result.set_len (lrshift_large (val, xi.val, xi.len, xi.precision,
get_precision (result), shift));
}
return result;
}
template <typename T1, typename T2>
inline typename wi::binary_traits <T1, T1>::result_type
wi::arshift (const T1 &x, const T2 &y)
{
typename wi::binary_traits <T1, T1>::result_type result = wi::int_traits <typename wi::binary_traits <T1, T1>::result_type>::get_binary_result (x, x); long *val = result.write_val ();
generic_wide_int <wide_int_ref_storage <wi::int_traits <T1>::is_sign_extended, wi::int_traits <T1>::host_dependent_precision> > xi (x);
generic_wide_int <wide_int_ref_storage <wi::int_traits <T2>::is_sign_extended, wi::int_traits <T2>::host_dependent_precision> > yi (y);
if (geu_p (yi, xi.precision))
{
val[0] = sign_mask (x);
result.set_len (1);
}
else
{
unsigned int shift = yi.to_uhwi ();
if (xi.precision <= 64)
{
val[0] = sext_hwi (xi.ulow () >> shift, xi.precision - shift);
result.set_len (1, true);
}
else
result.set_len (arshift_large (val, xi.val, xi.len, xi.precision,
get_precision (result), shift));
}
return result;
}
template <typename T1, typename T2>
inline typename wi::binary_traits <T1, T1>::result_type
wi::rshift (const T1 &x, const T2 &y, signop sgn)
{
if (sgn == UNSIGNED)
return lrshift (x, y);
else
return arshift (x, y);
}
template <typename T1, typename T2>
typename wi::binary_traits <T1, T1>::result_type
wi::lrotate (const T1 &x, const T2 &y, unsigned int width)
{
unsigned int precision = get_binary_precision (x, x);
if (width == 0)
width = precision;
typename wi::binary_traits <T2, T2>::result_type ymod = umod_trunc (y, width);
typename wi::binary_traits <T1, T1>::result_type left = wi::lshift (x, ymod);
typename wi::binary_traits <T1, T1>::result_type right = wi::lrshift (x, wi::sub (width, ymod));
if (width != precision)
return wi::zext (left, width) | wi::zext (right, width);
return left | right;
}
template <typename T1, typename T2>
typename wi::binary_traits <T1, T1>::result_type
wi::rrotate (const T1 &x, const T2 &y, unsigned int width)
{
unsigned int precision = get_binary_precision (x, x);
if (width == 0)
width = precision;
typename wi::binary_traits <T2, T2>::result_type ymod = umod_trunc (y, width);
typename wi::binary_traits <T1, T1>::result_type right = wi::lrshift (x, ymod);
typename wi::binary_traits <T1, T1>::result_type left = wi::lshift (x, wi::sub (width, ymod));
if (width != precision)
return wi::zext (left, width) | wi::zext (right, width);
return left | right;
}
inline int
wi::parity (const wide_int_ref &x)
{
return popcount (x) & 1;
}
template <typename T>
inline unsigned long
wi::extract_uhwi (const T &x, unsigned int bitpos, unsigned int width)
{
unsigned precision = get_precision (x);
if (precision < bitpos + width)
precision = bitpos + width;
generic_wide_int <wide_int_ref_storage <wi::int_traits <T>::is_sign_extended, wi::int_traits <T>::host_dependent_precision> > xi (x, precision);
if (width == 0)
return 0;
unsigned int start = bitpos / 64;
unsigned int shift = bitpos % 64;
unsigned long res = xi.elt (start);
res >>= shift;
if (shift + width > 64)
{
unsigned long upper = xi.elt (start + 1);
res |= upper << (-shift % 64);
}
return zext_hwi (res, width);
}
template <typename T>
inline unsigned int
wi::min_precision (const T &x, signop sgn)
{
if (sgn == SIGNED)
return get_precision (x) - clrsb (x);
else
return get_precision (x) - clz (x);
}
# 3248 "/home/giulianob/gcc_git_gnu/gcc/gcc/wide-int.h"
template <typename T1, typename T2> inline typename wi::binary_traits <T1, T2>::signed_predicate_result operator < (const T1 &x, const T2 &y) { return wi::lts_p (x, y); }
template <typename T1, typename T2> inline typename wi::binary_traits <T1, T2>::signed_predicate_result operator <= (const T1 &x, const T2 &y) { return wi::les_p (x, y); }
template <typename T1, typename T2> inline typename wi::binary_traits <T1, T2>::signed_predicate_result operator > (const T1 &x, const T2 &y) { return wi::gts_p (x, y); }
template <typename T1, typename T2> inline typename wi::binary_traits <T1, T2>::signed_predicate_result operator >= (const T1 &x, const T2 &y) { return wi::ges_p (x, y); }
# 3287 "/home/giulianob/gcc_git_gnu/gcc/gcc/wide-int.h"
template<typename T> typename wi::binary_traits <generic_wide_int<T>, generic_wide_int<T> >::result_type operator ~ (const generic_wide_int<T> &x) { return wi::bit_not (x); }
template<typename T> typename wi::binary_traits <generic_wide_int<T>, generic_wide_int<T> >::result_type operator - (const generic_wide_int<T> &x) { return wi::neg (x); }
template<typename T1, typename T2> typename wi::binary_traits <T1, T2>::predicate_result operator == (const T1 &x, const T2 &y) { return wi::eq_p (x, y); }
template<typename T1, typename T2> typename wi::binary_traits <T1, T2>::predicate_result operator != (const T1 &x, const T2 &y) { return wi::ne_p (x, y); }
template<typename T1, typename T2> typename wi::binary_traits <T1, T2>::operator_result operator & (const T1 &x, const T2 &y) { return wi::bit_and (x, y); }
template<typename T1, typename T2> typename wi::binary_traits <T1, T2>::operator_result operator | (const T1 &x, const T2 &y) { return wi::bit_or (x, y); }
template<typename T1, typename T2> typename wi::binary_traits <T1, T2>::operator_result operator ^ (const T1 &x, const T2 &y) { return wi::bit_xor (x, y); }
template<typename T1, typename T2> typename wi::binary_traits <T1, T2>::operator_result operator + (const T1 &x, const T2 &y) { return wi::add (x, y); }
template<typename T1, typename T2> typename wi::binary_traits <T1, T2>::operator_result operator - (const T1 &x, const T2 &y) { return wi::sub (x, y); }
template<typename T1, typename T2> typename wi::binary_traits <T1, T2>::operator_result operator * (const T1 &x, const T2 &y) { return wi::mul (x, y); }
template<typename T1, typename T2> typename wi::binary_traits <T1, T1>::operator_result operator << (const T1 &x, const T2 &y) { return wi::lshift (x, y); }
template <typename T1, typename T2>
inline typename wi::binary_traits <T1, T2>::signed_shift_result_type
operator >> (const T1 &x, const T2 &y)
{
return wi::arshift (x, y);
}
template <typename T1, typename T2>
inline typename wi::binary_traits <T1, T2>::signed_shift_result_type
operator / (const T1 &x, const T2 &y)
{
return wi::sdiv_trunc (x, y);
}
template <typename T1, typename T2>
inline typename wi::binary_traits <T1, T2>::signed_shift_result_type
operator % (const T1 &x, const T2 &y)
{
return wi::smod_trunc (x, y);
}
template<typename T>
void
gt_ggc_mx (generic_wide_int <T> *)
{
}
template<typename T>
void
gt_pch_nx (generic_wide_int <T> *)
{
}
template<typename T>
void
gt_pch_nx (generic_wide_int <T> *, void (*) (void *, void *), void *)
{
}
template<int N>
void
gt_ggc_mx (trailing_wide_ints <N> *)
{
}
template<int N>
void
gt_pch_nx (trailing_wide_ints <N> *)
{
}
template<int N>
void
gt_pch_nx (trailing_wide_ints <N> *, void (*) (void *, void *), void *)
{
}
namespace wi
{
struct never_used1 {};
struct never_used2 {};
wide_int min_value (unsigned int, signop);
wide_int min_value (never_used1 *);
wide_int min_value (never_used2 *);
wide_int max_value (unsigned int, signop);
wide_int max_value (never_used1 *);
wide_int max_value (never_used2 *);
wide_int from_buffer (const unsigned char *, unsigned int);
void to_mpz (const wide_int_ref &, mpz_t, signop);
wide_int mask (unsigned int, bool, unsigned int);
wide_int shifted_mask (unsigned int, unsigned int, bool, unsigned int);
wide_int set_bit_in_zero (unsigned int, unsigned int);
wide_int insert (const wide_int &x, const wide_int &y, unsigned int,
unsigned int);
wide_int round_down_for_mask (const wide_int &, const wide_int &);
wide_int round_up_for_mask (const wide_int &, const wide_int &);
wide_int mod_inv (const wide_int &a, const wide_int &b);
template <typename T>
T mask (unsigned int, bool);
template <typename T>
T shifted_mask (unsigned int, unsigned int, bool);
template <typename T>
T set_bit_in_zero (unsigned int);
unsigned int mask (long *, unsigned int, bool, unsigned int);
unsigned int shifted_mask (long *, unsigned int, unsigned int,
bool, unsigned int);
unsigned int from_array (long *, const long *,
unsigned int, unsigned int, bool);
}
inline wide_int
wi::mask (unsigned int width, bool negate_p, unsigned int precision)
{
wide_int result = wide_int::create (precision);
result.set_len (mask (result.write_val (), width, negate_p, precision));
return result;
}
inline wide_int
wi::shifted_mask (unsigned int start, unsigned int width, bool negate_p,
unsigned int precision)
{
wide_int result = wide_int::create (precision);
result.set_len (shifted_mask (result.write_val (), start, width, negate_p,
precision));
return result;
}
inline wide_int
wi::set_bit_in_zero (unsigned int bit, unsigned int precision)
{
return shifted_mask (bit, 1, false, precision);
}
template <typename T>
inline T
wi::mask (unsigned int width, bool negate_p)
{
static_assert ((wi::int_traits<T>::precision), "wi::int_traits<T>::precision");
T result;
result.set_len (mask (result.write_val (), width, negate_p,
wi::int_traits <T>::precision));
return result;
}
template <typename T>
inline T
wi::shifted_mask (unsigned int start, unsigned int width, bool negate_p)
{
static_assert ((wi::int_traits<T>::precision), "wi::int_traits<T>::precision");
T result;
result.set_len (shifted_mask (result.write_val (), start, width,
negate_p,
wi::int_traits <T>::precision));
return result;
}
template <typename T>
inline T
wi::set_bit_in_zero (unsigned int bit)
{
return shifted_mask <T> (bit, 1, false);
}
static inline void
wi::accumulate_overflow (wi::overflow_type &overflow,
wi::overflow_type suboverflow)
{
if (!suboverflow)
return;
if (!overflow)
overflow = suboverflow;
else if (overflow != suboverflow)
overflow = wi::OVF_UNKNOWN;
}
# 452 "/home/giulianob/gcc_git_gnu/gcc/gcc/coretypes.h" 2
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/wide-int-print.h" 1
# 29 "/home/giulianob/gcc_git_gnu/gcc/gcc/wide-int-print.h"
extern void print_dec (const wide_int_ref &wi, char *buf, signop sgn);
extern void print_dec (const wide_int_ref &wi, FILE *file, signop sgn);
extern void print_decs (const wide_int_ref &wi, char *buf);
extern void print_decs (const wide_int_ref &wi, FILE *file);
extern void print_decu (const wide_int_ref &wi, char *buf);
extern void print_decu (const wide_int_ref &wi, FILE *file);
extern void print_hex (const wide_int_ref &wi, char *buf);
extern void print_hex (const wide_int_ref &wi, FILE *file);
# 453 "/home/giulianob/gcc_git_gnu/gcc/gcc/coretypes.h" 2
# 466 "/home/giulianob/gcc_git_gnu/gcc/gcc/coretypes.h"
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/poly-int.h" 1
# 32 "/home/giulianob/gcc_git_gnu/gcc/gcc/poly-int.h"
template<unsigned int N, typename T> struct poly_int_pod;
template<unsigned int N, typename T> class poly_int;
# 62 "/home/giulianob/gcc_git_gnu/gcc/gcc/poly-int.h"
template<typename T, wi::precision_type = wi::int_traits<T>::precision_type>
struct poly_coeff_traits;
template<typename T>
struct poly_coeff_traits<T, wi::FLEXIBLE_PRECISION>
{
typedef T result;
typedef T int_type;
static const int signedness = (T (0) >= T (-1));
static const int precision = sizeof (T) * 8;
static const T max_value = (signedness
? ((T (1) << (precision - 2))
+ ((T (1) << (precision - 2)) - 1))
: T (-1));
static const int rank = sizeof (T) * 2 + !signedness;
};
template<typename T>
struct poly_coeff_traits<T, wi::VAR_PRECISION>
{
typedef T result;
typedef int int_type;
static const int signedness = -1;
static const int precision = (((160 + 64) / 64) * 64);
static const int rank = 0x7fffffff;
};
template<typename T>
struct poly_coeff_traits<T, wi::CONST_PRECISION>
{
typedef typename wi::binary_traits <T, T>::result_type result;
typedef int int_type;
static const int signedness = 1;
static const int precision = wi::int_traits<T>::precision;
static const int rank = precision * 2 / 8;
};
template<typename T1, typename T2>
struct poly_coeff_pair_traits
{
# 118 "/home/giulianob/gcc_git_gnu/gcc/gcc/poly-int.h"
static const bool lossless_p = (poly_coeff_traits<T1>::signedness
== poly_coeff_traits<T2>::signedness
? (poly_coeff_traits<T1>::precision
>= poly_coeff_traits<T2>::precision)
: (poly_coeff_traits<T1>::signedness == 1
&& poly_coeff_traits<T2>::signedness == 0
&& (poly_coeff_traits<T1>::precision
> poly_coeff_traits<T2>::precision)));
static const int result_kind
= ((poly_coeff_traits<T1>::rank <= poly_coeff_traits<long>::rank
&& poly_coeff_traits<T2>::rank <= poly_coeff_traits<long>::rank)
? 0
: (poly_coeff_traits<T1>::rank <= poly_coeff_traits<unsigned long>::rank
&& poly_coeff_traits<T2>::rank <= poly_coeff_traits<unsigned long>::rank)
? 1 : 2);
};
template<typename T1, typename T2, typename T3,
bool lossless_p = poly_coeff_pair_traits<T1, T2>::lossless_p>
struct if_lossless;
template<typename T1, typename T2, typename T3>
struct if_lossless<T1, T2, T3, true>
{
typedef T3 type;
};
# 166 "/home/giulianob/gcc_git_gnu/gcc/gcc/poly-int.h"
template<typename T>
struct poly_int_traits
{
static const bool is_poly = false;
static const unsigned int num_coeffs = 1;
typedef T coeff_type;
typedef typename poly_coeff_traits<T>::int_type int_type;
};
template<unsigned int N, typename C>
struct poly_int_traits<poly_int_pod<N, C> >
{
static const bool is_poly = true;
static const unsigned int num_coeffs = N;
typedef C coeff_type;
typedef typename poly_coeff_traits<C>::int_type int_type;
};
template<unsigned int N, typename C>
struct poly_int_traits<poly_int<N, C> > : poly_int_traits<poly_int_pod<N, C> >
{
};
template<typename T1, typename T2 = T1,
bool is_poly = poly_int_traits<T1>::is_poly>
struct if_nonpoly {};
template<typename T1, typename T2>
struct if_nonpoly<T1, T2, false>
{
typedef T2 type;
};
template<typename T1, typename T2, typename T3,
bool is_poly1 = poly_int_traits<T1>::is_poly,
bool is_poly2 = poly_int_traits<T2>::is_poly>
struct if_nonpoly2 {};
template<typename T1, typename T2, typename T3>
struct if_nonpoly2<T1, T2, T3, false, false>
{
typedef T3 type;
};
template<typename T1, typename T2 = T1,
bool is_poly = poly_int_traits<T1>::is_poly>
struct if_poly {};
template<typename T1, typename T2>
struct if_poly<T1, T2, true>
{
typedef T2 type;
};
# 234 "/home/giulianob/gcc_git_gnu/gcc/gcc/poly-int.h"
template<typename T1, typename T2 = T1,
int result_kind = poly_coeff_pair_traits<T1, T2>::result_kind>
struct poly_result;
template<typename T1, typename T2>
struct poly_result<T1, T2, 0>
{
typedef long type;
typedef type cast;
};
template<typename T1, typename T2>
struct poly_result<T1, T2, 1>
{
typedef unsigned long type;
typedef type cast;
};
template<typename T1, typename T2>
struct poly_result<T1, T2, 2>
{
typedef typename wi::binary_traits <T1, T2>::result_type type;
typedef const T1 &cast;
};
# 337 "/home/giulianob/gcc_git_gnu/gcc/gcc/poly-int.h"
template<unsigned int N, typename C>
struct poly_int_pod
{
public:
template<typename Ca>
poly_int_pod &operator = (const poly_int_pod<N, Ca> &);
template<typename Ca>
typename if_nonpoly<Ca, poly_int_pod>::type &operator = (const Ca &);
template<typename Ca>
poly_int_pod &operator += (const poly_int_pod<N, Ca> &);
template<typename Ca>
typename if_nonpoly<Ca, poly_int_pod>::type &operator += (const Ca &);
template<typename Ca>
poly_int_pod &operator -= (const poly_int_pod<N, Ca> &);
template<typename Ca>
typename if_nonpoly<Ca, poly_int_pod>::type &operator -= (const Ca &);
template<typename Ca>
typename if_nonpoly<Ca, poly_int_pod>::type &operator *= (const Ca &);
poly_int_pod &operator <<= (unsigned int);
bool is_constant () const;
template<typename T>
typename if_lossless<T, C, bool>::type is_constant (T *) const;
C to_constant () const;
template<typename Ca>
static poly_int<N, C> from (const poly_int_pod<N, Ca> &, unsigned int,
signop);
template<typename Ca>
static poly_int<N, C> from (const poly_int_pod<N, Ca> &, signop);
bool to_shwi (poly_int_pod<N, long> *) const;
bool to_uhwi (poly_int_pod<N, unsigned long> *) const;
poly_int<N, long> force_shwi () const;
poly_int<N, unsigned long> force_uhwi () const;
C coeffs[N];
};
template<unsigned int N, typename C>
template<typename Ca>
inline poly_int_pod<N, C>&
poly_int_pod<N, C>::operator = (const poly_int_pod<N, Ca> &a)
{
for (unsigned int i = 0; i < N; i++)
((void) (&(*this).coeffs[0] == (C *) 0), wi::int_traits<C>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((*this).coeffs[i] = a.coeffs[i]) : (void) ((*this).coeffs[i].~C (), new (&(*this).coeffs[i]) C (a.coeffs[i])));
return *this;
}
template<unsigned int N, typename C>
template<typename Ca>
inline typename if_nonpoly<Ca, poly_int_pod<N, C> >::type &
poly_int_pod<N, C>::operator = (const Ca &a)
{
((void) (&(*this).coeffs[0] == (C *) 0), wi::int_traits<C>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((*this).coeffs[0] = a) : (void) ((*this).coeffs[0].~C (), new (&(*this).coeffs[0]) C (a)));
if (N >= 2)
for (unsigned int i = 1; i < N; i++)
((void) (&(*this).coeffs[0] == (C *) 0), wi::int_traits<C>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((*this).coeffs[i] = wi::ints_for<C>::zero (this->coeffs[0])) : (void) ((*this).coeffs[i].~C (), new (&(*this).coeffs[i]) C (wi::ints_for<C>::zero (this->coeffs[0]))));
return *this;
}
template<unsigned int N, typename C>
template<typename Ca>
inline poly_int_pod<N, C>&
poly_int_pod<N, C>::operator += (const poly_int_pod<N, Ca> &a)
{
for (unsigned int i = 0; i < N; i++)
this->coeffs[i] += a.coeffs[i];
return *this;
}
template<unsigned int N, typename C>
template<typename Ca>
inline typename if_nonpoly<Ca, poly_int_pod<N, C> >::type &
poly_int_pod<N, C>::operator += (const Ca &a)
{
this->coeffs[0] += a;
return *this;
}
template<unsigned int N, typename C>
template<typename Ca>
inline poly_int_pod<N, C>&
poly_int_pod<N, C>::operator -= (const poly_int_pod<N, Ca> &a)
{
for (unsigned int i = 0; i < N; i++)
this->coeffs[i] -= a.coeffs[i];
return *this;
}
template<unsigned int N, typename C>
template<typename Ca>
inline typename if_nonpoly<Ca, poly_int_pod<N, C> >::type &
poly_int_pod<N, C>::operator -= (const Ca &a)
{
this->coeffs[0] -= a;
return *this;
}
template<unsigned int N, typename C>
template<typename Ca>
inline typename if_nonpoly<Ca, poly_int_pod<N, C> >::type &
poly_int_pod<N, C>::operator *= (const Ca &a)
{
for (unsigned int i = 0; i < N; i++)
this->coeffs[i] *= a;
return *this;
}
template<unsigned int N, typename C>
inline poly_int_pod<N, C>&
poly_int_pod<N, C>::operator <<= (unsigned int a)
{
for (unsigned int i = 0; i < N; i++)
this->coeffs[i] <<= a;
return *this;
}
template<unsigned int N, typename C>
inline bool
poly_int_pod<N, C>::is_constant () const
{
if (N >= 2)
for (unsigned int i = 1; i < N; i++)
if (this->coeffs[i] != 0)
return false;
return true;
}
template<unsigned int N, typename C>
template<typename T>
inline typename if_lossless<T, C, bool>::type
poly_int_pod<N, C>::is_constant (T *const_value) const
{
if (is_constant ())
{
*const_value = this->coeffs[0];
return true;
}
return false;
}
template<unsigned int N, typename C>
inline C
poly_int_pod<N, C>::to_constant () const
{
((void)(!(is_constant ()) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/poly-int.h", 504, __FUNCTION__), 0 : 0));
return this->coeffs[0];
}
template<unsigned int N, typename C>
template<typename Ca>
inline poly_int<N, C>
poly_int_pod<N, C>::from (const poly_int_pod<N, Ca> &a,
unsigned int bitsize, signop sgn)
{
poly_int<N, C> r;
for (unsigned int i = 0; i < N; i++)
((void) (&(r).coeffs[0] == (C *) 0), wi::int_traits<C>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((r).coeffs[i] = C::from (a.coeffs[i], bitsize, sgn)) : (void) ((r).coeffs[i].~C (), new (&(r).coeffs[i]) C (C::from (a.coeffs[i], bitsize, sgn))));
return r;
}
template<unsigned int N, typename C>
template<typename Ca>
inline poly_int<N, C>
poly_int_pod<N, C>::from (const poly_int_pod<N, Ca> &a, signop sgn)
{
poly_int<N, C> r;
for (unsigned int i = 0; i < N; i++)
((void) (&(r).coeffs[0] == (C *) 0), wi::int_traits<C>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((r).coeffs[i] = C::from (a.coeffs[i], sgn)) : (void) ((r).coeffs[i].~C (), new (&(r).coeffs[i]) C (C::from (a.coeffs[i], sgn))));
return r;
}
template<unsigned int N, typename C>
inline bool
poly_int_pod<N, C>::to_shwi (poly_int_pod<N, long> *r) const
{
for (unsigned int i = 0; i < N; i++)
if (!wi::fits_shwi_p (this->coeffs[i]))
return false;
for (unsigned int i = 0; i < N; i++)
r->coeffs[i] = this->coeffs[i].to_shwi ();
return true;
}
template<unsigned int N, typename C>
inline bool
poly_int_pod<N, C>::to_uhwi (poly_int_pod<N, unsigned long> *r) const
{
for (unsigned int i = 0; i < N; i++)
if (!wi::fits_uhwi_p (this->coeffs[i]))
return false;
for (unsigned int i = 0; i < N; i++)
r->coeffs[i] = this->coeffs[i].to_uhwi ();
return true;
}
template<unsigned int N, typename C>
inline poly_int<N, long>
poly_int_pod<N, C>::force_shwi () const
{
poly_int_pod<N, long> r;
for (unsigned int i = 0; i < N; i++)
r.coeffs[i] = this->coeffs[i].to_shwi ();
return r;
}
template<unsigned int N, typename C>
inline poly_int<N, unsigned long>
poly_int_pod<N, C>::force_uhwi () const
{
poly_int_pod<N, unsigned long> r;
for (unsigned int i = 0; i < N; i++)
r.coeffs[i] = this->coeffs[i].to_uhwi ();
return r;
}
# 611 "/home/giulianob/gcc_git_gnu/gcc/gcc/poly-int.h"
template<unsigned int N, typename C>
class poly_int : public poly_int_pod<N, C>
{
public:
poly_int () {}
template<typename Ca>
poly_int (const poly_int<N, Ca> &);
template<typename Ca>
poly_int (const poly_int_pod<N, Ca> &);
template<typename C0>
poly_int (const C0 &);
template<typename C0, typename C1>
poly_int (const C0 &, const C1 &);
template<typename Ca>
poly_int &operator = (const poly_int_pod<N, Ca> &);
template<typename Ca>
typename if_nonpoly<Ca, poly_int>::type &operator = (const Ca &);
template<typename Ca>
poly_int &operator += (const poly_int_pod<N, Ca> &);
template<typename Ca>
typename if_nonpoly<Ca, poly_int>::type &operator += (const Ca &);
template<typename Ca>
poly_int &operator -= (const poly_int_pod<N, Ca> &);
template<typename Ca>
typename if_nonpoly<Ca, poly_int>::type &operator -= (const Ca &);
template<typename Ca>
typename if_nonpoly<Ca, poly_int>::type &operator *= (const Ca &);
poly_int &operator <<= (unsigned int);
};
template<unsigned int N, typename C>
template<typename Ca>
inline
poly_int<N, C>::poly_int (const poly_int<N, Ca> &a)
{
for (unsigned int i = 0; i < N; i++)
((void) (&(*this).coeffs[0] == (C *) 0), wi::int_traits<C>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((*this).coeffs[i] = a.coeffs[i]) : (void) ((*this).coeffs[i].~C (), new (&(*this).coeffs[i]) C (a.coeffs[i])));
}
template<unsigned int N, typename C>
template<typename Ca>
inline
poly_int<N, C>::poly_int (const poly_int_pod<N, Ca> &a)
{
for (unsigned int i = 0; i < N; i++)
((void) (&(*this).coeffs[0] == (C *) 0), wi::int_traits<C>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((*this).coeffs[i] = a.coeffs[i]) : (void) ((*this).coeffs[i].~C (), new (&(*this).coeffs[i]) C (a.coeffs[i])));
}
template<unsigned int N, typename C>
template<typename C0>
inline
poly_int<N, C>::poly_int (const C0 &c0)
{
((void) (&(*this).coeffs[0] == (C *) 0), wi::int_traits<C>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((*this).coeffs[0] = c0) : (void) ((*this).coeffs[0].~C (), new (&(*this).coeffs[0]) C (c0)));
for (unsigned int i = 1; i < N; i++)
((void) (&(*this).coeffs[0] == (C *) 0), wi::int_traits<C>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((*this).coeffs[i] = wi::ints_for<C>::zero (this->coeffs[0])) : (void) ((*this).coeffs[i].~C (), new (&(*this).coeffs[i]) C (wi::ints_for<C>::zero (this->coeffs[0]))));
}
template<unsigned int N, typename C>
template<typename C0, typename C1>
inline
poly_int<N, C>::poly_int (const C0 &c0, const C1 &c1)
{
static_assert ((N >= 2), "N >= 2");
((void) (&(*this).coeffs[0] == (C *) 0), wi::int_traits<C>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((*this).coeffs[0] = c0) : (void) ((*this).coeffs[0].~C (), new (&(*this).coeffs[0]) C (c0)));
((void) (&(*this).coeffs[0] == (C *) 0), wi::int_traits<C>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((*this).coeffs[1] = c1) : (void) ((*this).coeffs[1].~C (), new (&(*this).coeffs[1]) C (c1)));
for (unsigned int i = 2; i < N; i++)
((void) (&(*this).coeffs[0] == (C *) 0), wi::int_traits<C>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((*this).coeffs[i] = wi::ints_for<C>::zero (this->coeffs[0])) : (void) ((*this).coeffs[i].~C (), new (&(*this).coeffs[i]) C (wi::ints_for<C>::zero (this->coeffs[0]))));
}
template<unsigned int N, typename C>
template<typename Ca>
inline poly_int<N, C>&
poly_int<N, C>::operator = (const poly_int_pod<N, Ca> &a)
{
for (unsigned int i = 0; i < N; i++)
this->coeffs[i] = a.coeffs[i];
return *this;
}
template<unsigned int N, typename C>
template<typename Ca>
inline typename if_nonpoly<Ca, poly_int<N, C> >::type &
poly_int<N, C>::operator = (const Ca &a)
{
this->coeffs[0] = a;
if (N >= 2)
for (unsigned int i = 1; i < N; i++)
this->coeffs[i] = wi::ints_for<C>::zero (this->coeffs[0]);
return *this;
}
template<unsigned int N, typename C>
template<typename Ca>
inline poly_int<N, C>&
poly_int<N, C>::operator += (const poly_int_pod<N, Ca> &a)
{
for (unsigned int i = 0; i < N; i++)
this->coeffs[i] += a.coeffs[i];
return *this;
}
template<unsigned int N, typename C>
template<typename Ca>
inline typename if_nonpoly<Ca, poly_int<N, C> >::type &
poly_int<N, C>::operator += (const Ca &a)
{
this->coeffs[0] += a;
return *this;
}
template<unsigned int N, typename C>
template<typename Ca>
inline poly_int<N, C>&
poly_int<N, C>::operator -= (const poly_int_pod<N, Ca> &a)
{
for (unsigned int i = 0; i < N; i++)
this->coeffs[i] -= a.coeffs[i];
return *this;
}
template<unsigned int N, typename C>
template<typename Ca>
inline typename if_nonpoly<Ca, poly_int<N, C> >::type &
poly_int<N, C>::operator -= (const Ca &a)
{
this->coeffs[0] -= a;
return *this;
}
template<unsigned int N, typename C>
template<typename Ca>
inline typename if_nonpoly<Ca, poly_int<N, C> >::type &
poly_int<N, C>::operator *= (const Ca &a)
{
for (unsigned int i = 0; i < N; i++)
this->coeffs[i] *= a;
return *this;
}
template<unsigned int N, typename C>
inline poly_int<N, C>&
poly_int<N, C>::operator <<= (unsigned int a)
{
for (unsigned int i = 0; i < N; i++)
this->coeffs[i] <<= a;
return *this;
}
template<typename Ca, typename Cb, typename Cc>
inline typename if_nonpoly<Ca, bool>::type
coeffs_in_range_p (const Ca &a, const Cb &b, const Cc &c)
{
return a >= b && a <= c;
}
template<unsigned int N, typename Ca, typename Cb, typename Cc>
inline typename if_nonpoly<Ca, bool>::type
coeffs_in_range_p (const poly_int_pod<N, Ca> &a, const Cb &b, const Cc &c)
{
for (unsigned int i = 0; i < N; i++)
if (a.coeffs[i] < b || a.coeffs[i] > c)
return false;
return true;
}
namespace wi {
template<unsigned int N>
inline poly_int<N, hwi_with_prec>
shwi (const poly_int_pod<N, long> &a, unsigned int precision)
{
poly_int<N, hwi_with_prec> r;
for (unsigned int i = 0; i < N; i++)
((void) (&(r).coeffs[0] == (hwi_with_prec *) 0), wi::int_traits<hwi_with_prec>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((r).coeffs[i] = wi::shwi (a.coeffs[i], precision)) : (void) ((r).coeffs[i].~hwi_with_prec (), new (&(r).coeffs[i]) hwi_with_prec (wi::shwi (a.coeffs[i], precision))));
return r;
}
template<unsigned int N>
inline poly_int<N, hwi_with_prec>
uhwi (const poly_int_pod<N, unsigned long> &a, unsigned int precision)
{
poly_int<N, hwi_with_prec> r;
for (unsigned int i = 0; i < N; i++)
((void) (&(r).coeffs[0] == (hwi_with_prec *) 0), wi::int_traits<hwi_with_prec>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((r).coeffs[i] = wi::uhwi (a.coeffs[i], precision)) : (void) ((r).coeffs[i].~hwi_with_prec (), new (&(r).coeffs[i]) hwi_with_prec (wi::uhwi (a.coeffs[i], precision))));
return r;
}
template<unsigned int N, typename Ca>
inline poly_int<N, typename poly_result<Ca, Ca>::type>
sext (const poly_int_pod<N, Ca> &a, unsigned int precision)
{
typedef typename poly_result<Ca, Ca>::type C;
poly_int<N, C> r;
for (unsigned int i = 0; i < N; i++)
((void) (&(r).coeffs[0] == (C *) 0), wi::int_traits<C>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((r).coeffs[i] = wi::sext (a.coeffs[i], precision)) : (void) ((r).coeffs[i].~C (), new (&(r).coeffs[i]) C (wi::sext (a.coeffs[i], precision))));
return r;
}
template<unsigned int N, typename Ca>
inline poly_int<N, typename poly_result<Ca, Ca>::type>
zext (const poly_int_pod<N, Ca> &a, unsigned int precision)
{
typedef typename poly_result<Ca, Ca>::type C;
poly_int<N, C> r;
for (unsigned int i = 0; i < N; i++)
((void) (&(r).coeffs[0] == (C *) 0), wi::int_traits<C>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((r).coeffs[i] = wi::zext (a.coeffs[i], precision)) : (void) ((r).coeffs[i].~C (), new (&(r).coeffs[i]) C (wi::zext (a.coeffs[i], precision))));
return r;
}
}
template<unsigned int N, typename Ca, typename Cb>
inline poly_int<N, typename poly_result<Ca, Cb>::type>
operator + (const poly_int_pod<N, Ca> &a, const poly_int_pod<N, Cb> &b)
{
typedef typename poly_result<Ca, Cb>::cast NCa;
typedef typename poly_result<Ca, Cb>::type C;
poly_int<N, C> r;
for (unsigned int i = 0; i < N; i++)
((void) (&(r).coeffs[0] == (C *) 0), wi::int_traits<C>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((r).coeffs[i] = NCa (a.coeffs[i]) + b.coeffs[i]) : (void) ((r).coeffs[i].~C (), new (&(r).coeffs[i]) C (NCa (a.coeffs[i]) + b.coeffs[i])));
return r;
}
template<unsigned int N, typename Ca, typename Cb>
inline poly_int<N, typename poly_result<Ca, typename if_nonpoly<Cb>::type>::type>
operator + (const poly_int_pod<N, Ca> &a, const Cb &b)
{
typedef typename poly_result<Ca, Cb>::cast NCa;
typedef typename poly_result<Ca, typename if_nonpoly<Cb>::type>::type C;
poly_int<N, C> r;
((void) (&(r).coeffs[0] == (C *) 0), wi::int_traits<C>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((r).coeffs[0] = NCa (a.coeffs[0]) + b) : (void) ((r).coeffs[0].~C (), new (&(r).coeffs[0]) C (NCa (a.coeffs[0]) + b)));
if (N >= 2)
for (unsigned int i = 1; i < N; i++)
((void) (&(r).coeffs[0] == (C *) 0), wi::int_traits<C>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((r).coeffs[i] = NCa (a.coeffs[i])) : (void) ((r).coeffs[i].~C (), new (&(r).coeffs[i]) C (NCa (a.coeffs[i]))));
return r;
}
template<unsigned int N, typename Ca, typename Cb>
inline poly_int<N, typename poly_result<typename if_nonpoly<Ca>::type, Cb>::type>
operator + (const Ca &a, const poly_int_pod<N, Cb> &b)
{
typedef typename poly_result<Cb, Ca>::cast NCb;
typedef typename poly_result<typename if_nonpoly<Ca>::type, Cb>::type C;
poly_int<N, C> r;
((void) (&(r).coeffs[0] == (C *) 0), wi::int_traits<C>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((r).coeffs[0] = a + NCb (b.coeffs[0])) : (void) ((r).coeffs[0].~C (), new (&(r).coeffs[0]) C (a + NCb (b.coeffs[0]))));
if (N >= 2)
for (unsigned int i = 1; i < N; i++)
((void) (&(r).coeffs[0] == (C *) 0), wi::int_traits<C>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((r).coeffs[i] = NCb (b.coeffs[i])) : (void) ((r).coeffs[i].~C (), new (&(r).coeffs[i]) C (NCb (b.coeffs[i]))));
return r;
}
namespace wi {
template<unsigned int N, typename Ca, typename Cb>
inline poly_int<N, typename wi::binary_traits <Ca, Cb>::result_type>
add (const poly_int_pod<N, Ca> &a, const poly_int_pod<N, Cb> &b)
{
typedef typename wi::binary_traits <Ca, Cb>::result_type C;
poly_int<N, C> r;
for (unsigned int i = 0; i < N; i++)
((void) (&(r).coeffs[0] == (C *) 0), wi::int_traits<C>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((r).coeffs[i] = wi::add (a.coeffs[i], b.coeffs[i])) : (void) ((r).coeffs[i].~C (), new (&(r).coeffs[i]) C (wi::add (a.coeffs[i], b.coeffs[i]))));
return r;
}
template<unsigned int N, typename Ca, typename Cb>
inline poly_int<N, typename wi::binary_traits <Ca, Cb>::result_type>
add (const poly_int_pod<N, Ca> &a, const Cb &b)
{
typedef typename wi::binary_traits <Ca, Cb>::result_type C;
poly_int<N, C> r;
((void) (&(r).coeffs[0] == (C *) 0), wi::int_traits<C>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((r).coeffs[0] = wi::add (a.coeffs[0], b)) : (void) ((r).coeffs[0].~C (), new (&(r).coeffs[0]) C (wi::add (a.coeffs[0], b))));
for (unsigned int i = 1; i < N; i++)
((void) (&(r).coeffs[0] == (C *) 0), wi::int_traits<C>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((r).coeffs[i] = wi::add (a.coeffs[i], wi::ints_for<Cb>::zero (b))) : (void) ((r).coeffs[i].~C (), new (&(r).coeffs[i]) C (wi::add (a.coeffs[i], wi::ints_for<Cb>::zero (b)))))
;
return r;
}
template<unsigned int N, typename Ca, typename Cb>
inline poly_int<N, typename wi::binary_traits <Ca, Cb>::result_type>
add (const Ca &a, const poly_int_pod<N, Cb> &b)
{
typedef typename wi::binary_traits <Ca, Cb>::result_type C;
poly_int<N, C> r;
((void) (&(r).coeffs[0] == (C *) 0), wi::int_traits<C>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((r).coeffs[0] = wi::add (a, b.coeffs[0])) : (void) ((r).coeffs[0].~C (), new (&(r).coeffs[0]) C (wi::add (a, b.coeffs[0]))));
for (unsigned int i = 1; i < N; i++)
((void) (&(r).coeffs[0] == (C *) 0), wi::int_traits<C>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((r).coeffs[i] = wi::add (wi::ints_for<Ca>::zero (a), b.coeffs[i])) : (void) ((r).coeffs[i].~C (), new (&(r).coeffs[i]) C (wi::add (wi::ints_for<Ca>::zero (a), b.coeffs[i]))))
;
return r;
}
template<unsigned int N, typename Ca, typename Cb>
inline poly_int<N, typename wi::binary_traits <Ca, Cb>::result_type>
add (const poly_int_pod<N, Ca> &a, const poly_int_pod<N, Cb> &b,
signop sgn, wi::overflow_type *overflow)
{
typedef typename wi::binary_traits <Ca, Cb>::result_type C;
poly_int<N, C> r;
((void) (&(r).coeffs[0] == (C *) 0), wi::int_traits<C>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((r).coeffs[0] = wi::add (a.coeffs[0], b.coeffs[0], sgn, overflow)) : (void) ((r).coeffs[0].~C (), new (&(r).coeffs[0]) C (wi::add (a.coeffs[0], b.coeffs[0], sgn, overflow))));
for (unsigned int i = 1; i < N; i++)
{
wi::overflow_type suboverflow;
((void) (&(r).coeffs[0] == (C *) 0), wi::int_traits<C>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((r).coeffs[i] = wi::add (a.coeffs[i], b.coeffs[i], sgn, &suboverflow)) : (void) ((r).coeffs[i].~C (), new (&(r).coeffs[i]) C (wi::add (a.coeffs[i], b.coeffs[i], sgn, &suboverflow))))
;
wi::accumulate_overflow (*overflow, suboverflow);
}
return r;
}
}
template<unsigned int N, typename Ca, typename Cb>
inline poly_int<N, typename poly_result<Ca, Cb>::type>
operator - (const poly_int_pod<N, Ca> &a, const poly_int_pod<N, Cb> &b)
{
typedef typename poly_result<Ca, Cb>::cast NCa;
typedef typename poly_result<Ca, Cb>::type C;
poly_int<N, C> r;
for (unsigned int i = 0; i < N; i++)
((void) (&(r).coeffs[0] == (C *) 0), wi::int_traits<C>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((r).coeffs[i] = NCa (a.coeffs[i]) - b.coeffs[i]) : (void) ((r).coeffs[i].~C (), new (&(r).coeffs[i]) C (NCa (a.coeffs[i]) - b.coeffs[i])));
return r;
}
template<unsigned int N, typename Ca, typename Cb>
inline poly_int<N, typename poly_result<Ca, typename if_nonpoly<Cb>::type>::type>
operator - (const poly_int_pod<N, Ca> &a, const Cb &b)
{
typedef typename poly_result<Ca, Cb>::cast NCa;
typedef typename poly_result<Ca, typename if_nonpoly<Cb>::type>::type C;
poly_int<N, C> r;
((void) (&(r).coeffs[0] == (C *) 0), wi::int_traits<C>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((r).coeffs[0] = NCa (a.coeffs[0]) - b) : (void) ((r).coeffs[0].~C (), new (&(r).coeffs[0]) C (NCa (a.coeffs[0]) - b)));
if (N >= 2)
for (unsigned int i = 1; i < N; i++)
((void) (&(r).coeffs[0] == (C *) 0), wi::int_traits<C>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((r).coeffs[i] = NCa (a.coeffs[i])) : (void) ((r).coeffs[i].~C (), new (&(r).coeffs[i]) C (NCa (a.coeffs[i]))));
return r;
}
template<unsigned int N, typename Ca, typename Cb>
inline poly_int<N, typename poly_result<typename if_nonpoly<Ca>::type, Cb>::type>
operator - (const Ca &a, const poly_int_pod<N, Cb> &b)
{
typedef typename poly_result<Cb, Ca>::cast NCb;
typedef typename poly_result<typename if_nonpoly<Ca>::type, Cb>::type C;
poly_int<N, C> r;
((void) (&(r).coeffs[0] == (C *) 0), wi::int_traits<C>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((r).coeffs[0] = a - NCb (b.coeffs[0])) : (void) ((r).coeffs[0].~C (), new (&(r).coeffs[0]) C (a - NCb (b.coeffs[0]))));
if (N >= 2)
for (unsigned int i = 1; i < N; i++)
((void) (&(r).coeffs[0] == (C *) 0), wi::int_traits<C>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((r).coeffs[i] = -NCb (b.coeffs[i])) : (void) ((r).coeffs[i].~C (), new (&(r).coeffs[i]) C (-NCb (b.coeffs[i]))));
return r;
}
namespace wi {
template<unsigned int N, typename Ca, typename Cb>
inline poly_int<N, typename wi::binary_traits <Ca, Cb>::result_type>
sub (const poly_int_pod<N, Ca> &a, const poly_int_pod<N, Cb> &b)
{
typedef typename wi::binary_traits <Ca, Cb>::result_type C;
poly_int<N, C> r;
for (unsigned int i = 0; i < N; i++)
((void) (&(r).coeffs[0] == (C *) 0), wi::int_traits<C>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((r).coeffs[i] = wi::sub (a.coeffs[i], b.coeffs[i])) : (void) ((r).coeffs[i].~C (), new (&(r).coeffs[i]) C (wi::sub (a.coeffs[i], b.coeffs[i]))));
return r;
}
template<unsigned int N, typename Ca, typename Cb>
inline poly_int<N, typename wi::binary_traits <Ca, Cb>::result_type>
sub (const poly_int_pod<N, Ca> &a, const Cb &b)
{
typedef typename wi::binary_traits <Ca, Cb>::result_type C;
poly_int<N, C> r;
((void) (&(r).coeffs[0] == (C *) 0), wi::int_traits<C>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((r).coeffs[0] = wi::sub (a.coeffs[0], b)) : (void) ((r).coeffs[0].~C (), new (&(r).coeffs[0]) C (wi::sub (a.coeffs[0], b))));
for (unsigned int i = 1; i < N; i++)
((void) (&(r).coeffs[0] == (C *) 0), wi::int_traits<C>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((r).coeffs[i] = wi::sub (a.coeffs[i], wi::ints_for<Cb>::zero (b))) : (void) ((r).coeffs[i].~C (), new (&(r).coeffs[i]) C (wi::sub (a.coeffs[i], wi::ints_for<Cb>::zero (b)))))
;
return r;
}
template<unsigned int N, typename Ca, typename Cb>
inline poly_int<N, typename wi::binary_traits <Ca, Cb>::result_type>
sub (const Ca &a, const poly_int_pod<N, Cb> &b)
{
typedef typename wi::binary_traits <Ca, Cb>::result_type C;
poly_int<N, C> r;
((void) (&(r).coeffs[0] == (C *) 0), wi::int_traits<C>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((r).coeffs[0] = wi::sub (a, b.coeffs[0])) : (void) ((r).coeffs[0].~C (), new (&(r).coeffs[0]) C (wi::sub (a, b.coeffs[0]))));
for (unsigned int i = 1; i < N; i++)
((void) (&(r).coeffs[0] == (C *) 0), wi::int_traits<C>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((r).coeffs[i] = wi::sub (wi::ints_for<Ca>::zero (a), b.coeffs[i])) : (void) ((r).coeffs[i].~C (), new (&(r).coeffs[i]) C (wi::sub (wi::ints_for<Ca>::zero (a), b.coeffs[i]))))
;
return r;
}
template<unsigned int N, typename Ca, typename Cb>
inline poly_int<N, typename wi::binary_traits <Ca, Cb>::result_type>
sub (const poly_int_pod<N, Ca> &a, const poly_int_pod<N, Cb> &b,
signop sgn, wi::overflow_type *overflow)
{
typedef typename wi::binary_traits <Ca, Cb>::result_type C;
poly_int<N, C> r;
((void) (&(r).coeffs[0] == (C *) 0), wi::int_traits<C>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((r).coeffs[0] = wi::sub (a.coeffs[0], b.coeffs[0], sgn, overflow)) : (void) ((r).coeffs[0].~C (), new (&(r).coeffs[0]) C (wi::sub (a.coeffs[0], b.coeffs[0], sgn, overflow))));
for (unsigned int i = 1; i < N; i++)
{
wi::overflow_type suboverflow;
((void) (&(r).coeffs[0] == (C *) 0), wi::int_traits<C>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((r).coeffs[i] = wi::sub (a.coeffs[i], b.coeffs[i], sgn, &suboverflow)) : (void) ((r).coeffs[i].~C (), new (&(r).coeffs[i]) C (wi::sub (a.coeffs[i], b.coeffs[i], sgn, &suboverflow))))
;
wi::accumulate_overflow (*overflow, suboverflow);
}
return r;
}
}
template<unsigned int N, typename Ca>
inline poly_int<N, typename poly_result<Ca, Ca>::type>
operator - (const poly_int_pod<N, Ca> &a)
{
typedef typename poly_result<Ca, Ca>::cast NCa;
typedef typename poly_result<Ca, Ca>::type C;
poly_int<N, C> r;
for (unsigned int i = 0; i < N; i++)
((void) (&(r).coeffs[0] == (C *) 0), wi::int_traits<C>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((r).coeffs[i] = -NCa (a.coeffs[i])) : (void) ((r).coeffs[i].~C (), new (&(r).coeffs[i]) C (-NCa (a.coeffs[i]))));
return r;
}
namespace wi {
template<unsigned int N, typename Ca>
inline poly_int<N, typename wi::binary_traits <Ca, Ca>::result_type>
neg (const poly_int_pod<N, Ca> &a)
{
typedef typename wi::binary_traits <Ca, Ca>::result_type C;
poly_int<N, C> r;
for (unsigned int i = 0; i < N; i++)
((void) (&(r).coeffs[0] == (C *) 0), wi::int_traits<C>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((r).coeffs[i] = wi::neg (a.coeffs[i])) : (void) ((r).coeffs[i].~C (), new (&(r).coeffs[i]) C (wi::neg (a.coeffs[i]))));
return r;
}
template<unsigned int N, typename Ca>
inline poly_int<N, typename wi::binary_traits <Ca, Ca>::result_type>
neg (const poly_int_pod<N, Ca> &a, wi::overflow_type *overflow)
{
typedef typename wi::binary_traits <Ca, Ca>::result_type C;
poly_int<N, C> r;
((void) (&(r).coeffs[0] == (C *) 0), wi::int_traits<C>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((r).coeffs[0] = wi::neg (a.coeffs[0], overflow)) : (void) ((r).coeffs[0].~C (), new (&(r).coeffs[0]) C (wi::neg (a.coeffs[0], overflow))));
for (unsigned int i = 1; i < N; i++)
{
wi::overflow_type suboverflow;
((void) (&(r).coeffs[0] == (C *) 0), wi::int_traits<C>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((r).coeffs[i] = wi::neg (a.coeffs[i], &suboverflow)) : (void) ((r).coeffs[i].~C (), new (&(r).coeffs[i]) C (wi::neg (a.coeffs[i], &suboverflow))));
wi::accumulate_overflow (*overflow, suboverflow);
}
return r;
}
}
template<unsigned int N, typename Ca>
inline poly_int<N, typename poly_result<Ca, Ca>::type>
operator ~ (const poly_int_pod<N, Ca> &a)
{
if (N >= 2)
return -1 - a;
return ~a.coeffs[0];
}
template<unsigned int N, typename Ca, typename Cb>
inline poly_int<N, typename poly_result<Ca, typename if_nonpoly<Cb>::type>::type>
operator * (const poly_int_pod<N, Ca> &a, const Cb &b)
{
typedef typename poly_result<Ca, Cb>::cast NCa;
typedef typename poly_result<Ca, typename if_nonpoly<Cb>::type>::type C;
poly_int<N, C> r;
for (unsigned int i = 0; i < N; i++)
((void) (&(r).coeffs[0] == (C *) 0), wi::int_traits<C>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((r).coeffs[i] = NCa (a.coeffs[i]) * b) : (void) ((r).coeffs[i].~C (), new (&(r).coeffs[i]) C (NCa (a.coeffs[i]) * b)));
return r;
}
template<unsigned int N, typename Ca, typename Cb>
inline poly_int<N, typename poly_result<typename if_nonpoly<Ca>::type, Cb>::type>
operator * (const Ca &a, const poly_int_pod<N, Cb> &b)
{
typedef typename poly_result<Ca, Cb>::cast NCa;
typedef typename poly_result<typename if_nonpoly<Ca>::type, Cb>::type C;
poly_int<N, C> r;
for (unsigned int i = 0; i < N; i++)
((void) (&(r).coeffs[0] == (C *) 0), wi::int_traits<C>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((r).coeffs[i] = NCa (a) * b.coeffs[i]) : (void) ((r).coeffs[i].~C (), new (&(r).coeffs[i]) C (NCa (a) * b.coeffs[i])));
return r;
}
namespace wi {
template<unsigned int N, typename Ca, typename Cb>
inline poly_int<N, typename wi::binary_traits <Ca, Cb>::result_type>
mul (const poly_int_pod<N, Ca> &a, const Cb &b)
{
typedef typename wi::binary_traits <Ca, Cb>::result_type C;
poly_int<N, C> r;
for (unsigned int i = 0; i < N; i++)
((void) (&(r).coeffs[0] == (C *) 0), wi::int_traits<C>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((r).coeffs[i] = wi::mul (a.coeffs[i], b)) : (void) ((r).coeffs[i].~C (), new (&(r).coeffs[i]) C (wi::mul (a.coeffs[i], b))));
return r;
}
template<unsigned int N, typename Ca, typename Cb>
inline poly_int<N, typename wi::binary_traits <Ca, Cb>::result_type>
mul (const Ca &a, const poly_int_pod<N, Cb> &b)
{
typedef typename wi::binary_traits <Ca, Cb>::result_type C;
poly_int<N, C> r;
for (unsigned int i = 0; i < N; i++)
((void) (&(r).coeffs[0] == (C *) 0), wi::int_traits<C>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((r).coeffs[i] = wi::mul (a, b.coeffs[i])) : (void) ((r).coeffs[i].~C (), new (&(r).coeffs[i]) C (wi::mul (a, b.coeffs[i]))));
return r;
}
template<unsigned int N, typename Ca, typename Cb>
inline poly_int<N, typename wi::binary_traits <Ca, Cb>::result_type>
mul (const poly_int_pod<N, Ca> &a, const Cb &b,
signop sgn, wi::overflow_type *overflow)
{
typedef typename wi::binary_traits <Ca, Cb>::result_type C;
poly_int<N, C> r;
((void) (&(r).coeffs[0] == (C *) 0), wi::int_traits<C>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((r).coeffs[0] = wi::mul (a.coeffs[0], b, sgn, overflow)) : (void) ((r).coeffs[0].~C (), new (&(r).coeffs[0]) C (wi::mul (a.coeffs[0], b, sgn, overflow))));
for (unsigned int i = 1; i < N; i++)
{
wi::overflow_type suboverflow;
((void) (&(r).coeffs[0] == (C *) 0), wi::int_traits<C>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((r).coeffs[i] = wi::mul (a.coeffs[i], b, sgn, &suboverflow)) : (void) ((r).coeffs[i].~C (), new (&(r).coeffs[i]) C (wi::mul (a.coeffs[i], b, sgn, &suboverflow))));
wi::accumulate_overflow (*overflow, suboverflow);
}
return r;
}
}
template<unsigned int N, typename Ca, typename Cb>
inline poly_int<N, typename poly_result<Ca, Ca>::type>
operator << (const poly_int_pod<N, Ca> &a, const Cb &b)
{
typedef typename poly_result<Ca, Ca>::cast NCa;
typedef typename poly_result<Ca, Ca>::type C;
poly_int<N, C> r;
for (unsigned int i = 0; i < N; i++)
((void) (&(r).coeffs[0] == (C *) 0), wi::int_traits<C>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((r).coeffs[i] = NCa (a.coeffs[i]) << b) : (void) ((r).coeffs[i].~C (), new (&(r).coeffs[i]) C (NCa (a.coeffs[i]) << b)));
return r;
}
namespace wi {
template<unsigned int N, typename Ca, typename Cb>
inline poly_int<N, typename wi::binary_traits <Ca, Ca>::result_type>
lshift (const poly_int_pod<N, Ca> &a, const Cb &b)
{
typedef typename wi::binary_traits <Ca, Ca>::result_type C;
poly_int<N, C> r;
for (unsigned int i = 0; i < N; i++)
((void) (&(r).coeffs[0] == (C *) 0), wi::int_traits<C>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((r).coeffs[i] = wi::lshift (a.coeffs[i], b)) : (void) ((r).coeffs[i].~C (), new (&(r).coeffs[i]) C (wi::lshift (a.coeffs[i], b))));
return r;
}
}
template<typename Ca, typename Cb>
inline bool
maybe_eq_2 (const Ca &a0, const Ca &a1, const Cb &b0, const Cb &b1)
{
if (a1 != b1)
return (a1 < b1
? b0 <= a0 && (a0 - b0) % (b1 - a1) == 0
: b0 >= a0 && (b0 - a0) % (a1 - b1) == 0);
return a0 == b0;
}
template<typename Ca, typename Cb>
inline bool
maybe_eq_2 (const Ca &a0, const Ca &a1, const Cb &b)
{
if (a1 != 0)
return (a1 < 0
? b <= a0 && (a0 - b) % a1 == 0
: b >= a0 && (b - a0) % a1 == 0);
return a0 == b;
}
template<unsigned int N, typename Ca, typename Cb>
inline bool
maybe_eq (const poly_int_pod<N, Ca> &a, const poly_int_pod<N, Cb> &b)
{
static_assert ((N <= 2), "N <= 2");
if (N == 2)
return maybe_eq_2 (a.coeffs[0], a.coeffs[1], b.coeffs[0], b.coeffs[1]);
return a.coeffs[0] == b.coeffs[0];
}
template<unsigned int N, typename Ca, typename Cb>
inline typename if_nonpoly<Cb, bool>::type
maybe_eq (const poly_int_pod<N, Ca> &a, const Cb &b)
{
static_assert ((N <= 2), "N <= 2");
if (N == 2)
return maybe_eq_2 (a.coeffs[0], a.coeffs[1], b);
return a.coeffs[0] == b;
}
template<unsigned int N, typename Ca, typename Cb>
inline typename if_nonpoly<Ca, bool>::type
maybe_eq (const Ca &a, const poly_int_pod<N, Cb> &b)
{
static_assert ((N <= 2), "N <= 2");
if (N == 2)
return maybe_eq_2 (b.coeffs[0], b.coeffs[1], a);
return a == b.coeffs[0];
}
template<typename Ca, typename Cb>
inline typename if_nonpoly2<Ca, Cb, bool>::type
maybe_eq (const Ca &a, const Cb &b)
{
return a == b;
}
template<unsigned int N, typename Ca, typename Cb>
inline bool
maybe_ne (const poly_int_pod<N, Ca> &a, const poly_int_pod<N, Cb> &b)
{
if (N >= 2)
for (unsigned int i = 1; i < N; i++)
if (a.coeffs[i] != b.coeffs[i])
return true;
return a.coeffs[0] != b.coeffs[0];
}
template<unsigned int N, typename Ca, typename Cb>
inline typename if_nonpoly<Cb, bool>::type
maybe_ne (const poly_int_pod<N, Ca> &a, const Cb &b)
{
if (N >= 2)
for (unsigned int i = 1; i < N; i++)
if (a.coeffs[i] != 0)
return true;
return a.coeffs[0] != b;
}
template<unsigned int N, typename Ca, typename Cb>
inline typename if_nonpoly<Ca, bool>::type
maybe_ne (const Ca &a, const poly_int_pod<N, Cb> &b)
{
if (N >= 2)
for (unsigned int i = 1; i < N; i++)
if (b.coeffs[i] != 0)
return true;
return a != b.coeffs[0];
}
template<typename Ca, typename Cb>
inline typename if_nonpoly2<Ca, Cb, bool>::type
maybe_ne (const Ca &a, const Cb &b)
{
return a != b;
}
# 1312 "/home/giulianob/gcc_git_gnu/gcc/gcc/poly-int.h"
template<unsigned int N, typename Ca, typename Cb>
inline bool
maybe_le (const poly_int_pod<N, Ca> &a, const poly_int_pod<N, Cb> &b)
{
if (N >= 2)
for (unsigned int i = 1; i < N; i++)
if (a.coeffs[i] < b.coeffs[i])
return true;
return a.coeffs[0] <= b.coeffs[0];
}
template<unsigned int N, typename Ca, typename Cb>
inline typename if_nonpoly<Cb, bool>::type
maybe_le (const poly_int_pod<N, Ca> &a, const Cb &b)
{
if (N >= 2)
for (unsigned int i = 1; i < N; i++)
if (a.coeffs[i] < 0)
return true;
return a.coeffs[0] <= b;
}
template<unsigned int N, typename Ca, typename Cb>
inline typename if_nonpoly<Ca, bool>::type
maybe_le (const Ca &a, const poly_int_pod<N, Cb> &b)
{
if (N >= 2)
for (unsigned int i = 1; i < N; i++)
if (b.coeffs[i] > 0)
return true;
return a <= b.coeffs[0];
}
template<typename Ca, typename Cb>
inline typename if_nonpoly2<Ca, Cb, bool>::type
maybe_le (const Ca &a, const Cb &b)
{
return a <= b;
}
template<unsigned int N, typename Ca, typename Cb>
inline bool
maybe_lt (const poly_int_pod<N, Ca> &a, const poly_int_pod<N, Cb> &b)
{
if (N >= 2)
for (unsigned int i = 1; i < N; i++)
if (a.coeffs[i] < b.coeffs[i])
return true;
return a.coeffs[0] < b.coeffs[0];
}
template<unsigned int N, typename Ca, typename Cb>
inline typename if_nonpoly<Cb, bool>::type
maybe_lt (const poly_int_pod<N, Ca> &a, const Cb &b)
{
if (N >= 2)
for (unsigned int i = 1; i < N; i++)
if (a.coeffs[i] < 0)
return true;
return a.coeffs[0] < b;
}
template<unsigned int N, typename Ca, typename Cb>
inline typename if_nonpoly<Ca, bool>::type
maybe_lt (const Ca &a, const poly_int_pod<N, Cb> &b)
{
if (N >= 2)
for (unsigned int i = 1; i < N; i++)
if (b.coeffs[i] > 0)
return true;
return a < b.coeffs[0];
}
template<typename Ca, typename Cb>
inline typename if_nonpoly2<Ca, Cb, bool>::type
maybe_lt (const Ca &a, const Cb &b)
{
return a < b;
}
# 1414 "/home/giulianob/gcc_git_gnu/gcc/gcc/poly-int.h"
template<typename T1, typename T2>
inline bool
ordered_p (const T1 &a, const T2 &b)
{
return ((poly_int_traits<T1>::num_coeffs == 1
&& poly_int_traits<T2>::num_coeffs == 1)
|| (!maybe_lt (b, a))
|| (!maybe_lt (a, b)));
}
template<unsigned int N, typename Ca, typename Cb>
inline poly_int<N, typename poly_result<Ca, Cb>::type>
ordered_min (const poly_int_pod<N, Ca> &a, const poly_int_pod<N, Cb> &b)
{
if ((!maybe_lt (b, a)))
return a;
else
{
if (N > 1)
((void)(!((!maybe_lt (a, b))) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/poly-int.h", 1439, __FUNCTION__), 0 : 0));
return b;
}
}
template<unsigned int N, typename Ca, typename Cb>
inline poly_int<N, typename poly_result<typename if_nonpoly<Ca>::type, Cb>::type>
ordered_min (const Ca &a, const poly_int_pod<N, Cb> &b)
{
if ((!maybe_lt (b, a)))
return a;
else
{
if (N > 1)
((void)(!((!maybe_lt (a, b))) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/poly-int.h", 1453, __FUNCTION__), 0 : 0));
return b;
}
}
template<unsigned int N, typename Ca, typename Cb>
inline poly_int<N, typename poly_result<Ca, typename if_nonpoly<Cb>::type>::type>
ordered_min (const poly_int_pod<N, Ca> &a, const Cb &b)
{
if ((!maybe_lt (b, a)))
return a;
else
{
if (N > 1)
((void)(!((!maybe_lt (a, b))) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/poly-int.h", 1467, __FUNCTION__), 0 : 0));
return b;
}
}
template<unsigned int N, typename Ca, typename Cb>
inline poly_int<N, typename poly_result<Ca, Cb>::type>
ordered_max (const poly_int_pod<N, Ca> &a, const poly_int_pod<N, Cb> &b)
{
if ((!maybe_lt (b, a)))
return b;
else
{
if (N > 1)
((void)(!((!maybe_lt (a, b))) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/poly-int.h", 1487, __FUNCTION__), 0 : 0));
return a;
}
}
template<unsigned int N, typename Ca, typename Cb>
inline poly_int<N, typename poly_result<typename if_nonpoly<Ca>::type, Cb>::type>
ordered_max (const Ca &a, const poly_int_pod<N, Cb> &b)
{
if ((!maybe_lt (b, a)))
return b;
else
{
if (N > 1)
((void)(!((!maybe_lt (a, b))) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/poly-int.h", 1501, __FUNCTION__), 0 : 0));
return a;
}
}
template<unsigned int N, typename Ca, typename Cb>
inline poly_int<N, typename poly_result<Ca, typename if_nonpoly<Cb>::type>::type>
ordered_max (const poly_int_pod<N, Ca> &a, const Cb &b)
{
if ((!maybe_lt (b, a)))
return b;
else
{
if (N > 1)
((void)(!((!maybe_lt (a, b))) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/poly-int.h", 1515, __FUNCTION__), 0 : 0));
return a;
}
}
template<unsigned int N, typename Ca>
inline Ca
constant_lower_bound (const poly_int_pod<N, Ca> &a)
{
((void)(!((!maybe_lt (a, typename poly_int_traits<Ca>::int_type (0)))) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/poly-int.h", 1527, __FUNCTION__), 0 : 0));
return a.coeffs[0];
}
template<unsigned int N, typename Ca, typename Cb>
inline typename poly_result<Ca, typename if_nonpoly<Cb>::type>::type
constant_lower_bound_with_limit (const poly_int_pod<N, Ca> &a, const Cb &b)
{
if ((!maybe_lt (a, b)))
return a.coeffs[0];
return b;
}
template<unsigned int N, typename Ca, typename Cb>
inline typename poly_result<Ca, typename if_nonpoly<Cb>::type>::type
constant_upper_bound_with_limit (const poly_int_pod<N, Ca> &a, const Cb &b)
{
if ((!maybe_lt (b, a)))
return a.coeffs[0];
return b;
}
template<unsigned int N, typename Ca, typename Cb>
inline poly_int<N, typename poly_result<Ca, typename if_nonpoly<Cb>::type>::type>
lower_bound (const poly_int_pod<N, Ca> &a, const Cb &b)
{
typedef typename poly_result<Ca, Cb>::cast NCa;
typedef typename poly_result<Cb, Ca>::cast NCb;
typedef typename poly_int_traits<Cb>::int_type ICb;
typedef typename poly_result<Ca, typename if_nonpoly<Cb>::type>::type C;
poly_int<N, C> r;
((void) (&(r).coeffs[0] == (C *) 0), wi::int_traits<C>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((r).coeffs[0] = ((NCa (a.coeffs[0])) < (NCb (b)) ? (NCa (a.coeffs[0])) : (NCb (b)))) : (void) ((r).coeffs[0].~C (), new (&(r).coeffs[0]) C (((NCa (a.coeffs[0])) < (NCb (b)) ? (NCa (a.coeffs[0])) : (NCb (b))))));
if (N >= 2)
for (unsigned int i = 1; i < N; i++)
((void) (&(r).coeffs[0] == (C *) 0), wi::int_traits<C>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((r).coeffs[i] = ((NCa (a.coeffs[i])) < (ICb (0)) ? (NCa (a.coeffs[i])) : (ICb (0)))) : (void) ((r).coeffs[i].~C (), new (&(r).coeffs[i]) C (((NCa (a.coeffs[i])) < (ICb (0)) ? (NCa (a.coeffs[i])) : (ICb (0))))));
return r;
}
template<unsigned int N, typename Ca, typename Cb>
inline poly_int<N, typename poly_result<typename if_nonpoly<Ca>::type, Cb>::type>
lower_bound (const Ca &a, const poly_int_pod<N, Cb> &b)
{
return lower_bound (b, a);
}
template<unsigned int N, typename Ca, typename Cb>
inline poly_int<N, typename poly_result<Ca, Cb>::type>
lower_bound (const poly_int_pod<N, Ca> &a, const poly_int_pod<N, Cb> &b)
{
typedef typename poly_result<Ca, Cb>::cast NCa;
typedef typename poly_result<Cb, Ca>::cast NCb;
typedef typename poly_result<Ca, Cb>::type C;
poly_int<N, C> r;
for (unsigned int i = 0; i < N; i++)
((void) (&(r).coeffs[0] == (C *) 0), wi::int_traits<C>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((r).coeffs[i] = ((NCa (a.coeffs[i])) < (NCb (b.coeffs[i])) ? (NCa (a.coeffs[i])) : (NCb (b.coeffs[i])))) : (void) ((r).coeffs[i].~C (), new (&(r).coeffs[i]) C (((NCa (a.coeffs[i])) < (NCb (b.coeffs[i])) ? (NCa (a.coeffs[i])) : (NCb (b.coeffs[i]))))));
return r;
}
template<typename Ca, typename Cb>
inline typename poly_result<typename if_nonpoly<Ca>::type, typename if_nonpoly<Cb>::type>::type
lower_bound (const Ca &a, const Cb &b)
{
return a < b ? a : b;
}
template<unsigned int N, typename Ca, typename Cb>
inline poly_int<N, typename poly_result<Ca, typename if_nonpoly<Cb>::type>::type>
upper_bound (const poly_int_pod<N, Ca> &a, const Cb &b)
{
typedef typename poly_result<Ca, Cb>::cast NCa;
typedef typename poly_result<Cb, Ca>::cast NCb;
typedef typename poly_int_traits<Cb>::int_type ICb;
typedef typename poly_result<Ca, typename if_nonpoly<Cb>::type>::type C;
poly_int<N, C> r;
((void) (&(r).coeffs[0] == (C *) 0), wi::int_traits<C>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((r).coeffs[0] = ((NCa (a.coeffs[0])) > (NCb (b)) ? (NCa (a.coeffs[0])) : (NCb (b)))) : (void) ((r).coeffs[0].~C (), new (&(r).coeffs[0]) C (((NCa (a.coeffs[0])) > (NCb (b)) ? (NCa (a.coeffs[0])) : (NCb (b))))));
if (N >= 2)
for (unsigned int i = 1; i < N; i++)
((void) (&(r).coeffs[0] == (C *) 0), wi::int_traits<C>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((r).coeffs[i] = ((NCa (a.coeffs[i])) > (ICb (0)) ? (NCa (a.coeffs[i])) : (ICb (0)))) : (void) ((r).coeffs[i].~C (), new (&(r).coeffs[i]) C (((NCa (a.coeffs[i])) > (ICb (0)) ? (NCa (a.coeffs[i])) : (ICb (0))))));
return r;
}
template<unsigned int N, typename Ca, typename Cb>
inline poly_int<N, typename poly_result<typename if_nonpoly<Ca>::type, Cb>::type>
upper_bound (const Ca &a, const poly_int_pod<N, Cb> &b)
{
return upper_bound (b, a);
}
template<unsigned int N, typename Ca, typename Cb>
inline poly_int<N, typename poly_result<Ca, Cb>::type>
upper_bound (const poly_int_pod<N, Ca> &a, const poly_int_pod<N, Cb> &b)
{
typedef typename poly_result<Ca, Cb>::cast NCa;
typedef typename poly_result<Cb, Ca>::cast NCb;
typedef typename poly_result<Ca, Cb>::type C;
poly_int<N, C> r;
for (unsigned int i = 0; i < N; i++)
((void) (&(r).coeffs[0] == (C *) 0), wi::int_traits<C>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((r).coeffs[i] = ((NCa (a.coeffs[i])) > (NCb (b.coeffs[i])) ? (NCa (a.coeffs[i])) : (NCb (b.coeffs[i])))) : (void) ((r).coeffs[i].~C (), new (&(r).coeffs[i]) C (((NCa (a.coeffs[i])) > (NCb (b.coeffs[i])) ? (NCa (a.coeffs[i])) : (NCb (b.coeffs[i]))))));
return r;
}
template<unsigned int N, typename Ca>
inline typename poly_result<typename poly_int_traits<Ca>::coeff_type, typename poly_int_traits<Ca>::coeff_type>::type
coeff_gcd (const poly_int_pod<N, Ca> &a)
{
unsigned int i;
for (i = N - 1; i > 0; --i)
if (a.coeffs[i] != 0)
break;
typedef typename poly_result<typename poly_int_traits<Ca>::coeff_type, typename poly_int_traits<Ca>::coeff_type>::type C;
C r = a.coeffs[i];
for (unsigned int j = 0; j < i; ++j)
if (a.coeffs[j] != 0)
r = gcd (r, C (a.coeffs[j]));
return r;
}
template<unsigned int N, typename Ca, typename Cb>
poly_int<N, typename poly_result<Ca, typename if_nonpoly<Cb>::type>::type>
common_multiple (const poly_int_pod<N, Ca> &a, Cb b)
{
typename poly_result<typename poly_int_traits<Ca>::coeff_type, typename poly_int_traits<Ca>::coeff_type>::type xgcd = coeff_gcd (a);
return a * (least_common_multiple (xgcd, b) / xgcd);
}
template<unsigned int N, typename Ca, typename Cb>
inline poly_int<N, typename poly_result<typename if_nonpoly<Ca>::type, Cb>::type>
common_multiple (const Ca &a, const poly_int_pod<N, Cb> &b)
{
return common_multiple (b, a);
}
# 1692 "/home/giulianob/gcc_git_gnu/gcc/gcc/poly-int.h"
template<unsigned int N, typename Ca, typename Cb>
poly_int<N, typename poly_result<Ca, Cb>::type>
force_common_multiple (const poly_int_pod<N, Ca> &a,
const poly_int_pod<N, Cb> &b)
{
if (b.is_constant ())
return common_multiple (a, b.coeffs[0]);
if (a.is_constant ())
return common_multiple (a.coeffs[0], b);
typedef typename poly_result<Ca, Cb>::cast NCa;
typedef typename poly_result<Cb, Ca>::cast NCb;
typedef typename poly_result<typename poly_int_traits<Ca>::coeff_type, typename poly_int_traits<Cb>::coeff_type>::type C;
typedef typename poly_int_traits<Ca>::int_type ICa;
for (unsigned int i = 1; i < N; ++i)
if (a.coeffs[i] != ICa (0))
{
C lcm = least_common_multiple (NCa (a.coeffs[i]), NCb (b.coeffs[i]));
C amul = lcm / a.coeffs[i];
C bmul = lcm / b.coeffs[i];
for (unsigned int j = 0; j < N; ++j)
((void)(!(a.coeffs[j] * amul == b.coeffs[j] * bmul) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/poly-int.h", 1714, __FUNCTION__), 0 : 0));
return a * amul;
}
(fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/poly-int.h", 1717, __FUNCTION__));
}
# 1731 "/home/giulianob/gcc_git_gnu/gcc/gcc/poly-int.h"
template<unsigned int N, typename Ca, typename Cb>
inline int
compare_sizes_for_sort (const poly_int_pod<N, Ca> &a,
const poly_int_pod<N, Cb> &b)
{
for (unsigned int i = N; i-- > 0; )
if (a.coeffs[i] != b.coeffs[i])
return a.coeffs[i] < b.coeffs[i] ? -1 : 1;
return 0;
}
template<unsigned int N, typename Ca, typename Cb>
inline bool
can_align_p (const poly_int_pod<N, Ca> &value, Cb align)
{
for (unsigned int i = 1; i < N; i++)
if ((value.coeffs[i] & (align - 1)) != 0)
return false;
return true;
}
template<unsigned int N, typename Ca, typename Cb>
inline bool
can_align_up (const poly_int_pod<N, Ca> &value, Cb align,
poly_int_pod<N, Ca> *aligned)
{
if (!can_align_p (value, align))
return false;
*aligned = value + (-value.coeffs[0] & (align - 1));
return true;
}
template<unsigned int N, typename Ca, typename Cb>
inline bool
can_align_down (const poly_int_pod<N, Ca> &value, Cb align,
poly_int_pod<N, Ca> *aligned)
{
if (!can_align_p (value, align))
return false;
*aligned = value - (value.coeffs[0] & (align - 1));
return true;
}
template<unsigned int N, typename Ca, typename Cb, typename Cc>
inline bool
known_equal_after_align_up (const poly_int_pod<N, Ca> &a,
const poly_int_pod<N, Cb> &b,
Cc align)
{
poly_int<N, Ca> aligned_a;
poly_int<N, Cb> aligned_b;
return (can_align_up (a, align, &aligned_a)
&& can_align_up (b, align, &aligned_b)
&& (!maybe_ne (aligned_a, aligned_b)));
}
template<unsigned int N, typename Ca, typename Cb, typename Cc>
inline bool
known_equal_after_align_down (const poly_int_pod<N, Ca> &a,
const poly_int_pod<N, Cb> &b,
Cc align)
{
poly_int<N, Ca> aligned_a;
poly_int<N, Cb> aligned_b;
return (can_align_down (a, align, &aligned_a)
&& can_align_down (b, align, &aligned_b)
&& (!maybe_ne (aligned_a, aligned_b)));
}
# 1823 "/home/giulianob/gcc_git_gnu/gcc/gcc/poly-int.h"
template<unsigned int N, typename Ca, typename Cb>
inline poly_int<N, Ca>
force_align_up (const poly_int_pod<N, Ca> &value, Cb align)
{
((void)(!(can_align_p (value, align)) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/poly-int.h", 1827, __FUNCTION__), 0 : 0));
return value + (-value.coeffs[0] & (align - 1));
}
# 1838 "/home/giulianob/gcc_git_gnu/gcc/gcc/poly-int.h"
template<unsigned int N, typename Ca, typename Cb>
inline poly_int<N, Ca>
force_align_down (const poly_int_pod<N, Ca> &value, Cb align)
{
((void)(!(can_align_p (value, align)) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/poly-int.h", 1842, __FUNCTION__), 0 : 0));
return value - (value.coeffs[0] & (align - 1));
}
template<unsigned int N, typename Ca, typename Cb>
inline poly_int<N, Ca>
aligned_lower_bound (const poly_int_pod<N, Ca> &value, Cb align)
{
poly_int<N, Ca> r;
for (unsigned int i = 0; i < N; i++)
((void) (&(r).coeffs[0] == (Ca *) 0), wi::int_traits<Ca>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((r).coeffs[i] = (value.coeffs[i] - (value.coeffs[i] & (align - 1)))) : (void) ((r).coeffs[i].~Ca (), new (&(r).coeffs[i]) Ca ((value.coeffs[i] - (value.coeffs[i] & (align - 1))))))
;
return r;
}
template<unsigned int N, typename Ca, typename Cb>
inline poly_int<N, Ca>
aligned_upper_bound (const poly_int_pod<N, Ca> &value, Cb align)
{
poly_int<N, Ca> r;
for (unsigned int i = 0; i < N; i++)
((void) (&(r).coeffs[0] == (Ca *) 0), wi::int_traits<Ca>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((r).coeffs[i] = (value.coeffs[i] + (-value.coeffs[i] & (align - 1)))) : (void) ((r).coeffs[i].~Ca (), new (&(r).coeffs[i]) Ca ((value.coeffs[i] + (-value.coeffs[i] & (align - 1))))))
;
return r;
}
# 1886 "/home/giulianob/gcc_git_gnu/gcc/gcc/poly-int.h"
template<unsigned int N, typename Ca, typename Cb>
inline poly_int<N, Ca>
force_align_down_and_div (const poly_int_pod<N, Ca> &value, Cb align)
{
((void)(!(can_align_p (value, align)) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/poly-int.h", 1890, __FUNCTION__), 0 : 0));
poly_int<N, Ca> r;
((void) (&(r).coeffs[0] == (Ca *) 0), wi::int_traits<Ca>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((r).coeffs[0] = ((value.coeffs[0] - (value.coeffs[0] & (align - 1))) / align)) : (void) ((r).coeffs[0].~Ca (), new (&(r).coeffs[0]) Ca (((value.coeffs[0] - (value.coeffs[0] & (align - 1))) / align))))
;
if (N >= 2)
for (unsigned int i = 1; i < N; i++)
((void) (&(r).coeffs[0] == (Ca *) 0), wi::int_traits<Ca>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((r).coeffs[i] = value.coeffs[i] / align) : (void) ((r).coeffs[i].~Ca (), new (&(r).coeffs[i]) Ca (value.coeffs[i] / align)));
return r;
}
# 1910 "/home/giulianob/gcc_git_gnu/gcc/gcc/poly-int.h"
template<unsigned int N, typename Ca, typename Cb>
inline poly_int<N, Ca>
force_align_up_and_div (const poly_int_pod<N, Ca> &value, Cb align)
{
((void)(!(can_align_p (value, align)) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/poly-int.h", 1914, __FUNCTION__), 0 : 0));
poly_int<N, Ca> r;
((void) (&(r).coeffs[0] == (Ca *) 0), wi::int_traits<Ca>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((r).coeffs[0] = ((value.coeffs[0] + (-value.coeffs[0] & (align - 1))) / align)) : (void) ((r).coeffs[0].~Ca (), new (&(r).coeffs[0]) Ca (((value.coeffs[0] + (-value.coeffs[0] & (align - 1))) / align))))
;
if (N >= 2)
for (unsigned int i = 1; i < N; i++)
((void) (&(r).coeffs[0] == (Ca *) 0), wi::int_traits<Ca>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((r).coeffs[i] = value.coeffs[i] / align) : (void) ((r).coeffs[i].~Ca (), new (&(r).coeffs[i]) Ca (value.coeffs[i] / align)));
return r;
}
template<unsigned int N, typename Ca, typename Cb, typename Cm>
inline bool
known_misalignment (const poly_int_pod<N, Ca> &value, Cb align, Cm *misalign)
{
((void)(!(align != 0) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/poly-int.h", 1934, __FUNCTION__), 0 : 0));
if (!can_align_p (value, align))
return false;
*misalign = value.coeffs[0] & (align - 1);
return true;
}
template<unsigned int N, typename Ca, typename Cb>
inline typename poly_result<typename poly_int_traits<Ca>::coeff_type, typename poly_int_traits<Ca>::coeff_type>::type
force_get_misalignment (const poly_int_pod<N, Ca> &a, Cb align)
{
((void)(!(can_align_p (a, align)) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/poly-int.h", 1949, __FUNCTION__), 0 : 0));
return a.coeffs[0] & (align - 1);
}
template<unsigned int N, typename Ca>
inline typename poly_result<typename poly_int_traits<Ca>::coeff_type, typename poly_int_traits<Ca>::coeff_type>::type
known_alignment (const poly_int_pod<N, Ca> &a)
{
typedef typename poly_result<typename poly_int_traits<Ca>::coeff_type, typename poly_int_traits<Ca>::coeff_type>::type C;
C r = a.coeffs[0];
for (unsigned int i = 1; i < N; ++i)
r |= a.coeffs[i];
return r & -r;
}
template<unsigned int N, typename Ca, typename Cb, typename Cr>
inline typename if_nonpoly<Cb, bool>::type
can_ior_p (const poly_int_pod<N, Ca> &a, Cb b, Cr *result)
{
typedef typename poly_int_traits<Ca>::int_type int_type;
if (N >= 2)
for (unsigned int i = 1; i < N; i++)
if ((-(a.coeffs[i] & -a.coeffs[i]) & b) != int_type (0))
return false;
*result = a;
result->coeffs[0] |= b;
return true;
}
template<unsigned int N, typename Ca, typename Cb, typename Cm>
inline typename if_nonpoly<Cb, bool>::type
constant_multiple_p (const poly_int_pod<N, Ca> &a, Cb b, Cm *multiple)
{
typedef typename poly_result<Ca, Cb>::cast NCa;
typedef typename poly_result<Cb, Ca>::cast NCb;
if (NCa (a.coeffs[0]) % NCb (b) != 0 || !a.is_constant ())
return false;
*multiple = NCa (a.coeffs[0]) / NCb (b);
return true;
}
template<unsigned int N, typename Ca, typename Cb, typename Cm>
inline typename if_nonpoly<Ca, bool>::type
constant_multiple_p (Ca a, const poly_int_pod<N, Cb> &b, Cm *multiple)
{
typedef typename poly_result<Ca, Cb>::cast NCa;
typedef typename poly_result<Cb, Ca>::cast NCb;
typedef typename poly_int_traits<Ca>::int_type int_type;
if (NCa (a) % NCb (b.coeffs[0]) != 0
|| (a != int_type (0) && !b.is_constant ()))
return false;
*multiple = NCa (a) / NCb (b.coeffs[0]);
return true;
}
template<unsigned int N, typename Ca, typename Cb, typename Cm>
inline bool
constant_multiple_p (const poly_int_pod<N, Ca> &a,
const poly_int_pod<N, Cb> &b, Cm *multiple)
{
typedef typename poly_result<Ca, Cb>::cast NCa;
typedef typename poly_result<Cb, Ca>::cast NCb;
typedef typename poly_int_traits<Ca>::int_type ICa;
typedef typename poly_int_traits<Cb>::int_type ICb;
typedef typename poly_result<typename poly_int_traits<Ca>::coeff_type, typename poly_int_traits<Cb>::coeff_type>::type C;
if (NCa (a.coeffs[0]) % NCb (b.coeffs[0]) != 0)
return false;
C r = NCa (a.coeffs[0]) / NCb (b.coeffs[0]);
for (unsigned int i = 1; i < N; ++i)
if (b.coeffs[i] == ICb (0)
? a.coeffs[i] != ICa (0)
: (NCa (a.coeffs[i]) % NCb (b.coeffs[i]) != 0
|| NCa (a.coeffs[i]) / NCb (b.coeffs[i]) != r))
return false;
*multiple = r;
return true;
}
template<typename Ca, typename Cb>
inline typename if_nonpoly2<Ca, Cb, bool>::type
multiple_p (Ca a, Cb b)
{
return a % b == 0;
}
template<unsigned int N, typename Ca, typename Cb>
inline typename if_nonpoly<Cb, bool>::type
multiple_p (const poly_int_pod<N, Ca> &a, Cb b)
{
for (unsigned int i = 0; i < N; ++i)
if (a.coeffs[i] % b != 0)
return false;
return true;
}
template<unsigned int N, typename Ca, typename Cb>
inline typename if_nonpoly<Ca, bool>::type
multiple_p (Ca a, const poly_int_pod<N, Cb> &b)
{
typedef typename poly_int_traits<Ca>::int_type int_type;
return a % b.coeffs[0] == 0 && (a == int_type (0) || b.is_constant ());
}
template<unsigned int N, typename Ca, typename Cb>
inline bool
multiple_p (const poly_int_pod<N, Ca> &a, const poly_int_pod<N, Cb> &b)
{
if (b.is_constant ())
return multiple_p (a, b.coeffs[0]);
typename poly_result<typename poly_int_traits<Ca>::coeff_type, typename poly_int_traits<Ca>::coeff_type>::type tmp;
return constant_multiple_p (a, b, &tmp);
}
template<typename Ca, typename Cb, typename Cm>
inline typename if_nonpoly2<Ca, Cb, bool>::type
multiple_p (Ca a, Cb b, Cm *multiple)
{
if (a % b != 0)
return false;
*multiple = a / b;
return true;
}
template<unsigned int N, typename Ca, typename Cb, typename Cm>
inline typename if_nonpoly<Cb, bool>::type
multiple_p (const poly_int_pod<N, Ca> &a, Cb b, poly_int_pod<N, Cm> *multiple)
{
if (!multiple_p (a, b))
return false;
for (unsigned int i = 0; i < N; ++i)
multiple->coeffs[i] = a.coeffs[i] / b;
return true;
}
template<unsigned int N, typename Ca, typename Cb, typename Cm>
inline typename if_nonpoly<Ca, bool>::type
multiple_p (Ca a, const poly_int_pod<N, Cb> &b, Cm *multiple)
{
typedef typename poly_result<Ca, Cb>::cast NCa;
if (a % b.coeffs[0] != 0 || (NCa (a) != 0 && !b.is_constant ()))
return false;
*multiple = a / b.coeffs[0];
return true;
}
template<unsigned int N, typename Ca, typename Cb, typename Cm>
inline bool
multiple_p (const poly_int_pod<N, Ca> &a, const poly_int_pod<N, Cb> &b,
poly_int_pod<N, Cm> *multiple)
{
if (b.is_constant ())
return multiple_p (a, b.coeffs[0], multiple);
return constant_multiple_p (a, b, multiple);
}
template<unsigned int N, typename Ca, typename Cb>
inline poly_int<N, typename poly_result<Ca, typename if_nonpoly<Cb>::type>::type>
exact_div (const poly_int_pod<N, Ca> &a, Cb b)
{
typedef typename poly_result<Ca, typename if_nonpoly<Cb>::type>::type C;
poly_int<N, C> r;
for (unsigned int i = 0; i < N; i++)
{
((void)(!(a.coeffs[i] % b == 0) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/poly-int.h", 2162, __FUNCTION__), 0 : 0));
((void) (&(r).coeffs[0] == (C *) 0), wi::int_traits<C>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((r).coeffs[i] = a.coeffs[i] / b) : (void) ((r).coeffs[i].~C (), new (&(r).coeffs[i]) C (a.coeffs[i] / b)));
}
return r;
}
template<unsigned int N, typename Ca, typename Cb>
inline poly_int<N, typename poly_result<Ca, Cb>::type>
exact_div (const poly_int_pod<N, Ca> &a, const poly_int_pod<N, Cb> &b)
{
if (b.is_constant ())
return exact_div (a, b.coeffs[0]);
typedef typename poly_result<Ca, Cb>::cast NCa;
typedef typename poly_result<Cb, Ca>::cast NCb;
typedef typename poly_result<typename poly_int_traits<Ca>::coeff_type, typename poly_int_traits<Cb>::coeff_type>::type C;
typedef typename poly_int_traits<Cb>::int_type int_type;
((void)(!(a.coeffs[0] % b.coeffs[0] == 0) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/poly-int.h", 2182, __FUNCTION__), 0 : 0));
C r = NCa (a.coeffs[0]) / NCb (b.coeffs[0]);
for (unsigned int i = 1; i < N; ++i)
((void)(!(b.coeffs[i] == int_type (0) ? a.coeffs[i] == int_type (0) : (a.coeffs[i] % b.coeffs[i] == 0 && NCa (a.coeffs[i]) / NCb (b.coeffs[i]) == r)) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/poly-int.h", 2185, __FUNCTION__), 0 : 0))
;
return r;
}
# 2201 "/home/giulianob/gcc_git_gnu/gcc/gcc/poly-int.h"
template<unsigned int N, typename Ca, typename Cb, typename Cq>
inline typename if_nonpoly2<Cb, Cq, bool>::type
can_div_trunc_p (const poly_int_pod<N, Ca> &a, Cb b, Cq *quotient)
{
typedef typename poly_result<Ca, Cb>::cast NCa;
typedef typename poly_result<Cb, Ca>::cast NCb;
Cq q = NCa (a.coeffs[0]) / NCb (b);
if (!a.is_constant ())
return false;
*quotient = q;
return true;
}
template<unsigned int N, typename Ca, typename Cb, typename Cq>
inline typename if_nonpoly<Cq, bool>::type
can_div_trunc_p (const poly_int_pod<N, Ca> &a,
const poly_int_pod<N, Cb> &b,
Cq *quotient)
{
typedef typename poly_result<Ca, Cb>::cast NCa;
typedef typename poly_result<Cb, Ca>::cast NCb;
typedef typename poly_int_traits<Ca>::int_type ICa;
typedef typename poly_int_traits<Cb>::int_type ICb;
typedef typename poly_result<typename poly_int_traits<Ca>::coeff_type, typename poly_int_traits<Cb>::coeff_type>::type C;
C q = NCa (a.coeffs[0]) / NCb (b.coeffs[0]);
# 2277 "/home/giulianob/gcc_git_gnu/gcc/gcc/poly-int.h"
bool rem_p = NCa (a.coeffs[0]) % NCb (b.coeffs[0]) != 0;
for (unsigned int i = 1; i < N; ++i)
{
if (b.coeffs[i] == ICb (0))
{
if (a.coeffs[i] != ICa (0))
return false;
}
else
{
if (q == 0)
{
if (a.coeffs[i] != ICa (0))
{
C neg_abs_a = (a.coeffs[i] < 0 ? a.coeffs[i] : -a.coeffs[i]);
C neg_abs_b = (b.coeffs[i] < 0 ? b.coeffs[i] : -b.coeffs[i]);
if (neg_abs_a < neg_abs_b)
return false;
rem_p = true;
}
}
else
{
if (NCa (a.coeffs[i]) / NCb (b.coeffs[i]) != q)
return false;
if (NCa (a.coeffs[i]) % NCb (b.coeffs[i]) != 0)
rem_p = true;
}
}
}
if (rem_p && (!ordered_p (a, ICa (0)) || !ordered_p (b, ICb (0))))
return false;
*quotient = q;
return true;
}
template<unsigned int N, typename Ca, typename Cb, typename Cq, typename Cr>
inline typename if_nonpoly<Cq, bool>::type
can_div_trunc_p (const poly_int_pod<N, Ca> &a,
const poly_int_pod<N, Cb> &b,
Cq *quotient, Cr *remainder)
{
if (!can_div_trunc_p (a, b, quotient))
return false;
*remainder = a - *quotient * b;
return true;
}
# 2345 "/home/giulianob/gcc_git_gnu/gcc/gcc/poly-int.h"
template<unsigned int N, typename Ca, typename Cb, typename Cq>
inline typename if_nonpoly<Cb, bool>::type
can_div_trunc_p (const poly_int_pod<N, Ca> &a, Cb b,
poly_int_pod<N, Cq> *quotient)
{
for (unsigned int i = 1; i < N; ++i)
if (a.coeffs[i] % b != 0)
return false;
for (unsigned int i = 0; i < N; ++i)
quotient->coeffs[i] = a.coeffs[i] / b;
return true;
}
template<unsigned int N, typename Ca, typename Cb, typename Cq, typename Cr>
inline typename if_nonpoly<Cb, bool>::type
can_div_trunc_p (const poly_int_pod<N, Ca> &a, Cb b,
poly_int_pod<N, Cq> *quotient, Cr *remainder)
{
if (!can_div_trunc_p (a, b, quotient))
return false;
*remainder = a.coeffs[0] % b;
return true;
}
template<unsigned int N, typename Ca, typename Cb, typename Cq>
inline bool
can_div_trunc_p (const poly_int_pod<N, Ca> &a,
const poly_int_pod<N, Cb> &b,
poly_int_pod<N, Cq> *quotient)
{
if (b.is_constant ())
return can_div_trunc_p (a, b.coeffs[0], quotient);
if (!can_div_trunc_p (a, b, "ient->coeffs[0]))
return false;
for (unsigned int i = 1; i < N; ++i)
quotient->coeffs[i] = 0;
return true;
}
# 2401 "/home/giulianob/gcc_git_gnu/gcc/gcc/poly-int.h"
template<unsigned int N, typename Ca, typename Cb, typename Cq>
inline typename if_nonpoly<Cq, bool>::type
can_div_away_from_zero_p (const poly_int_pod<N, Ca> &a,
const poly_int_pod<N, Cb> &b,
Cq *quotient)
{
if (!can_div_trunc_p (a, b, quotient))
return false;
if (maybe_ne (*quotient * b, a))
*quotient += (*quotient < 0 ? -1 : 1);
return true;
}
template<unsigned int N, typename C>
void
print_dec (const poly_int_pod<N, C> &value, FILE *file, signop sgn)
{
if (value.is_constant ())
print_dec (value.coeffs[0], file, sgn);
else
{
fprintf (file, "[");
for (unsigned int i = 0; i < N; ++i)
{
print_dec (value.coeffs[i], file, sgn);
fputc (i == N - 1 ? ']' : ',', file);
}
}
}
template<unsigned int N, typename C>
void
print_dec (const poly_int_pod<N, C> &value, FILE *file)
{
static_assert ((poly_coeff_traits<C>::signedness >= 0), "poly_coeff_traits<C>::signedness >= 0");
print_dec (value, file,
poly_coeff_traits<C>::signedness ? SIGNED : UNSIGNED);
}
template<unsigned int N, typename C>
void
print_hex (const poly_int_pod<N, C> &value, FILE *file)
{
if (value.is_constant ())
print_hex (value.coeffs[0], file);
else
{
fprintf (file, "[");
for (unsigned int i = 0; i < N; ++i)
{
print_hex (value.coeffs[i], file);
fputc (i == N - 1 ? ']' : ',', file);
}
}
}
# 2482 "/home/giulianob/gcc_git_gnu/gcc/gcc/poly-int.h"
template<typename T1, typename T2,
typename Res = typename poly_result<typename poly_int_traits<typename poly_result<typename poly_int_traits<T1>::coeff_type, typename poly_int_traits<T2>::coeff_type>::type>::coeff_type, typename poly_int_traits<unsigned long>::coeff_type>::type
>
struct poly_span_traits
{
template<typename T>
static const T &cast (const T &x) { return x; }
};
template<typename T1, typename T2>
struct poly_span_traits<T1, T2, unsigned long>
{
template<typename T>
static typename if_nonpoly<T, unsigned long>::type
cast (const T &x) { return x; }
template<unsigned int N, typename T>
static poly_int<N, unsigned long>
cast (const poly_int_pod<N, T> &x) { return x; }
};
template<typename T>
inline bool
known_size_p (const T &a)
{
return maybe_ne (a, typename poly_int_traits<T>::int_type (-1));
}
template<typename T1, typename T2, typename T3>
inline bool
maybe_in_range_p (const T1 &val, const T2 &pos, const T3 &size)
{
typedef poly_span_traits<T1, T2> start_span;
typedef poly_span_traits<T3, T3> size_span;
if ((!maybe_le (pos, val)))
return false;
if (!known_size_p (size))
return true;
if ((poly_int_traits<T1>::num_coeffs > 1
|| poly_int_traits<T2>::num_coeffs > 1)
&& maybe_lt (val, pos))
return true;
return maybe_lt (start_span::cast (val) - start_span::cast (pos),
size_span::cast (size));
}
template<typename T1, typename T2, typename T3>
inline bool
known_in_range_p (const T1 &val, const T2 &pos, const T3 &size)
{
typedef poly_span_traits<T1, T2> start_span;
typedef poly_span_traits<T3, T3> size_span;
return (known_size_p (size)
&& (!maybe_lt (val, pos))
&& (!maybe_le (size_span::cast (size), start_span::cast (val) - start_span::cast (pos)))
);
}
template<typename T1, typename T2, typename T3, typename T4>
inline bool
ranges_maybe_overlap_p (const T1 &pos1, const T2 &size1,
const T3 &pos2, const T4 &size2)
{
if (maybe_in_range_p (pos2, pos1, size1))
return maybe_ne (size2, typename poly_int_traits<T4>::int_type (0));
if (maybe_in_range_p (pos1, pos2, size2))
return maybe_ne (size1, typename poly_int_traits<T2>::int_type (0));
return false;
}
template<typename T1, typename T2, typename T3, typename T4>
inline bool
ranges_known_overlap_p (const T1 &pos1, const T2 &size1,
const T3 &pos2, const T4 &size2)
{
typedef poly_span_traits<T1, T3> start_span;
typedef poly_span_traits<T2, T2> size1_span;
typedef poly_span_traits<T4, T4> size2_span;
# 2593 "/home/giulianob/gcc_git_gnu/gcc/gcc/poly-int.h"
return (known_size_p (size1)
&& known_size_p (size2)
&& (!maybe_le (size1_span::cast (size1), start_span::cast (pos2) - start_span::cast (lower_bound (pos1, pos2))))
&& (!maybe_le (size2_span::cast (size2), start_span::cast (pos1) - start_span::cast (lower_bound (pos1, pos2))))
);
}
template<typename T1, typename T2, typename T3, typename T4>
inline bool
known_subrange_p (const T1 &pos1, const T2 &size1,
const T3 &pos2, const T4 &size2)
{
typedef typename poly_int_traits<T2>::coeff_type C2;
typedef poly_span_traits<T1, T3> start_span;
typedef poly_span_traits<T2, T4> size_span;
return ((!maybe_le (size1, typename poly_int_traits<T2>::int_type (0)))
&& (poly_coeff_traits<C2>::signedness > 0
|| known_size_p (size1))
&& known_size_p (size2)
&& (!maybe_lt (pos1, pos2))
&& (!maybe_lt (size2, size1))
&& (!maybe_lt (size_span::cast (size2) - size_span::cast (size1), start_span::cast (pos1) - start_span::cast (pos2)))
);
}
template<typename T>
inline typename if_nonpoly<T, bool>::type
endpoint_representable_p (const T &pos, const T &size)
{
return (!known_size_p (size)
|| pos <= poly_coeff_traits<T>::max_value - size);
}
template<unsigned int N, typename C>
inline bool
endpoint_representable_p (const poly_int_pod<N, C> &pos,
const poly_int_pod<N, C> &size)
{
if (known_size_p (size))
for (unsigned int i = 0; i < N; ++i)
if (pos.coeffs[i] > poly_coeff_traits<C>::max_value - size.coeffs[i])
return false;
return true;
}
template<unsigned int N, typename C>
void
gt_ggc_mx (poly_int_pod<N, C> *)
{
}
template<unsigned int N, typename C>
void
gt_pch_nx (poly_int_pod<N, C> *)
{
}
template<unsigned int N, typename C>
void
gt_pch_nx (poly_int_pod<N, C> *, void (*) (void *, void *), void *)
{
}
# 467 "/home/giulianob/gcc_git_gnu/gcc/gcc/coretypes.h" 2
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/poly-int-types.h" 1
# 23 "/home/giulianob/gcc_git_gnu/gcc/gcc/poly-int-types.h"
typedef poly_int_pod<1, unsigned short> poly_uint16_pod;
typedef poly_int_pod<1, long> poly_int64_pod;
typedef poly_int_pod<1,
unsigned long> poly_uint64_pod;
typedef poly_int_pod<1, offset_int> poly_offset_int_pod;
typedef poly_int_pod<1, wide_int> poly_wide_int_pod;
typedef poly_int_pod<1, widest_int> poly_widest_int_pod;
typedef poly_int<1, unsigned short> poly_uint16;
typedef poly_int<1, long> poly_int64;
typedef poly_int<1, unsigned long> poly_uint64;
typedef poly_int<1, offset_int> poly_offset_int;
typedef poly_int<1, wide_int> poly_wide_int;
typedef poly_int<1, wide_int_ref> poly_wide_int_ref;
typedef poly_int<1, widest_int> poly_widest_int;
# 468 "/home/giulianob/gcc_git_gnu/gcc/gcc/coretypes.h" 2
# 1 "./insn-modes-inline.h" 1
# 10 "./insn-modes-inline.h"
inline __attribute__((__always_inline__))
poly_uint16
mode_size_inline (machine_mode mode)
{
extern poly_uint16_pod mode_size[NUM_MACHINE_MODES];
((void)(!(mode >= 0 && mode < NUM_MACHINE_MODES) ? fancy_abort ("./insn-modes-inline.h", 18, __FUNCTION__), 0 : 0));
switch (mode)
{
case E_VOIDmode: return 0;
case E_BLKmode: return 0;
case E_CCmode: return 4;
case E_CCGCmode: return 4;
case E_CCGOCmode: return 4;
case E_CCNOmode: return 4;
case E_CCGZmode: return 4;
case E_CCAmode: return 4;
case E_CCCmode: return 4;
case E_CCOmode: return 4;
case E_CCPmode: return 4;
case E_CCSmode: return 4;
case E_CCZmode: return 4;
case E_CCFPmode: return 4;
case E_BImode: return 1;
case E_QImode: return 1;
case E_HImode: return 2;
case E_SImode: return 4;
case E_DImode: return 8;
case E_TImode: return 16;
case E_OImode: return 32;
case E_XImode: return 64;
case E_P2QImode: return 2;
case E_P2HImode: return 4;
case E_POImode: return 32;
case E_QQmode: return 1;
case E_HQmode: return 2;
case E_SQmode: return 4;
case E_DQmode: return 8;
case E_TQmode: return 16;
case E_UQQmode: return 1;
case E_UHQmode: return 2;
case E_USQmode: return 4;
case E_UDQmode: return 8;
case E_UTQmode: return 16;
case E_HAmode: return 2;
case E_SAmode: return 4;
case E_DAmode: return 8;
case E_TAmode: return 16;
case E_UHAmode: return 2;
case E_USAmode: return 4;
case E_UDAmode: return 8;
case E_UTAmode: return 16;
case E_SFmode: return 4;
case E_DFmode: return 8;
case E_TFmode: return 16;
case E_SDmode: return 4;
case E_DDmode: return 8;
case E_TDmode: return 16;
case E_CQImode: return 2;
case E_CP2QImode: return 4;
case E_CHImode: return 4;
case E_CP2HImode: return 8;
case E_CSImode: return 8;
case E_CDImode: return 16;
case E_CTImode: return 32;
case E_CPOImode: return 64;
case E_COImode: return 64;
case E_CXImode: return 128;
case E_SCmode: return 8;
case E_DCmode: return 16;
case E_TCmode: return 32;
case E_V2QImode: return 2;
case E_V4QImode: return 4;
case E_V2HImode: return 4;
case E_V1SImode: return 4;
case E_V8QImode: return 8;
case E_V4HImode: return 8;
case E_V2SImode: return 8;
case E_V1DImode: return 8;
case E_V12QImode: return 12;
case E_V6HImode: return 12;
case E_V14QImode: return 14;
case E_V16QImode: return 16;
case E_V8HImode: return 16;
case E_V4SImode: return 16;
case E_V2DImode: return 16;
case E_V1TImode: return 16;
case E_V32QImode: return 32;
case E_V16HImode: return 32;
case E_V8SImode: return 32;
case E_V4DImode: return 32;
case E_V2TImode: return 32;
case E_V64QImode: return 64;
case E_V32HImode: return 64;
case E_V16SImode: return 64;
case E_V8DImode: return 64;
case E_V4TImode: return 64;
case E_V128QImode: return 128;
case E_V64HImode: return 128;
case E_V32SImode: return 128;
case E_V16DImode: return 128;
case E_V8TImode: return 128;
case E_V64SImode: return 256;
case E_V2SFmode: return 8;
case E_V4SFmode: return 16;
case E_V2DFmode: return 16;
case E_V8SFmode: return 32;
case E_V4DFmode: return 32;
case E_V2TFmode: return 32;
case E_V16SFmode: return 64;
case E_V8DFmode: return 64;
case E_V4TFmode: return 64;
case E_V32SFmode: return 128;
case E_V16DFmode: return 128;
case E_V8TFmode: return 128;
case E_V64SFmode: return 256;
case E_V32DFmode: return 256;
case E_V16TFmode: return 256;
default: return mode_size[mode];
}
}
inline __attribute__((__always_inline__))
poly_uint16
mode_nunits_inline (machine_mode mode)
{
extern const poly_uint16_pod mode_nunits[NUM_MACHINE_MODES];
switch (mode)
{
case E_VOIDmode: return 0;
case E_BLKmode: return 0;
case E_CCmode: return 1;
case E_CCGCmode: return 1;
case E_CCGOCmode: return 1;
case E_CCNOmode: return 1;
case E_CCGZmode: return 1;
case E_CCAmode: return 1;
case E_CCCmode: return 1;
case E_CCOmode: return 1;
case E_CCPmode: return 1;
case E_CCSmode: return 1;
case E_CCZmode: return 1;
case E_CCFPmode: return 1;
case E_BImode: return 1;
case E_QImode: return 1;
case E_HImode: return 1;
case E_SImode: return 1;
case E_DImode: return 1;
case E_TImode: return 1;
case E_OImode: return 1;
case E_XImode: return 1;
case E_P2QImode: return 1;
case E_P2HImode: return 1;
case E_POImode: return 1;
case E_QQmode: return 1;
case E_HQmode: return 1;
case E_SQmode: return 1;
case E_DQmode: return 1;
case E_TQmode: return 1;
case E_UQQmode: return 1;
case E_UHQmode: return 1;
case E_USQmode: return 1;
case E_UDQmode: return 1;
case E_UTQmode: return 1;
case E_HAmode: return 1;
case E_SAmode: return 1;
case E_DAmode: return 1;
case E_TAmode: return 1;
case E_UHAmode: return 1;
case E_USAmode: return 1;
case E_UDAmode: return 1;
case E_UTAmode: return 1;
case E_SFmode: return 1;
case E_DFmode: return 1;
case E_XFmode: return 1;
case E_TFmode: return 1;
case E_SDmode: return 1;
case E_DDmode: return 1;
case E_TDmode: return 1;
case E_CQImode: return 2;
case E_CP2QImode: return 2;
case E_CHImode: return 2;
case E_CP2HImode: return 2;
case E_CSImode: return 2;
case E_CDImode: return 2;
case E_CTImode: return 2;
case E_CPOImode: return 2;
case E_COImode: return 2;
case E_CXImode: return 2;
case E_SCmode: return 2;
case E_DCmode: return 2;
case E_XCmode: return 2;
case E_TCmode: return 2;
case E_V2QImode: return 2;
case E_V4QImode: return 4;
case E_V2HImode: return 2;
case E_V1SImode: return 1;
case E_V8QImode: return 8;
case E_V4HImode: return 4;
case E_V2SImode: return 2;
case E_V1DImode: return 1;
case E_V12QImode: return 12;
case E_V6HImode: return 6;
case E_V14QImode: return 14;
case E_V16QImode: return 16;
case E_V8HImode: return 8;
case E_V4SImode: return 4;
case E_V2DImode: return 2;
case E_V1TImode: return 1;
case E_V32QImode: return 32;
case E_V16HImode: return 16;
case E_V8SImode: return 8;
case E_V4DImode: return 4;
case E_V2TImode: return 2;
case E_V64QImode: return 64;
case E_V32HImode: return 32;
case E_V16SImode: return 16;
case E_V8DImode: return 8;
case E_V4TImode: return 4;
case E_V128QImode: return 128;
case E_V64HImode: return 64;
case E_V32SImode: return 32;
case E_V16DImode: return 16;
case E_V8TImode: return 8;
case E_V64SImode: return 64;
case E_V2SFmode: return 2;
case E_V4SFmode: return 4;
case E_V2DFmode: return 2;
case E_V8SFmode: return 8;
case E_V4DFmode: return 4;
case E_V2TFmode: return 2;
case E_V16SFmode: return 16;
case E_V8DFmode: return 8;
case E_V4TFmode: return 4;
case E_V32SFmode: return 32;
case E_V16DFmode: return 16;
case E_V8TFmode: return 8;
case E_V64SFmode: return 64;
case E_V32DFmode: return 32;
case E_V16TFmode: return 16;
default: return mode_nunits[mode];
}
}
inline __attribute__((__always_inline__))
unsigned char
mode_inner_inline (machine_mode mode)
{
extern const unsigned char mode_inner[NUM_MACHINE_MODES];
((void)(!(mode >= 0 && mode < NUM_MACHINE_MODES) ? fancy_abort ("./insn-modes-inline.h", 269, __FUNCTION__), 0 : 0));
switch (mode)
{
case E_VOIDmode: return E_VOIDmode;
case E_BLKmode: return E_BLKmode;
case E_CCmode: return E_CCmode;
case E_CCGCmode: return E_CCGCmode;
case E_CCGOCmode: return E_CCGOCmode;
case E_CCNOmode: return E_CCNOmode;
case E_CCGZmode: return E_CCGZmode;
case E_CCAmode: return E_CCAmode;
case E_CCCmode: return E_CCCmode;
case E_CCOmode: return E_CCOmode;
case E_CCPmode: return E_CCPmode;
case E_CCSmode: return E_CCSmode;
case E_CCZmode: return E_CCZmode;
case E_CCFPmode: return E_CCFPmode;
case E_BImode: return E_BImode;
case E_QImode: return E_QImode;
case E_HImode: return E_HImode;
case E_SImode: return E_SImode;
case E_DImode: return E_DImode;
case E_TImode: return E_TImode;
case E_OImode: return E_OImode;
case E_XImode: return E_XImode;
case E_P2QImode: return E_P2QImode;
case E_P2HImode: return E_P2HImode;
case E_POImode: return E_POImode;
case E_QQmode: return E_QQmode;
case E_HQmode: return E_HQmode;
case E_SQmode: return E_SQmode;
case E_DQmode: return E_DQmode;
case E_TQmode: return E_TQmode;
case E_UQQmode: return E_UQQmode;
case E_UHQmode: return E_UHQmode;
case E_USQmode: return E_USQmode;
case E_UDQmode: return E_UDQmode;
case E_UTQmode: return E_UTQmode;
case E_HAmode: return E_HAmode;
case E_SAmode: return E_SAmode;
case E_DAmode: return E_DAmode;
case E_TAmode: return E_TAmode;
case E_UHAmode: return E_UHAmode;
case E_USAmode: return E_USAmode;
case E_UDAmode: return E_UDAmode;
case E_UTAmode: return E_UTAmode;
case E_SFmode: return E_SFmode;
case E_DFmode: return E_DFmode;
case E_XFmode: return E_XFmode;
case E_TFmode: return E_TFmode;
case E_SDmode: return E_SDmode;
case E_DDmode: return E_DDmode;
case E_TDmode: return E_TDmode;
case E_CQImode: return E_QImode;
case E_CP2QImode: return E_P2QImode;
case E_CHImode: return E_HImode;
case E_CP2HImode: return E_P2HImode;
case E_CSImode: return E_SImode;
case E_CDImode: return E_DImode;
case E_CTImode: return E_TImode;
case E_CPOImode: return E_POImode;
case E_COImode: return E_OImode;
case E_CXImode: return E_XImode;
case E_SCmode: return E_SFmode;
case E_DCmode: return E_DFmode;
case E_XCmode: return E_XFmode;
case E_TCmode: return E_TFmode;
case E_V2QImode: return E_QImode;
case E_V4QImode: return E_QImode;
case E_V2HImode: return E_HImode;
case E_V1SImode: return E_SImode;
case E_V8QImode: return E_QImode;
case E_V4HImode: return E_HImode;
case E_V2SImode: return E_SImode;
case E_V1DImode: return E_DImode;
case E_V12QImode: return E_QImode;
case E_V6HImode: return E_HImode;
case E_V14QImode: return E_QImode;
case E_V16QImode: return E_QImode;
case E_V8HImode: return E_HImode;
case E_V4SImode: return E_SImode;
case E_V2DImode: return E_DImode;
case E_V1TImode: return E_TImode;
case E_V32QImode: return E_QImode;
case E_V16HImode: return E_HImode;
case E_V8SImode: return E_SImode;
case E_V4DImode: return E_DImode;
case E_V2TImode: return E_TImode;
case E_V64QImode: return E_QImode;
case E_V32HImode: return E_HImode;
case E_V16SImode: return E_SImode;
case E_V8DImode: return E_DImode;
case E_V4TImode: return E_TImode;
case E_V128QImode: return E_QImode;
case E_V64HImode: return E_HImode;
case E_V32SImode: return E_SImode;
case E_V16DImode: return E_DImode;
case E_V8TImode: return E_TImode;
case E_V64SImode: return E_SImode;
case E_V2SFmode: return E_SFmode;
case E_V4SFmode: return E_SFmode;
case E_V2DFmode: return E_DFmode;
case E_V8SFmode: return E_SFmode;
case E_V4DFmode: return E_DFmode;
case E_V2TFmode: return E_TFmode;
case E_V16SFmode: return E_SFmode;
case E_V8DFmode: return E_DFmode;
case E_V4TFmode: return E_TFmode;
case E_V32SFmode: return E_SFmode;
case E_V16DFmode: return E_DFmode;
case E_V8TFmode: return E_TFmode;
case E_V64SFmode: return E_SFmode;
case E_V32DFmode: return E_DFmode;
case E_V16TFmode: return E_TFmode;
default: return mode_inner[mode];
}
}
inline __attribute__((__always_inline__))
unsigned char
mode_unit_size_inline (machine_mode mode)
{
extern unsigned char mode_unit_size[NUM_MACHINE_MODES];
((void)(!(mode >= 0 && mode < NUM_MACHINE_MODES) ? fancy_abort ("./insn-modes-inline.h", 396, __FUNCTION__), 0 : 0));
switch (mode)
{
case E_VOIDmode: return 0;
case E_BLKmode: return 0;
case E_CCmode: return 4;
case E_CCGCmode: return 4;
case E_CCGOCmode: return 4;
case E_CCNOmode: return 4;
case E_CCGZmode: return 4;
case E_CCAmode: return 4;
case E_CCCmode: return 4;
case E_CCOmode: return 4;
case E_CCPmode: return 4;
case E_CCSmode: return 4;
case E_CCZmode: return 4;
case E_CCFPmode: return 4;
case E_BImode: return 1;
case E_QImode: return 1;
case E_HImode: return 2;
case E_SImode: return 4;
case E_DImode: return 8;
case E_TImode: return 16;
case E_OImode: return 32;
case E_XImode: return 64;
case E_P2QImode: return 2;
case E_P2HImode: return 4;
case E_POImode: return 32;
case E_QQmode: return 1;
case E_HQmode: return 2;
case E_SQmode: return 4;
case E_DQmode: return 8;
case E_TQmode: return 16;
case E_UQQmode: return 1;
case E_UHQmode: return 2;
case E_USQmode: return 4;
case E_UDQmode: return 8;
case E_UTQmode: return 16;
case E_HAmode: return 2;
case E_SAmode: return 4;
case E_DAmode: return 8;
case E_TAmode: return 16;
case E_UHAmode: return 2;
case E_USAmode: return 4;
case E_UDAmode: return 8;
case E_UTAmode: return 16;
case E_SFmode: return 4;
case E_DFmode: return 8;
case E_TFmode: return 16;
case E_SDmode: return 4;
case E_DDmode: return 8;
case E_TDmode: return 16;
case E_CQImode: return 1;
case E_CP2QImode: return 2;
case E_CHImode: return 2;
case E_CP2HImode: return 4;
case E_CSImode: return 4;
case E_CDImode: return 8;
case E_CTImode: return 16;
case E_CPOImode: return 32;
case E_COImode: return 32;
case E_CXImode: return 64;
case E_SCmode: return 4;
case E_DCmode: return 8;
case E_TCmode: return 16;
case E_V2QImode: return 1;
case E_V4QImode: return 1;
case E_V2HImode: return 2;
case E_V1SImode: return 4;
case E_V8QImode: return 1;
case E_V4HImode: return 2;
case E_V2SImode: return 4;
case E_V1DImode: return 8;
case E_V12QImode: return 1;
case E_V6HImode: return 2;
case E_V14QImode: return 1;
case E_V16QImode: return 1;
case E_V8HImode: return 2;
case E_V4SImode: return 4;
case E_V2DImode: return 8;
case E_V1TImode: return 16;
case E_V32QImode: return 1;
case E_V16HImode: return 2;
case E_V8SImode: return 4;
case E_V4DImode: return 8;
case E_V2TImode: return 16;
case E_V64QImode: return 1;
case E_V32HImode: return 2;
case E_V16SImode: return 4;
case E_V8DImode: return 8;
case E_V4TImode: return 16;
case E_V128QImode: return 1;
case E_V64HImode: return 2;
case E_V32SImode: return 4;
case E_V16DImode: return 8;
case E_V8TImode: return 16;
case E_V64SImode: return 4;
case E_V2SFmode: return 4;
case E_V4SFmode: return 4;
case E_V2DFmode: return 8;
case E_V8SFmode: return 4;
case E_V4DFmode: return 8;
case E_V2TFmode: return 16;
case E_V16SFmode: return 4;
case E_V8DFmode: return 8;
case E_V4TFmode: return 16;
case E_V32SFmode: return 4;
case E_V16DFmode: return 8;
case E_V8TFmode: return 16;
case E_V64SFmode: return 4;
case E_V32DFmode: return 8;
case E_V16TFmode: return 16;
default: return mode_unit_size[mode];
}
}
inline __attribute__((__always_inline__))
unsigned short
mode_unit_precision_inline (machine_mode mode)
{
extern const unsigned short mode_unit_precision[NUM_MACHINE_MODES];
((void)(!(mode >= 0 && mode < NUM_MACHINE_MODES) ? fancy_abort ("./insn-modes-inline.h", 521, __FUNCTION__), 0 : 0));
switch (mode)
{
case E_VOIDmode: return 0;
case E_BLKmode: return 0;
case E_CCmode: return 4*(8);
case E_CCGCmode: return 4*(8);
case E_CCGOCmode: return 4*(8);
case E_CCNOmode: return 4*(8);
case E_CCGZmode: return 4*(8);
case E_CCAmode: return 4*(8);
case E_CCCmode: return 4*(8);
case E_CCOmode: return 4*(8);
case E_CCPmode: return 4*(8);
case E_CCSmode: return 4*(8);
case E_CCZmode: return 4*(8);
case E_CCFPmode: return 4*(8);
case E_BImode: return 1;
case E_QImode: return 1*(8);
case E_HImode: return 2*(8);
case E_SImode: return 4*(8);
case E_DImode: return 8*(8);
case E_TImode: return 16*(8);
case E_OImode: return 32*(8);
case E_XImode: return 64*(8);
case E_P2QImode: return 16;
case E_P2HImode: return 32;
case E_POImode: return 160;
case E_QQmode: return 1*(8);
case E_HQmode: return 2*(8);
case E_SQmode: return 4*(8);
case E_DQmode: return 8*(8);
case E_TQmode: return 16*(8);
case E_UQQmode: return 1*(8);
case E_UHQmode: return 2*(8);
case E_USQmode: return 4*(8);
case E_UDQmode: return 8*(8);
case E_UTQmode: return 16*(8);
case E_HAmode: return 2*(8);
case E_SAmode: return 4*(8);
case E_DAmode: return 8*(8);
case E_TAmode: return 16*(8);
case E_UHAmode: return 2*(8);
case E_USAmode: return 4*(8);
case E_UDAmode: return 8*(8);
case E_UTAmode: return 16*(8);
case E_SFmode: return 4*(8);
case E_DFmode: return 8*(8);
case E_XFmode: return 80;
case E_TFmode: return 16*(8);
case E_SDmode: return 4*(8);
case E_DDmode: return 8*(8);
case E_TDmode: return 16*(8);
case E_CQImode: return 1*(8);
case E_CP2QImode: return 16;
case E_CHImode: return 2*(8);
case E_CP2HImode: return 32;
case E_CSImode: return 4*(8);
case E_CDImode: return 8*(8);
case E_CTImode: return 16*(8);
case E_CPOImode: return 160;
case E_COImode: return 32*(8);
case E_CXImode: return 64*(8);
case E_SCmode: return 4*(8);
case E_DCmode: return 8*(8);
case E_XCmode: return 80;
case E_TCmode: return 16*(8);
case E_V2QImode: return 1*(8);
case E_V4QImode: return 1*(8);
case E_V2HImode: return 2*(8);
case E_V1SImode: return 4*(8);
case E_V8QImode: return 1*(8);
case E_V4HImode: return 2*(8);
case E_V2SImode: return 4*(8);
case E_V1DImode: return 8*(8);
case E_V12QImode: return 1*(8);
case E_V6HImode: return 2*(8);
case E_V14QImode: return 1*(8);
case E_V16QImode: return 1*(8);
case E_V8HImode: return 2*(8);
case E_V4SImode: return 4*(8);
case E_V2DImode: return 8*(8);
case E_V1TImode: return 16*(8);
case E_V32QImode: return 1*(8);
case E_V16HImode: return 2*(8);
case E_V8SImode: return 4*(8);
case E_V4DImode: return 8*(8);
case E_V2TImode: return 16*(8);
case E_V64QImode: return 1*(8);
case E_V32HImode: return 2*(8);
case E_V16SImode: return 4*(8);
case E_V8DImode: return 8*(8);
case E_V4TImode: return 16*(8);
case E_V128QImode: return 1*(8);
case E_V64HImode: return 2*(8);
case E_V32SImode: return 4*(8);
case E_V16DImode: return 8*(8);
case E_V8TImode: return 16*(8);
case E_V64SImode: return 4*(8);
case E_V2SFmode: return 4*(8);
case E_V4SFmode: return 4*(8);
case E_V2DFmode: return 8*(8);
case E_V8SFmode: return 4*(8);
case E_V4DFmode: return 8*(8);
case E_V2TFmode: return 16*(8);
case E_V16SFmode: return 4*(8);
case E_V8DFmode: return 8*(8);
case E_V4TFmode: return 16*(8);
case E_V32SFmode: return 4*(8);
case E_V16DFmode: return 8*(8);
case E_V8TFmode: return 16*(8);
case E_V64SFmode: return 4*(8);
case E_V32DFmode: return 8*(8);
case E_V16TFmode: return 16*(8);
default: return mode_unit_precision[mode];
}
}
# 469 "/home/giulianob/gcc_git_gnu/gcc/gcc/coretypes.h" 2
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/machmode.h" 1
# 23 "/home/giulianob/gcc_git_gnu/gcc/gcc/machmode.h"
typedef opt_mode<machine_mode> opt_machine_mode;
extern poly_uint16_pod mode_size[NUM_MACHINE_MODES];
extern const poly_uint16_pod mode_precision[NUM_MACHINE_MODES];
extern const unsigned char mode_inner[NUM_MACHINE_MODES];
extern const poly_uint16_pod mode_nunits[NUM_MACHINE_MODES];
extern unsigned char mode_unit_size[NUM_MACHINE_MODES];
extern const unsigned short mode_unit_precision[NUM_MACHINE_MODES];
extern const unsigned char mode_wider[NUM_MACHINE_MODES];
extern const unsigned char mode_2xwider[NUM_MACHINE_MODES];
template<typename T>
struct mode_traits
{
# 68 "/home/giulianob/gcc_git_gnu/gcc/gcc/machmode.h"
enum from_int { dummy = MAX_MACHINE_MODE };
};
template<>
struct mode_traits<machine_mode>
{
typedef machine_mode from_int;
};
# 89 "/home/giulianob/gcc_git_gnu/gcc/gcc/machmode.h"
extern const char * const mode_name[NUM_MACHINE_MODES];
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/mode-classes.def" 1
# 95 "/home/giulianob/gcc_git_gnu/gcc/gcc/machmode.h" 2
enum mode_class { MODE_RANDOM, MODE_CC, MODE_INT, MODE_PARTIAL_INT, MODE_FRACT, MODE_UFRACT, MODE_ACCUM, MODE_UACCUM, MODE_FLOAT, MODE_DECIMAL_FLOAT, MODE_COMPLEX_INT, MODE_COMPLEX_FLOAT, MODE_VECTOR_BOOL, MODE_VECTOR_INT, MODE_VECTOR_FRACT, MODE_VECTOR_UFRACT, MODE_VECTOR_ACCUM, MODE_VECTOR_UACCUM, MODE_VECTOR_FLOAT, MAX_MODE_CLASS };
extern const unsigned char mode_class[NUM_MACHINE_MODES];
# 241 "/home/giulianob/gcc_git_gnu/gcc/gcc/machmode.h"
template<typename T>
class opt_mode
{
public:
enum from_int { dummy = MAX_MACHINE_MODE };
inline __attribute__ ((always_inline)) constexpr opt_mode () : m_mode (E_VOIDmode) {}
inline __attribute__ ((always_inline)) constexpr opt_mode (const T &m) : m_mode (m) {}
template<typename U>
inline __attribute__ ((always_inline)) constexpr opt_mode (const U &m) : m_mode (T (m)) {}
inline __attribute__ ((always_inline)) constexpr opt_mode (from_int m) : m_mode (machine_mode (m)) {}
machine_mode else_void () const;
machine_mode else_blk () const { return else_mode (((void) 0, E_BLKmode)); }
machine_mode else_mode (machine_mode) const;
T require () const;
bool exists () const;
template<typename U> bool exists (U *) const;
bool operator== (const T &m) const { return m_mode == m; }
bool operator!= (const T &m) const { return m_mode != m; }
private:
machine_mode m_mode;
};
template<typename T>
inline __attribute__ ((always_inline)) machine_mode
opt_mode<T>::else_void () const
{
return m_mode;
}
template<typename T>
inline machine_mode
opt_mode<T>::else_mode (machine_mode fallback) const
{
return m_mode == E_VOIDmode ? fallback : m_mode;
}
template<typename T>
inline T
opt_mode<T>::require () const
{
((void)(!(m_mode != E_VOIDmode) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/machmode.h", 293, __FUNCTION__), 0 : 0));
return typename mode_traits<T>::from_int (m_mode);
}
template<typename T>
inline __attribute__ ((always_inline)) bool
opt_mode<T>::exists () const
{
return m_mode != E_VOIDmode;
}
template<typename T>
template<typename U>
inline bool
opt_mode<T>::exists (U *mode) const
{
if (m_mode != E_VOIDmode)
{
*mode = T (typename mode_traits<T>::from_int (m_mode));
return true;
}
return false;
}
template<typename T>
struct pod_mode
{
typedef typename mode_traits<T>::from_int from_int;
typedef typename T::measurement_type measurement_type;
machine_mode m_mode;
inline __attribute__ ((always_inline)) constexpr
operator machine_mode () const { return m_mode; }
inline __attribute__ ((always_inline)) constexpr
operator T () const { return from_int (m_mode); }
inline __attribute__ ((always_inline)) pod_mode &operator = (const T &m) { m_mode = m; return *this; }
};
template<typename T>
inline bool
is_a (machine_mode m)
{
return T::includes_p (m);
}
template<typename T, typename U>
inline bool
is_a (const opt_mode<U> &m)
{
return T::includes_p (m.else_void ());
}
template<typename T>
inline T
as_a (machine_mode m)
{
((void)(!(T::includes_p (m)) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/machmode.h", 361, __FUNCTION__), 0 : 0));
return typename mode_traits<T>::from_int (m);
}
template<typename T, typename U>
inline T
as_a (const opt_mode<U> &m)
{
return as_a <T> (m.else_void ());
}
template<typename T>
inline opt_mode<T>
dyn_cast (machine_mode m)
{
if (T::includes_p (m))
return T (typename mode_traits<T>::from_int (m));
return opt_mode<T> ();
}
template<typename T, typename U>
inline opt_mode<T>
dyn_cast (const opt_mode<U> &m)
{
return dyn_cast <T> (m.else_void ());
}
template<typename T, typename U>
inline bool
is_a (machine_mode m, U *result)
{
if (T::includes_p (m))
{
*result = T (typename mode_traits<T>::from_int (m));
return true;
}
return false;
}
class scalar_int_mode
{
public:
typedef mode_traits<scalar_int_mode>::from_int from_int;
typedef unsigned short measurement_type;
inline __attribute__ ((always_inline)) scalar_int_mode () {}
inline __attribute__ ((always_inline)) constexpr
scalar_int_mode (from_int m) : m_mode (machine_mode (m)) {}
inline __attribute__ ((always_inline)) constexpr operator machine_mode () const { return m_mode; }
static bool includes_p (machine_mode);
protected:
machine_mode m_mode;
};
inline bool
scalar_int_mode::includes_p (machine_mode m)
{
return (((enum mode_class) mode_class[m]) == MODE_INT || ((enum mode_class) mode_class[m]) == MODE_PARTIAL_INT);
}
class scalar_float_mode
{
public:
typedef mode_traits<scalar_float_mode>::from_int from_int;
typedef unsigned short measurement_type;
inline __attribute__ ((always_inline)) scalar_float_mode () {}
inline __attribute__ ((always_inline)) constexpr
scalar_float_mode (from_int m) : m_mode (machine_mode (m)) {}
inline __attribute__ ((always_inline)) constexpr operator machine_mode () const { return m_mode; }
static bool includes_p (machine_mode);
protected:
machine_mode m_mode;
};
inline bool
scalar_float_mode::includes_p (machine_mode m)
{
return (((enum mode_class) mode_class[m]) == MODE_FLOAT || ((enum mode_class) mode_class[m]) == MODE_DECIMAL_FLOAT);
}
class scalar_mode
{
public:
typedef mode_traits<scalar_mode>::from_int from_int;
typedef unsigned short measurement_type;
inline __attribute__ ((always_inline)) scalar_mode () {}
inline __attribute__ ((always_inline)) constexpr
scalar_mode (from_int m) : m_mode (machine_mode (m)) {}
inline __attribute__ ((always_inline)) constexpr
scalar_mode (const scalar_int_mode &m) : m_mode (m) {}
inline __attribute__ ((always_inline)) constexpr
scalar_mode (const scalar_float_mode &m) : m_mode (m) {}
inline __attribute__ ((always_inline)) constexpr
scalar_mode (const scalar_int_mode_pod &m) : m_mode (m) {}
inline __attribute__ ((always_inline)) constexpr operator machine_mode () const { return m_mode; }
static bool includes_p (machine_mode);
protected:
machine_mode m_mode;
};
inline bool
scalar_mode::includes_p (machine_mode m)
{
switch (((enum mode_class) mode_class[m]))
{
case MODE_INT:
case MODE_PARTIAL_INT:
case MODE_FRACT:
case MODE_UFRACT:
case MODE_ACCUM:
case MODE_UACCUM:
case MODE_FLOAT:
case MODE_DECIMAL_FLOAT:
return true;
default:
return false;
}
}
class complex_mode
{
public:
typedef mode_traits<complex_mode>::from_int from_int;
typedef unsigned short measurement_type;
inline __attribute__ ((always_inline)) complex_mode () {}
inline __attribute__ ((always_inline)) constexpr
complex_mode (from_int m) : m_mode (machine_mode (m)) {}
inline __attribute__ ((always_inline)) constexpr operator machine_mode () const { return m_mode; }
static bool includes_p (machine_mode);
protected:
machine_mode m_mode;
};
inline bool
complex_mode::includes_p (machine_mode m)
{
return (((enum mode_class) mode_class[m]) == MODE_COMPLEX_INT || ((enum mode_class) mode_class[m]) == MODE_COMPLEX_FLOAT);
}
inline __attribute__ ((always_inline)) poly_uint16
mode_to_bytes (machine_mode mode)
{
return (__builtin_constant_p (mode)
? mode_size_inline (mode) : mode_size[mode]);
}
inline __attribute__ ((always_inline)) poly_uint16
mode_to_bits (machine_mode mode)
{
return mode_to_bytes (mode) * (8);
}
inline __attribute__ ((always_inline)) poly_uint16
mode_to_precision (machine_mode mode)
{
return mode_precision[mode];
}
inline __attribute__ ((always_inline)) scalar_mode
mode_to_inner (machine_mode mode)
{
return scalar_mode::from_int (__builtin_constant_p (mode)
? mode_inner_inline (mode)
: mode_inner[mode]);
}
inline __attribute__ ((always_inline)) unsigned char
mode_to_unit_size (machine_mode mode)
{
return (__builtin_constant_p (mode)
? mode_unit_size_inline (mode) : mode_unit_size[mode]);
}
inline __attribute__ ((always_inline)) unsigned short
mode_to_unit_precision (machine_mode mode)
{
return (__builtin_constant_p (mode)
? mode_unit_precision_inline (mode) : mode_unit_precision[mode]);
}
inline __attribute__ ((always_inline)) poly_uint16
mode_to_nunits (machine_mode mode)
{
return (__builtin_constant_p (mode)
? mode_nunits_inline (mode) : mode_nunits[mode]);
}
inline __attribute__ ((always_inline)) poly_uint16
GET_MODE_SIZE (machine_mode mode)
{
return mode_to_bytes (mode);
}
template<typename T>
inline __attribute__ ((always_inline)) typename if_poly<typename T::measurement_type>::type
GET_MODE_SIZE (const T &mode)
{
return mode_to_bytes (mode);
}
template<typename T>
inline __attribute__ ((always_inline)) typename if_nonpoly<typename T::measurement_type>::type
GET_MODE_SIZE (const T &mode)
{
return mode_to_bytes (mode).coeffs[0];
}
inline __attribute__ ((always_inline)) poly_uint16
GET_MODE_BITSIZE (machine_mode mode)
{
return mode_to_bits (mode);
}
template<typename T>
inline __attribute__ ((always_inline)) typename if_poly<typename T::measurement_type>::type
GET_MODE_BITSIZE (const T &mode)
{
return mode_to_bits (mode);
}
template<typename T>
inline __attribute__ ((always_inline)) typename if_nonpoly<typename T::measurement_type>::type
GET_MODE_BITSIZE (const T &mode)
{
return mode_to_bits (mode).coeffs[0];
}
# 679 "/home/giulianob/gcc_git_gnu/gcc/gcc/machmode.h"
inline __attribute__ ((always_inline)) poly_uint16
GET_MODE_PRECISION (machine_mode mode)
{
return mode_to_precision (mode);
}
template<typename T>
inline __attribute__ ((always_inline)) typename if_poly<typename T::measurement_type>::type
GET_MODE_PRECISION (const T &mode)
{
return mode_to_precision (mode);
}
template<typename T>
inline __attribute__ ((always_inline)) typename if_nonpoly<typename T::measurement_type>::type
GET_MODE_PRECISION (const T &mode)
{
return mode_to_precision (mode).coeffs[0];
}
extern const unsigned char mode_ibit[NUM_MACHINE_MODES];
extern const unsigned char mode_fbit[NUM_MACHINE_MODES];
extern const unsigned long mode_mask_array[NUM_MACHINE_MODES];
# 737 "/home/giulianob/gcc_git_gnu/gcc/gcc/machmode.h"
inline __attribute__ ((always_inline)) poly_uint16
GET_MODE_NUNITS (machine_mode mode)
{
return mode_to_nunits (mode);
}
template<typename T>
inline __attribute__ ((always_inline)) typename if_poly<typename T::measurement_type>::type
GET_MODE_NUNITS (const T &mode)
{
return mode_to_nunits (mode);
}
template<typename T>
inline __attribute__ ((always_inline)) typename if_nonpoly<typename T::measurement_type>::type
GET_MODE_NUNITS (const T &mode)
{
return mode_to_nunits (mode).coeffs[0];
}
template<typename T>
inline __attribute__ ((always_inline)) opt_mode<T>
GET_MODE_WIDER_MODE (const T &m)
{
return typename opt_mode<T>::from_int (mode_wider[m]);
}
template<typename T>
inline __attribute__ ((always_inline)) opt_mode<T>
GET_MODE_2XWIDER_MODE (const T &m)
{
return typename opt_mode<T>::from_int (mode_2xwider[m]);
}
extern const unsigned char mode_complex[NUM_MACHINE_MODES];
class fixed_size_mode
{
public:
typedef mode_traits<fixed_size_mode>::from_int from_int;
typedef unsigned short measurement_type;
inline __attribute__ ((always_inline)) fixed_size_mode () {}
inline __attribute__ ((always_inline)) constexpr
fixed_size_mode (from_int m) : m_mode (machine_mode (m)) {}
inline __attribute__ ((always_inline)) constexpr
fixed_size_mode (const scalar_mode &m) : m_mode (m) {}
inline __attribute__ ((always_inline)) constexpr
fixed_size_mode (const scalar_int_mode &m) : m_mode (m) {}
inline __attribute__ ((always_inline)) constexpr
fixed_size_mode (const scalar_float_mode &m) : m_mode (m) {}
inline __attribute__ ((always_inline)) constexpr
fixed_size_mode (const scalar_mode_pod &m) : m_mode (m) {}
inline __attribute__ ((always_inline)) constexpr
fixed_size_mode (const scalar_int_mode_pod &m) : m_mode (m) {}
inline __attribute__ ((always_inline)) constexpr
fixed_size_mode (const complex_mode &m) : m_mode (m) {}
inline __attribute__ ((always_inline)) constexpr operator machine_mode () const { return m_mode; }
static bool includes_p (machine_mode);
protected:
machine_mode m_mode;
};
inline bool
fixed_size_mode::includes_p (machine_mode mode)
{
return mode_to_bytes (mode).is_constant ();
}
# 841 "/home/giulianob/gcc_git_gnu/gcc/gcc/machmode.h"
extern opt_machine_mode mode_for_size (poly_uint64, enum mode_class, int);
inline opt_scalar_int_mode
int_mode_for_size (poly_uint64 size, int limit)
{
return dyn_cast <scalar_int_mode> (mode_for_size (size, MODE_INT, limit));
}
inline opt_scalar_float_mode
float_mode_for_size (poly_uint64 size)
{
return dyn_cast <scalar_float_mode> (mode_for_size (size, MODE_FLOAT, 0));
}
inline opt_scalar_float_mode
decimal_float_mode_for_size (unsigned int size)
{
return dyn_cast <scalar_float_mode>
(mode_for_size (size, MODE_DECIMAL_FLOAT, 0));
}
extern machine_mode smallest_mode_for_size (poly_uint64, enum mode_class);
inline scalar_int_mode
smallest_int_mode_for_size (poly_uint64 size)
{
return as_a <scalar_int_mode> (smallest_mode_for_size (size, MODE_INT));
}
extern opt_scalar_int_mode int_mode_for_mode (machine_mode);
extern opt_machine_mode bitwise_mode_for_mode (machine_mode);
extern opt_machine_mode mode_for_vector (scalar_mode, poly_uint64);
extern opt_machine_mode related_vector_mode (machine_mode, scalar_mode,
poly_uint64 = 0);
extern opt_machine_mode related_int_vector_mode (machine_mode);
class bit_field_mode_iterator
{
public:
bit_field_mode_iterator (long, long,
poly_int64, poly_int64,
unsigned int, bool);
bool next_mode (scalar_int_mode *);
bool prefer_smaller_modes ();
private:
opt_scalar_int_mode m_mode;
long m_bitsize;
long m_bitpos;
poly_int64 m_bitregion_start;
poly_int64 m_bitregion_end;
unsigned int m_align;
bool m_volatilep;
int m_count;
};
extern bool get_best_mode (int, int, poly_uint64, poly_uint64, unsigned int,
unsigned long, bool, scalar_int_mode *);
extern unsigned short mode_base_align[NUM_MACHINE_MODES];
extern unsigned get_mode_alignment (machine_mode);
extern const unsigned char class_narrowest_mode[MAX_MODE_CLASS];
# 939 "/home/giulianob/gcc_git_gnu/gcc/gcc/machmode.h"
template<typename T>
inline T
get_narrowest_mode (T mode)
{
return typename mode_traits<T>::from_int
(class_narrowest_mode[((enum mode_class) mode_class[mode])]);
}
extern scalar_int_mode byte_mode;
extern scalar_int_mode word_mode;
extern scalar_int_mode ptr_mode;
extern void init_adjust_machine_modes (void);
# 964 "/home/giulianob/gcc_git_gnu/gcc/gcc/machmode.h"
inline bool
HWI_COMPUTABLE_MODE_P (machine_mode mode)
{
machine_mode mme = mode;
return ((((enum mode_class) mode_class[mme]) == MODE_INT || ((enum mode_class) mode_class[mme]) == MODE_PARTIAL_INT)
&& mode_to_precision (mme).coeffs[0] <= 64);
}
inline bool
HWI_COMPUTABLE_MODE_P (scalar_int_mode mode)
{
return GET_MODE_PRECISION (mode) <= 64;
}
struct int_n_data_t {
unsigned int bitsize;
scalar_int_mode_pod m;
};
extern bool int_n_enabled_p[1];
extern const int_n_data_t int_n_data[1];
template<typename T>
inline bool
is_int_mode (machine_mode mode, T *int_mode)
{
if (((enum mode_class) mode_class[mode]) == MODE_INT)
{
*int_mode = scalar_int_mode (scalar_int_mode::from_int (mode));
return true;
}
return false;
}
template<typename T>
inline bool
is_float_mode (machine_mode mode, T *float_mode)
{
if (((enum mode_class) mode_class[mode]) == MODE_FLOAT)
{
*float_mode = scalar_float_mode (scalar_float_mode::from_int (mode));
return true;
}
return false;
}
template<typename T>
inline bool
is_complex_int_mode (machine_mode mode, T *cmode)
{
if (((enum mode_class) mode_class[mode]) == MODE_COMPLEX_INT)
{
*cmode = complex_mode (complex_mode::from_int (mode));
return true;
}
return false;
}
template<typename T>
inline bool
is_complex_float_mode (machine_mode mode, T *cmode)
{
if (((enum mode_class) mode_class[mode]) == MODE_COMPLEX_FLOAT)
{
*cmode = complex_mode (complex_mode::from_int (mode));
return true;
}
return false;
}
inline bool
is_narrower_int_mode (machine_mode mode, scalar_int_mode limit)
{
scalar_int_mode int_mode;
return (is_a <scalar_int_mode> (mode, &int_mode)
&& GET_MODE_PRECISION (int_mode) < GET_MODE_PRECISION (limit));
}
namespace mode_iterator
{
template<typename T>
inline void
start (opt_mode<T> *iter, enum mode_class mclass)
{
if (((machine_mode) class_narrowest_mode[mclass]) == E_VOIDmode)
*iter = opt_mode<T> ();
else
*iter = as_a<T> (((machine_mode) class_narrowest_mode[mclass]));
}
inline void
start (machine_mode *iter, enum mode_class mclass)
{
*iter = ((machine_mode) class_narrowest_mode[mclass]);
}
template<typename T>
inline bool
iterate_p (opt_mode<T> *iter)
{
return iter->exists ();
}
inline bool
iterate_p (machine_mode *iter)
{
return *iter != E_VOIDmode;
}
template<typename T>
inline void
get_wider (opt_mode<T> *iter)
{
*iter = GET_MODE_WIDER_MODE (iter->require ());
}
inline void
get_wider (machine_mode *iter)
{
*iter = GET_MODE_WIDER_MODE (*iter).else_void ();
}
template<typename T>
inline void
get_known_wider (T *iter)
{
*iter = GET_MODE_WIDER_MODE (*iter).require ();
}
template<typename T>
inline void
get_2xwider (opt_mode<T> *iter)
{
*iter = GET_MODE_2XWIDER_MODE (iter->require ());
}
inline void
get_2xwider (machine_mode *iter)
{
*iter = GET_MODE_2XWIDER_MODE (*iter).else_void ();
}
}
# 1183 "/home/giulianob/gcc_git_gnu/gcc/gcc/machmode.h"
template<typename T>
void
gt_ggc_mx (pod_mode<T> *)
{
}
template<typename T>
void
gt_pch_nx (pod_mode<T> *)
{
}
template<typename T>
void
gt_pch_nx (pod_mode<T> *, void (*) (void *, void *), void *)
{
}
# 470 "/home/giulianob/gcc_git_gnu/gcc/gcc/coretypes.h" 2
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/double-int.h" 1
# 49 "/home/giulianob/gcc_git_gnu/gcc/gcc/double-int.h"
struct double_int
{
static double_int from_uhwi (unsigned long cst);
static double_int from_shwi (long cst);
static double_int from_pair (long high, unsigned long low);
static double_int from_buffer (const unsigned char *buffer, int len);
static double_int mask (unsigned prec);
static double_int max_value (unsigned int prec, bool uns);
static double_int min_value (unsigned int prec, bool uns);
double_int &operator ++ ();
double_int &operator -- ();
double_int &operator *= (double_int);
double_int &operator += (double_int);
double_int &operator -= (double_int);
double_int &operator &= (double_int);
double_int &operator ^= (double_int);
double_int &operator |= (double_int);
long to_shwi () const;
unsigned long to_uhwi () const;
bool fits_uhwi () const;
bool fits_shwi () const;
bool fits_hwi (bool uns) const;
int trailing_zeros () const;
int popcount () const;
bool multiple_of (double_int, bool, double_int *) const;
double_int set_bit (unsigned) const;
double_int mul_with_sign (double_int, bool unsigned_p, bool *overflow) const;
double_int wide_mul_with_sign (double_int, bool unsigned_p,
double_int *higher, bool *overflow) const;
double_int add_with_sign (double_int, bool unsigned_p, bool *overflow) const;
double_int sub_with_overflow (double_int, bool *overflow) const;
double_int neg_with_overflow (bool *overflow) const;
double_int operator * (double_int) const;
double_int operator + (double_int) const;
double_int operator - (double_int) const;
double_int operator - () const;
double_int operator ~ () const;
double_int operator & (double_int) const;
double_int operator | (double_int) const;
double_int operator ^ (double_int) const;
double_int and_not (double_int) const;
double_int lshift (long count) const;
double_int lshift (long count, unsigned int prec, bool arith) const;
double_int rshift (long count) const;
double_int rshift (long count, unsigned int prec, bool arith) const;
double_int alshift (long count, unsigned int prec) const;
double_int arshift (long count, unsigned int prec) const;
double_int llshift (long count, unsigned int prec) const;
double_int lrshift (long count, unsigned int prec) const;
double_int lrotate (long count, unsigned int prec) const;
double_int rrotate (long count, unsigned int prec) const;
double_int div (double_int, bool, unsigned) const;
double_int sdiv (double_int, unsigned) const;
double_int udiv (double_int, unsigned) const;
double_int mod (double_int, bool, unsigned) const;
double_int smod (double_int, unsigned) const;
double_int umod (double_int, unsigned) const;
double_int divmod_with_overflow (double_int, bool, unsigned,
double_int *, bool *) const;
double_int divmod (double_int, bool, unsigned, double_int *) const;
double_int sdivmod (double_int, unsigned, double_int *) const;
double_int udivmod (double_int, unsigned, double_int *) const;
double_int ext (unsigned prec, bool uns) const;
double_int zext (unsigned prec) const;
double_int sext (unsigned prec) const;
bool is_zero () const;
bool is_one () const;
bool is_minus_one () const;
bool is_negative () const;
int cmp (double_int b, bool uns) const;
int ucmp (double_int b) const;
int scmp (double_int b) const;
bool ult (double_int b) const;
bool ule (double_int b) const;
bool ugt (double_int b) const;
bool slt (double_int b) const;
bool sle (double_int b) const;
bool sgt (double_int b) const;
double_int max (double_int b, bool uns);
double_int smax (double_int b);
double_int umax (double_int b);
double_int min (double_int b, bool uns);
double_int smin (double_int b);
double_int umin (double_int b);
bool operator == (double_int cst2) const;
bool operator != (double_int cst2) const;
unsigned long low;
long high;
};
# 207 "/home/giulianob/gcc_git_gnu/gcc/gcc/double-int.h"
inline double_int
double_int::from_shwi (long cst)
{
double_int r;
r.low = (unsigned long) cst;
r.high = cst < 0 ? -1 : 0;
return r;
}
# 230 "/home/giulianob/gcc_git_gnu/gcc/gcc/double-int.h"
inline double_int
double_int::from_uhwi (unsigned long cst)
{
double_int r;
r.low = cst;
r.high = 0;
return r;
}
inline double_int
double_int::from_pair (long high, unsigned long low)
{
double_int r;
r.low = low;
r.high = high;
return r;
}
inline double_int &
double_int::operator ++ ()
{
*this += (double_int::from_shwi (1));
return *this;
}
inline double_int &
double_int::operator -- ()
{
*this -= (double_int::from_shwi (1));
return *this;
}
inline double_int &
double_int::operator &= (double_int b)
{
*this = *this & b;
return *this;
}
inline double_int &
double_int::operator ^= (double_int b)
{
*this = *this ^ b;
return *this;
}
inline double_int &
double_int::operator |= (double_int b)
{
*this = *this | b;
return *this;
}
inline long
double_int::to_shwi () const
{
return (long) low;
}
inline unsigned long
double_int::to_uhwi () const
{
return low;
}
inline bool
double_int::fits_uhwi () const
{
return high == 0;
}
inline double_int
double_int::operator ~ () const
{
double_int result;
result.low = ~low;
result.high = ~high;
return result;
}
inline double_int
double_int::operator | (double_int b) const
{
double_int result;
result.low = low | b.low;
result.high = high | b.high;
return result;
}
inline double_int
double_int::operator & (double_int b) const
{
double_int result;
result.low = low & b.low;
result.high = high & b.high;
return result;
}
inline double_int
double_int::and_not (double_int b) const
{
double_int result;
result.low = low & ~b.low;
result.high = high & ~b.high;
return result;
}
inline double_int
double_int::operator ^ (double_int b) const
{
double_int result;
result.low = low ^ b.low;
result.high = high ^ b.high;
return result;
}
void dump_double_int (FILE *, double_int, bool);
# 376 "/home/giulianob/gcc_git_gnu/gcc/gcc/double-int.h"
inline bool
double_int::is_zero () const
{
return low == 0 && high == 0;
}
inline bool
double_int::is_one () const
{
return low == 1 && high == 0;
}
inline bool
double_int::is_minus_one () const
{
return low == -1UL && high == -1;
}
inline bool
double_int::is_negative () const
{
return high < 0;
}
inline bool
double_int::operator == (double_int cst2) const
{
return low == cst2.low && high == cst2.high;
}
inline bool
double_int::operator != (double_int cst2) const
{
return low != cst2.low || high != cst2.high;
}
inline int
double_int::popcount () const
{
return popcount_hwi (high) + popcount_hwi (low);
}
void mpz_set_double_int (mpz_t, double_int, bool);
double_int mpz_get_double_int (const_tree, mpz_t, bool);
namespace wi
{
template <>
struct int_traits <double_int>
{
static const enum precision_type precision_type = CONST_PRECISION;
static const bool host_dependent_precision = true;
static const unsigned int precision = (2 * 64);
static unsigned int get_precision (const double_int &);
static wi::storage_ref decompose (long *, unsigned int,
const double_int &);
};
}
inline unsigned int
wi::int_traits <double_int>::get_precision (const double_int &)
{
return precision;
}
inline wi::storage_ref
wi::int_traits <double_int>::decompose (long *scratch, unsigned int p,
const double_int &x)
{
((void)(!(precision == p) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/double-int.h", 462, __FUNCTION__), 0 : 0));
scratch[0] = x.low;
if ((x.high == 0 && scratch[0] >= 0) || (x.high == -1 && scratch[0] < 0))
return wi::storage_ref (scratch, 1, precision);
scratch[1] = x.high;
return wi::storage_ref (scratch, 2, precision);
}
# 471 "/home/giulianob/gcc_git_gnu/gcc/gcc/coretypes.h" 2
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/align.h" 1
# 22 "/home/giulianob/gcc_git_gnu/gcc/gcc/align.h"
struct align_flags_tuple
{
int log;
int maxskip;
void normalize ()
{
int n = (1 << log);
if (maxskip > n)
maxskip = n - 1;
}
int get_value ()
{
return maxskip + 1;
}
};
class align_flags
{
public:
align_flags (int log0 = 0, int maxskip0 = 0, int log1 = 0, int maxskip1 = 0)
{
levels[0].log = log0;
levels[0].maxskip = maxskip0;
levels[1].log = log1;
levels[1].maxskip = maxskip1;
normalize ();
}
void normalize ()
{
for (unsigned i = 0; i < 2; i++)
levels[i].normalize ();
}
static align_flags max (const align_flags f0, const align_flags f1)
{
int log0 = ((f0.levels[0].log) > (f1.levels[0].log) ? (f0.levels[0].log) : (f1.levels[0].log));
int maxskip0 = ((f0.levels[0].maxskip) > (f1.levels[0].maxskip) ? (f0.levels[0].maxskip) : (f1.levels[0].maxskip));
int log1 = ((f0.levels[1].log) > (f1.levels[1].log) ? (f0.levels[1].log) : (f1.levels[1].log));
int maxskip1 = ((f0.levels[1].maxskip) > (f1.levels[1].maxskip) ? (f0.levels[1].maxskip) : (f1.levels[1].maxskip));
return align_flags (log0, maxskip0, log1, maxskip1);
}
align_flags_tuple levels[2];
};
# 472 "/home/giulianob/gcc_git_gnu/gcc/gcc/coretypes.h" 2
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/real.h" 1
# 26 "/home/giulianob/gcc_git_gnu/gcc/gcc/real.h"
enum real_value_class {
rvc_zero,
rvc_normal,
rvc_inf,
rvc_nan
};
struct real_value {
unsigned int cl : 2;
unsigned int decimal : 1;
unsigned int sign : 1;
unsigned int signalling : 1;
unsigned int canonical : 1;
unsigned int uexp : (32 - 6);
unsigned long sig[((128 + (8 * 8)) / (8 * 8))];
};
# 80 "/home/giulianob/gcc_git_gnu/gcc/gcc/real.h"
extern char test_real_width
[sizeof (struct real_value) <= (((128 + (8 * 8)) + 32)/64 + (((128 + (8 * 8)) + 32)%64 ? 1 : 0)) * sizeof (long) ? 1 : -1];
# 118 "/home/giulianob/gcc_git_gnu/gcc/gcc/real.h"
struct real_format
{
void (*encode) (const struct real_format *, long *,
const struct real_value *);
void (*decode) (const struct real_format *, struct real_value *,
const long *);
int b;
int p;
int pnan;
int emin;
int emax;
int signbit_ro;
int signbit_rw;
# 158 "/home/giulianob/gcc_git_gnu/gcc/gcc/real.h"
int ieee_bits;
bool round_towards_zero;
bool has_sign_dependent_rounding;
bool has_nans;
bool has_inf;
bool has_denorm;
bool has_signed_zero;
bool qnan_msb_set;
bool canonical_nan_lsbs_set;
const char *name;
};
extern const struct real_format *
real_format_for_mode[MAX_MODE_FLOAT - MIN_MODE_FLOAT + 1
+ MAX_MODE_DECIMAL_FLOAT - MIN_MODE_DECIMAL_FLOAT + 1];
# 217 "/home/giulianob/gcc_git_gnu/gcc/gcc/real.h"
class format_helper
{
public:
format_helper (const real_format *format) : m_format (format) {}
template<typename T> format_helper (const T &);
const real_format *operator-> () const { return m_format; }
operator const real_format *() const { return m_format; }
bool decimal_p () const { return m_format && m_format->b == 10; }
bool can_represent_integral_type_p (tree type) const;
private:
const real_format *m_format;
};
template<typename T>
inline format_helper::format_helper (const T &m)
: m_format (m == ((void) 0, E_VOIDmode) ? 0 : (real_format_for_mode[(((enum mode_class) mode_class[m]) == MODE_DECIMAL_FLOAT) ? (((m) - MIN_MODE_DECIMAL_FLOAT) + (MAX_MODE_FLOAT - MIN_MODE_FLOAT + 1)) : ((enum mode_class) mode_class[m]) == MODE_FLOAT ? ((m) - MIN_MODE_FLOAT) : ((fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/real.h", 234, __FUNCTION__)), 0)]))
{}
# 244 "/home/giulianob/gcc_git_gnu/gcc/gcc/real.h"
extern bool HONOR_NANS (machine_mode);
extern bool HONOR_NANS (const_tree);
extern bool HONOR_NANS (const_rtx);
extern bool HONOR_SNANS (machine_mode);
extern bool HONOR_SNANS (const_tree);
extern bool HONOR_SNANS (const_rtx);
extern bool HONOR_INFINITIES (machine_mode);
extern bool HONOR_INFINITIES (const_tree);
extern bool HONOR_INFINITIES (const_rtx);
extern bool HONOR_SIGNED_ZEROS (machine_mode);
extern bool HONOR_SIGNED_ZEROS (const_tree);
extern bool HONOR_SIGNED_ZEROS (const_rtx);
extern bool HONOR_SIGN_DEPENDENT_ROUNDING (machine_mode);
extern bool HONOR_SIGN_DEPENDENT_ROUNDING (const_tree);
extern bool HONOR_SIGN_DEPENDENT_ROUNDING (const_rtx);
extern bool real_arithmetic (struct real_value *, int, const struct real_value *,
const struct real_value *);
extern bool real_compare (int, const struct real_value *, const struct real_value *);
extern bool real_isinf (const struct real_value *);
extern bool real_isnan (const struct real_value *);
extern bool real_issignaling_nan (const struct real_value *);
extern bool real_isfinite (const struct real_value *);
extern bool real_isneg (const struct real_value *);
extern bool real_isnegzero (const struct real_value *);
extern bool real_identical (const struct real_value *, const struct real_value *);
extern bool real_equal (const struct real_value *, const struct real_value *);
extern bool real_less (const struct real_value *, const struct real_value *);
extern void real_convert (struct real_value *, format_helper,
const struct real_value *);
extern bool exact_real_truncate (format_helper, const struct real_value *);
extern void real_to_decimal (char *, const struct real_value *, size_t,
size_t, int);
extern void real_to_decimal_for_mode (char *, const struct real_value *, size_t,
size_t, int, machine_mode);
extern void real_to_hexadecimal (char *, const struct real_value *,
size_t, size_t, int);
extern long real_to_integer (const struct real_value *);
extern int real_from_string (struct real_value *, const char *);
extern void real_from_string3 (struct real_value *, const char *, format_helper);
extern long real_to_target (long *, const struct real_value *, format_helper);
extern void real_from_target (struct real_value *, const long *,
format_helper);
extern void real_inf (struct real_value *);
extern bool real_nan (struct real_value *, const char *, int, format_helper);
extern void real_maxval (struct real_value *, int, machine_mode);
extern void real_2expN (struct real_value *, int, format_helper);
extern unsigned int real_hash (const struct real_value *);
extern const struct real_format ieee_single_format;
extern const struct real_format mips_single_format;
extern const struct real_format motorola_single_format;
extern const struct real_format spu_single_format;
extern const struct real_format ieee_double_format;
extern const struct real_format mips_double_format;
extern const struct real_format motorola_double_format;
extern const struct real_format ieee_extended_motorola_format;
extern const struct real_format ieee_extended_intel_96_format;
extern const struct real_format ieee_extended_intel_96_round_53_format;
extern const struct real_format ieee_extended_intel_128_format;
extern const struct real_format ibm_extended_format;
extern const struct real_format mips_extended_format;
extern const struct real_format ieee_quad_format;
extern const struct real_format mips_quad_format;
extern const struct real_format vax_f_format;
extern const struct real_format vax_d_format;
extern const struct real_format vax_g_format;
extern const struct real_format real_internal_format;
extern const struct real_format decimal_single_format;
extern const struct real_format decimal_double_format;
extern const struct real_format decimal_quad_format;
extern const struct real_format ieee_half_format;
extern const struct real_format arm_half_format;
extern const struct real_format arm_bfloat_half_format;
# 418 "/home/giulianob/gcc_git_gnu/gcc/gcc/real.h"
extern struct real_value real_value_truncate (format_helper, struct real_value);
extern struct real_value real_value_negate (const struct real_value *);
extern struct real_value real_value_abs (const struct real_value *);
extern int significand_size (format_helper);
extern struct real_value real_from_string2 (const char *, format_helper);
# 443 "/home/giulianob/gcc_git_gnu/gcc/gcc/real.h"
extern int real_exponent (const struct real_value *);
extern void real_ldexp (struct real_value *, const struct real_value *, int);
extern struct real_value dconst0;
extern struct real_value dconst1;
extern struct real_value dconst2;
extern struct real_value dconstm1;
extern struct real_value dconsthalf;
# 466 "/home/giulianob/gcc_git_gnu/gcc/gcc/real.h"
extern const struct real_value * dconst_e_ptr (void);
extern const struct real_value *dconst_third_ptr (void);
extern const struct real_value *dconst_quarter_ptr (void);
extern const struct real_value *dconst_sixth_ptr (void);
extern const struct real_value *dconst_ninth_ptr (void);
extern const struct real_value * dconst_sqrt2_ptr (void);
struct real_value real_value_from_int_cst (const_tree, const_tree);
extern rtx const_double_from_real_value (struct real_value, machine_mode);
extern bool exact_real_inverse (format_helper, struct real_value *);
bool real_can_shorten_arithmetic (machine_mode, machine_mode);
extern tree build_real (tree, struct real_value);
extern tree build_real_truncate (tree, struct real_value);
extern bool real_powi (struct real_value *, format_helper,
const struct real_value *, long);
extern void real_trunc (struct real_value *, format_helper,
const struct real_value *);
extern void real_floor (struct real_value *, format_helper,
const struct real_value *);
extern void real_ceil (struct real_value *, format_helper,
const struct real_value *);
extern void real_round (struct real_value *, format_helper,
const struct real_value *);
extern void real_roundeven (struct real_value *, format_helper,
const struct real_value *);
extern void real_copysign (struct real_value *, const struct real_value *);
extern bool real_isinteger (const struct real_value *, format_helper);
extern bool real_isinteger (const struct real_value *, long *);
extern bool real_nextafter (struct real_value *, format_helper,
const struct real_value *, const struct real_value *);
extern void get_max_float (const struct real_format *, char *, size_t, bool);
extern wide_int real_to_integer (const struct real_value *, bool *, int);
extern void real_from_integer (struct real_value *, format_helper,
const wide_int_ref &, signop);
extern void build_sinatan_real (struct real_value *, tree);
# 475 "/home/giulianob/gcc_git_gnu/gcc/gcc/coretypes.h" 2
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/fixed-value.h" 1
# 23 "/home/giulianob/gcc_git_gnu/gcc/gcc/fixed-value.h"
struct fixed_value
{
double_int data;
scalar_mode_pod mode;
};
# 36 "/home/giulianob/gcc_git_gnu/gcc/gcc/fixed-value.h"
extern struct fixed_value fconst0[18];
extern struct fixed_value fconst1[8];
# 46 "/home/giulianob/gcc_git_gnu/gcc/gcc/fixed-value.h"
extern rtx const_fixed_from_fixed_value (struct fixed_value, machine_mode);
extern struct fixed_value fixed_from_double_int (double_int, scalar_mode);
static inline rtx
const_fixed_from_double_int (double_int payload,
scalar_mode mode)
{
return
const_fixed_from_fixed_value (fixed_from_double_int (payload, mode),
mode);
}
extern void fixed_from_string (struct fixed_value *, const char *,
scalar_mode);
extern tree build_fixed (tree, struct fixed_value);
extern bool fixed_convert (struct fixed_value *, scalar_mode,
const struct fixed_value *, bool);
extern bool fixed_convert_from_int (struct fixed_value *, scalar_mode,
double_int, bool, bool);
extern bool fixed_convert_from_real (struct fixed_value *, scalar_mode,
const struct real_value *, bool);
extern void real_convert_from_fixed (struct real_value *, scalar_mode,
const struct fixed_value *);
extern bool fixed_identical (const struct fixed_value *, const struct fixed_value *);
extern unsigned int fixed_hash (const struct fixed_value *);
extern void fixed_to_decimal (char *str, const struct fixed_value *, size_t);
extern bool fixed_arithmetic (struct fixed_value *, int, const struct fixed_value *,
const struct fixed_value *, bool);
extern bool fixed_compare (int, const struct fixed_value *,
const struct fixed_value *);
extern bool fixed_isneg (const struct fixed_value *);
# 476 "/home/giulianob/gcc_git_gnu/gcc/gcc/coretypes.h" 2
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/hash-table.h" 1
# 246 "/home/giulianob/gcc_git_gnu/gcc/gcc/hash-table.h"
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/statistics.h" 1
# 61 "/home/giulianob/gcc_git_gnu/gcc/gcc/statistics.h"
struct function;
extern void statistics_early_init (void);
extern void statistics_init (void);
extern void statistics_fini (void);
extern void statistics_fini_pass (void);
extern void statistics_counter_event (struct function *, const char *, int);
extern void statistics_histogram_event (struct function *, const char *, int);
# 247 "/home/giulianob/gcc_git_gnu/gcc/gcc/hash-table.h" 2
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/ggc.h" 1
# 30 "/home/giulianob/gcc_git_gnu/gcc/gcc/ggc.h"
# 1 "./gtype-desc.h" 1
# 31 "./gtype-desc.h"
extern void gt_ggc_mx_line_maps (void *);
extern void gt_ggc_mx_cpp_token (void *);
extern void gt_ggc_mx_cpp_macro (void *);
extern void gt_ggc_mx_string_concat (void *);
extern void gt_ggc_mx_string_concat_db (void *);
extern void gt_ggc_mx_hash_map_location_hash_string_concat__ (void *);
extern void gt_ggc_mx_bitmap_head (void *);
extern void gt_ggc_mx_rtx_def (void *);
extern void gt_ggc_mx_rtvec_def (void *);
extern void gt_ggc_mx_gimple (void *);
extern void gt_ggc_mx_symtab_node (void *);
extern void gt_ggc_mx_cgraph_edge (void *);
extern void gt_ggc_mx_section (void *);
extern void gt_ggc_mx_cl_target_option (void *);
extern void gt_ggc_mx_cl_optimization (void *);
extern void gt_ggc_mx_edge_def (void *);
extern void gt_ggc_mx_basic_block_def (void *);
extern void gt_ggc_mx_stack_local_entry (void *);
extern void gt_ggc_mx_machine_function (void *);
extern void gt_ggc_mx_bitmap_element (void *);
extern void gt_ggc_mx_generic_wide_int_wide_int_storage_ (void *);
extern void gt_ggc_mx_coverage_data (void *);
extern void gt_ggc_mx_mem_attrs (void *);
extern void gt_ggc_mx_reg_attrs (void *);
extern void gt_ggc_mx_object_block (void *);
extern void gt_ggc_mx_vec_rtx_va_gc_ (void *);
extern void gt_ggc_mx_real_value (void *);
extern void gt_ggc_mx_fixed_value (void *);
extern void gt_ggc_mx_constant_descriptor_rtx (void *);
extern void gt_ggc_mx_function (void *);
extern void gt_ggc_mx_target_rtl (void *);
extern void gt_ggc_mx_cgraph_rtl_info (void *);
extern void gt_ggc_mx_hash_map_tree_tree_decl_tree_cache_traits_ (void *);
extern void gt_ggc_mx_hash_map_tree_tree_type_tree_cache_traits_ (void *);
extern void gt_ggc_mx_ptr_info_def (void *);
extern void gt_ggc_mx_range_info_def (void *);
extern void gt_ggc_mx_die_struct (void *);
extern void gt_ggc_mx_vec_constructor_elt_va_gc_ (void *);
extern void gt_ggc_mx_vec_tree_va_gc_ (void *);
extern void gt_ggc_mx_lang_type (void *);
extern void gt_ggc_mx_lang_decl (void *);
extern void gt_ggc_mx_tree_statement_list_node (void *);
extern void gt_ggc_mx_target_globals (void *);
extern void gt_ggc_mx_lang_tree_node (void *);
extern void gt_ggc_mx_tree_map (void *);
extern void gt_ggc_mx_tree_decl_map (void *);
extern void gt_ggc_mx_tree_int_map (void *);
extern void gt_ggc_mx_tree_vec_map (void *);
extern void gt_ggc_mx_vec_alias_pair_va_gc_ (void *);
extern void gt_ggc_mx_libfunc_entry (void *);
extern void gt_ggc_mx_hash_table_libfunc_hasher_ (void *);
extern void gt_ggc_mx_target_libfuncs (void *);
extern void gt_ggc_mx_sequence_stack (void *);
extern void gt_ggc_mx_vec_rtx_insn__va_gc_ (void *);
extern void gt_ggc_mx_call_site_record_d (void *);
extern void gt_ggc_mx_vec_uchar_va_gc_ (void *);
extern void gt_ggc_mx_vec_call_site_record_va_gc_ (void *);
extern void gt_ggc_mx_gimple_df (void *);
extern void gt_ggc_mx_dw_fde_node (void *);
extern void gt_ggc_mx_rtx_constant_pool (void *);
extern void gt_ggc_mx_frame_space (void *);
extern void gt_ggc_mx_vec_callinfo_callee_va_gc_ (void *);
extern void gt_ggc_mx_vec_callinfo_dalloc_va_gc_ (void *);
extern void gt_ggc_mx_stack_usage (void *);
extern void gt_ggc_mx_eh_status (void *);
extern void gt_ggc_mx_control_flow_graph (void *);
extern void gt_ggc_mx_loops (void *);
extern void gt_ggc_mx_language_function (void *);
extern void gt_ggc_mx_hash_set_tree_ (void *);
extern void gt_ggc_mx_types_used_by_vars_entry (void *);
extern void gt_ggc_mx_hash_table_used_type_hasher_ (void *);
extern void gt_ggc_mx_nb_iter_bound (void *);
extern void gt_ggc_mx_loop_exit (void *);
extern void gt_ggc_mx_loop (void *);
extern void gt_ggc_mx_control_iv (void *);
extern void gt_ggc_mx_vec_loop_p_va_gc_ (void *);
extern void gt_ggc_mx_niter_desc (void *);
extern void gt_ggc_mx_hash_table_loop_exit_hasher_ (void *);
extern void gt_ggc_mx_vec_basic_block_va_gc_ (void *);
extern void gt_ggc_mx_rtl_bb_info (void *);
extern void gt_ggc_mx_vec_edge_va_gc_ (void *);
extern void gt_ggc_mx_vec_ipa_ref_t_va_gc_ (void *);
extern void gt_ggc_mx_section_hash_entry (void *);
extern void gt_ggc_mx_lto_file_decl_data (void *);
extern void gt_ggc_mx_ipa_replace_map (void *);
extern void gt_ggc_mx_vec_ipa_replace_map__va_gc_ (void *);
extern void gt_ggc_mx_ipa_param_adjustments (void *);
extern void gt_ggc_mx_vec_ipa_param_performed_split_va_gc_ (void *);
extern void gt_ggc_mx_cgraph_simd_clone (void *);
extern void gt_ggc_mx_cgraph_function_version_info (void *);
extern void gt_ggc_mx_hash_table_cgraph_edge_hasher_ (void *);
extern void gt_ggc_mx_cgraph_indirect_call_info (void *);
extern void gt_ggc_mx_asm_node (void *);
extern void gt_ggc_mx_symbol_table (void *);
extern void gt_ggc_mx_hash_table_section_name_hasher_ (void *);
extern void gt_ggc_mx_hash_table_asmname_hasher_ (void *);
extern void gt_ggc_mx_hash_map_symtab_node__symbol_priority_map_ (void *);
extern void gt_ggc_mx_constant_descriptor_tree (void *);
extern void gt_ggc_mx_hash_map_alias_set_hash_int_ (void *);
extern void gt_ggc_mx_alias_set_entry (void *);
extern void gt_ggc_mx_vec_alias_set_entry__va_gc_ (void *);
extern void gt_ggc_mx_hash_table_function_version_hasher_ (void *);
extern void gt_ggc_mx_lto_in_decl_state (void *);
extern void gt_ggc_mx_hash_table_ipa_bit_ggc_hash_traits_ (void *);
extern void gt_ggc_mx_hash_table_ipa_vr_ggc_hash_traits_ (void *);
extern void gt_ggc_mx_ipa_node_params (void *);
extern void gt_ggc_mx_ipa_edge_args (void *);
extern void gt_ggc_mx_ipa_agg_replacement_value (void *);
extern void gt_ggc_mx_ipa_fn_summary (void *);
extern void gt_ggc_mx_odr_type_d (void *);
extern void gt_ggc_mx_vec_ipa_adjusted_param_va_gc_ (void *);
extern void gt_ggc_mx_param_access (void *);
extern void gt_ggc_mx_vec_param_access__va_gc_ (void *);
extern void gt_ggc_mx_isra_func_summary (void *);
extern void gt_ggc_mx_vec_isra_param_desc_va_gc_ (void *);
extern void gt_ggc_mx_ipa_sra_function_summaries (void *);
extern void gt_ggc_mx_typeinfo (void *);
extern void gt_ggc_mx_dw_cfi_node (void *);
extern void gt_ggc_mx_dw_loc_descr_node (void *);
extern void gt_ggc_mx_dw_loc_list_struct (void *);
extern void gt_ggc_mx_dw_discr_list_node (void *);
extern void gt_ggc_mx_dw_cfa_location (void *);
extern void gt_ggc_mx_vec_dw_cfi_ref_va_gc_ (void *);
extern void gt_ggc_mx_addr_table_entry (void *);
extern void gt_ggc_mx_indirect_string_node (void *);
extern void gt_ggc_mx_dwarf_file_data (void *);
extern void gt_ggc_mx_hash_map_char__tree_ (void *);
extern void gt_ggc_mx_dw_cfi_row (void *);
extern void gt_ggc_mx_reg_saved_in_data (void *);
extern void gt_ggc_mx_vec_dw_fde_ref_va_gc_ (void *);
extern void gt_ggc_mx_hash_table_indirect_string_hasher_ (void *);
extern void gt_ggc_mx_comdat_type_node (void *);
extern void gt_ggc_mx_vec_dw_line_info_entry_va_gc_ (void *);
extern void gt_ggc_mx_dw_line_info_table (void *);
extern void gt_ggc_mx_vec_dw_attr_node_va_gc_ (void *);
extern void gt_ggc_mx_limbo_die_struct (void *);
extern void gt_ggc_mx_hash_table_dwarf_file_hasher_ (void *);
extern void gt_ggc_mx_hash_table_decl_die_hasher_ (void *);
extern void gt_ggc_mx_vec_dw_die_ref_va_gc_ (void *);
extern void gt_ggc_mx_variable_value_struct (void *);
extern void gt_ggc_mx_hash_table_variable_value_hasher_ (void *);
extern void gt_ggc_mx_hash_table_block_die_hasher_ (void *);
extern void gt_ggc_mx_var_loc_node (void *);
extern void gt_ggc_mx_var_loc_list_def (void *);
extern void gt_ggc_mx_call_arg_loc_node (void *);
extern void gt_ggc_mx_hash_table_decl_loc_hasher_ (void *);
extern void gt_ggc_mx_cached_dw_loc_list_def (void *);
extern void gt_ggc_mx_hash_table_dw_loc_list_hasher_ (void *);
extern void gt_ggc_mx_vec_dw_line_info_table__va_gc_ (void *);
extern void gt_ggc_mx_vec_pubname_entry_va_gc_ (void *);
extern void gt_ggc_mx_vec_macinfo_entry_va_gc_ (void *);
extern void gt_ggc_mx_vec_dw_ranges_va_gc_ (void *);
extern void gt_ggc_mx_vec_dw_ranges_by_label_va_gc_ (void *);
extern void gt_ggc_mx_vec_die_arg_entry_va_gc_ (void *);
extern void gt_ggc_mx_hash_table_addr_hasher_ (void *);
extern void gt_ggc_mx_hash_map_tree_sym_off_pair_ (void *);
extern void gt_ggc_mx_inline_entry_data (void *);
extern void gt_ggc_mx_hash_table_inline_entry_data_hasher_ (void *);
extern void gt_ggc_mx_temp_slot (void *);
extern void gt_ggc_mx_initial_value_struct (void *);
extern void gt_ggc_mx_vec_temp_slot_p_va_gc_ (void *);
extern void gt_ggc_mx_hash_table_const_int_hasher_ (void *);
extern void gt_ggc_mx_hash_table_const_wide_int_hasher_ (void *);
extern void gt_ggc_mx_hash_table_const_poly_int_hasher_ (void *);
extern void gt_ggc_mx_hash_table_reg_attr_hasher_ (void *);
extern void gt_ggc_mx_hash_table_const_double_hasher_ (void *);
extern void gt_ggc_mx_hash_table_const_fixed_hasher_ (void *);
extern void gt_ggc_mx_eh_region_d (void *);
extern void gt_ggc_mx_eh_landing_pad_d (void *);
extern void gt_ggc_mx_eh_catch_d (void *);
extern void gt_ggc_mx_vec_eh_region_va_gc_ (void *);
extern void gt_ggc_mx_vec_eh_landing_pad_va_gc_ (void *);
extern void gt_ggc_mx_hash_map_gimple__int_ (void *);
extern void gt_ggc_mx_hash_table_insn_cache_hasher_ (void *);
extern void gt_ggc_mx_temp_slot_address_entry (void *);
extern void gt_ggc_mx_hash_table_temp_address_hasher_ (void *);
extern void gt_ggc_mx_hash_map_tree_hash_tree_ (void *);
extern void gt_ggc_mx_test_struct (void *);
extern void gt_ggc_mx_test_of_length (void *);
extern void gt_ggc_mx_test_other (void *);
extern void gt_ggc_mx_test_of_union (void *);
extern void gt_ggc_mx_example_base (void *);
extern void gt_ggc_mx_test_node (void *);
extern void gt_ggc_mx_user_struct (void *);
extern void gt_ggc_mx_hash_table_libfunc_decl_hasher_ (void *);
extern void gt_ggc_mx_string_pool_data (void *);
extern void gt_ggc_mx_type_hash (void *);
extern void gt_ggc_mx_hash_table_type_cache_hasher_ (void *);
extern void gt_ggc_mx_hash_table_int_cst_hasher_ (void *);
extern void gt_ggc_mx_hash_table_poly_int_cst_hasher_ (void *);
extern void gt_ggc_mx_hash_table_cl_option_hasher_ (void *);
extern void gt_ggc_mx_hash_table_tree_decl_map_cache_hasher_ (void *);
extern void gt_ggc_mx_hash_table_tree_vec_map_cache_hasher_ (void *);
extern void gt_ggc_mx_hash_table_section_hasher_ (void *);
extern void gt_ggc_mx_hash_table_object_block_hasher_ (void *);
extern void gt_ggc_mx_hash_table_tree_descriptor_hasher_ (void *);
extern void gt_ggc_mx_hash_table_const_rtx_desc_hasher_ (void *);
extern void gt_ggc_mx_hash_table_tm_clone_hasher_ (void *);
extern void gt_ggc_mx_tm_restart_node (void *);
extern void gt_ggc_mx_hash_map_tree_tree_ (void *);
extern void gt_ggc_mx_hash_table_ssa_name_hasher_ (void *);
extern void gt_ggc_mx_hash_table_tm_restart_hasher_ (void *);
extern void gt_ggc_mx_vec_mem_addr_template_va_gc_ (void *);
extern void gt_ggc_mx_scev_info_str (void *);
extern void gt_ggc_mx_hash_table_scev_info_hasher_ (void *);
extern void gt_ggc_mx_ssa_operand_memory_d (void *);
extern void gt_ggc_mx_vec_omp_declare_variant_entry_va_gc_ (void *);
extern void gt_ggc_mx_omp_declare_variant_base_entry (void *);
extern void gt_ggc_mx_hash_table_omp_declare_variant_hasher_ (void *);
extern void gt_ggc_mx_hash_table_omp_declare_variant_alt_hasher_ (void *);
extern void gt_ggc_mx_hash_table_dllimport_hasher_ (void *);
extern void gt_ggc_mx_hash_map_char__unsigned_ (void *);
extern void gt_ggc_mx_vec_gimple__va_gc_ (void *);
extern void gt_ggc_mx_int_range_1_ (void *);
extern void gt_ggc_mx_vec_ipa_agg_jf_item_va_gc_ (void *);
extern void gt_ggc_mx_ipa_bits (void *);
extern void gt_ggc_mx_vec_ipa_param_descriptor_va_gc_ (void *);
extern void gt_ggc_mx_vec_ipa_bits__va_gc_ (void *);
extern void gt_ggc_mx_vec_ipa_vr_va_gc_ (void *);
extern void gt_ggc_mx_ipcp_transformation (void *);
extern void gt_ggc_mx_vec_ipa_jump_func_va_gc_ (void *);
extern void gt_ggc_mx_vec_ipa_polymorphic_call_context_va_gc_ (void *);
extern void gt_ggc_mx_ipa_node_params_t (void *);
extern void gt_ggc_mx_ipa_edge_args_sum_t (void *);
extern void gt_ggc_mx_function_summary_ipcp_transformation__ (void *);
extern void gt_ggc_mx_hash_table_tm_wrapper_hasher_ (void *);
extern void gt_ggc_mx_hash_table_decl_state_hasher_ (void *);
extern void gt_ggc_mx_vec_expr_eval_op_va_gc_ (void *);
extern void gt_ggc_mx_vec_condition_va_gc_ (void *);
extern void gt_ggc_mx_vec_size_time_entry_va_gc_ (void *);
extern void gt_ggc_mx_fast_function_summary_ipa_fn_summary__va_gc_ (void *);
extern void gt_ggc_mx_tree_type_map (void *);
extern void gt_ggc_mx_hash_table_tree_type_map_cache_hasher_ (void *);
extern void gt_ggc_mx_vec_odr_type_va_gc_ (void *);
extern void gt_ggc_mx_hash_table_value_annotation_hasher_ (void *);
extern void gt_ggc_mx_vec_Entity_Id_va_gc_atomic_ (void *);
extern void gt_ggc_mx_tree_entity_vec_map (void *);
extern void gt_ggc_mx_hash_table_dummy_type_hasher_ (void *);
extern void gt_ggc_mx_parm_attr_d (void *);
extern void gt_ggc_mx_vec_parm_attr_va_gc_ (void *);
extern void gt_ggc_mx_stmt_group (void *);
extern void gt_ggc_mx_elab_info (void *);
extern void gt_ggc_mx_range_check_info_d (void *);
extern void gt_ggc_mx_vec_range_check_info_va_gc_ (void *);
extern void gt_ggc_mx_loop_info_d (void *);
extern void gt_ggc_mx_vec_loop_info_va_gc_ (void *);
extern void gt_ggc_mx_gnat_binding_level (void *);
extern void gt_ggc_mx_packable_type_hash (void *);
extern void gt_ggc_mx_hash_table_packable_type_hasher_ (void *);
extern void gt_ggc_mx_pad_type_hash (void *);
extern void gt_ggc_mx_hash_table_pad_type_hasher_ (void *);
extern void gt_ggc_mx_c_label_vars (void *);
extern void gt_ggc_mx_c_binding (void *);
extern void gt_ggc_mx_c_scope (void *);
extern void gt_ggc_mx_c_goto_bindings (void *);
extern void gt_ggc_mx_vec_c_goto_bindings_p_va_gc_ (void *);
extern void gt_ggc_mx_c_inline_static (void *);
extern void gt_ggc_mx_sorted_fields_type (void *);
extern void gt_ggc_mx_vec_const_char_p_va_gc_ (void *);
extern void gt_ggc_mx_vec_tree_gc_vec_va_gc_ (void *);
extern void gt_ggc_mx_align_stack (void *);
extern void gt_ggc_mx_vec_pending_weak_va_gc_ (void *);
extern void gt_ggc_mx_vec_pending_redefinition_va_gc_ (void *);
extern void gt_ggc_mx_opt_stack (void *);
extern void gt_ggc_mx_c_parser (void *);
extern void gt_ggc_mx_vec_c_token_va_gc_ (void *);
extern void gt_ggc_mx_binding_table_s (void *);
extern void gt_ggc_mx_binding_entry_s (void *);
extern void gt_ggc_mx_cxx_binding (void *);
extern void gt_ggc_mx_cp_binding_level (void *);
extern void gt_ggc_mx_vec_cp_class_binding_va_gc_ (void *);
extern void gt_ggc_mx_cp_token_cache (void *);
extern void gt_ggc_mx_vec_deferred_access_check_va_gc_ (void *);
extern void gt_ggc_mx_vec_cxx_saved_binding_va_gc_ (void *);
extern void gt_ggc_mx_saved_scope (void *);
extern void gt_ggc_mx_cxx_int_tree_map (void *);
extern void gt_ggc_mx_named_label_entry (void *);
extern void gt_ggc_mx_hash_table_named_label_hash_ (void *);
extern void gt_ggc_mx_hash_table_cxx_int_tree_map_hasher_ (void *);
extern void gt_ggc_mx_tree_pair_s (void *);
extern void gt_ggc_mx_vec_tree_pair_s_va_gc_ (void *);
extern void gt_ggc_mx_hash_table_named_decl_hash_ (void *);
extern void gt_ggc_mx_tinst_level (void *);
extern void gt_ggc_mx_tree_check (void *);
extern void gt_ggc_mx_vec_cp_token_va_gc_ (void *);
extern void gt_ggc_mx_cp_lexer (void *);
extern void gt_ggc_mx_vec_cp_default_arg_entry_va_gc_ (void *);
extern void gt_ggc_mx_cp_parser_context (void *);
extern void gt_ggc_mx_vec_cp_unparsed_functions_entry_va_gc_ (void *);
extern void gt_ggc_mx_cp_parser (void *);
extern void gt_ggc_mx_hash_map_tree_int_ (void *);
extern void gt_ggc_mx_constexpr_fundef (void *);
extern void gt_ggc_mx_hash_table_constexpr_fundef_hasher_ (void *);
extern void gt_ggc_mx_constexpr_call (void *);
extern void gt_ggc_mx_hash_table_constexpr_call_hasher_ (void *);
extern void gt_ggc_mx_sat_entry (void *);
extern void gt_ggc_mx_hash_table_sat_hasher_ (void *);
extern void gt_ggc_mx_coroutine_info (void *);
extern void gt_ggc_mx_hash_table_coroutine_info_hasher_ (void *);
extern void gt_ggc_mx_source_location_table_entry (void *);
extern void gt_ggc_mx_hash_table_source_location_table_entry_hash_ (void *);
extern void gt_ggc_mx_named_label_use_entry (void *);
extern void gt_ggc_mx_vec_incomplete_var_va_gc_ (void *);
extern void gt_ggc_mx_hash_table_typename_hasher_ (void *);
extern void gt_ggc_mx_hash_table_mangled_decl_hash_ (void *);
extern void gt_ggc_mx_vec_pending_noexcept_va_gc_ (void *);
extern void gt_ggc_mx_vec_tree_int_va_gc_ (void *);
extern void gt_ggc_mx_hash_table_conv_type_hasher_ (void *);
extern void gt_ggc_mx_subsumption_entry (void *);
extern void gt_ggc_mx_hash_table_subsumption_hasher_ (void *);
extern void gt_ggc_mx_pending_template (void *);
extern void gt_ggc_mx_spec_entry (void *);
extern void gt_ggc_mx_hash_table_spec_hasher_ (void *);
extern void gt_ggc_mx_hash_map_tree_tree_pair_p_ (void *);
extern void gt_ggc_mx_vec_tinfo_s_va_gc_ (void *);
extern void gt_ggc_mx_vec_deferred_access_va_gc_ (void *);
extern void gt_ggc_mx_hash_table_cplus_array_hasher_ (void *);
extern void gt_ggc_mx_hash_table_list_hasher_ (void *);
extern void gt_ggc_mx_pending_abstract_type (void *);
extern void gt_ggc_mx_hash_table_abstract_type_hasher_ (void *);
extern void gt_ggc_mx_Statement (void *);
extern void gt_ggc_mx_binding_level (void *);
extern void gt_ggc_mx_d_label_use_entry (void *);
extern void gt_ggc_mx_hash_map_Statement__d_label_entry_ (void *);
extern void gt_ggc_mx_hash_table_module_hasher_ (void *);
extern void gt_ggc_mx_module_htab_entry (void *);
extern void gt_ggc_mx_hash_table_module_decl_hasher_ (void *);
extern void gt_ggc_mx_objc_map_private (void *);
extern void gt_ggc_mx_hashed_entry (void *);
extern void gt_ggc_mx_hashed_attribute (void *);
extern void gt_ggc_mx_imp_entry (void *);
extern void gt_ggc_mx_string_descriptor (void *);
extern void gt_ggc_mx_hash_table_objc_string_hasher_ (void *);
extern void gt_ggc_mx_vec_ident_data_tuple_va_gc_ (void *);
extern void gt_ggc_mx_vec_msgref_entry_va_gc_ (void *);
extern void gt_ggc_mx_vec_prot_list_entry_va_gc_ (void *);
extern void gt_ggc_mx_vec_ivarref_entry_va_gc_ (void *);
# 1388 "./gtype-desc.h"
extern void gt_pch_nx_line_maps (void *);
extern void gt_pch_nx_cpp_token (void *);
extern void gt_pch_nx_cpp_macro (void *);
extern void gt_pch_nx_string_concat (void *);
extern void gt_pch_nx_string_concat_db (void *);
extern void gt_pch_nx_hash_map_location_hash_string_concat__ (void *);
extern void gt_pch_nx_bitmap_head (void *);
extern void gt_pch_nx_rtx_def (void *);
extern void gt_pch_nx_rtvec_def (void *);
extern void gt_pch_nx_gimple (void *);
extern void gt_pch_nx_symtab_node (void *);
extern void gt_pch_nx_cgraph_edge (void *);
extern void gt_pch_nx_section (void *);
extern void gt_pch_nx_cl_target_option (void *);
extern void gt_pch_nx_cl_optimization (void *);
extern void gt_pch_nx_edge_def (void *);
extern void gt_pch_nx_basic_block_def (void *);
extern void gt_pch_nx_stack_local_entry (void *);
extern void gt_pch_nx_machine_function (void *);
extern void gt_pch_nx_bitmap_element (void *);
extern void gt_pch_nx_generic_wide_int_wide_int_storage_ (void *);
extern void gt_pch_nx_coverage_data (void *);
extern void gt_pch_nx_mem_attrs (void *);
extern void gt_pch_nx_reg_attrs (void *);
extern void gt_pch_nx_object_block (void *);
extern void gt_pch_nx_vec_rtx_va_gc_ (void *);
extern void gt_pch_nx_real_value (void *);
extern void gt_pch_nx_fixed_value (void *);
extern void gt_pch_nx_constant_descriptor_rtx (void *);
extern void gt_pch_nx_function (void *);
extern void gt_pch_nx_target_rtl (void *);
extern void gt_pch_nx_cgraph_rtl_info (void *);
extern void gt_pch_nx_hash_map_tree_tree_decl_tree_cache_traits_ (void *);
extern void gt_pch_nx_hash_map_tree_tree_type_tree_cache_traits_ (void *);
extern void gt_pch_nx_ptr_info_def (void *);
extern void gt_pch_nx_range_info_def (void *);
extern void gt_pch_nx_die_struct (void *);
extern void gt_pch_nx_vec_constructor_elt_va_gc_ (void *);
extern void gt_pch_nx_vec_tree_va_gc_ (void *);
extern void gt_pch_nx_lang_type (void *);
extern void gt_pch_nx_lang_decl (void *);
extern void gt_pch_nx_tree_statement_list_node (void *);
extern void gt_pch_nx_target_globals (void *);
extern void gt_pch_nx_lang_tree_node (void *);
extern void gt_pch_nx_tree_map (void *);
extern void gt_pch_nx_tree_decl_map (void *);
extern void gt_pch_nx_tree_int_map (void *);
extern void gt_pch_nx_tree_vec_map (void *);
extern void gt_pch_nx_vec_alias_pair_va_gc_ (void *);
extern void gt_pch_nx_libfunc_entry (void *);
extern void gt_pch_nx_hash_table_libfunc_hasher_ (void *);
extern void gt_pch_nx_target_libfuncs (void *);
extern void gt_pch_nx_sequence_stack (void *);
extern void gt_pch_nx_vec_rtx_insn__va_gc_ (void *);
extern void gt_pch_nx_call_site_record_d (void *);
extern void gt_pch_nx_vec_uchar_va_gc_ (void *);
extern void gt_pch_nx_vec_call_site_record_va_gc_ (void *);
extern void gt_pch_nx_gimple_df (void *);
extern void gt_pch_nx_dw_fde_node (void *);
extern void gt_pch_nx_rtx_constant_pool (void *);
extern void gt_pch_nx_frame_space (void *);
extern void gt_pch_nx_vec_callinfo_callee_va_gc_ (void *);
extern void gt_pch_nx_vec_callinfo_dalloc_va_gc_ (void *);
extern void gt_pch_nx_stack_usage (void *);
extern void gt_pch_nx_eh_status (void *);
extern void gt_pch_nx_control_flow_graph (void *);
extern void gt_pch_nx_loops (void *);
extern void gt_pch_nx_language_function (void *);
extern void gt_pch_nx_hash_set_tree_ (void *);
extern void gt_pch_nx_types_used_by_vars_entry (void *);
extern void gt_pch_nx_hash_table_used_type_hasher_ (void *);
extern void gt_pch_nx_nb_iter_bound (void *);
extern void gt_pch_nx_loop_exit (void *);
extern void gt_pch_nx_loop (void *);
extern void gt_pch_nx_control_iv (void *);
extern void gt_pch_nx_vec_loop_p_va_gc_ (void *);
extern void gt_pch_nx_niter_desc (void *);
extern void gt_pch_nx_hash_table_loop_exit_hasher_ (void *);
extern void gt_pch_nx_vec_basic_block_va_gc_ (void *);
extern void gt_pch_nx_rtl_bb_info (void *);
extern void gt_pch_nx_vec_edge_va_gc_ (void *);
extern void gt_pch_nx_vec_ipa_ref_t_va_gc_ (void *);
extern void gt_pch_nx_section_hash_entry (void *);
extern void gt_pch_nx_lto_file_decl_data (void *);
extern void gt_pch_nx_ipa_replace_map (void *);
extern void gt_pch_nx_vec_ipa_replace_map__va_gc_ (void *);
extern void gt_pch_nx_ipa_param_adjustments (void *);
extern void gt_pch_nx_vec_ipa_param_performed_split_va_gc_ (void *);
extern void gt_pch_nx_cgraph_simd_clone (void *);
extern void gt_pch_nx_cgraph_function_version_info (void *);
extern void gt_pch_nx_hash_table_cgraph_edge_hasher_ (void *);
extern void gt_pch_nx_cgraph_indirect_call_info (void *);
extern void gt_pch_nx_asm_node (void *);
extern void gt_pch_nx_symbol_table (void *);
extern void gt_pch_nx_hash_table_section_name_hasher_ (void *);
extern void gt_pch_nx_hash_table_asmname_hasher_ (void *);
extern void gt_pch_nx_hash_map_symtab_node__symbol_priority_map_ (void *);
extern void gt_pch_nx_constant_descriptor_tree (void *);
extern void gt_pch_nx_hash_map_alias_set_hash_int_ (void *);
extern void gt_pch_nx_alias_set_entry (void *);
extern void gt_pch_nx_vec_alias_set_entry__va_gc_ (void *);
extern void gt_pch_nx_hash_table_function_version_hasher_ (void *);
extern void gt_pch_nx_lto_in_decl_state (void *);
extern void gt_pch_nx_hash_table_ipa_bit_ggc_hash_traits_ (void *);
extern void gt_pch_nx_hash_table_ipa_vr_ggc_hash_traits_ (void *);
extern void gt_pch_nx_ipa_node_params (void *);
extern void gt_pch_nx_ipa_edge_args (void *);
extern void gt_pch_nx_ipa_agg_replacement_value (void *);
extern void gt_pch_nx_ipa_fn_summary (void *);
extern void gt_pch_nx_odr_type_d (void *);
extern void gt_pch_nx_vec_ipa_adjusted_param_va_gc_ (void *);
extern void gt_pch_nx_param_access (void *);
extern void gt_pch_nx_vec_param_access__va_gc_ (void *);
extern void gt_pch_nx_isra_func_summary (void *);
extern void gt_pch_nx_vec_isra_param_desc_va_gc_ (void *);
extern void gt_pch_nx_ipa_sra_function_summaries (void *);
extern void gt_pch_nx_typeinfo (void *);
extern void gt_pch_nx_dw_cfi_node (void *);
extern void gt_pch_nx_dw_loc_descr_node (void *);
extern void gt_pch_nx_dw_loc_list_struct (void *);
extern void gt_pch_nx_dw_discr_list_node (void *);
extern void gt_pch_nx_dw_cfa_location (void *);
extern void gt_pch_nx_vec_dw_cfi_ref_va_gc_ (void *);
extern void gt_pch_nx_addr_table_entry (void *);
extern void gt_pch_nx_indirect_string_node (void *);
extern void gt_pch_nx_dwarf_file_data (void *);
extern void gt_pch_nx_hash_map_char__tree_ (void *);
extern void gt_pch_nx_dw_cfi_row (void *);
extern void gt_pch_nx_reg_saved_in_data (void *);
extern void gt_pch_nx_vec_dw_fde_ref_va_gc_ (void *);
extern void gt_pch_nx_hash_table_indirect_string_hasher_ (void *);
extern void gt_pch_nx_comdat_type_node (void *);
extern void gt_pch_nx_vec_dw_line_info_entry_va_gc_ (void *);
extern void gt_pch_nx_dw_line_info_table (void *);
extern void gt_pch_nx_vec_dw_attr_node_va_gc_ (void *);
extern void gt_pch_nx_limbo_die_struct (void *);
extern void gt_pch_nx_hash_table_dwarf_file_hasher_ (void *);
extern void gt_pch_nx_hash_table_decl_die_hasher_ (void *);
extern void gt_pch_nx_vec_dw_die_ref_va_gc_ (void *);
extern void gt_pch_nx_variable_value_struct (void *);
extern void gt_pch_nx_hash_table_variable_value_hasher_ (void *);
extern void gt_pch_nx_hash_table_block_die_hasher_ (void *);
extern void gt_pch_nx_var_loc_node (void *);
extern void gt_pch_nx_var_loc_list_def (void *);
extern void gt_pch_nx_call_arg_loc_node (void *);
extern void gt_pch_nx_hash_table_decl_loc_hasher_ (void *);
extern void gt_pch_nx_cached_dw_loc_list_def (void *);
extern void gt_pch_nx_hash_table_dw_loc_list_hasher_ (void *);
extern void gt_pch_nx_vec_dw_line_info_table__va_gc_ (void *);
extern void gt_pch_nx_vec_pubname_entry_va_gc_ (void *);
extern void gt_pch_nx_vec_macinfo_entry_va_gc_ (void *);
extern void gt_pch_nx_vec_dw_ranges_va_gc_ (void *);
extern void gt_pch_nx_vec_dw_ranges_by_label_va_gc_ (void *);
extern void gt_pch_nx_vec_die_arg_entry_va_gc_ (void *);
extern void gt_pch_nx_hash_table_addr_hasher_ (void *);
extern void gt_pch_nx_hash_map_tree_sym_off_pair_ (void *);
extern void gt_pch_nx_inline_entry_data (void *);
extern void gt_pch_nx_hash_table_inline_entry_data_hasher_ (void *);
extern void gt_pch_nx_temp_slot (void *);
extern void gt_pch_nx_initial_value_struct (void *);
extern void gt_pch_nx_vec_temp_slot_p_va_gc_ (void *);
extern void gt_pch_nx_hash_table_const_int_hasher_ (void *);
extern void gt_pch_nx_hash_table_const_wide_int_hasher_ (void *);
extern void gt_pch_nx_hash_table_const_poly_int_hasher_ (void *);
extern void gt_pch_nx_hash_table_reg_attr_hasher_ (void *);
extern void gt_pch_nx_hash_table_const_double_hasher_ (void *);
extern void gt_pch_nx_hash_table_const_fixed_hasher_ (void *);
extern void gt_pch_nx_eh_region_d (void *);
extern void gt_pch_nx_eh_landing_pad_d (void *);
extern void gt_pch_nx_eh_catch_d (void *);
extern void gt_pch_nx_vec_eh_region_va_gc_ (void *);
extern void gt_pch_nx_vec_eh_landing_pad_va_gc_ (void *);
extern void gt_pch_nx_hash_map_gimple__int_ (void *);
extern void gt_pch_nx_hash_table_insn_cache_hasher_ (void *);
extern void gt_pch_nx_temp_slot_address_entry (void *);
extern void gt_pch_nx_hash_table_temp_address_hasher_ (void *);
extern void gt_pch_nx_hash_map_tree_hash_tree_ (void *);
extern void gt_pch_nx_test_struct (void *);
extern void gt_pch_nx_test_of_length (void *);
extern void gt_pch_nx_test_other (void *);
extern void gt_pch_nx_test_of_union (void *);
extern void gt_pch_nx_example_base (void *);
extern void gt_pch_nx_test_node (void *);
extern void gt_pch_nx_user_struct (void *);
extern void gt_pch_nx_hash_table_libfunc_decl_hasher_ (void *);
extern void gt_pch_nx_string_pool_data (void *);
extern void gt_pch_nx_type_hash (void *);
extern void gt_pch_nx_hash_table_type_cache_hasher_ (void *);
extern void gt_pch_nx_hash_table_int_cst_hasher_ (void *);
extern void gt_pch_nx_hash_table_poly_int_cst_hasher_ (void *);
extern void gt_pch_nx_hash_table_cl_option_hasher_ (void *);
extern void gt_pch_nx_hash_table_tree_decl_map_cache_hasher_ (void *);
extern void gt_pch_nx_hash_table_tree_vec_map_cache_hasher_ (void *);
extern void gt_pch_nx_hash_table_section_hasher_ (void *);
extern void gt_pch_nx_hash_table_object_block_hasher_ (void *);
extern void gt_pch_nx_hash_table_tree_descriptor_hasher_ (void *);
extern void gt_pch_nx_hash_table_const_rtx_desc_hasher_ (void *);
extern void gt_pch_nx_hash_table_tm_clone_hasher_ (void *);
extern void gt_pch_nx_tm_restart_node (void *);
extern void gt_pch_nx_hash_map_tree_tree_ (void *);
extern void gt_pch_nx_hash_table_ssa_name_hasher_ (void *);
extern void gt_pch_nx_hash_table_tm_restart_hasher_ (void *);
extern void gt_pch_nx_vec_mem_addr_template_va_gc_ (void *);
extern void gt_pch_nx_scev_info_str (void *);
extern void gt_pch_nx_hash_table_scev_info_hasher_ (void *);
extern void gt_pch_nx_ssa_operand_memory_d (void *);
extern void gt_pch_nx_vec_omp_declare_variant_entry_va_gc_ (void *);
extern void gt_pch_nx_omp_declare_variant_base_entry (void *);
extern void gt_pch_nx_hash_table_omp_declare_variant_hasher_ (void *);
extern void gt_pch_nx_hash_table_omp_declare_variant_alt_hasher_ (void *);
extern void gt_pch_nx_hash_table_dllimport_hasher_ (void *);
extern void gt_pch_nx_hash_map_char__unsigned_ (void *);
extern void gt_pch_nx_vec_gimple__va_gc_ (void *);
extern void gt_pch_nx_int_range_1_ (void *);
extern void gt_pch_nx_vec_ipa_agg_jf_item_va_gc_ (void *);
extern void gt_pch_nx_ipa_bits (void *);
extern void gt_pch_nx_vec_ipa_param_descriptor_va_gc_ (void *);
extern void gt_pch_nx_vec_ipa_bits__va_gc_ (void *);
extern void gt_pch_nx_vec_ipa_vr_va_gc_ (void *);
extern void gt_pch_nx_ipcp_transformation (void *);
extern void gt_pch_nx_vec_ipa_jump_func_va_gc_ (void *);
extern void gt_pch_nx_vec_ipa_polymorphic_call_context_va_gc_ (void *);
extern void gt_pch_nx_ipa_node_params_t (void *);
extern void gt_pch_nx_ipa_edge_args_sum_t (void *);
extern void gt_pch_nx_function_summary_ipcp_transformation__ (void *);
extern void gt_pch_nx_hash_table_tm_wrapper_hasher_ (void *);
extern void gt_pch_nx_hash_table_decl_state_hasher_ (void *);
extern void gt_pch_nx_vec_expr_eval_op_va_gc_ (void *);
extern void gt_pch_nx_vec_condition_va_gc_ (void *);
extern void gt_pch_nx_vec_size_time_entry_va_gc_ (void *);
extern void gt_pch_nx_fast_function_summary_ipa_fn_summary__va_gc_ (void *);
extern void gt_pch_nx_tree_type_map (void *);
extern void gt_pch_nx_hash_table_tree_type_map_cache_hasher_ (void *);
extern void gt_pch_nx_vec_odr_type_va_gc_ (void *);
extern void gt_pch_nx_hash_table_value_annotation_hasher_ (void *);
extern void gt_pch_nx_vec_Entity_Id_va_gc_atomic_ (void *);
extern void gt_pch_nx_tree_entity_vec_map (void *);
extern void gt_pch_nx_hash_table_dummy_type_hasher_ (void *);
extern void gt_pch_nx_parm_attr_d (void *);
extern void gt_pch_nx_vec_parm_attr_va_gc_ (void *);
extern void gt_pch_nx_stmt_group (void *);
extern void gt_pch_nx_elab_info (void *);
extern void gt_pch_nx_range_check_info_d (void *);
extern void gt_pch_nx_vec_range_check_info_va_gc_ (void *);
extern void gt_pch_nx_loop_info_d (void *);
extern void gt_pch_nx_vec_loop_info_va_gc_ (void *);
extern void gt_pch_nx_gnat_binding_level (void *);
extern void gt_pch_nx_packable_type_hash (void *);
extern void gt_pch_nx_hash_table_packable_type_hasher_ (void *);
extern void gt_pch_nx_pad_type_hash (void *);
extern void gt_pch_nx_hash_table_pad_type_hasher_ (void *);
extern void gt_pch_nx_c_label_vars (void *);
extern void gt_pch_nx_c_binding (void *);
extern void gt_pch_nx_c_scope (void *);
extern void gt_pch_nx_c_goto_bindings (void *);
extern void gt_pch_nx_vec_c_goto_bindings_p_va_gc_ (void *);
extern void gt_pch_nx_c_inline_static (void *);
extern void gt_pch_nx_sorted_fields_type (void *);
extern void gt_pch_nx_vec_const_char_p_va_gc_ (void *);
extern void gt_pch_nx_vec_tree_gc_vec_va_gc_ (void *);
extern void gt_pch_nx_align_stack (void *);
extern void gt_pch_nx_vec_pending_weak_va_gc_ (void *);
extern void gt_pch_nx_vec_pending_redefinition_va_gc_ (void *);
extern void gt_pch_nx_opt_stack (void *);
extern void gt_pch_nx_c_parser (void *);
extern void gt_pch_nx_vec_c_token_va_gc_ (void *);
extern void gt_pch_nx_binding_table_s (void *);
extern void gt_pch_nx_binding_entry_s (void *);
extern void gt_pch_nx_cxx_binding (void *);
extern void gt_pch_nx_cp_binding_level (void *);
extern void gt_pch_nx_vec_cp_class_binding_va_gc_ (void *);
extern void gt_pch_nx_cp_token_cache (void *);
extern void gt_pch_nx_vec_deferred_access_check_va_gc_ (void *);
extern void gt_pch_nx_vec_cxx_saved_binding_va_gc_ (void *);
extern void gt_pch_nx_saved_scope (void *);
extern void gt_pch_nx_cxx_int_tree_map (void *);
extern void gt_pch_nx_named_label_entry (void *);
extern void gt_pch_nx_hash_table_named_label_hash_ (void *);
extern void gt_pch_nx_hash_table_cxx_int_tree_map_hasher_ (void *);
extern void gt_pch_nx_tree_pair_s (void *);
extern void gt_pch_nx_vec_tree_pair_s_va_gc_ (void *);
extern void gt_pch_nx_hash_table_named_decl_hash_ (void *);
extern void gt_pch_nx_tinst_level (void *);
extern void gt_pch_nx_tree_check (void *);
extern void gt_pch_nx_vec_cp_token_va_gc_ (void *);
extern void gt_pch_nx_cp_lexer (void *);
extern void gt_pch_nx_vec_cp_default_arg_entry_va_gc_ (void *);
extern void gt_pch_nx_cp_parser_context (void *);
extern void gt_pch_nx_vec_cp_unparsed_functions_entry_va_gc_ (void *);
extern void gt_pch_nx_cp_parser (void *);
extern void gt_pch_nx_hash_map_tree_int_ (void *);
extern void gt_pch_nx_constexpr_fundef (void *);
extern void gt_pch_nx_hash_table_constexpr_fundef_hasher_ (void *);
extern void gt_pch_nx_constexpr_call (void *);
extern void gt_pch_nx_hash_table_constexpr_call_hasher_ (void *);
extern void gt_pch_nx_sat_entry (void *);
extern void gt_pch_nx_hash_table_sat_hasher_ (void *);
extern void gt_pch_nx_coroutine_info (void *);
extern void gt_pch_nx_hash_table_coroutine_info_hasher_ (void *);
extern void gt_pch_nx_source_location_table_entry (void *);
extern void gt_pch_nx_hash_table_source_location_table_entry_hash_ (void *);
extern void gt_pch_nx_named_label_use_entry (void *);
extern void gt_pch_nx_vec_incomplete_var_va_gc_ (void *);
extern void gt_pch_nx_hash_table_typename_hasher_ (void *);
extern void gt_pch_nx_hash_table_mangled_decl_hash_ (void *);
extern void gt_pch_nx_vec_pending_noexcept_va_gc_ (void *);
extern void gt_pch_nx_vec_tree_int_va_gc_ (void *);
extern void gt_pch_nx_hash_table_conv_type_hasher_ (void *);
extern void gt_pch_nx_subsumption_entry (void *);
extern void gt_pch_nx_hash_table_subsumption_hasher_ (void *);
extern void gt_pch_nx_pending_template (void *);
extern void gt_pch_nx_spec_entry (void *);
extern void gt_pch_nx_hash_table_spec_hasher_ (void *);
extern void gt_pch_nx_hash_map_tree_tree_pair_p_ (void *);
extern void gt_pch_nx_vec_tinfo_s_va_gc_ (void *);
extern void gt_pch_nx_vec_deferred_access_va_gc_ (void *);
extern void gt_pch_nx_hash_table_cplus_array_hasher_ (void *);
extern void gt_pch_nx_hash_table_list_hasher_ (void *);
extern void gt_pch_nx_pending_abstract_type (void *);
extern void gt_pch_nx_hash_table_abstract_type_hasher_ (void *);
extern void gt_pch_nx_Statement (void *);
extern void gt_pch_nx_binding_level (void *);
extern void gt_pch_nx_d_label_use_entry (void *);
extern void gt_pch_nx_hash_map_Statement__d_label_entry_ (void *);
extern void gt_pch_nx_hash_table_module_hasher_ (void *);
extern void gt_pch_nx_module_htab_entry (void *);
extern void gt_pch_nx_hash_table_module_decl_hasher_ (void *);
extern void gt_pch_nx_objc_map_private (void *);
extern void gt_pch_nx_hashed_entry (void *);
extern void gt_pch_nx_hashed_attribute (void *);
extern void gt_pch_nx_imp_entry (void *);
extern void gt_pch_nx_string_descriptor (void *);
extern void gt_pch_nx_hash_table_objc_string_hasher_ (void *);
extern void gt_pch_nx_vec_ident_data_tuple_va_gc_ (void *);
extern void gt_pch_nx_vec_msgref_entry_va_gc_ (void *);
extern void gt_pch_nx_vec_prot_list_entry_va_gc_ (void *);
extern void gt_pch_nx_vec_ivarref_entry_va_gc_ (void *);
extern void gt_pch_p_9line_maps
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_9cpp_token
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_9cpp_macro
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_13string_concat
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_16string_concat_db
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_38hash_map_location_hash_string_concat__
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_11bitmap_head
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_7rtx_def
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_7rtx_def
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_7rtx_def
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_7rtx_def
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_7rtx_def
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_7rtx_def
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_7rtx_def
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_7rtx_def
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_7rtx_def
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_7rtx_def
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_7rtx_def
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_7rtx_def
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_7rtx_def
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_9rtvec_def
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_6gimple
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_6gimple
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_6gimple
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_6gimple
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_6gimple
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_6gimple
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_6gimple
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_6gimple
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_6gimple
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_6gimple
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_6gimple
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_6gimple
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_6gimple
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_6gimple
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_6gimple
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_6gimple
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_6gimple
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_6gimple
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_6gimple
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_6gimple
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_6gimple
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_6gimple
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_6gimple
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_6gimple
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_6gimple
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_6gimple
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_6gimple
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_6gimple
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_6gimple
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_6gimple
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_6gimple
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_6gimple
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_11symtab_node
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_11symtab_node
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_11symtab_node
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_11cgraph_edge
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_7section
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_16cl_target_option
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_15cl_optimization
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_8edge_def
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_15basic_block_def
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_17stack_local_entry
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_16machine_function
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_14bitmap_element
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_34generic_wide_int_wide_int_storage_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_13coverage_data
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_9mem_attrs
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_9reg_attrs
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_12object_block
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_14vec_rtx_va_gc_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_10real_value
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_11fixed_value
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_23constant_descriptor_rtx
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_8function
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_10target_rtl
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_15cgraph_rtl_info
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_42hash_map_tree_tree_decl_tree_cache_traits_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_42hash_map_tree_tree_type_tree_cache_traits_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_12ptr_info_def
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_14range_info_def
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_10die_struct
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_26vec_constructor_elt_va_gc_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_15vec_tree_va_gc_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_9lang_type
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_9lang_decl
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_24tree_statement_list_node
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_14target_globals
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_14lang_tree_node
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_8tree_map
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_13tree_decl_map
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_12tree_int_map
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_12tree_vec_map
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_21vec_alias_pair_va_gc_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_13libfunc_entry
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_26hash_table_libfunc_hasher_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_15target_libfuncs
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_14sequence_stack
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_20vec_rtx_insn__va_gc_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_18call_site_record_d
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_16vec_uchar_va_gc_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_27vec_call_site_record_va_gc_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_9gimple_df
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_11dw_fde_node
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_17rtx_constant_pool
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_11frame_space
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_26vec_callinfo_callee_va_gc_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_26vec_callinfo_dalloc_va_gc_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_11stack_usage
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_9eh_status
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_18control_flow_graph
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_5loops
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_17language_function
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_14hash_set_tree_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_24types_used_by_vars_entry
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_28hash_table_used_type_hasher_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_13nb_iter_bound
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_9loop_exit
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_4loop
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_10control_iv
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_17vec_loop_p_va_gc_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_10niter_desc
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_28hash_table_loop_exit_hasher_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_22vec_basic_block_va_gc_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_11rtl_bb_info
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_15vec_edge_va_gc_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_20vec_ipa_ref_t_va_gc_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_18section_hash_entry
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_18lto_file_decl_data
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_15ipa_replace_map
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_27vec_ipa_replace_map__va_gc_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_21ipa_param_adjustments
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_36vec_ipa_param_performed_split_va_gc_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_17cgraph_simd_clone
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_28cgraph_function_version_info
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_30hash_table_cgraph_edge_hasher_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_25cgraph_indirect_call_info
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_8asm_node
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_12symbol_table
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_31hash_table_section_name_hasher_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_26hash_table_asmname_hasher_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_42hash_map_symtab_node__symbol_priority_map_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_24constant_descriptor_tree
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_28hash_map_alias_set_hash_int_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_15alias_set_entry
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_27vec_alias_set_entry__va_gc_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_35hash_table_function_version_hasher_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_17lto_in_decl_state
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_35hash_table_ipa_bit_ggc_hash_traits_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_34hash_table_ipa_vr_ggc_hash_traits_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_15ipa_node_params
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_13ipa_edge_args
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_25ipa_agg_replacement_value
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_14ipa_fn_summary
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_10odr_type_d
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_29vec_ipa_adjusted_param_va_gc_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_12param_access
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_24vec_param_access__va_gc_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_17isra_func_summary
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_26vec_isra_param_desc_va_gc_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_26ipa_sra_function_summaries
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_8typeinfo
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_11dw_cfi_node
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_17dw_loc_descr_node
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_18dw_loc_list_struct
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_18dw_discr_list_node
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_15dw_cfa_location
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_21vec_dw_cfi_ref_va_gc_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_16addr_table_entry
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_20indirect_string_node
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_15dwarf_file_data
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_20hash_map_char__tree_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_10dw_cfi_row
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_17reg_saved_in_data
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_21vec_dw_fde_ref_va_gc_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_34hash_table_indirect_string_hasher_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_16comdat_type_node
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_29vec_dw_line_info_entry_va_gc_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_18dw_line_info_table
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_23vec_dw_attr_node_va_gc_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_16limbo_die_struct
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_29hash_table_dwarf_file_hasher_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_27hash_table_decl_die_hasher_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_21vec_dw_die_ref_va_gc_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_21variable_value_struct
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_33hash_table_variable_value_hasher_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_28hash_table_block_die_hasher_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_12var_loc_node
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_16var_loc_list_def
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_17call_arg_loc_node
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_27hash_table_decl_loc_hasher_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_22cached_dw_loc_list_def
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_30hash_table_dw_loc_list_hasher_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_30vec_dw_line_info_table__va_gc_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_24vec_pubname_entry_va_gc_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_24vec_macinfo_entry_va_gc_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_20vec_dw_ranges_va_gc_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_29vec_dw_ranges_by_label_va_gc_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_24vec_die_arg_entry_va_gc_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_23hash_table_addr_hasher_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_27hash_map_tree_sym_off_pair_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_17inline_entry_data
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_36hash_table_inline_entry_data_hasher_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_9temp_slot
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_20initial_value_struct
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_22vec_temp_slot_p_va_gc_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_28hash_table_const_int_hasher_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_33hash_table_const_wide_int_hasher_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_33hash_table_const_poly_int_hasher_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_27hash_table_reg_attr_hasher_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_31hash_table_const_double_hasher_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_30hash_table_const_fixed_hasher_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_11eh_region_d
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_16eh_landing_pad_d
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_10eh_catch_d
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_20vec_eh_region_va_gc_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_25vec_eh_landing_pad_va_gc_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_21hash_map_gimple__int_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_29hash_table_insn_cache_hasher_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_23temp_slot_address_entry
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_31hash_table_temp_address_hasher_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_24hash_map_tree_hash_tree_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_11test_struct
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_14test_of_length
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_10test_other
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_13test_of_union
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_12example_base
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_12example_base
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_12example_base
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_9test_node
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_11user_struct
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_31hash_table_libfunc_decl_hasher_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_16string_pool_data
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_9type_hash
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_29hash_table_type_cache_hasher_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_26hash_table_int_cst_hasher_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_31hash_table_poly_int_cst_hasher_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_28hash_table_cl_option_hasher_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_38hash_table_tree_decl_map_cache_hasher_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_37hash_table_tree_vec_map_cache_hasher_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_26hash_table_section_hasher_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_31hash_table_object_block_hasher_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_34hash_table_tree_descriptor_hasher_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_33hash_table_const_rtx_desc_hasher_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_27hash_table_tm_clone_hasher_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_6gimple
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_6gimple
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_6gimple
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_6gimple
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_6gimple
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_6gimple
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_6gimple
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_6gimple
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_6gimple
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_6gimple
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_6gimple
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_6gimple
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_6gimple
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_15tm_restart_node
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_19hash_map_tree_tree_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_27hash_table_ssa_name_hasher_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_29hash_table_tm_restart_hasher_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_28vec_mem_addr_template_va_gc_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_13scev_info_str
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_28hash_table_scev_info_hasher_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_20ssa_operand_memory_d
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_36vec_omp_declare_variant_entry_va_gc_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_30omp_declare_variant_base_entry
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_38hash_table_omp_declare_variant_hasher_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_42hash_table_omp_declare_variant_alt_hasher_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_28hash_table_dllimport_hasher_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_24hash_map_char__unsigned_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_18vec_gimple__va_gc_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_12int_range_1_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_26vec_ipa_agg_jf_item_va_gc_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_8ipa_bits
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_31vec_ipa_param_descriptor_va_gc_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_20vec_ipa_bits__va_gc_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_17vec_ipa_vr_va_gc_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_19ipcp_transformation
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_24vec_ipa_jump_func_va_gc_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_39vec_ipa_polymorphic_call_context_va_gc_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_17ipa_node_params_t
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_19ipa_edge_args_sum_t
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_38function_summary_ipcp_transformation__
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_29hash_table_tm_wrapper_hasher_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_29hash_table_decl_state_hasher_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_23vec_expr_eval_op_va_gc_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_20vec_condition_va_gc_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_26vec_size_time_entry_va_gc_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_44fast_function_summary_ipa_fn_summary__va_gc_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_13tree_type_map
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_38hash_table_tree_type_map_cache_hasher_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_19vec_odr_type_va_gc_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_35hash_table_value_annotation_hasher_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_27vec_Entity_Id_va_gc_atomic_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_19tree_entity_vec_map
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_29hash_table_dummy_type_hasher_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_11parm_attr_d
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_20vec_parm_attr_va_gc_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_10stmt_group
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_9elab_info
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_18range_check_info_d
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_27vec_range_check_info_va_gc_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_11loop_info_d
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_20vec_loop_info_va_gc_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_18gnat_binding_level
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_18packable_type_hash
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_32hash_table_packable_type_hasher_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_13pad_type_hash
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_27hash_table_pad_type_hasher_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_12c_label_vars
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_9c_binding
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_7c_scope
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_15c_goto_bindings
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_28vec_c_goto_bindings_p_va_gc_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_15c_inline_static
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_18sorted_fields_type
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_23vec_const_char_p_va_gc_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_22vec_tree_gc_vec_va_gc_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_11align_stack
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_23vec_pending_weak_va_gc_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_31vec_pending_redefinition_va_gc_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_9opt_stack
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_8c_parser
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_18vec_c_token_va_gc_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_15binding_table_s
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_15binding_entry_s
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_11cxx_binding
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_16cp_binding_level
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_27vec_cp_class_binding_va_gc_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_14cp_token_cache
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_32vec_deferred_access_check_va_gc_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_28vec_cxx_saved_binding_va_gc_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_11saved_scope
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_16cxx_int_tree_map
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_17named_label_entry
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_28hash_table_named_label_hash_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_35hash_table_cxx_int_tree_map_hasher_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_11tree_pair_s
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_22vec_tree_pair_s_va_gc_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_27hash_table_named_decl_hash_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_11tinst_level
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_10tree_check
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_19vec_cp_token_va_gc_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_8cp_lexer
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_31vec_cp_default_arg_entry_va_gc_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_17cp_parser_context
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_38vec_cp_unparsed_functions_entry_va_gc_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_9cp_parser
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_18hash_map_tree_int_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_16constexpr_fundef
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_35hash_table_constexpr_fundef_hasher_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_14constexpr_call
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_33hash_table_constexpr_call_hasher_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_9sat_entry
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_22hash_table_sat_hasher_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_14coroutine_info
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_33hash_table_coroutine_info_hasher_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_27source_location_table_entry
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_44hash_table_source_location_table_entry_hash_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_21named_label_use_entry
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_25vec_incomplete_var_va_gc_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_27hash_table_typename_hasher_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_29hash_table_mangled_decl_hash_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_27vec_pending_noexcept_va_gc_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_19vec_tree_int_va_gc_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_28hash_table_conv_type_hasher_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_17subsumption_entry
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_30hash_table_subsumption_hasher_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_16pending_template
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_10spec_entry
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_23hash_table_spec_hasher_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_26hash_map_tree_tree_pair_p_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_18vec_tinfo_s_va_gc_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_26vec_deferred_access_va_gc_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_30hash_table_cplus_array_hasher_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_23hash_table_list_hasher_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_21pending_abstract_type
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_32hash_table_abstract_type_hasher_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_9Statement
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_13binding_level
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_17d_label_use_entry
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_34hash_map_Statement__d_label_entry_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_25hash_table_module_hasher_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_17module_htab_entry
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_30hash_table_module_decl_hasher_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_16objc_map_private
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_12hashed_entry
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_16hashed_attribute
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_9imp_entry
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_17string_descriptor
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_30hash_table_objc_string_hasher_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_27vec_ident_data_tuple_va_gc_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_23vec_msgref_entry_va_gc_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_26vec_prot_list_entry_va_gc_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_24vec_ivarref_entry_va_gc_
(void *, void *, gt_pointer_operator, void *);
# 31 "/home/giulianob/gcc_git_gnu/gcc/gcc/ggc.h" 2
typedef void (*gt_note_pointers) (void *, void *, gt_pointer_operator,
void *);
typedef void (*gt_handle_reorder) (void *, void *, gt_pointer_operator,
void *);
extern int gt_pch_note_object (void *, void *, gt_note_pointers);
extern void gt_pch_note_reorder (void *, void *, gt_handle_reorder);
extern void gt_clear_caches ();
typedef void (*gt_pointer_walker) (void *);
struct ggc_root_tab {
void *base;
size_t nelt;
size_t stride;
gt_pointer_walker cb;
gt_pointer_walker pchw;
};
extern const struct ggc_root_tab * const gt_ggc_rtab[];
extern const struct ggc_root_tab * const gt_ggc_deletable_rtab[];
extern const struct ggc_root_tab * const gt_pch_scalar_rtab[];
# 91 "/home/giulianob/gcc_git_gnu/gcc/gcc/ggc.h"
extern int ggc_set_mark (const void *);
extern int ggc_marked_p (const void *);
extern void gt_pch_n_S (const void *);
extern void gt_ggc_m_S (const void *);
extern void init_stringpool (void);
extern void init_ggc (void);
extern bool ggc_protect_identifiers;
extern void gt_pch_save (FILE *f);
extern void *ggc_internal_alloc (size_t, void (*)(void *), size_t,
size_t )
__attribute__ ((__malloc__));
inline void *
ggc_internal_alloc (size_t s )
{
return ggc_internal_alloc (s, nullptr, 0, 1 );
}
extern size_t ggc_round_alloc_size (size_t requested_size);
extern void *ggc_internal_cleared_alloc (size_t, void (*)(void *),
size_t, size_t
) __attribute__ ((__malloc__));
inline void *
ggc_internal_cleared_alloc (size_t s )
{
return ggc_internal_cleared_alloc (s, nullptr, 0, 1 );
}
extern void *ggc_realloc (void *, size_t );
extern void ggc_free (void *);
extern void dump_ggc_loc_statistics ();
template<typename T>
void
finalize (void *p)
{
static_cast<T *> (p)->~T ();
}
template<typename T>
inline bool
need_finalization_p ()
{
return !__has_trivial_destructor (T);
}
template<typename T>
inline T *
ggc_alloc ()
{
if (need_finalization_p<T> ())
return static_cast<T *> (ggc_internal_alloc (sizeof (T), finalize<T>, 0, 1
));
else
return static_cast<T *> (ggc_internal_alloc (sizeof (T), nullptr, 0, 1
));
}
template<typename T>
inline T *
ggc_alloc_no_dtor ()
{
return static_cast<T *> (ggc_internal_alloc (sizeof (T), nullptr, 0, 1
));
}
template<typename T>
inline T *
ggc_cleared_alloc ()
{
if (need_finalization_p<T> ())
return static_cast<T *> (ggc_internal_cleared_alloc (sizeof (T),
finalize<T>, 0, 1
));
else
return static_cast<T *> (ggc_internal_cleared_alloc (sizeof (T), nullptr, 0, 1
));
}
template<typename T>
inline T *
ggc_vec_alloc (size_t c )
{
if (need_finalization_p<T> ())
return static_cast<T *> (ggc_internal_alloc (c * sizeof (T), finalize<T>,
sizeof (T), c ));
else
return static_cast<T *> (ggc_internal_alloc (c * sizeof (T), nullptr, 0, 0
));
}
template<typename T>
inline T *
ggc_cleared_vec_alloc (size_t c )
{
if (need_finalization_p<T> ())
return static_cast<T *> (ggc_internal_cleared_alloc (c * sizeof (T),
finalize<T>,
sizeof (T), c
));
else
return static_cast<T *> (ggc_internal_cleared_alloc (c * sizeof (T), nullptr,
0, 0 ));
}
inline void *
ggc_alloc_atomic (size_t s )
{
return ggc_internal_alloc (s );
}
template <typename T>
inline void
ggc_delete (T *ptr)
{
ptr->~T ();
ggc_free (ptr);
}
extern const char *ggc_alloc_string (const char *contents, int length
);
extern void ggc_collect (void);
extern void ggc_trim (void);
extern void ggc_grow (void);
extern void ggc_register_root_tab (const struct ggc_root_tab *);
extern void gt_pch_restore (FILE *f);
extern void ggc_print_statistics (void);
extern void stringpool_statistics (void);
extern void init_ggc_heuristics (void);
extern void report_heap_memory_use (void);
inline struct rtx_def *
ggc_alloc_rtx_def_stat (size_t s )
{
return (struct rtx_def *) ggc_internal_alloc (s );
}
inline union tree_node *
ggc_alloc_tree_node_stat (size_t s )
{
return (union tree_node *) ggc_internal_alloc (s );
}
inline union tree_node *
ggc_alloc_cleared_tree_node_stat (size_t s )
{
return (union tree_node *) ggc_internal_cleared_alloc (s );
}
inline gimple *
ggc_alloc_cleared_gimple_statement_stat (size_t s )
{
return (gimple *) ggc_internal_cleared_alloc (s );
}
inline void
gt_ggc_mx (const char *s)
{
((const_cast<char *> (s)) != nullptr && ((void *) (const_cast<char *> (s))) != (void *) 1 && ! ggc_set_mark (const_cast<char *> (s)));
}
inline void
gt_pch_nx (const char *)
{
}
inline void
gt_ggc_mx (int)
{
}
inline void
gt_pch_nx (int)
{
}
inline void
gt_pch_nx (unsigned int)
{
}
# 248 "/home/giulianob/gcc_git_gnu/gcc/gcc/hash-table.h" 2
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/vec.h" 1
# 30 "/home/giulianob/gcc_git_gnu/gcc/gcc/vec.h"
extern void ggc_free (void *);
extern size_t ggc_round_alloc_size (size_t requested_size);
extern void *ggc_realloc (void *, size_t );
# 183 "/home/giulianob/gcc_git_gnu/gcc/gcc/vec.h"
extern void dump_vec_loc_statistics (void);
extern htab_t vec_mem_usage_hash;
struct vec_prefix
{
void register_overhead (void *, size_t, size_t );
void release_overhead (void *, size_t, size_t, bool );
static unsigned calculate_allocation (vec_prefix *, unsigned, bool);
static unsigned calculate_allocation_1 (unsigned, unsigned);
template <typename, typename, typename> friend struct vec;
friend struct va_gc;
friend struct va_gc_atomic;
friend struct va_heap;
unsigned m_alloc : 31;
unsigned m_using_auto_storage : 1;
unsigned m_num;
};
inline unsigned
vec_prefix::calculate_allocation (vec_prefix *pfx, unsigned reserve,
bool exact)
{
if (exact)
return (pfx ? pfx->m_num : 0) + reserve;
else if (!pfx)
return ((4) > (reserve) ? (4) : (reserve));
return calculate_allocation_1 (pfx->m_alloc, pfx->m_num + reserve);
}
template<typename, typename, typename> struct vec;
struct vl_embed { };
struct vl_ptr { };
# 254 "/home/giulianob/gcc_git_gnu/gcc/gcc/vec.h"
struct va_heap
{
typedef vl_ptr default_layout;
template<typename T>
static void reserve (vec<T, va_heap, vl_embed> *&, unsigned, bool
);
template<typename T>
static void release (vec<T, va_heap, vl_embed> *&);
};
template<typename T>
inline void
va_heap::reserve (vec<T, va_heap, vl_embed> *&v, unsigned reserve, bool exact
)
{
size_t elt_size = sizeof (T);
unsigned alloc
= vec_prefix::calculate_allocation (v ? &v->m_vecpfx : 0, reserve, exact);
((void)(!(alloc) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/vec.h", 282, __FUNCTION__), 0 : 0));
if (0 && v)
v->m_vecpfx.release_overhead (v, elt_size * v->allocated (),
v->allocated (), false);
size_t size = vec<T, va_heap, vl_embed>::embedded_size (alloc);
unsigned nelem = v ? v->length () : 0;
v = static_cast <vec<T, va_heap, vl_embed> *> (xrealloc (v, size));
v->embedded_init (alloc, nelem);
if (0)
v->m_vecpfx.register_overhead (v, alloc, elt_size );
}
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wfree-nonheap-object"
template<typename T>
void
va_heap::release (vec<T, va_heap, vl_embed> *&v)
{
size_t elt_size = sizeof (T);
if (v == nullptr)
return;
if (0)
v->m_vecpfx.release_overhead (v, elt_size * v->allocated (),
v->allocated (), true);
::free (v);
v = nullptr;
}
#pragma GCC diagnostic pop
struct va_gc
{
typedef vl_embed default_layout;
template<typename T, typename A>
static void reserve (vec<T, A, vl_embed> *&, unsigned, bool
);
template<typename T, typename A>
static void release (vec<T, A, vl_embed> *&v);
};
template<typename T, typename A>
inline void
va_gc::release (vec<T, A, vl_embed> *&v)
{
if (v)
::ggc_free (v);
v = nullptr;
}
template<typename T, typename A>
void
va_gc::reserve (vec<T, A, vl_embed> *&v, unsigned reserve, bool exact
)
{
unsigned alloc
= vec_prefix::calculate_allocation (v ? &v->m_vecpfx : 0, reserve, exact);
if (!alloc)
{
::ggc_free (v);
v = nullptr;
return;
}
size_t size = vec<T, A, vl_embed>::embedded_size (alloc);
size = ::ggc_round_alloc_size (size);
size_t vec_offset = sizeof (vec_prefix);
size_t elt_size = sizeof (T);
alloc = (size - vec_offset) / elt_size;
size = vec_offset + alloc * elt_size;
unsigned nelem = v ? v->length () : 0;
v = static_cast <vec<T, A, vl_embed> *> (::ggc_realloc (v, size
));
v->embedded_init (alloc, nelem);
}
struct va_gc_atomic : va_gc
{
};
# 415 "/home/giulianob/gcc_git_gnu/gcc/gcc/vec.h"
template<typename T,
typename A = va_heap,
typename L = typename A::default_layout>
struct vec
{
};
# 433 "/home/giulianob/gcc_git_gnu/gcc/gcc/vec.h"
template<typename T>
void
debug_helper (vec<T> &ref)
{
unsigned i;
for (i = 0; i < ref.length (); ++i)
{
fprintf (
# 440 "/home/giulianob/gcc_git_gnu/gcc/gcc/vec.h" 3 4
stderr
# 440 "/home/giulianob/gcc_git_gnu/gcc/gcc/vec.h"
, "[%d] = ", i);
debug_slim (ref[i]);
fputc ('\n',
# 442 "/home/giulianob/gcc_git_gnu/gcc/gcc/vec.h" 3 4
stderr
# 442 "/home/giulianob/gcc_git_gnu/gcc/gcc/vec.h"
);
}
}
template<typename T>
void
debug_helper (vec<T, va_gc> &ref)
{
unsigned i;
for (i = 0; i < ref.length (); ++i)
{
fprintf (
# 458 "/home/giulianob/gcc_git_gnu/gcc/gcc/vec.h" 3 4
stderr
# 458 "/home/giulianob/gcc_git_gnu/gcc/gcc/vec.h"
, "[%d] = ", i);
debug_slim (ref[i]);
fputc ('\n',
# 460 "/home/giulianob/gcc_git_gnu/gcc/gcc/vec.h" 3 4
stderr
# 460 "/home/giulianob/gcc_git_gnu/gcc/gcc/vec.h"
);
}
}
# 501 "/home/giulianob/gcc_git_gnu/gcc/gcc/vec.h"
template <typename T>
inline void
vec_default_construct (T *dst, unsigned n)
{
# 520 "/home/giulianob/gcc_git_gnu/gcc/gcc/vec.h"
for ( ; n; ++dst, --n)
::new (static_cast<void*>(dst)) T ();
}
template <typename T>
inline void
vec_copy_construct (T *dst, const T *src, unsigned n)
{
for ( ; n; ++dst, ++src, --n)
::new (static_cast<void*>(dst)) T (*src);
}
struct vnull
{
template <typename T, typename A, typename L>
constexpr operator vec<T, A, L> () { return vec<T, A, L>(); }
};
extern vnull vNULL;
# 574 "/home/giulianob/gcc_git_gnu/gcc/gcc/vec.h"
template<typename T, typename A>
struct vec<T, A, vl_embed>
{
public:
unsigned allocated (void) const { return m_vecpfx.m_alloc; }
unsigned length (void) const { return m_vecpfx.m_num; }
bool is_empty (void) const { return m_vecpfx.m_num == 0; }
T *address (void) { return m_vecdata; }
const T *address (void) const { return m_vecdata; }
T *begin () { return address (); }
const T *begin () const { return address (); }
T *end () { return address () + length (); }
const T *end () const { return address () + length (); }
const T &operator[] (unsigned) const;
T &operator[] (unsigned);
T &last (void);
bool space (unsigned) const;
bool iterate (unsigned, T *) const;
bool iterate (unsigned, T **) const;
vec *copy () const;
void splice (const vec &);
void splice (const vec *src);
T *quick_push (const T &);
T &pop (void);
void truncate (unsigned);
void quick_insert (unsigned, const T &);
void ordered_remove (unsigned);
void unordered_remove (unsigned);
void block_remove (unsigned, unsigned);
void qsort (int (*) (const void *, const void *));
void sort (int (*) (const void *, const void *, void *), void *);
T *bsearch (const void *key, int (*compar)(const void *, const void *));
T *bsearch (const void *key,
int (*compar)(const void *, const void *, void *), void *);
unsigned lower_bound (T, bool (*)(const T &, const T &)) const;
bool contains (const T &search) const;
static size_t embedded_size (unsigned);
void embedded_init (unsigned, unsigned = 0, unsigned = 0);
void quick_grow (unsigned len);
void quick_grow_cleared (unsigned len);
template <typename, typename, typename> friend struct vec;
friend struct va_gc;
friend struct va_gc_atomic;
friend struct va_heap;
vec_prefix m_vecpfx;
T m_vecdata[1];
};
# 645 "/home/giulianob/gcc_git_gnu/gcc/gcc/vec.h"
template<typename T, typename A>
inline bool
vec_safe_space (const vec<T, A, vl_embed> *v, unsigned nelems)
{
return v ? v->space (nelems) : nelems == 0;
}
template<typename T, typename A>
inline unsigned
vec_safe_length (const vec<T, A, vl_embed> *v)
{
return v ? v->length () : 0;
}
template<typename T, typename A>
inline T *
vec_safe_address (vec<T, A, vl_embed> *v)
{
return v ? v->address () : nullptr;
}
template<typename T, typename A>
inline bool
vec_safe_is_empty (vec<T, A, vl_embed> *v)
{
return v ? v->is_empty () : true;
}
template<typename T, typename A>
inline bool
vec_safe_reserve (vec<T, A, vl_embed> *&v, unsigned nelems, bool exact = false
)
{
bool extend = nelems ? !vec_safe_space (v, nelems) : false;
if (extend)
A::reserve (v, nelems, exact );
return extend;
}
template<typename T, typename A>
inline bool
vec_safe_reserve_exact (vec<T, A, vl_embed> *&v, unsigned nelems
)
{
return vec_safe_reserve (v, nelems, true );
}
template<typename T, typename A>
inline void
vec_alloc (vec<T, A, vl_embed> *&v, unsigned nelems )
{
v = nullptr;
vec_safe_reserve (v, nelems, false );
}
template<typename T, typename A>
inline void
vec_free (vec<T, A, vl_embed> *&v)
{
A::release (v);
}
template<typename T, typename A>
inline void
vec_safe_grow (vec<T, A, vl_embed> *&v, unsigned len )
{
unsigned oldlen = vec_safe_length (v);
((void)(!(len >= oldlen) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/vec.h", 729, __FUNCTION__), 0 : 0));
vec_safe_reserve_exact (v, len - oldlen );
v->quick_grow (len);
}
template<typename T, typename A>
inline void
vec_safe_grow_cleared (vec<T, A, vl_embed> *&v, unsigned len )
{
unsigned oldlen = vec_safe_length (v);
vec_safe_grow (v, len );
vec_default_construct (v->address () + oldlen, len - oldlen);
}
template<typename T>
inline void
vec_safe_grow_cleared (vec<T, va_heap, vl_ptr> *&v,
unsigned len )
{
v->safe_grow_cleared (len );
}
template<typename T>
inline bool
vec_safe_reserve (vec<T, va_heap, vl_ptr> *&v, unsigned nelems, bool exact = false
)
{
return v->reserve (nelems, exact);
}
template<typename T, typename A>
inline bool
vec_safe_iterate (const vec<T, A, vl_embed> *v, unsigned ix, T **ptr)
{
if (v)
return v->iterate (ix, ptr);
else
{
*ptr = 0;
return false;
}
}
template<typename T, typename A>
inline bool
vec_safe_iterate (const vec<T, A, vl_embed> *v, unsigned ix, T *ptr)
{
if (v)
return v->iterate (ix, ptr);
else
{
*ptr = 0;
return false;
}
}
template<typename T, typename A>
inline T *
vec_safe_push (vec<T, A, vl_embed> *&v, const T &obj )
{
vec_safe_reserve (v, 1, false );
return v->quick_push (obj);
}
template<typename T, typename A>
inline void
vec_safe_insert (vec<T, A, vl_embed> *&v, unsigned ix, const T &obj
)
{
vec_safe_reserve (v, 1, false );
v->quick_insert (ix, obj);
}
template<typename T, typename A>
inline void
vec_safe_truncate (vec<T, A, vl_embed> *v, unsigned size)
{
if (v)
v->truncate (size);
}
template<typename T, typename A>
inline vec<T, A, vl_embed> *
vec_safe_copy (vec<T, A, vl_embed> *src )
{
return src ? src->copy () : nullptr;
}
template<typename T, typename A>
inline void
vec_safe_splice (vec<T, A, vl_embed> *&dst, const vec<T, A, vl_embed> *src
)
{
unsigned src_len = vec_safe_length (src);
if (src_len)
{
vec_safe_reserve_exact (dst, vec_safe_length (dst) + src_len
);
dst->splice (*src);
}
}
template<typename T, typename A>
inline bool
vec_safe_contains (vec<T, A, vl_embed> *v, const T &search)
{
return v ? v->contains (search) : false;
}
template<typename T, typename A>
inline const T &
vec<T, A, vl_embed>::operator[] (unsigned ix) const
{
((void)(!(ix < m_vecpfx.m_num) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/vec.h", 870, __FUNCTION__), 0 : 0));
return m_vecdata[ix];
}
template<typename T, typename A>
inline T &
vec<T, A, vl_embed>::operator[] (unsigned ix)
{
((void)(!(ix < m_vecpfx.m_num) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/vec.h", 878, __FUNCTION__), 0 : 0));
return m_vecdata[ix];
}
template<typename T, typename A>
inline T &
vec<T, A, vl_embed>::last (void)
{
((void)(!(m_vecpfx.m_num > 0) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/vec.h", 889, __FUNCTION__), 0 : 0));
return (*this)[m_vecpfx.m_num - 1];
}
# 900 "/home/giulianob/gcc_git_gnu/gcc/gcc/vec.h"
template<typename T, typename A>
inline bool
vec<T, A, vl_embed>::space (unsigned nelems) const
{
return m_vecpfx.m_alloc - m_vecpfx.m_num >= nelems;
}
# 915 "/home/giulianob/gcc_git_gnu/gcc/gcc/vec.h"
template<typename T, typename A>
inline bool
vec<T, A, vl_embed>::iterate (unsigned ix, T *ptr) const
{
if (ix < m_vecpfx.m_num)
{
*ptr = m_vecdata[ix];
return true;
}
else
{
*ptr = 0;
return false;
}
}
# 941 "/home/giulianob/gcc_git_gnu/gcc/gcc/vec.h"
template<typename T, typename A>
inline bool
vec<T, A, vl_embed>::iterate (unsigned ix, T **ptr) const
{
if (ix < m_vecpfx.m_num)
{
*ptr = (const_cast<T *> ((&m_vecdata[ix])));
return true;
}
else
{
*ptr = 0;
return false;
}
}
template<typename T, typename A>
inline vec<T, A, vl_embed> *
vec<T, A, vl_embed>::copy (void) const
{
vec<T, A, vl_embed> *new_vec = nullptr;
unsigned len = length ();
if (len)
{
vec_alloc (new_vec, len );
new_vec->embedded_init (len, len);
vec_copy_construct (new_vec->address (), m_vecdata, len);
}
return new_vec;
}
template<typename T, typename A>
inline void
vec<T, A, vl_embed>::splice (const vec<T, A, vl_embed> &src)
{
unsigned len = src.length ();
if (len)
{
((void)(!(space (len)) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/vec.h", 986, __FUNCTION__), 0 : 0));
vec_copy_construct (end (), src.address (), len);
m_vecpfx.m_num += len;
}
}
template<typename T, typename A>
inline void
vec<T, A, vl_embed>::splice (const vec<T, A, vl_embed> *src)
{
if (src)
splice (*src);
}
template<typename T, typename A>
inline T *
vec<T, A, vl_embed>::quick_push (const T &obj)
{
((void)(!(space (1)) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/vec.h", 1009, __FUNCTION__), 0 : 0));
T *slot = &m_vecdata[m_vecpfx.m_num++];
*slot = obj;
return slot;
}
template<typename T, typename A>
inline T &
vec<T, A, vl_embed>::pop (void)
{
((void)(!(length () > 0) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/vec.h", 1022, __FUNCTION__), 0 : 0));
return m_vecdata[--m_vecpfx.m_num];
}
template<typename T, typename A>
inline void
vec<T, A, vl_embed>::truncate (unsigned size)
{
((void)(!(length () >= size) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/vec.h", 1034, __FUNCTION__), 0 : 0));
m_vecpfx.m_num = size;
}
template<typename T, typename A>
inline void
vec<T, A, vl_embed>::quick_insert (unsigned ix, const T &obj)
{
((void)(!(length () < allocated ()) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/vec.h", 1046, __FUNCTION__), 0 : 0));
((void)(!(ix <= length ()) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/vec.h", 1047, __FUNCTION__), 0 : 0));
T *slot = &m_vecdata[ix];
memmove (slot + 1, slot, (m_vecpfx.m_num++ - ix) * sizeof (T));
*slot = obj;
}
template<typename T, typename A>
inline void
vec<T, A, vl_embed>::ordered_remove (unsigned ix)
{
((void)(!(ix < length ()) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/vec.h", 1062, __FUNCTION__), 0 : 0));
T *slot = &m_vecdata[ix];
memmove (slot, slot + 1, (--m_vecpfx.m_num - ix) * sizeof (T));
}
# 1105 "/home/giulianob/gcc_git_gnu/gcc/gcc/vec.h"
template<typename T, typename A>
inline void
vec<T, A, vl_embed>::unordered_remove (unsigned ix)
{
((void)(!(ix < length ()) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/vec.h", 1109, __FUNCTION__), 0 : 0));
m_vecdata[ix] = m_vecdata[--m_vecpfx.m_num];
}
template<typename T, typename A>
inline void
vec<T, A, vl_embed>::block_remove (unsigned ix, unsigned len)
{
((void)(!(ix + len <= length ()) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/vec.h", 1121, __FUNCTION__), 0 : 0));
T *slot = &m_vecdata[ix];
m_vecpfx.m_num -= len;
memmove (slot, slot + len, (m_vecpfx.m_num - ix) * sizeof (T));
}
template<typename T, typename A>
inline void
vec<T, A, vl_embed>::qsort (int (*cmp) (const void *, const void *))
{
if (length () > 1)
gcc_qsort (address (), length (), sizeof (T), cmp);
}
template<typename T, typename A>
inline void
vec<T, A, vl_embed>::sort (int (*cmp) (const void *, const void *, void *),
void *data)
{
if (length () > 1)
gcc_sort_r (address (), length (), sizeof (T), cmp, data);
}
template<typename T, typename A>
inline T *
vec<T, A, vl_embed>::bsearch (const void *key,
int (*compar) (const void *, const void *))
{
const void *base = this->address ();
size_t nmemb = this->length ();
size_t size = sizeof (T);
size_t l, u, idx;
const void *p;
int comparison;
l = 0;
u = nmemb;
while (l < u)
{
idx = (l + u) / 2;
p = (const void *) (((const char *) base) + (idx * size));
comparison = (*compar) (key, p);
if (comparison < 0)
u = idx;
else if (comparison > 0)
l = idx + 1;
else
return (T *)const_cast<void *>(p);
}
return nullptr;
}
template<typename T, typename A>
inline T *
vec<T, A, vl_embed>::bsearch (const void *key,
int (*compar) (const void *, const void *,
void *), void *data)
{
const void *base = this->address ();
size_t nmemb = this->length ();
size_t size = sizeof (T);
size_t l, u, idx;
const void *p;
int comparison;
l = 0;
u = nmemb;
while (l < u)
{
idx = (l + u) / 2;
p = (const void *) (((const char *) base) + (idx * size));
comparison = (*compar) (key, p, data);
if (comparison < 0)
u = idx;
else if (comparison > 0)
l = idx + 1;
else
return (T *)const_cast<void *>(p);
}
return nullptr;
}
template<typename T, typename A>
inline bool
vec<T, A, vl_embed>::contains (const T &search) const
{
unsigned int len = length ();
for (unsigned int i = 0; i < len; i++)
if ((*this)[i] == search)
return true;
return false;
}
template<typename T, typename A>
unsigned
vec<T, A, vl_embed>::lower_bound (T obj, bool (*lessthan)(const T &, const T &))
const
{
unsigned int len = length ();
unsigned int half, middle;
unsigned int first = 0;
while (len > 0)
{
half = len / 2;
middle = first;
middle += half;
T middle_elem = (*this)[middle];
if (lessthan (middle_elem, obj))
{
first = middle;
++first;
len = len - half - 1;
}
else
len = half;
}
return first;
}
# 1280 "/home/giulianob/gcc_git_gnu/gcc/gcc/vec.h"
template<typename T, typename A>
inline size_t
vec<T, A, vl_embed>::embedded_size (unsigned alloc)
{
struct alignas (T) U { char data[sizeof (T)]; };
typedef vec<U, A, vl_embed> vec_embedded;
typedef typename std::conditional<std::is_standard_layout<T>::value,
vec, vec_embedded>::type vec_stdlayout;
static_assert (sizeof (vec_stdlayout) == sizeof (vec), "");
static_assert (alignof (vec_stdlayout) == alignof (vec), "");
return
# 1290 "/home/giulianob/gcc_git_gnu/gcc/gcc/vec.h" 3 4
__builtin_offsetof (
# 1290 "/home/giulianob/gcc_git_gnu/gcc/gcc/vec.h"
vec_stdlayout
# 1290 "/home/giulianob/gcc_git_gnu/gcc/gcc/vec.h" 3 4
,
# 1290 "/home/giulianob/gcc_git_gnu/gcc/gcc/vec.h"
m_vecdata
# 1290 "/home/giulianob/gcc_git_gnu/gcc/gcc/vec.h" 3 4
)
# 1290 "/home/giulianob/gcc_git_gnu/gcc/gcc/vec.h"
+ alloc * sizeof (T);
}
template<typename T, typename A>
inline void
vec<T, A, vl_embed>::embedded_init (unsigned alloc, unsigned num, unsigned aut)
{
m_vecpfx.m_alloc = alloc;
m_vecpfx.m_using_auto_storage = aut;
m_vecpfx.m_num = num;
}
template<typename T, typename A>
inline void
vec<T, A, vl_embed>::quick_grow (unsigned len)
{
((void)(!(length () <= len && len <= m_vecpfx.m_alloc) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/vec.h", 1314, __FUNCTION__), 0 : 0));
m_vecpfx.m_num = len;
}
template<typename T, typename A>
inline void
vec<T, A, vl_embed>::quick_grow_cleared (unsigned len)
{
unsigned oldlen = length ();
size_t growby = len - oldlen;
quick_grow (len);
if (growby != 0)
vec_default_construct (address () + oldlen, growby);
}
template<typename T>
void
gt_ggc_mx (vec<T, va_gc> *v)
{
extern void gt_ggc_mx (T &);
for (unsigned i = 0; i < v->length (); i++)
gt_ggc_mx ((*v)[i]);
}
template<typename T>
void
gt_ggc_mx (vec<T, va_gc_atomic, vl_embed> *v __attribute__ ((__unused__)))
{
}
template<typename T, typename A>
void
gt_pch_nx (vec<T, A, vl_embed> *v)
{
extern void gt_pch_nx (T &);
for (unsigned i = 0; i < v->length (); i++)
gt_pch_nx ((*v)[i]);
}
template<typename T, typename A>
void
gt_pch_nx (vec<T *, A, vl_embed> *v, gt_pointer_operator op, void *cookie)
{
for (unsigned i = 0; i < v->length (); i++)
op (&((*v)[i]), cookie);
}
template<typename T, typename A>
void
gt_pch_nx (vec<T, A, vl_embed> *v, gt_pointer_operator op, void *cookie)
{
extern void gt_pch_nx (T *, gt_pointer_operator, void *);
for (unsigned i = 0; i < v->length (); i++)
gt_pch_nx (&((*v)[i]), op, cookie);
}
# 1410 "/home/giulianob/gcc_git_gnu/gcc/gcc/vec.h"
template<typename T>
struct vec<T, va_heap, vl_ptr>
{
public:
void create (unsigned nelems );
void release (void);
bool exists (void) const
{ return m_vec != nullptr; }
bool is_empty (void) const
{ return m_vec ? m_vec->is_empty () : true; }
unsigned length (void) const
{ return m_vec ? m_vec->length () : 0; }
T *address (void)
{ return m_vec ? m_vec->m_vecdata : nullptr; }
const T *address (void) const
{ return m_vec ? m_vec->m_vecdata : nullptr; }
T *begin () { return address (); }
const T *begin () const { return address (); }
T *end () { return begin () + length (); }
const T *end () const { return begin () + length (); }
const T &operator[] (unsigned ix) const
{ return (*m_vec)[ix]; }
bool operator!=(const vec &other) const
{ return !(*this == other); }
bool operator==(const vec &other) const
{ return address () == other.address (); }
T &operator[] (unsigned ix)
{ return (*m_vec)[ix]; }
T &last (void)
{ return m_vec->last (); }
bool space (int nelems) const
{ return m_vec ? m_vec->space (nelems) : nelems == 0; }
bool iterate (unsigned ix, T *p) const;
bool iterate (unsigned ix, T **p) const;
vec copy () const;
bool reserve (unsigned, bool = false );
bool reserve_exact (unsigned );
void splice (const vec &);
void safe_splice (const vec & );
T *quick_push (const T &);
T *safe_push (const T &);
T &pop (void);
void truncate (unsigned);
void safe_grow (unsigned );
void safe_grow_cleared (unsigned );
void quick_grow (unsigned);
void quick_grow_cleared (unsigned);
void quick_insert (unsigned, const T &);
void safe_insert (unsigned, const T & );
void ordered_remove (unsigned);
void unordered_remove (unsigned);
void block_remove (unsigned, unsigned);
void qsort (int (*) (const void *, const void *));
void sort (int (*) (const void *, const void *, void *), void *);
T *bsearch (const void *key, int (*compar)(const void *, const void *));
T *bsearch (const void *key,
int (*compar)(const void *, const void *, void *), void *);
unsigned lower_bound (T, bool (*)(const T &, const T &)) const;
bool contains (const T &search) const;
void reverse (void);
bool using_auto_storage () const;
vec<T, va_heap, vl_embed> *m_vec;
};
# 1500 "/home/giulianob/gcc_git_gnu/gcc/gcc/vec.h"
template<typename T, size_t N = 0>
class auto_vec : public vec<T, va_heap>
{
public:
auto_vec ()
{
m_auto.embedded_init (((N) > (2) ? (N) : (2)), 0, 1);
this->m_vec = &m_auto;
}
auto_vec (size_t s)
{
if (s > N)
{
this->create (s);
return;
}
m_auto.embedded_init (((N) > (2) ? (N) : (2)), 0, 1);
this->m_vec = &m_auto;
}
~auto_vec ()
{
this->release ();
}
private:
vec<T, va_heap, vl_embed> m_auto;
T m_data[((N - 1) > (1) ? (N - 1) : (1))];
};
template<typename T>
class auto_vec<T, 0> : public vec<T, va_heap>
{
public:
auto_vec () { this->m_vec = nullptr; }
auto_vec (size_t n) { this->create (n); }
~auto_vec () { this->release (); }
};
template<typename T>
inline void
vec_alloc (vec<T> *&v, unsigned nelems )
{
v = new vec<T>;
v->create (nelems );
}
class auto_string_vec : public auto_vec <char *>
{
public:
~auto_string_vec ();
};
# 1578 "/home/giulianob/gcc_git_gnu/gcc/gcc/vec.h"
template <typename T>
class auto_delete_vec : public auto_vec <T *>
{
public:
auto_delete_vec () {}
auto_delete_vec (size_t s) : auto_vec <T *> (s) {}
~auto_delete_vec ();
private:
auto_delete_vec<T> (const auto_delete_vec<T>&) = delete; void operator= (const auto_delete_vec<T> &) = delete;
};
template<typename T>
inline void
vec_check_alloc (vec<T, va_heap> *&vec, unsigned nelems )
{
if (!vec)
vec_alloc (vec, nelems );
}
template<typename T>
inline void
vec_free (vec<T> *&v)
{
if (v == nullptr)
return;
v->release ();
delete v;
v = nullptr;
}
# 1624 "/home/giulianob/gcc_git_gnu/gcc/gcc/vec.h"
template<typename T>
inline bool
vec<T, va_heap, vl_ptr>::iterate (unsigned ix, T *ptr) const
{
if (m_vec)
return m_vec->iterate (ix, ptr);
else
{
*ptr = 0;
return false;
}
}
# 1647 "/home/giulianob/gcc_git_gnu/gcc/gcc/vec.h"
template<typename T>
inline bool
vec<T, va_heap, vl_ptr>::iterate (unsigned ix, T **ptr) const
{
if (m_vec)
return m_vec->iterate (ix, ptr);
else
{
*ptr = 0;
return false;
}
}
# 1686 "/home/giulianob/gcc_git_gnu/gcc/gcc/vec.h"
inline
auto_string_vec::~auto_string_vec ()
{
int i;
char *str;
for (i = 0; (*this).iterate ((i), &(str)); ++(i))
free (str);
}
template <typename T>
inline
auto_delete_vec<T>::~auto_delete_vec ()
{
int i;
T *item;
for (i = 0; (*this).iterate ((i), &(item)); ++(i))
delete item;
}
template<typename T>
inline vec<T, va_heap, vl_ptr>
vec<T, va_heap, vl_ptr>::copy (void) const
{
vec<T, va_heap, vl_ptr> new_vec = vNULL;
if (length ())
new_vec.m_vec = m_vec->copy ();
return new_vec;
}
# 1731 "/home/giulianob/gcc_git_gnu/gcc/gcc/vec.h"
template<typename T>
inline bool
vec<T, va_heap, vl_ptr>::reserve (unsigned nelems, bool exact )
{
if (space (nelems))
return false;
vec<T, va_heap, vl_embed> *oldvec = m_vec;
unsigned int oldsize = 0;
bool handle_auto_vec = m_vec && using_auto_storage ();
if (handle_auto_vec)
{
m_vec = nullptr;
oldsize = oldvec->length ();
nelems += oldsize;
}
va_heap::reserve (m_vec, nelems, exact );
if (handle_auto_vec)
{
vec_copy_construct (m_vec->address (), oldvec->address (), oldsize);
m_vec->m_vecpfx.m_num = oldsize;
}
return true;
}
template<typename T>
inline bool
vec<T, va_heap, vl_ptr>::reserve_exact (unsigned nelems )
{
return reserve (nelems, true );
}
template<typename T>
inline void
vec<T, va_heap, vl_ptr>::create (unsigned nelems )
{
m_vec = nullptr;
if (nelems > 0)
reserve_exact (nelems );
}
template<typename T>
inline void
vec<T, va_heap, vl_ptr>::release (void)
{
if (!m_vec)
return;
if (using_auto_storage ())
{
m_vec->m_vecpfx.m_num = 0;
return;
}
va_heap::release (m_vec);
}
template<typename T>
inline void
vec<T, va_heap, vl_ptr>::splice (const vec<T, va_heap, vl_ptr> &src)
{
if (src.length ())
m_vec->splice (*(src.m_vec));
}
template<typename T>
inline void
vec<T, va_heap, vl_ptr>::safe_splice (const vec<T, va_heap, vl_ptr> &src
)
{
if (src.length ())
{
reserve_exact (src.length ());
splice (src);
}
}
template<typename T>
inline T *
vec<T, va_heap, vl_ptr>::quick_push (const T &obj)
{
return m_vec->quick_push (obj);
}
template<typename T>
inline T *
vec<T, va_heap, vl_ptr>::safe_push (const T &obj )
{
reserve (1, false );
return quick_push (obj);
}
template<typename T>
inline T &
vec<T, va_heap, vl_ptr>::pop (void)
{
return m_vec->pop ();
}
template<typename T>
inline void
vec<T, va_heap, vl_ptr>::truncate (unsigned size)
{
if (m_vec)
m_vec->truncate (size);
else
((void)(!(size == 0) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/vec.h", 1885, __FUNCTION__), 0 : 0));
}
template<typename T>
inline void
vec<T, va_heap, vl_ptr>::safe_grow (unsigned len )
{
unsigned oldlen = length ();
((void)(!(oldlen <= len) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/vec.h", 1898, __FUNCTION__), 0 : 0));
reserve_exact (len - oldlen );
if (m_vec)
m_vec->quick_grow (len);
else
((void)(!(len == 0) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/vec.h", 1903, __FUNCTION__), 0 : 0));
}
template<typename T>
inline void
vec<T, va_heap, vl_ptr>::safe_grow_cleared (unsigned len )
{
unsigned oldlen = length ();
size_t growby = len - oldlen;
safe_grow (len );
if (growby != 0)
vec_default_construct (address () + oldlen, growby);
}
template<typename T>
inline void
vec<T, va_heap, vl_ptr>::quick_grow (unsigned len)
{
((void)(!(m_vec) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/vec.h", 1930, __FUNCTION__), 0 : 0));
m_vec->quick_grow (len);
}
template<typename T>
inline void
vec<T, va_heap, vl_ptr>::quick_grow_cleared (unsigned len)
{
((void)(!(m_vec) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/vec.h", 1943, __FUNCTION__), 0 : 0));
m_vec->quick_grow_cleared (len);
}
template<typename T>
inline void
vec<T, va_heap, vl_ptr>::quick_insert (unsigned ix, const T &obj)
{
m_vec->quick_insert (ix, obj);
}
template<typename T>
inline void
vec<T, va_heap, vl_ptr>::safe_insert (unsigned ix, const T &obj )
{
reserve (1, false );
quick_insert (ix, obj);
}
template<typename T>
inline void
vec<T, va_heap, vl_ptr>::ordered_remove (unsigned ix)
{
m_vec->ordered_remove (ix);
}
template<typename T>
inline void
vec<T, va_heap, vl_ptr>::unordered_remove (unsigned ix)
{
m_vec->unordered_remove (ix);
}
template<typename T>
inline void
vec<T, va_heap, vl_ptr>::block_remove (unsigned ix, unsigned len)
{
m_vec->block_remove (ix, len);
}
template<typename T>
inline void
vec<T, va_heap, vl_ptr>::qsort (int (*cmp) (const void *, const void *))
{
if (m_vec)
m_vec->qsort (cmp);
}
template<typename T>
inline void
vec<T, va_heap, vl_ptr>::sort (int (*cmp) (const void *, const void *,
void *), void *data)
{
if (m_vec)
m_vec->sort (cmp, data);
}
template<typename T>
inline T *
vec<T, va_heap, vl_ptr>::bsearch (const void *key,
int (*cmp) (const void *, const void *))
{
if (m_vec)
return m_vec->bsearch (key, cmp);
return nullptr;
}
template<typename T>
inline T *
vec<T, va_heap, vl_ptr>::bsearch (const void *key,
int (*cmp) (const void *, const void *,
void *), void *data)
{
if (m_vec)
return m_vec->bsearch (key, cmp, data);
return nullptr;
}
template<typename T>
inline unsigned
vec<T, va_heap, vl_ptr>::lower_bound (T obj,
bool (*lessthan)(const T &, const T &))
const
{
return m_vec ? m_vec->lower_bound (obj, lessthan) : 0;
}
template<typename T>
inline bool
vec<T, va_heap, vl_ptr>::contains (const T &search) const
{
return m_vec ? m_vec->contains (search) : false;
}
template<typename T>
inline void
vec<T, va_heap, vl_ptr>::reverse (void)
{
unsigned l = length ();
T *ptr = address ();
for (unsigned i = 0; i < l / 2; i++)
std::swap (ptr[i], ptr[l - i - 1]);
}
template<typename T>
inline bool
vec<T, va_heap, vl_ptr>::using_auto_storage () const
{
return m_vec->m_vecpfx.m_using_auto_storage;
}
template<typename T>
inline void
release_vec_vec (vec<vec<T> > &vec)
{
for (unsigned i = 0; i < vec.length (); i++)
vec[i].release ();
vec.release ();
}
# 249 "/home/giulianob/gcc_git_gnu/gcc/gcc/hash-table.h" 2
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/../include/hashtab.h" 1
# 250 "/home/giulianob/gcc_git_gnu/gcc/gcc/hash-table.h" 2
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/inchash.h" 1
# 31 "/home/giulianob/gcc_git_gnu/gcc/gcc/inchash.h"
hashval_t iterative_hash_host_wide_int (long, hashval_t);
hashval_t iterative_hash_hashval_t (hashval_t, hashval_t);
namespace inchash
{
class hash
{
public:
hash (hashval_t seed = 0)
{
val = seed;
bits = 0;
}
hashval_t end ()
{
return val;
}
void add_int (unsigned v)
{
val = iterative_hash_hashval_t (v, val);
}
template<unsigned int N, typename T>
void add_poly_int (const poly_int_pod<N, T> &v)
{
for (unsigned int i = 0; i < N; ++i)
add_int (v.coeffs[i]);
}
void add_hwi (long v)
{
val = iterative_hash_host_wide_int (v, val);
}
template<unsigned int N, typename T>
void add_poly_hwi (const poly_int_pod<N, T> &v)
{
for (unsigned int i = 0; i < N; ++i)
add_hwi (v.coeffs[i]);
}
template<typename T>
void add_wide_int (const generic_wide_int<T> &x)
{
add_int (x.get_len ());
for (unsigned i = 0; i < x.get_len (); i++)
add_hwi (x.sext_elt (i));
}
void add_ptr (const void *ptr)
{
add (&ptr, sizeof (ptr));
}
void add (const void *data, size_t len)
{
val = iterative_hash (data, len, val);
}
void merge_hash (hashval_t other)
{
val = iterative_hash_hashval_t (other, val);
}
void merge (hash &other)
{
merge_hash (other.val);
}
template<class T> void add_object(T &obj)
{
add (&obj, sizeof(T));
}
void add_flag (bool flag)
{
bits = (bits << 1) | flag;
}
void commit_flag ()
{
add_int (bits);
bits = 0;
}
void add_commutative (hash &a, hash &b)
{
if (a.end() > b.end())
{
merge (b);
merge (a);
}
else
{
merge (a);
merge (b);
}
}
private:
hashval_t val;
unsigned bits;
};
}
# 174 "/home/giulianob/gcc_git_gnu/gcc/gcc/inchash.h"
inline
hashval_t
iterative_hash_hashval_t (hashval_t val, hashval_t val2)
{
hashval_t a = 0x9e3779b9;
{ a -= val; a -= val2; a ^= (val2>>13); val -= val2; val -= a; val ^= (a<< 8); val2 -= a; val2 -= val; val2 ^= ((val&0xffffffff)>>13); a -= val; a -= val2; a ^= ((val2&0xffffffff)>>12); val -= val2; val -= a; val = (val ^ (a<<16)) & 0xffffffff; val2 -= a; val2 -= val; val2 = (val2 ^ (val>> 5)) & 0xffffffff; a -= val; a -= val2; a = (a ^ (val2>> 3)) & 0xffffffff; val -= val2; val -= a; val = (val ^ (a<<10)) & 0xffffffff; val2 -= a; val2 -= val; val2 = (val2 ^ (val>>15)) & 0xffffffff; };
return val2;
}
inline
hashval_t
iterative_hash_host_wide_int (long val, hashval_t val2)
{
if (sizeof (long) == sizeof (hashval_t))
return iterative_hash_hashval_t (val, val2);
else
{
hashval_t a = (hashval_t) val;
int zero = 0;
hashval_t b = (hashval_t) (val >> (sizeof (hashval_t) * 8 + zero));
{ a -= b; a -= val2; a ^= (val2>>13); b -= val2; b -= a; b ^= (a<< 8); val2 -= a; val2 -= b; val2 ^= ((b&0xffffffff)>>13); a -= b; a -= val2; a ^= ((val2&0xffffffff)>>12); b -= val2; b -= a; b = (b ^ (a<<16)) & 0xffffffff; val2 -= a; val2 -= b; val2 = (val2 ^ (b>> 5)) & 0xffffffff; a -= b; a -= val2; a = (a ^ (val2>> 3)) & 0xffffffff; b -= val2; b -= a; b = (b ^ (a<<10)) & 0xffffffff; val2 -= a; val2 -= b; val2 = (val2 ^ (b>>15)) & 0xffffffff; };
if (sizeof (long) > 2 * sizeof (hashval_t))
{
hashval_t a = (hashval_t) (val >> (sizeof (hashval_t) * 16 + zero));
hashval_t b = (hashval_t) (val >> (sizeof (hashval_t) * 24 + zero));
{ a -= b; a -= val2; a ^= (val2>>13); b -= val2; b -= a; b ^= (a<< 8); val2 -= a; val2 -= b; val2 ^= ((b&0xffffffff)>>13); a -= b; a -= val2; a ^= ((val2&0xffffffff)>>12); b -= val2; b -= a; b = (b ^ (a<<16)) & 0xffffffff; val2 -= a; val2 -= b; val2 = (val2 ^ (b>> 5)) & 0xffffffff; a -= b; a -= val2; a = (a ^ (val2>> 3)) & 0xffffffff; b -= val2; b -= a; b = (b ^ (a<<10)) & 0xffffffff; val2 -= a; val2 -= b; val2 = (val2 ^ (b>>15)) & 0xffffffff; };
}
return val2;
}
}
# 251 "/home/giulianob/gcc_git_gnu/gcc/gcc/hash-table.h" 2
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/mem-stats-traits.h" 1
# 25 "/home/giulianob/gcc_git_gnu/gcc/gcc/mem-stats-traits.h"
enum mem_alloc_origin
{
HASH_TABLE_ORIGIN,
HASH_MAP_ORIGIN,
HASH_SET_ORIGIN,
VEC_ORIGIN,
BITMAP_ORIGIN,
GGC_ORIGIN,
ALLOC_POOL_ORIGIN,
MEM_ALLOC_ORIGIN_LENGTH
};
static const char * mem_alloc_origin_names[] = { "Hash tables", "Hash maps",
"Hash sets", "Heap vectors", "Bitmaps", "GGC memory", "Allocation pool" };
# 252 "/home/giulianob/gcc_git_gnu/gcc/gcc/hash-table.h" 2
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/hash-traits.h" 1
# 25 "/home/giulianob/gcc_git_gnu/gcc/gcc/hash-traits.h"
template <typename Type>
struct typed_free_remove
{
static inline void remove (Type *p);
};
template <typename Type>
inline void
typed_free_remove <Type>::remove (Type *p)
{
free (p);
}
template <typename Type>
struct typed_delete_remove
{
static inline void remove (Type *p);
};
template <typename Type>
inline void
typed_delete_remove <Type>::remove (Type *p)
{
delete p;
}
template <typename Type>
struct typed_noop_remove
{
static inline void remove (Type &);
};
template <typename Type>
inline void
typed_noop_remove <Type>::remove (Type &)
{
}
template <typename Type, Type Empty, Type Deleted = Empty>
struct int_hash : typed_noop_remove <Type>
{
typedef Type value_type;
typedef Type compare_type;
static inline hashval_t hash (value_type);
static inline bool equal (value_type existing, value_type candidate);
static inline void mark_deleted (Type &);
static const bool empty_zero_p = Empty == 0;
static inline void mark_empty (Type &);
static inline bool is_deleted (Type);
static inline bool is_empty (Type);
};
template <typename Type, Type Empty, Type Deleted>
inline hashval_t
int_hash <Type, Empty, Deleted>::hash (value_type x)
{
return x;
}
template <typename Type, Type Empty, Type Deleted>
inline bool
int_hash <Type, Empty, Deleted>::equal (value_type x, value_type y)
{
return x == y;
}
template <typename Type, Type Empty, Type Deleted>
inline void
int_hash <Type, Empty, Deleted>::mark_deleted (Type &x)
{
((void)(!(Empty != Deleted) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/hash-traits.h", 115, __FUNCTION__), 0 : 0));
x = Deleted;
}
template <typename Type, Type Empty, Type Deleted>
inline void
int_hash <Type, Empty, Deleted>::mark_empty (Type &x)
{
x = Empty;
}
template <typename Type, Type Empty, Type Deleted>
inline bool
int_hash <Type, Empty, Deleted>::is_deleted (Type x)
{
return Empty != Deleted && x == Deleted;
}
template <typename Type, Type Empty, Type Deleted>
inline bool
int_hash <Type, Empty, Deleted>::is_empty (Type x)
{
return x == Empty;
}
template <typename Type>
struct pointer_hash
{
typedef Type *value_type;
typedef Type *compare_type;
static inline hashval_t hash (const value_type &);
static inline bool equal (const value_type &existing,
const compare_type &candidate);
static inline void mark_deleted (Type *&);
static const bool empty_zero_p = true;
static inline void mark_empty (Type *&);
static inline bool is_deleted (Type *);
static inline bool is_empty (Type *);
};
template <typename Type>
inline hashval_t
pointer_hash <Type>::hash (const value_type &candidate)
{
return (hashval_t) ((intptr_t)candidate >> 3);
}
template <typename Type>
inline bool
pointer_hash <Type>::equal (const value_type &existing,
const compare_type &candidate)
{
return existing == candidate;
}
template <typename Type>
inline void
pointer_hash <Type>::mark_deleted (Type *&e)
{
e = reinterpret_cast<Type *> (1);
}
template <typename Type>
inline void
pointer_hash <Type>::mark_empty (Type *&e)
{
e = nullptr;
}
template <typename Type>
inline bool
pointer_hash <Type>::is_deleted (Type *e)
{
return e == reinterpret_cast<Type *> (1);
}
template <typename Type>
inline bool
pointer_hash <Type>::is_empty (Type *e)
{
return e == nullptr;
}
struct string_hash : pointer_hash <const char>
{
static inline hashval_t hash (const char *);
static inline bool equal (const char *, const char *);
};
inline hashval_t
string_hash::hash (const char *id)
{
return htab_hash_string (id);
}
inline bool
string_hash::equal (const char *id1, const char *id2)
{
return strcmp (id1, id2) == 0;
}
template<typename T>
struct ggc_remove
{
static void remove (T &) {}
static void
ggc_mx (T &p)
{
extern void gt_ggc_mx (T &);
gt_ggc_mx (p);
}
static void
ggc_maybe_mx (T &p)
{
ggc_mx (p);
}
static void
pch_nx (T &p)
{
extern void gt_pch_nx (T &);
gt_pch_nx (p);
}
static void
pch_nx (T &p, gt_pointer_operator op, void *cookie)
{
op (&p, cookie);
}
};
template<typename T>
struct ggc_cache_remove : ggc_remove<T>
{
static void ggc_maybe_mx (T &) {}
static int
keep_cache_entry (T &e)
{
return ggc_marked_p (e) ? -1 : 0;
}
};
template <typename T>
struct nofree_ptr_hash : pointer_hash <T>, typed_noop_remove <T *> {};
template <typename T>
struct free_ptr_hash : pointer_hash <T>, typed_free_remove <T> {};
template <typename T>
struct delete_ptr_hash : pointer_hash <T>, typed_delete_remove <T> {};
template <typename T>
struct ggc_ptr_hash : pointer_hash <T>, ggc_remove <T *> {};
template <typename T>
struct ggc_cache_ptr_hash : pointer_hash <T>, ggc_cache_remove <T *> {};
struct nofree_string_hash : string_hash, typed_noop_remove <const char *> {};
template <typename T1, typename T2>
struct pair_hash
{
typedef std::pair <typename T1::value_type,
typename T2::value_type> value_type;
typedef std::pair <typename T1::compare_type,
typename T2::compare_type> compare_type;
static inline hashval_t hash (const value_type &);
static inline bool equal (const value_type &, const compare_type &);
static inline void remove (value_type &);
static inline void mark_deleted (value_type &);
static const bool empty_zero_p = T1::empty_zero_p;
static inline void mark_empty (value_type &);
static inline bool is_deleted (const value_type &);
static inline bool is_empty (const value_type &);
};
template <typename T1, typename T2>
inline hashval_t
pair_hash <T1, T2>::hash (const value_type &x)
{
return iterative_hash_hashval_t (T1::hash (x.first), T2::hash (x.second));
}
template <typename T1, typename T2>
inline bool
pair_hash <T1, T2>::equal (const value_type &x, const compare_type &y)
{
return T1::equal (x.first, y.first) && T2::equal (x.second, y.second);
}
template <typename T1, typename T2>
inline void
pair_hash <T1, T2>::remove (value_type &x)
{
T1::remove (x.first);
T2::remove (x.second);
}
template <typename T1, typename T2>
inline void
pair_hash <T1, T2>::mark_deleted (value_type &x)
{
T1::mark_deleted (x.first);
}
template <typename T1, typename T2>
inline void
pair_hash <T1, T2>::mark_empty (value_type &x)
{
T1::mark_empty (x.first);
}
template <typename T1, typename T2>
inline bool
pair_hash <T1, T2>::is_deleted (const value_type &x)
{
return T1::is_deleted (x.first);
}
template <typename T1, typename T2>
inline bool
pair_hash <T1, T2>::is_empty (const value_type &x)
{
return T1::is_empty (x.first);
}
template <typename T> struct default_hash_traits : T {};
template <typename T>
struct default_hash_traits <T *> : ggc_ptr_hash <T> {};
# 253 "/home/giulianob/gcc_git_gnu/gcc/gcc/hash-table.h" 2
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/hash-map-traits.h" 1
# 31 "/home/giulianob/gcc_git_gnu/gcc/gcc/hash-map-traits.h"
template <typename H, typename Value>
struct simple_hashmap_traits
{
typedef typename H::value_type key_type;
static const bool maybe_mx = true;
static inline hashval_t hash (const key_type &);
static inline bool equal_keys (const key_type &, const key_type &);
template <typename T> static inline void remove (T &);
static const bool empty_zero_p = H::empty_zero_p;
template <typename T> static inline bool is_empty (const T &);
template <typename T> static inline bool is_deleted (const T &);
template <typename T> static inline void mark_empty (T &);
template <typename T> static inline void mark_deleted (T &);
};
template <typename H, typename Value>
inline hashval_t
simple_hashmap_traits <H, Value>::hash (const key_type &h)
{
return H::hash (h);
}
template <typename H, typename Value>
inline bool
simple_hashmap_traits <H, Value>::equal_keys (const key_type &k1,
const key_type &k2)
{
return H::equal (k1, k2);
}
template <typename H, typename Value>
template <typename T>
inline void
simple_hashmap_traits <H, Value>::remove (T &entry)
{
H::remove (entry.m_key);
entry.m_value.~Value ();
}
template <typename H, typename Value>
template <typename T>
inline bool
simple_hashmap_traits <H, Value>::is_empty (const T &entry)
{
return H::is_empty (entry.m_key);
}
template <typename H, typename Value>
template <typename T>
inline bool
simple_hashmap_traits <H, Value>::is_deleted (const T &entry)
{
return H::is_deleted (entry.m_key);
}
template <typename H, typename Value>
template <typename T>
inline void
simple_hashmap_traits <H, Value>::mark_empty (T &entry)
{
H::mark_empty (entry.m_key);
}
template <typename H, typename Value>
template <typename T>
inline void
simple_hashmap_traits <H, Value>::mark_deleted (T &entry)
{
H::mark_deleted (entry.m_key);
}
template <typename H, typename Value>
struct simple_cache_map_traits: public simple_hashmap_traits<H,Value>
{
static const bool maybe_mx = false;
};
template <typename Value>
struct unbounded_hashmap_traits
{
template <typename T> static inline void remove (T &);
static const bool empty_zero_p = default_hash_traits <Value>::empty_zero_p;
template <typename T> static inline bool is_empty (const T &);
template <typename T> static inline bool is_deleted (const T &);
template <typename T> static inline void mark_empty (T &);
template <typename T> static inline void mark_deleted (T &);
};
template <typename Value>
template <typename T>
inline void
unbounded_hashmap_traits <Value>::remove (T &entry)
{
default_hash_traits <Value>::remove (entry.m_value);
}
template <typename Value>
template <typename T>
inline bool
unbounded_hashmap_traits <Value>::is_empty (const T &entry)
{
return default_hash_traits <Value>::is_empty (entry.m_value);
}
template <typename Value>
template <typename T>
inline bool
unbounded_hashmap_traits <Value>::is_deleted (const T &entry)
{
return default_hash_traits <Value>::is_deleted (entry.m_value);
}
template <typename Value>
template <typename T>
inline void
unbounded_hashmap_traits <Value>::mark_empty (T &entry)
{
default_hash_traits <Value>::mark_empty (entry.m_value);
}
template <typename Value>
template <typename T>
inline void
unbounded_hashmap_traits <Value>::mark_deleted (T &entry)
{
default_hash_traits <Value>::mark_deleted (entry.m_value);
}
template <typename Key, typename Value>
struct unbounded_int_hashmap_traits : unbounded_hashmap_traits <Value>
{
typedef Key key_type;
static inline hashval_t hash (Key);
static inline bool equal_keys (Key, Key);
};
template <typename Key, typename Value>
inline hashval_t
unbounded_int_hashmap_traits <Key, Value>::hash (Key k)
{
return k;
}
template <typename Key, typename Value>
inline bool
unbounded_int_hashmap_traits <Key, Value>::equal_keys (Key k1, Key k2)
{
return k1 == k2;
}
# 254 "/home/giulianob/gcc_git_gnu/gcc/gcc/hash-table.h" 2
template<typename, typename, typename> class hash_map;
template<typename, bool, typename> class hash_set;
template <typename Type>
struct xcallocator
{
static Type *data_alloc (size_t count);
static void data_free (Type *memory);
};
template <typename Type>
inline Type *
xcallocator <Type>::data_alloc (size_t count)
{
return static_cast <Type *> (xcalloc (count, sizeof (Type)));
}
template <typename Type>
inline void
xcallocator <Type>::data_free (Type *memory)
{
return ::free (memory);
}
struct prime_ent
{
hashval_t prime;
hashval_t inv;
hashval_t inv_m2;
hashval_t shift;
};
extern struct prime_ent const prime_tab[];
extern unsigned int hash_table_sanitize_eq_limit;
extern unsigned int hash_table_higher_prime_index (unsigned long n)
__attribute__ ((__pure__));
extern __attribute__ ((__noreturn__)) __attribute__ ((__cold__)) void hashtab_chk_error ();
# 322 "/home/giulianob/gcc_git_gnu/gcc/gcc/hash-table.h"
inline hashval_t
mul_mod (hashval_t x, hashval_t y, hashval_t inv, int shift)
{
hashval_t t1, t2, t3, t4, q, r;
t1 = ((uint64_t)x * inv) >> 32;
t2 = x - t1;
t3 = t2 >> 1;
t4 = t1 + t3;
q = t4 >> shift;
r = x - (q * y);
return r;
}
inline hashval_t
hash_table_mod1 (hashval_t hash, unsigned int index)
{
const struct prime_ent *p = &prime_tab[index];
((void)(!(sizeof (hashval_t) * 8 <= 32) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/hash-table.h", 343, __FUNCTION__), 0 : 0));
return mul_mod (hash, p->prime, p->inv, p->shift);
}
inline hashval_t
hash_table_mod2 (hashval_t hash, unsigned int index)
{
const struct prime_ent *p = &prime_tab[index];
((void)(!(sizeof (hashval_t) * 8 <= 32) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/hash-table.h", 353, __FUNCTION__), 0 : 0));
return 1 + mul_mod (hash, p->prime - 2, p->inv_m2, p->shift);
}
class mem_usage;
# 372 "/home/giulianob/gcc_git_gnu/gcc/gcc/hash-table.h"
template <typename Descriptor, bool Lazy = false,
template<typename Type> class Allocator = xcallocator>
class hash_table
{
typedef typename Descriptor::value_type value_type;
typedef typename Descriptor::compare_type compare_type;
public:
explicit hash_table (size_t, bool ggc = false,
bool sanitize_eq_and_hash = true,
bool gather_mem_stats = 0,
mem_alloc_origin origin = HASH_TABLE_ORIGIN
);
explicit hash_table (const hash_table &, bool ggc = false,
bool sanitize_eq_and_hash = true,
bool gather_mem_stats = 0,
mem_alloc_origin origin = HASH_TABLE_ORIGIN
);
~hash_table ();
static hash_table *
create_ggc (size_t n, bool sanitize_eq_and_hash = true )
{
hash_table *table = ggc_alloc<hash_table> ();
new (table) hash_table (n, true, sanitize_eq_and_hash, 0,
HASH_TABLE_ORIGIN );
return table;
}
size_t size () const { return m_size; }
size_t elements () const { return m_n_elements - m_n_deleted; }
size_t elements_with_deleted () const { return m_n_elements; }
void empty () { if (elements ()) empty_slow (); }
bool is_empty () const { return elements () == 0; }
void clear_slot (value_type *);
value_type &find_with_hash (const compare_type &, hashval_t);
value_type &find (const value_type &value)
{
return find_with_hash (value, Descriptor::hash (value));
}
value_type *find_slot (const value_type &value, insert_option insert)
{
return find_slot_with_hash (value, Descriptor::hash (value), insert);
}
# 445 "/home/giulianob/gcc_git_gnu/gcc/gcc/hash-table.h"
value_type *find_slot_with_hash (const compare_type &comparable,
hashval_t hash, enum insert_option insert);
void remove_elt_with_hash (const compare_type &, hashval_t);
void remove_elt (const value_type &value)
{
remove_elt_with_hash (value, Descriptor::hash (value));
}
template <typename Argument,
int (*Callback) (value_type *slot, Argument argument)>
void traverse_noresize (Argument argument);
template <typename Argument,
int (*Callback) (value_type *slot, Argument argument)>
void traverse (Argument argument);
class iterator
{
public:
iterator () : m_slot (nullptr), m_limit (nullptr) {}
iterator (value_type *slot, value_type *limit) :
m_slot (slot), m_limit (limit) {}
inline value_type &operator * () { return *m_slot; }
void slide ();
inline iterator &operator ++ ();
bool operator != (const iterator &other) const
{
return m_slot != other.m_slot || m_limit != other.m_limit;
}
private:
value_type *m_slot;
value_type *m_limit;
};
iterator begin () const
{
if (Lazy && m_entries == nullptr)
return iterator ();
iterator iter (m_entries, m_entries + m_size);
iter.slide ();
return iter;
}
iterator end () const { return iterator (); }
double collisions () const
{
return m_searches ? static_cast <double> (m_collisions) / m_searches : 0;
}
private:
void operator= (hash_table&);
template<typename T> friend void gt_ggc_mx (hash_table<T> *);
template<typename T> friend void gt_pch_nx (hash_table<T> *);
template<typename T> friend void
hashtab_entry_note_pointers (void *, void *, gt_pointer_operator, void *);
template<typename T, typename U, typename V> friend void
gt_pch_nx (hash_map<T, U, V> *, gt_pointer_operator, void *);
template<typename T, typename U>
friend void gt_pch_nx (hash_set<T, false, U> *, gt_pointer_operator, void *);
template<typename T> friend void gt_pch_nx (hash_table<T> *,
gt_pointer_operator, void *);
template<typename T> friend void gt_cleare_cache (hash_table<T> *);
void empty_slow ();
value_type *alloc_entries (size_t n ) const;
value_type *find_empty_slot_for_expand (hashval_t);
void verify (const compare_type &comparable, hashval_t hash);
bool too_empty_p (unsigned int);
void expand ();
static bool is_deleted (value_type &v)
{
return Descriptor::is_deleted (v);
}
static bool is_empty (value_type &v)
{
return Descriptor::is_empty (v);
}
static void mark_deleted (value_type &v)
{
Descriptor::mark_deleted (v);
}
static void mark_empty (value_type &v)
{
Descriptor::mark_empty (v);
}
typename Descriptor::value_type *m_entries;
size_t m_size;
size_t m_n_elements;
size_t m_n_deleted;
unsigned int m_searches;
unsigned int m_collisions;
unsigned int m_size_prime_index;
bool m_ggc;
bool m_sanitize_eq_and_hash;
static const bool m_gather_mem_stats = false;
};
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/mem-stats.h" 1
# 25 "/home/giulianob/gcc_git_gnu/gcc/gcc/mem-stats.h"
template<typename Key, typename Value,
typename Traits = simple_hashmap_traits<default_hash_traits<Key>,
Value> >
class hash_map;
class mem_location
{
public:
inline
mem_location () {}
inline
mem_location (mem_alloc_origin origin, bool ggc,
const char *filename = nullptr, int line = 0,
const char *function = nullptr):
m_filename (filename), m_function (function), m_line (line), m_origin
(origin), m_ggc (ggc) {}
inline
mem_location (mem_location &other): m_filename (other.m_filename),
m_function (other.m_function), m_line (other.m_line),
m_origin (other.m_origin), m_ggc (other.m_ggc) {}
hashval_t
hash ()
{
inchash::hash hash;
hash.add_ptr (m_filename);
hash.add_ptr (m_function);
hash.add_int (m_line);
return hash.end ();
}
int
equal (const mem_location &other)
{
return m_filename == other.m_filename && m_function == other.m_function
&& m_line == other.m_line;
}
inline const char *
get_trimmed_filename ()
{
const char *s1 = m_filename;
const char *s2;
while ((s2 = strstr (s1, "gcc/")))
s1 = s2 + 4;
return s1;
}
inline char *
to_string ()
{
unsigned l = strlen (get_trimmed_filename ()) + strlen (m_function)
+ 30;
char *s = ((char *) xmalloc (sizeof (char) * (l)));
sprintf (s, "%s:%i (%s)", get_trimmed_filename (),
m_line, m_function);
s[((48) < (l - 1) ? (48) : (l - 1))] = '\0';
return s;
}
static const char *
get_origin_name (mem_alloc_origin origin)
{
return mem_alloc_origin_names[(unsigned) origin];
}
const char *m_filename;
const char *m_function;
int m_line;
mem_alloc_origin m_origin;
bool m_ggc;
};
class mem_usage
{
public:
mem_usage (): m_allocated (0), m_times (0), m_peak (0), m_instances (1) {}
mem_usage (size_t allocated, size_t times, size_t peak, size_t instances = 0):
m_allocated (allocated), m_times (times), m_peak (peak),
m_instances (instances) {}
inline void
register_overhead (size_t size)
{
m_allocated += size;
m_times++;
if (m_peak < m_allocated)
m_peak = m_allocated;
}
inline void
release_overhead (size_t size)
{
((void)(!(size <= m_allocated) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/mem-stats.h", 153, __FUNCTION__), 0 : 0));
m_allocated -= size;
}
mem_usage
operator+ (const mem_usage &second)
{
return mem_usage (m_allocated + second.m_allocated,
m_times + second.m_times,
m_peak + second.m_peak,
m_instances + second.m_instances);
}
inline bool
operator== (const mem_usage &second) const
{
return (m_allocated == second.m_allocated
&& m_peak == second.m_peak
&& m_times == second.m_times);
}
inline bool
operator< (const mem_usage &second) const
{
if (*this == second)
return false;
return (m_allocated == second.m_allocated ?
(m_peak == second.m_peak ? m_times < second.m_times
: m_peak < second.m_peak) : m_allocated < second.m_allocated);
}
static int
compare (const void *first, const void *second)
{
typedef std::pair<mem_location *, mem_usage *> mem_pair_t;
const mem_pair_t f = *(const mem_pair_t *)first;
const mem_pair_t s = *(const mem_pair_t *)second;
if (*f.second == *s.second)
return 0;
return *f.second < *s.second ? 1 : -1;
}
inline void
dump (mem_location *loc, const mem_usage &total) const
{
char *location_string = loc->to_string ();
fprintf (
# 210 "/home/giulianob/gcc_git_gnu/gcc/gcc/mem-stats.h" 3 4
stderr
# 210 "/home/giulianob/gcc_git_gnu/gcc/gcc/mem-stats.h"
, "%-48s " "%" "9"
# 210 "/home/giulianob/gcc_git_gnu/gcc/gcc/mem-stats.h" 3 4
"l" "u"
# 210 "/home/giulianob/gcc_git_gnu/gcc/gcc/mem-stats.h"
"%c" ":%5.1f%%"
"%" "9"
# 211 "/home/giulianob/gcc_git_gnu/gcc/gcc/mem-stats.h" 3 4
"l" "u"
# 211 "/home/giulianob/gcc_git_gnu/gcc/gcc/mem-stats.h"
"%c" "%" "9"
# 211 "/home/giulianob/gcc_git_gnu/gcc/gcc/mem-stats.h" 3 4
"l" "u"
# 211 "/home/giulianob/gcc_git_gnu/gcc/gcc/mem-stats.h"
"%c" ":%5.1f%%%10s\n",
location_string, (uint64_t)(((m_allocated) < 10 * 1024 ? (m_allocated) : ((m_allocated) < 10 * (1024 * 1024) ? (m_allocated) / 1024 : (m_allocated) / (1024 * 1024)))), ((m_allocated) < 10 * 1024 ? ' ' : ((m_allocated) < 10 * (1024 * 1024) ? 'k' : 'M')),
get_percent (m_allocated, total.m_allocated),
(uint64_t)(((m_peak) < 10 * 1024 ? (m_peak) : ((m_peak) < 10 * (1024 * 1024) ? (m_peak) / 1024 : (m_peak) / (1024 * 1024)))), ((m_peak) < 10 * 1024 ? ' ' : ((m_peak) < 10 * (1024 * 1024) ? 'k' : 'M')), (uint64_t)(((m_times) < 10 * 1024 ? (m_times) : ((m_times) < 10 * (1024 * 1024) ? (m_times) / 1024 : (m_times) / (1024 * 1024)))), ((m_times) < 10 * 1024 ? ' ' : ((m_times) < 10 * (1024 * 1024) ? 'k' : 'M')),
get_percent (m_times, total.m_times), loc->m_ggc ? "ggc" : "heap");
free (location_string);
}
inline void
dump_footer () const
{
fprintf (
# 224 "/home/giulianob/gcc_git_gnu/gcc/gcc/mem-stats.h" 3 4
stderr
# 224 "/home/giulianob/gcc_git_gnu/gcc/gcc/mem-stats.h"
, "%s" "%" "53"
# 224 "/home/giulianob/gcc_git_gnu/gcc/gcc/mem-stats.h" 3 4
"l" "u"
# 224 "/home/giulianob/gcc_git_gnu/gcc/gcc/mem-stats.h"
"%c" "%" "26"
# 224 "/home/giulianob/gcc_git_gnu/gcc/gcc/mem-stats.h" 3 4
"l" "u"
# 224 "/home/giulianob/gcc_git_gnu/gcc/gcc/mem-stats.h"
"%c" "\n", "Total",
(uint64_t)(((m_allocated) < 10 * 1024 ? (m_allocated) : ((m_allocated) < 10 * (1024 * 1024) ? (m_allocated) / 1024 : (m_allocated) / (1024 * 1024)))), ((m_allocated) < 10 * 1024 ? ' ' : ((m_allocated) < 10 * (1024 * 1024) ? 'k' : 'M')), (uint64_t)(((m_times) < 10 * 1024 ? (m_times) : ((m_times) < 10 * (1024 * 1024) ? (m_times) / 1024 : (m_times) / (1024 * 1024)))), ((m_times) < 10 * 1024 ? ' ' : ((m_times) < 10 * (1024 * 1024) ? 'k' : 'M')));
}
static inline float
get_percent (size_t nominator, size_t denominator)
{
return denominator == 0 ? 0.0f : nominator * 100.0 / denominator;
}
static inline void
print_dash_line (size_t count = 140)
{
while (count--)
fputc ('-',
# 240 "/home/giulianob/gcc_git_gnu/gcc/gcc/mem-stats.h" 3 4
stderr
# 240 "/home/giulianob/gcc_git_gnu/gcc/gcc/mem-stats.h"
);
fputc ('\n',
# 241 "/home/giulianob/gcc_git_gnu/gcc/gcc/mem-stats.h" 3 4
stderr
# 241 "/home/giulianob/gcc_git_gnu/gcc/gcc/mem-stats.h"
);
}
static inline void
dump_header (const char *name)
{
fprintf (
# 248 "/home/giulianob/gcc_git_gnu/gcc/gcc/mem-stats.h" 3 4
stderr
# 248 "/home/giulianob/gcc_git_gnu/gcc/gcc/mem-stats.h"
, "%-48s %11s%16s%10s%17s\n", name, "Leak", "Peak",
"Times", "Type");
}
size_t m_allocated;
size_t m_times;
size_t m_peak;
size_t m_instances;
};
template <class T>
class mem_usage_pair
{
public:
mem_usage_pair (T *usage_, size_t allocated_): usage (usage_),
allocated (allocated_) {}
T *usage;
size_t allocated;
};
template <class T>
class mem_alloc_description
{
public:
struct mem_location_hash : nofree_ptr_hash <mem_location>
{
static hashval_t
hash (value_type l)
{
inchash::hash hstate;
hstate.add_ptr ((const void *)l->m_filename);
hstate.add_ptr (l->m_function);
hstate.add_int (l->m_line);
return hstate.end ();
}
static bool
equal (value_type l1, value_type l2)
{
return (l1->m_filename == l2->m_filename
&& l1->m_function == l2->m_function
&& l1->m_line == l2->m_line);
}
};
typedef hash_map <mem_location_hash, T *> mem_map_t;
typedef hash_map <const void *, mem_usage_pair<T> > reverse_mem_map_t;
typedef hash_map <const void *, std::pair<T *, size_t> > reverse_object_map_t;
typedef std::pair <mem_location *, T *> mem_list_t;
mem_alloc_description ();
~mem_alloc_description ();
bool contains_descriptor_for_instance (const void *ptr);
T *get_descriptor_for_instance (const void *ptr);
T *register_descriptor (const void *ptr, mem_location *location);
T *register_descriptor (const void *ptr, mem_alloc_origin origin,
bool ggc, const char *name, int line,
const char *function);
T *register_instance_overhead (size_t size, const void *ptr);
void register_object_overhead (T *usage, size_t size, const void *ptr);
T *release_instance_overhead (void *ptr, size_t size,
bool remove_from_map = false);
void release_object_overhead (void *ptr);
void unregister_descriptor (void *ptr);
T get_sum (mem_alloc_origin origin);
mem_list_t *get_list (mem_alloc_origin origin, unsigned *length);
void dump (mem_alloc_origin origin);
reverse_object_map_t *m_reverse_object_map;
private:
T *register_overhead (size_t size, mem_alloc_origin origin, const char *name,
int line, const char *function, const void *ptr);
mem_location m_location;
mem_map_t *m_map;
reverse_mem_map_t *m_reverse_map;
};
template <class T>
inline bool
mem_alloc_description<T>::contains_descriptor_for_instance (const void *ptr)
{
return m_reverse_map->get (ptr);
}
template <class T>
inline T*
mem_alloc_description<T>::get_descriptor_for_instance (const void *ptr)
{
return m_reverse_map->get (ptr) ? (*m_reverse_map->get (ptr)).usage : nullptr;
}
template <class T>
inline T*
mem_alloc_description<T>::register_descriptor (const void *ptr,
mem_location *location)
{
T *usage = nullptr;
T **slot = m_map->get (location);
if (slot)
{
delete location;
usage = *slot;
usage->m_instances++;
}
else
{
usage = new T ();
m_map->put (location, usage);
}
if (!m_reverse_map->get (ptr))
m_reverse_map->put (ptr, mem_usage_pair<T> (usage, 0));
return usage;
}
template <class T>
inline T*
mem_alloc_description<T>::register_descriptor (const void *ptr,
mem_alloc_origin origin,
bool ggc,
const char *filename,
int line,
const char *function)
{
mem_location *l = new mem_location (origin, ggc, filename, line, function);
return register_descriptor (ptr, l);
}
template <class T>
inline T*
mem_alloc_description<T>::register_instance_overhead (size_t size,
const void *ptr)
{
mem_usage_pair <T> *slot = m_reverse_map->get (ptr);
if (!slot)
{
return nullptr;
}
T *usage = (*slot).usage;
usage->register_overhead (size);
return usage;
}
template <class T>
void
mem_alloc_description<T>::register_object_overhead (T *usage, size_t size,
const void *ptr)
{
m_reverse_object_map->put (ptr, std::pair<T *, size_t> (usage, size));
}
template <class T>
inline T*
mem_alloc_description<T>::register_overhead (size_t size,
mem_alloc_origin origin,
const char *filename,
int line,
const char *function,
const void *ptr)
{
T *usage = register_descriptor (ptr, origin, filename, line, function);
usage->register_overhead (size);
return usage;
}
template <class T>
inline T *
mem_alloc_description<T>::release_instance_overhead (void *ptr, size_t size,
bool remove_from_map)
{
mem_usage_pair<T> *slot = m_reverse_map->get (ptr);
if (!slot)
{
return nullptr;
}
T *usage = (*slot).usage;
usage->release_overhead (size);
if (remove_from_map)
m_reverse_map->remove (ptr);
return usage;
}
template <class T>
inline void
mem_alloc_description<T>::release_object_overhead (void *ptr)
{
std::pair <T *, size_t> *entry = m_reverse_object_map->get (ptr);
entry->first->release_overhead (entry->second);
m_reverse_object_map->remove (ptr);
}
template <class T>
inline void
mem_alloc_description<T>::unregister_descriptor (void *ptr)
{
m_reverse_map->remove (ptr);
}
template <class T>
inline
mem_alloc_description<T>::mem_alloc_description ()
{
m_map = new mem_map_t (13, false, false, false);
m_reverse_map = new reverse_mem_map_t (13, false, false, false);
m_reverse_object_map = new reverse_object_map_t (13, false, false, false);
}
template <class T>
inline
mem_alloc_description<T>::~mem_alloc_description ()
{
for (typename mem_map_t::iterator it = m_map->begin (); it != m_map->end ();
++it)
{
delete (*it).first;
delete (*it).second;
}
delete m_map;
delete m_reverse_map;
delete m_reverse_object_map;
}
template <class T>
inline
typename mem_alloc_description<T>::mem_list_t *
mem_alloc_description<T>::get_list (mem_alloc_origin origin, unsigned *length)
{
size_t element_size = sizeof (mem_list_t);
mem_list_t *list = ((mem_list_t *) xcalloc ((m_map->elements ()), sizeof (mem_list_t)));
unsigned i = 0;
for (typename mem_map_t::iterator it = m_map->begin (); it != m_map->end ();
++it)
if ((*it).first->m_origin == origin)
list[i++] = std::pair<mem_location*, T*> (*it);
gcc_qsort (list, i, element_size, T::compare);
*length = i;
return list;
}
template <class T>
inline T
mem_alloc_description<T>::get_sum (mem_alloc_origin origin)
{
unsigned length;
mem_list_t *list = get_list (origin, &length);
T sum;
for (unsigned i = 0; i < length; i++)
sum = sum + *list[i].second;
free ((void*) (list));
return sum;
}
template <class T>
inline void
mem_alloc_description<T>::dump (mem_alloc_origin origin)
{
unsigned length;
fprintf (
# 636 "/home/giulianob/gcc_git_gnu/gcc/gcc/mem-stats.h" 3 4
stderr
# 636 "/home/giulianob/gcc_git_gnu/gcc/gcc/mem-stats.h"
, "\n");
mem_list_t *list = get_list (origin, &length);
T total = get_sum (origin);
T::print_dash_line ();
T::dump_header (mem_location::get_origin_name (origin));
T::print_dash_line ();
for (int i = length - 1; i >= 0; i--)
list[i].second->dump (list[i].first, total);
T::print_dash_line ();
T::dump_header (mem_location::get_origin_name (origin));
T::print_dash_line ();
total.dump_footer ();
T::print_dash_line ();
free ((void*) (list));
fprintf (
# 655 "/home/giulianob/gcc_git_gnu/gcc/gcc/mem-stats.h" 3 4
stderr
# 655 "/home/giulianob/gcc_git_gnu/gcc/gcc/mem-stats.h"
, "\n");
}
# 595 "/home/giulianob/gcc_git_gnu/gcc/gcc/hash-table.h" 2
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/hash-map.h" 1
# 35 "/home/giulianob/gcc_git_gnu/gcc/gcc/hash-map.h"
const size_t default_hash_map_size = 13;
template<typename KeyId, typename Value,
typename Traits
>
class hash_map
{
typedef typename Traits::key_type Key;
struct hash_entry
{
Key m_key;
Value m_value;
typedef hash_entry value_type;
typedef Key compare_type;
static hashval_t hash (const hash_entry &e)
{
return Traits::hash (e.m_key);
}
static bool equal (const hash_entry &a, const Key &b)
{
return Traits::equal_keys (a.m_key, b);
}
static void remove (hash_entry &e) { Traits::remove (e); }
static void mark_deleted (hash_entry &e) { Traits::mark_deleted (e); }
static bool is_deleted (const hash_entry &e)
{
return Traits::is_deleted (e);
}
static const bool empty_zero_p = Traits::empty_zero_p;
static void mark_empty (hash_entry &e) { Traits::mark_empty (e); }
static bool is_empty (const hash_entry &e) { return Traits::is_empty (e); }
static void ggc_mx (hash_entry &e)
{
gt_ggc_mx (e.m_key);
gt_ggc_mx (e.m_value);
}
static void ggc_maybe_mx (hash_entry &e)
{
if (Traits::maybe_mx)
ggc_mx (e);
}
static void pch_nx (hash_entry &e)
{
gt_pch_nx (e.m_key);
gt_pch_nx (e.m_value);
}
static void pch_nx (hash_entry &e, gt_pointer_operator op, void *c)
{
pch_nx_helper (e.m_key, op, c);
pch_nx_helper (e.m_value, op, c);
}
static int keep_cache_entry (hash_entry &e)
{
return ggc_marked_p (e.m_key);
}
private:
template<typename T>
static void
pch_nx_helper (T &x, gt_pointer_operator op, void *cookie)
{
gt_pch_nx (&x, op, cookie);
}
static void
pch_nx_helper (int, gt_pointer_operator, void *)
{
}
static void
pch_nx_helper (unsigned int, gt_pointer_operator, void *)
{
}
static void
pch_nx_helper (bool, gt_pointer_operator, void *)
{
}
template<typename T>
static void
pch_nx_helper (T *&x, gt_pointer_operator op, void *cookie)
{
op (&x, cookie);
}
};
public:
explicit hash_map (size_t n = default_hash_map_size, bool ggc = false,
bool sanitize_eq_and_hash = true,
bool gather_mem_stats = 0
)
: m_table (n, ggc, sanitize_eq_and_hash, gather_mem_stats,
HASH_MAP_ORIGIN )
{
}
explicit hash_map (const hash_map &h, bool ggc = false,
bool sanitize_eq_and_hash = true,
bool gather_mem_stats = 0
)
: m_table (h.m_table, ggc, sanitize_eq_and_hash, gather_mem_stats,
HASH_MAP_ORIGIN ) {}
static hash_map *create_ggc (size_t size = default_hash_map_size,
bool gather_mem_stats = 0
)
{
hash_map *map = ggc_alloc<hash_map> ();
new (map) hash_map (size, true, true, gather_mem_stats );
return map;
}
bool put (const Key &k, const Value &v)
{
hash_entry *e = m_table.find_slot_with_hash (k, Traits::hash (k),
INSERT);
bool ins = hash_entry::is_empty (*e);
if (ins)
{
e->m_key = k;
new ((void *) &e->m_value) Value (v);
}
else
e->m_value = v;
return !ins;
}
Value *get (const Key &k)
{
hash_entry &e = m_table.find_with_hash (k, Traits::hash (k));
return Traits::is_empty (e) ? nullptr : &e.m_value;
}
Value &get_or_insert (const Key &k, bool *existed = nullptr)
{
hash_entry *e = m_table.find_slot_with_hash (k, Traits::hash (k),
INSERT);
bool ins = Traits::is_empty (*e);
if (ins)
{
e->m_key = k;
new ((void *)&e->m_value) Value ();
}
if (existed != nullptr)
*existed = !ins;
return e->m_value;
}
void remove (const Key &k)
{
m_table.remove_elt_with_hash (k, Traits::hash (k));
}
template<typename Arg, bool (*f)(const typename Traits::key_type &,
const Value &, Arg)>
void traverse (Arg a) const
{
for (typename hash_table<hash_entry>::iterator iter = m_table.begin ();
iter != m_table.end (); ++iter)
f ((*iter).m_key, (*iter).m_value, a);
}
template<typename Arg, bool (*f)(const typename Traits::key_type &,
Value *, Arg)>
void traverse (Arg a) const
{
for (typename hash_table<hash_entry>::iterator iter = m_table.begin ();
iter != m_table.end (); ++iter)
if (!f ((*iter).m_key, &(*iter).m_value, a))
break;
}
size_t elements () const { return m_table.elements (); }
void empty () { m_table.empty(); }
bool is_empty () const { return m_table.is_empty (); }
class iterator
{
public:
explicit iterator (const typename hash_table<hash_entry>::iterator &iter) :
m_iter (iter) {}
iterator &operator++ ()
{
++m_iter;
return *this;
}
class reference_pair {
public:
const Key &first;
Value &second;
reference_pair (const Key &key, Value &value) : first (key), second (value) {}
template <typename K, typename V>
operator std::pair<K, V> () const { return std::pair<K, V> (first, second); }
};
reference_pair operator* ()
{
hash_entry &e = *m_iter;
return reference_pair (e.m_key, e.m_value);
}
bool
operator != (const iterator &other) const
{
return m_iter != other.m_iter;
}
private:
typename hash_table<hash_entry>::iterator m_iter;
};
iterator begin () const { return iterator (m_table.begin ()); }
iterator end () const { return iterator (m_table.end ()); }
private:
template<typename T, typename U, typename V> friend void gt_ggc_mx (hash_map<T, U, V> *);
template<typename T, typename U, typename V> friend void gt_pch_nx (hash_map<T, U, V> *);
template<typename T, typename U, typename V> friend void gt_pch_nx (hash_map<T, U, V> *, gt_pointer_operator, void *);
template<typename T, typename U, typename V> friend void gt_cleare_cache (hash_map<T, U, V> *);
hash_table<hash_entry> m_table;
};
template<typename K, typename V, typename H>
static inline void
gt_ggc_mx (hash_map<K, V, H> *h)
{
gt_ggc_mx (&h->m_table);
}
template<typename K, typename V, typename H>
static inline void
gt_pch_nx (hash_map<K, V, H> *h)
{
gt_pch_nx (&h->m_table);
}
template<typename K, typename V, typename H>
static inline void
gt_cleare_cache (hash_map<K, V, H> *h)
{
if (h)
gt_cleare_cache (&h->m_table);
}
template<typename K, typename V, typename H>
static inline void
gt_pch_nx (hash_map<K, V, H> *h, gt_pointer_operator op, void *cookie)
{
op (&h->m_table.m_entries, cookie);
}
enum hm_alloc { hm_heap = false, hm_ggc = true };
template<bool ggc, typename K, typename V, typename H>
inline hash_map<K,V,H> *
hash_map_maybe_create (hash_map<K,V,H> *&h,
size_t size = default_hash_map_size)
{
if (!h)
{
if (ggc)
h = hash_map<K,V,H>::create_ggc (size);
else
h = new hash_map<K,V,H> (size);
}
return h;
}
template<typename K, typename V, typename H>
inline V*
hash_map_safe_get (hash_map<K,V,H> *h, const K& k)
{
return h ? h->get (k) : nullptr;
}
template<bool ggc, typename K, typename V, typename H>
inline V&
hash_map_safe_get_or_insert (hash_map<K,V,H> *&h, const K& k, bool *e = nullptr,
size_t size = default_hash_map_size)
{
return hash_map_maybe_create<ggc> (h, size)->get_or_insert (k, e);
}
template<bool ggc, typename K, typename V, typename H>
inline bool
hash_map_safe_put (hash_map<K,V,H> *&h, const K& k, const V& v,
size_t size = default_hash_map_size)
{
return hash_map_maybe_create<ggc> (h, size)->put (k, v);
}
# 596 "/home/giulianob/gcc_git_gnu/gcc/gcc/hash-table.h" 2
extern mem_alloc_description<mem_usage>& hash_table_usage (void);
extern void dump_hash_table_loc_statistics (void);
template<typename Descriptor, bool Lazy,
template<typename Type> class Allocator>
hash_table<Descriptor, Lazy, Allocator>::hash_table (size_t size, bool ggc,
bool sanitize_eq_and_hash,
bool gather_mem_stats
__attribute__ ((__unused__)),
mem_alloc_origin origin
) :
m_n_elements (0), m_n_deleted (0), m_searches (0), m_collisions (0),
m_ggc (ggc), m_sanitize_eq_and_hash (sanitize_eq_and_hash)
{
unsigned int size_prime_index;
size_prime_index = hash_table_higher_prime_index (size);
size = prime_tab[size_prime_index].prime;
if (m_gather_mem_stats)
hash_table_usage ().register_descriptor (this, origin, ggc
, 0,0,0);
if (Lazy)
m_entries = nullptr;
else
m_entries = alloc_entries (size );
m_size = size;
m_size_prime_index = size_prime_index;
}
template<typename Descriptor, bool Lazy,
template<typename Type> class Allocator>
hash_table<Descriptor, Lazy, Allocator>::hash_table (const hash_table &h,
bool ggc,
bool sanitize_eq_and_hash,
bool gather_mem_stats
__attribute__ ((__unused__)),
mem_alloc_origin origin
) :
m_n_elements (h.m_n_elements), m_n_deleted (h.m_n_deleted),
m_searches (0), m_collisions (0), m_ggc (ggc),
m_sanitize_eq_and_hash (sanitize_eq_and_hash)
{
size_t size = h.m_size;
if (m_gather_mem_stats)
hash_table_usage ().register_descriptor (this, origin, ggc
, 0,0,0);
if (Lazy && h.m_entries == nullptr)
m_entries = nullptr;
else
{
value_type *nentries = alloc_entries (size );
for (size_t i = 0; i < size; ++i)
{
value_type &entry = h.m_entries[i];
if (is_deleted (entry))
mark_deleted (nentries[i]);
else if (!is_empty (entry))
new ((void*) (nentries + i)) value_type (entry);
}
m_entries = nentries;
}
m_size = size;
m_size_prime_index = h.m_size_prime_index;
}
template<typename Descriptor, bool Lazy,
template<typename Type> class Allocator>
hash_table<Descriptor, Lazy, Allocator>::~hash_table ()
{
if (!Lazy || m_entries)
{
for (size_t i = m_size - 1; i < m_size; i--)
if (!is_empty (m_entries[i]) && !is_deleted (m_entries[i]))
Descriptor::remove (m_entries[i]);
if (!m_ggc)
Allocator <value_type> ::data_free (m_entries);
else
ggc_free (m_entries);
if (m_gather_mem_stats)
hash_table_usage ().release_instance_overhead (this,
sizeof (value_type)
* m_size, true);
}
else if (m_gather_mem_stats)
hash_table_usage ().unregister_descriptor (this);
}
template<typename Descriptor, bool Lazy,
template<typename Type> class Allocator>
inline typename hash_table<Descriptor, Lazy, Allocator>::value_type *
hash_table<Descriptor, Lazy,
Allocator>::alloc_entries (size_t n ) const
{
value_type *nentries;
if (m_gather_mem_stats)
hash_table_usage ().register_instance_overhead (sizeof (value_type) * n, this);
if (!m_ggc)
nentries = Allocator <value_type> ::data_alloc (n);
else
nentries = ::ggc_cleared_vec_alloc<value_type> (n );
((void)(!(nentries != nullptr) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/hash-table.h", 715, __FUNCTION__), 0 : 0));
if (!Descriptor::empty_zero_p)
for (size_t i = 0; i < n; i++)
mark_empty (nentries[i]);
return nentries;
}
# 730 "/home/giulianob/gcc_git_gnu/gcc/gcc/hash-table.h"
template<typename Descriptor, bool Lazy,
template<typename Type> class Allocator>
typename hash_table<Descriptor, Lazy, Allocator>::value_type *
hash_table<Descriptor, Lazy,
Allocator>::find_empty_slot_for_expand (hashval_t hash)
{
hashval_t index = hash_table_mod1 (hash, m_size_prime_index);
size_t size = m_size;
value_type *slot = m_entries + index;
hashval_t hash2;
if (is_empty (*slot))
return slot;
((void)(!(!is_deleted (*slot)) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/hash-table.h", 743, __FUNCTION__), 0 : 0));
hash2 = hash_table_mod2 (hash, m_size_prime_index);
for (;;)
{
index += hash2;
if (index >= size)
index -= size;
slot = m_entries + index;
if (is_empty (*slot))
return slot;
((void)(!(!is_deleted (*slot)) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/hash-table.h", 755, __FUNCTION__), 0 : 0));
}
}
template<typename Descriptor, bool Lazy,
template<typename Type> class Allocator>
inline bool
hash_table<Descriptor, Lazy, Allocator>::too_empty_p (unsigned int elts)
{
return elts * 8 < m_size && m_size > 32;
}
# 776 "/home/giulianob/gcc_git_gnu/gcc/gcc/hash-table.h"
template<typename Descriptor, bool Lazy,
template<typename Type> class Allocator>
void
hash_table<Descriptor, Lazy, Allocator>::expand ()
{
value_type *oentries = m_entries;
unsigned int oindex = m_size_prime_index;
size_t osize = size ();
value_type *olimit = oentries + osize;
size_t elts = elements ();
unsigned int nindex;
size_t nsize;
if (elts * 2 > osize || too_empty_p (elts))
{
nindex = hash_table_higher_prime_index (elts * 2);
nsize = prime_tab[nindex].prime;
}
else
{
nindex = oindex;
nsize = osize;
}
value_type *nentries = alloc_entries (nsize);
if (m_gather_mem_stats)
hash_table_usage ().release_instance_overhead (this, sizeof (value_type)
* osize);
m_entries = nentries;
m_size = nsize;
m_size_prime_index = nindex;
m_n_elements -= m_n_deleted;
m_n_deleted = 0;
value_type *p = oentries;
do
{
value_type &x = *p;
if (!is_empty (x) && !is_deleted (x))
{
value_type *q = find_empty_slot_for_expand (Descriptor::hash (x));
new ((void*) q) value_type (x);
}
p++;
}
while (p < olimit);
if (!m_ggc)
Allocator <value_type> ::data_free (oentries);
else
ggc_free (oentries);
}
template<typename Descriptor, bool Lazy,
template<typename Type> class Allocator>
void
hash_table<Descriptor, Lazy, Allocator>::empty_slow ()
{
size_t size = m_size;
size_t nsize = size;
value_type *entries = m_entries;
for (size_t i = size - 1; i < size; i--)
if (!is_empty (entries[i]) && !is_deleted (entries[i]))
Descriptor::remove (entries[i]);
if (size > 1024*1024 / sizeof (value_type))
nsize = 1024 / sizeof (value_type);
else if (too_empty_p (m_n_elements))
nsize = m_n_elements * 2;
if (nsize != size)
{
unsigned int nindex = hash_table_higher_prime_index (nsize);
nsize = prime_tab[nindex].prime;
if (!m_ggc)
Allocator <value_type> ::data_free (m_entries);
else
ggc_free (m_entries);
m_entries = alloc_entries (nsize);
m_size = nsize;
m_size_prime_index = nindex;
}
else if (Descriptor::empty_zero_p)
memset ((void *) entries, 0, size * sizeof (value_type));
else
for (size_t i = 0; i < size; i++)
mark_empty (entries[i]);
m_n_deleted = 0;
m_n_elements = 0;
}
template<typename Descriptor, bool Lazy,
template<typename Type> class Allocator>
void
hash_table<Descriptor, Lazy, Allocator>::clear_slot (value_type *slot)
{
((void)(!(!(slot < m_entries || slot >= m_entries + size () || is_empty (*slot) || is_deleted (*slot))) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/hash-table.h", 890, __FUNCTION__), 0 : 0))
;
Descriptor::remove (*slot);
mark_deleted (*slot);
m_n_deleted++;
}
template<typename Descriptor, bool Lazy,
template<typename Type> class Allocator>
typename hash_table<Descriptor, Lazy, Allocator>::value_type &
hash_table<Descriptor, Lazy, Allocator>
::find_with_hash (const compare_type &comparable, hashval_t hash)
{
m_searches++;
size_t size = m_size;
hashval_t index = hash_table_mod1 (hash, m_size_prime_index);
if (Lazy && m_entries == nullptr)
m_entries = alloc_entries (size);
if (m_sanitize_eq_and_hash)
verify (comparable, hash);
value_type *entry = &m_entries[index];
if (is_empty (*entry)
|| (!is_deleted (*entry) && Descriptor::equal (*entry, comparable)))
return *entry;
hashval_t hash2 = hash_table_mod2 (hash, m_size_prime_index);
for (;;)
{
m_collisions++;
index += hash2;
if (index >= size)
index -= size;
entry = &m_entries[index];
if (is_empty (*entry)
|| (!is_deleted (*entry) && Descriptor::equal (*entry, comparable)))
return *entry;
}
}
# 949 "/home/giulianob/gcc_git_gnu/gcc/gcc/hash-table.h"
template<typename Descriptor, bool Lazy,
template<typename Type> class Allocator>
typename hash_table<Descriptor, Lazy, Allocator>::value_type *
hash_table<Descriptor, Lazy, Allocator>
::find_slot_with_hash (const compare_type &comparable, hashval_t hash,
enum insert_option insert)
{
if (Lazy && m_entries == nullptr)
{
if (insert == INSERT)
m_entries = alloc_entries (m_size);
else
return nullptr;
}
if (insert == INSERT && m_size * 3 <= m_n_elements * 4)
expand ();
if (m_sanitize_eq_and_hash)
verify (comparable, hash);
m_searches++;
value_type *first_deleted_slot = nullptr;
hashval_t index = hash_table_mod1 (hash, m_size_prime_index);
hashval_t hash2 = hash_table_mod2 (hash, m_size_prime_index);
value_type *entry = &m_entries[index];
size_t size = m_size;
if (is_empty (*entry))
goto empty_entry;
else if (is_deleted (*entry))
first_deleted_slot = &m_entries[index];
else if (Descriptor::equal (*entry, comparable))
return &m_entries[index];
for (;;)
{
m_collisions++;
index += hash2;
if (index >= size)
index -= size;
entry = &m_entries[index];
if (is_empty (*entry))
goto empty_entry;
else if (is_deleted (*entry))
{
if (!first_deleted_slot)
first_deleted_slot = &m_entries[index];
}
else if (Descriptor::equal (*entry, comparable))
return &m_entries[index];
}
empty_entry:
if (insert == NO_INSERT)
return nullptr;
if (first_deleted_slot)
{
m_n_deleted--;
mark_empty (*first_deleted_slot);
return first_deleted_slot;
}
m_n_elements++;
return &m_entries[index];
}
template<typename Descriptor, bool Lazy,
template<typename Type> class Allocator>
void
hash_table<Descriptor, Lazy, Allocator>
::verify (const compare_type &comparable, hashval_t hash)
{
for (size_t i = 0; i < ((hash_table_sanitize_eq_limit) < (m_size) ? (hash_table_sanitize_eq_limit) : (m_size)); i++)
{
value_type *entry = &m_entries[i];
if (!is_empty (*entry) && !is_deleted (*entry)
&& hash != Descriptor::hash (*entry)
&& Descriptor::equal (*entry, comparable))
hashtab_chk_error ();
}
}
template<typename Descriptor, bool Lazy,
template<typename Type> class Allocator>
void
hash_table<Descriptor, Lazy, Allocator>
::remove_elt_with_hash (const compare_type &comparable, hashval_t hash)
{
value_type *slot = find_slot_with_hash (comparable, hash, NO_INSERT);
if (slot == nullptr)
return;
Descriptor::remove (*slot);
mark_deleted (*slot);
m_n_deleted++;
}
template<typename Descriptor, bool Lazy,
template<typename Type> class Allocator>
template<typename Argument,
int (*Callback)
(typename hash_table<Descriptor, Lazy, Allocator>::value_type *slot,
Argument argument)>
void
hash_table<Descriptor, Lazy, Allocator>::traverse_noresize (Argument argument)
{
if (Lazy && m_entries == nullptr)
return;
value_type *slot = m_entries;
value_type *limit = slot + size ();
do
{
value_type &x = *slot;
if (!is_empty (x) && !is_deleted (x))
if (! Callback (slot, argument))
break;
}
while (++slot < limit);
}
template <typename Descriptor, bool Lazy,
template <typename Type> class Allocator>
template <typename Argument,
int (*Callback)
(typename hash_table<Descriptor, Lazy, Allocator>::value_type *slot,
Argument argument)>
void
hash_table<Descriptor, Lazy, Allocator>::traverse (Argument argument)
{
if (too_empty_p (elements ()) && (!Lazy || m_entries))
expand ();
traverse_noresize <Argument, Callback> (argument);
}
template<typename Descriptor, bool Lazy,
template<typename Type> class Allocator>
void
hash_table<Descriptor, Lazy, Allocator>::iterator::slide ()
{
for ( ; m_slot < m_limit; ++m_slot )
{
value_type &x = *m_slot;
if (!is_empty (x) && !is_deleted (x))
return;
}
m_slot = nullptr;
m_limit = nullptr;
}
template<typename Descriptor, bool Lazy,
template<typename Type> class Allocator>
inline typename hash_table<Descriptor, Lazy, Allocator>::iterator &
hash_table<Descriptor, Lazy, Allocator>::iterator::operator ++ ()
{
++m_slot;
slide ();
return *this;
}
# 1146 "/home/giulianob/gcc_git_gnu/gcc/gcc/hash-table.h"
template<typename E>
static inline void
gt_ggc_mx (hash_table<E> *h)
{
typedef hash_table<E> table;
if (!((h->m_entries) != nullptr && ((void *) (h->m_entries)) != (void *) 1 && ! ggc_set_mark (h->m_entries)))
return;
for (size_t i = 0; i < h->m_size; i++)
{
if (table::is_empty (h->m_entries[i])
|| table::is_deleted (h->m_entries[i]))
continue;
E::ggc_maybe_mx (h->m_entries[i]);
}
}
template<typename D>
static inline void
hashtab_entry_note_pointers (void *obj, void *h, gt_pointer_operator op,
void *cookie)
{
hash_table<D> *map = static_cast<hash_table<D> *> (h);
((void)(!(map->m_entries == obj) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/hash-table.h", 1173, __FUNCTION__), 0 : 0));
for (size_t i = 0; i < map->m_size; i++)
{
typedef hash_table<D> table;
if (table::is_empty (map->m_entries[i])
|| table::is_deleted (map->m_entries[i]))
continue;
D::pch_nx (map->m_entries[i], op, cookie);
}
}
template<typename D>
static void
gt_pch_nx (hash_table<D> *h)
{
bool success
= gt_pch_note_object (h->m_entries, h, hashtab_entry_note_pointers<D>);
((void)(!(success) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/hash-table.h", 1191, __FUNCTION__), 0 : 0));
for (size_t i = 0; i < h->m_size; i++)
{
if (hash_table<D>::is_empty (h->m_entries[i])
|| hash_table<D>::is_deleted (h->m_entries[i]))
continue;
D::pch_nx (h->m_entries[i]);
}
}
template<typename D>
static inline void
gt_pch_nx (hash_table<D> *h, gt_pointer_operator op, void *cookie)
{
op (&h->m_entries, cookie);
}
template<typename H>
inline void
gt_cleare_cache (hash_table<H> *h)
{
typedef hash_table<H> table;
if (!h)
return;
for (typename table::iterator iter = h->begin (); iter != h->end (); ++iter)
if (!table::is_empty (*iter) && !table::is_deleted (*iter))
{
int res = H::keep_cache_entry (*iter);
if (res == 0)
h->clear_slot (&*iter);
else if (res != -1)
H::ggc_mx (*iter);
}
}
# 477 "/home/giulianob/gcc_git_gnu/gcc/gcc/coretypes.h" 2
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/hash-set.h" 1
# 34 "/home/giulianob/gcc_git_gnu/gcc/gcc/hash-set.h"
template<typename KeyId, bool Lazy = false,
typename Traits = default_hash_traits<KeyId> >
class hash_set
{
public:
typedef typename Traits::value_type Key;
explicit hash_set (size_t n = 13, bool ggc = false )
: m_table (n, ggc, true, 0, HASH_SET_ORIGIN ) {}
static hash_set *
create_ggc (size_t n)
{
hash_set *set = ggc_alloc<hash_set> ();
new (set) hash_set (n, true);
return set;
}
bool add (const Key &k)
{
Key *e = m_table.find_slot_with_hash (k, Traits::hash (k), INSERT);
bool existed = !Traits::is_empty (*e);
if (!existed)
new (e) Key (k);
return existed;
}
bool contains (const Key &k)
{
if (Lazy)
return (m_table.find_slot_with_hash (k, Traits::hash (k), NO_INSERT)
!= nullptr);
Key &e = m_table.find_with_hash (k, Traits::hash (k));
return !Traits::is_empty (e);
}
void remove (const Key &k)
{
m_table.remove_elt_with_hash (k, Traits::hash (k));
}
template<typename Arg, bool (*f)(const typename Traits::value_type &, Arg)>
void traverse (Arg a) const
{
for (typename hash_table<Traits, Lazy>::iterator iter = m_table.begin ();
iter != m_table.end (); ++iter)
f (*iter, a);
}
size_t elements () const { return m_table.elements (); }
void empty () { m_table.empty (); }
bool is_empty () const { return m_table.is_empty (); }
class iterator
{
public:
explicit iterator (const typename hash_table<Traits,
Lazy>::iterator &iter) :
m_iter (iter) {}
iterator &operator++ ()
{
++m_iter;
return *this;
}
Key
operator* ()
{
return *m_iter;
}
bool
operator != (const iterator &other) const
{
return m_iter != other.m_iter;
}
private:
typename hash_table<Traits, Lazy>::iterator m_iter;
};
iterator begin () const { return iterator (m_table.begin ()); }
iterator end () const { return iterator (m_table.end ()); }
private:
template<typename T, typename U>
friend void gt_ggc_mx (hash_set<T, false, U> *);
template<typename T, typename U>
friend void gt_pch_nx (hash_set<T, false, U> *);
template<typename T, typename U>
friend void gt_pch_nx (hash_set<T, false, U> *, gt_pointer_operator, void *);
hash_table<Traits, Lazy> m_table;
};
# 161 "/home/giulianob/gcc_git_gnu/gcc/gcc/hash-set.h"
template<typename T>
void
debug_helper (hash_set<T> &ref)
{
for (typename hash_set<T>::iterator it = ref.begin ();
it != ref.end (); ++it)
{
debug_slim (*it);
fputc ('\n',
# 169 "/home/giulianob/gcc_git_gnu/gcc/gcc/hash-set.h" 3 4
stderr
# 169 "/home/giulianob/gcc_git_gnu/gcc/gcc/hash-set.h"
);
}
}
# 191 "/home/giulianob/gcc_git_gnu/gcc/gcc/hash-set.h"
template<typename K, typename H>
static inline void
gt_ggc_mx (hash_set<K, false, H> *h)
{
gt_ggc_mx (&h->m_table);
}
template<typename K, typename H>
static inline void
gt_pch_nx (hash_set<K, false, H> *h)
{
gt_pch_nx (&h->m_table);
}
template<typename K, typename H>
static inline void
gt_pch_nx (hash_set<K, false, H> *h, gt_pointer_operator op, void *cookie)
{
op (&h->m_table.m_entries, cookie);
}
# 478 "/home/giulianob/gcc_git_gnu/gcc/gcc/coretypes.h" 2
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/input.h" 1
# 24 "/home/giulianob/gcc_git_gnu/gcc/gcc/input.h"
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/../libcpp/include/line-map.h" 1
# 50 "/home/giulianob/gcc_git_gnu/gcc/gcc/../libcpp/include/line-map.h"
typedef unsigned int linenum_type;
typedef long long linenum_arith_t;
inline int compare (linenum_type lhs, linenum_type rhs)
{
linenum_arith_t diff = (linenum_arith_t)lhs - (linenum_arith_t)rhs;
if (diff)
return diff > 0 ? 1 : -1;
return 0;
}
enum lc_reason
{
LC_ENTER = 0,
LC_LEAVE,
LC_RENAME,
LC_RENAME_VERBATIM,
LC_ENTER_MACRO,
LC_HWM
};
# 291 "/home/giulianob/gcc_git_gnu/gcc/gcc/../libcpp/include/line-map.h"
typedef unsigned int location_t;
const unsigned int LINE_MAP_MAX_COLUMN_NUMBER = (1U << 12);
const location_t LINE_MAP_MAX_LOCATION_WITH_PACKED_RANGES = 0x50000000;
const location_t LINE_MAP_MAX_LOCATION_WITH_COLS = 0x60000000;
const location_t LINE_MAP_MAX_LOCATION = 0x70000000;
# 319 "/home/giulianob/gcc_git_gnu/gcc/gcc/../libcpp/include/line-map.h"
struct source_range
{
location_t m_start;
location_t m_finish;
static source_range from_location (location_t loc)
{
source_range result;
result.m_start = loc;
result.m_finish = loc;
return result;
}
static source_range from_locations (location_t start,
location_t finish)
{
source_range result;
result.m_start = start;
result.m_finish = finish;
return result;
}
};
typedef void *(*line_map_realloc) (void *, size_t);
typedef size_t (*line_map_round_alloc_size_func) (size_t);
# 384 "/home/giulianob/gcc_git_gnu/gcc/gcc/../libcpp/include/line-map.h"
struct line_map {
location_t start_location;
};
# 402 "/home/giulianob/gcc_git_gnu/gcc/gcc/../libcpp/include/line-map.h"
struct line_map_ordinary : public line_map {
enum lc_reason reason : 8;
unsigned char sysp;
unsigned int m_column_and_range_bits : 8;
# 433 "/home/giulianob/gcc_git_gnu/gcc/gcc/../libcpp/include/line-map.h"
unsigned int m_range_bits : 8;
const char *to_file;
linenum_type to_line;
location_t included_from;
};
const location_t MAX_LOCATION_T = 0x7FFFFFFF;
struct cpp_hashnode;
struct line_map_macro : public line_map {
unsigned int n_tokens;
struct cpp_hashnode *
macro;
# 527 "/home/giulianob/gcc_git_gnu/gcc/gcc/../libcpp/include/line-map.h"
location_t * macro_locations;
location_t expansion;
};
# 566 "/home/giulianob/gcc_git_gnu/gcc/gcc/../libcpp/include/line-map.h"
inline bool
IS_ORDINARY_LOC (location_t loc)
{
return loc < LINE_MAP_MAX_LOCATION;
}
inline bool
IS_ADHOC_LOC (location_t loc)
{
return loc > MAX_LOCATION_T;
}
inline bool
IS_MACRO_LOC (location_t loc)
{
return !IS_ORDINARY_LOC (loc) && !IS_ADHOC_LOC (loc);
}
inline bool
MAP_ORDINARY_P (const line_map *map)
{
return IS_ORDINARY_LOC (map->start_location);
}
bool
linemap_macro_expansion_map_p (const line_map *);
inline line_map_ordinary *
linemap_check_ordinary (line_map *map)
{
do { if (! (MAP_ORDINARY_P (map))) fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/../libcpp/include/line-map.h", 604, __FUNCTION__); } while (0);
return (line_map_ordinary *)map;
}
inline const line_map_ordinary *
linemap_check_ordinary (const line_map *map)
{
do { if (! (MAP_ORDINARY_P (map))) fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/../libcpp/include/line-map.h", 615, __FUNCTION__); } while (0);
return (const line_map_ordinary *)map;
}
inline line_map_macro *linemap_check_macro (line_map *map)
{
do { if (! (!MAP_ORDINARY_P (map))) fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/../libcpp/include/line-map.h", 624, __FUNCTION__); } while (0);
return (line_map_macro *)map;
}
inline const line_map_macro *
linemap_check_macro (const line_map *map)
{
do { if (! (!MAP_ORDINARY_P (map))) fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/../libcpp/include/line-map.h", 634, __FUNCTION__); } while (0);
return (const line_map_macro *)map;
}
inline location_t
MAP_START_LOCATION (const line_map *map)
{
return map->start_location;
}
inline linenum_type
ORDINARY_MAP_STARTING_LINE_NUMBER (const line_map_ordinary *ord_map)
{
return ord_map->to_line;
}
inline unsigned char
ORDINARY_MAP_IN_SYSTEM_HEADER_P (const line_map_ordinary *ord_map)
{
return ord_map->sysp;
}
inline const char *
ORDINARY_MAP_FILE_NAME (const line_map_ordinary *ord_map)
{
return ord_map->to_file;
}
inline cpp_hashnode *
MACRO_MAP_MACRO (const line_map_macro *macro_map)
{
return macro_map->macro;
}
inline unsigned int
MACRO_MAP_NUM_MACRO_TOKENS (const line_map_macro *macro_map)
{
return macro_map->n_tokens;
}
inline location_t *
MACRO_MAP_LOCATIONS (const line_map_macro *macro_map)
{
return macro_map->macro_locations;
}
inline location_t
MACRO_MAP_EXPANSION_POINT_LOCATION (const line_map_macro *macro_map)
{
return macro_map->expansion;
}
# 714 "/home/giulianob/gcc_git_gnu/gcc/gcc/../libcpp/include/line-map.h"
struct maps_info_ordinary {
line_map_ordinary * maps;
unsigned int allocated;
unsigned int used;
mutable unsigned int cache;
};
struct maps_info_macro {
line_map_macro * maps;
unsigned int allocated;
unsigned int used;
mutable unsigned int cache;
};
struct location_adhoc_data {
location_t locus;
source_range src_range;
void * data;
};
struct htab;
# 765 "/home/giulianob/gcc_git_gnu/gcc/gcc/../libcpp/include/line-map.h"
struct location_adhoc_data_map {
struct htab * htab;
location_t curr_loc;
unsigned int allocated;
struct location_adhoc_data *data;
};
class line_maps {
public:
~line_maps ();
maps_info_ordinary info_ordinary;
maps_info_macro info_macro;
unsigned int depth;
bool trace_includes;
location_t highest_location;
location_t highest_line;
unsigned int max_column_hint;
line_map_realloc reallocator;
line_map_round_alloc_size_func round_alloc_size;
struct location_adhoc_data_map location_adhoc_data_map;
location_t builtin_location;
bool seen_line_directive;
unsigned int default_range_bits;
unsigned int num_optimized_ranges;
unsigned int num_unoptimized_ranges;
};
inline unsigned int
LINEMAPS_ALLOCATED (const line_maps *set, bool map_kind)
{
if (map_kind)
return set->info_macro.allocated;
else
return set->info_ordinary.allocated;
}
inline unsigned int &
LINEMAPS_ALLOCATED (line_maps *set, bool map_kind)
{
if (map_kind)
return set->info_macro.allocated;
else
return set->info_ordinary.allocated;
}
inline unsigned int
LINEMAPS_USED (const line_maps *set, bool map_kind)
{
if (map_kind)
return set->info_macro.used;
else
return set->info_ordinary.used;
}
inline unsigned int &
LINEMAPS_USED (line_maps *set, bool map_kind)
{
if (map_kind)
return set->info_macro.used;
else
return set->info_ordinary.used;
}
inline unsigned int &
LINEMAPS_CACHE (const line_maps *set, bool map_kind)
{
if (map_kind)
return set->info_macro.cache;
else
return set->info_ordinary.cache;
}
inline line_map *
LINEMAPS_MAP_AT (const line_maps *set, bool map_kind, int index)
{
if (map_kind)
return &set->info_macro.maps[index];
else
return &set->info_ordinary.maps[index];
}
inline line_map *
LINEMAPS_LAST_MAP (const line_maps *set, bool map_kind)
{
return LINEMAPS_MAP_AT (set, map_kind,
LINEMAPS_USED (set, map_kind) - 1);
}
inline line_map *
LINEMAPS_LAST_ALLOCATED_MAP (const line_maps *set, bool map_kind)
{
return LINEMAPS_MAP_AT (set, map_kind,
LINEMAPS_ALLOCATED (set, map_kind) - 1);
}
inline line_map_ordinary *
LINEMAPS_ORDINARY_MAPS (const line_maps *set)
{
return set->info_ordinary.maps;
}
inline line_map_ordinary *
LINEMAPS_ORDINARY_MAP_AT (const line_maps *set, int index)
{
do { if (! (index >= 0 && (unsigned int)index < LINEMAPS_USED (set, false))) fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/../libcpp/include/line-map.h", 919, __FUNCTION__); } while (0)
;
return (line_map_ordinary *)LINEMAPS_MAP_AT (set, false, index);
}
inline unsigned int
LINEMAPS_ORDINARY_ALLOCATED (const line_maps *set)
{
return LINEMAPS_ALLOCATED (set, false);
}
inline unsigned int
LINEMAPS_ORDINARY_USED (const line_maps *set)
{
return LINEMAPS_USED (set, false);
}
inline unsigned int &
LINEMAPS_ORDINARY_CACHE (const line_maps *set)
{
return LINEMAPS_CACHE (set, false);
}
inline line_map_ordinary *
LINEMAPS_LAST_ORDINARY_MAP (const line_maps *set)
{
return (line_map_ordinary *)LINEMAPS_LAST_MAP (set, false);
}
inline line_map_ordinary *
LINEMAPS_LAST_ALLOCATED_ORDINARY_MAP (const line_maps *set)
{
return (line_map_ordinary *)LINEMAPS_LAST_ALLOCATED_MAP (set, false);
}
inline line_map_macro *
LINEMAPS_MACRO_MAPS (const line_maps *set)
{
return set->info_macro.maps;
}
inline line_map_macro *
LINEMAPS_MACRO_MAP_AT (const line_maps *set, int index)
{
do { if (! (index >= 0 && (unsigned int)index < LINEMAPS_USED (set, true))) fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/../libcpp/include/line-map.h", 975, __FUNCTION__); } while (0)
;
return (line_map_macro *)LINEMAPS_MAP_AT (set, true, index);
}
inline unsigned int
LINEMAPS_MACRO_ALLOCATED (const line_maps *set)
{
return LINEMAPS_ALLOCATED (set, true);
}
inline unsigned int
LINEMAPS_MACRO_USED (const line_maps *set)
{
return LINEMAPS_USED (set, true);
}
inline unsigned int &
LINEMAPS_MACRO_CACHE (const line_maps *set)
{
return LINEMAPS_CACHE (set, true);
}
inline line_map_macro *
LINEMAPS_LAST_MACRO_MAP (const line_maps *set)
{
return (line_map_macro *)LINEMAPS_LAST_MAP (set, true);
}
inline location_t
LINEMAPS_MACRO_LOWEST_LOCATION (const line_maps *set)
{
return LINEMAPS_MACRO_USED (set)
? MAP_START_LOCATION (LINEMAPS_LAST_MACRO_MAP (set))
: MAX_LOCATION_T + 1;
}
inline line_map_macro *
LINEMAPS_LAST_ALLOCATED_MACRO_MAP (const line_maps *set)
{
return (line_map_macro *)LINEMAPS_LAST_ALLOCATED_MAP (set, true);
}
extern location_t get_combined_adhoc_loc (line_maps *, location_t,
source_range, void *);
extern void *get_data_from_adhoc_loc (const line_maps *, location_t);
extern location_t get_location_from_adhoc_loc (const line_maps *,
location_t);
extern source_range get_range_from_loc (line_maps *set, location_t loc);
bool
pure_location_p (line_maps *set, location_t loc);
extern location_t get_pure_location (line_maps *set, location_t loc);
inline location_t
COMBINE_LOCATION_DATA (class line_maps *set,
location_t loc,
source_range src_range,
void *block)
{
return get_combined_adhoc_loc (set, loc, src_range, block);
}
extern void rebuild_location_adhoc_htab (class line_maps *);
extern void linemap_init (class line_maps *set,
location_t builtin_location);
extern void linemap_check_files_exited (class line_maps *);
extern location_t linemap_line_start
(class line_maps *set, linenum_type to_line, unsigned int max_column_hint);
# 1092 "/home/giulianob/gcc_git_gnu/gcc/gcc/../libcpp/include/line-map.h"
extern const line_map *linemap_add
(class line_maps *, enum lc_reason, unsigned int sysp,
const char *to_file, linenum_type to_line);
extern const line_map *linemap_lookup
(const line_maps *, location_t);
bool linemap_tracks_macro_expansion_locs_p (class line_maps *);
const char* linemap_map_get_macro_name (const line_map_macro *);
# 1121 "/home/giulianob/gcc_git_gnu/gcc/gcc/../libcpp/include/line-map.h"
int linemap_location_in_system_header_p (class line_maps *,
location_t);
bool linemap_location_from_macro_expansion_p (const line_maps *,
location_t);
bool linemap_location_from_macro_definition_p (class line_maps *,
location_t);
extern location_t linemap_macro_map_loc_unwind_toward_spelling
(line_maps *set, const line_map_macro *macro_map, location_t location);
const location_t RESERVED_LOCATION_COUNT = 2;
inline linenum_type
SOURCE_LINE (const line_map_ordinary *ord_map, location_t loc)
{
return ((loc - ord_map->start_location)
>> ord_map->m_column_and_range_bits) + ord_map->to_line;
}
inline linenum_type
SOURCE_COLUMN (const line_map_ordinary *ord_map, location_t loc)
{
return ((loc - ord_map->start_location)
& ((1 << ord_map->m_column_and_range_bits) - 1)) >> ord_map->m_range_bits;
}
inline location_t
linemap_included_from (const line_map_ordinary *ord_map)
{
return ord_map->included_from;
}
const line_map_ordinary *linemap_included_from_linemap
(line_maps *set, const line_map_ordinary *map);
inline bool
MAIN_FILE_P (const line_map_ordinary *ord_map)
{
return ord_map->included_from == 0;
}
extern location_t
linemap_position_for_column (class line_maps *, unsigned int);
location_t
linemap_position_for_line_and_column (line_maps *set,
const line_map_ordinary *,
linenum_type, unsigned int);
location_t
linemap_position_for_loc_and_offset (class line_maps *set,
location_t loc,
unsigned int offset);
inline const char *
LINEMAP_FILE (const line_map_ordinary *ord_map)
{
return ord_map->to_file;
}
inline linenum_type
LINEMAP_LINE (const line_map_ordinary *ord_map)
{
return ord_map->to_line;
}
inline unsigned char
LINEMAP_SYSP (const line_map_ordinary *ord_map)
{
return ord_map->sysp;
}
int linemap_compare_locations (class line_maps *set,
location_t pre,
location_t post);
inline bool
linemap_location_before_p (class line_maps *set,
location_t loc_a,
location_t loc_b)
{
return linemap_compare_locations (set, loc_a, loc_b) >= 0;
}
typedef struct
{
const char *file;
int line;
int column;
void *data;
bool sysp;
} expanded_location;
class range_label;
# 1279 "/home/giulianob/gcc_git_gnu/gcc/gcc/../libcpp/include/line-map.h"
enum range_display_kind
{
SHOW_RANGE_WITH_CARET,
SHOW_RANGE_WITHOUT_CARET,
SHOW_LINES_WITHOUT_RANGE
};
struct location_range
{
location_t m_loc;
enum range_display_kind m_range_display_kind;
const range_label *m_label;
};
# 1320 "/home/giulianob/gcc_git_gnu/gcc/gcc/../libcpp/include/line-map.h"
template <typename T, int NUM_EMBEDDED>
class semi_embedded_vec
{
public:
semi_embedded_vec ();
~semi_embedded_vec ();
unsigned int count () const { return m_num; }
T& operator[] (int idx);
const T& operator[] (int idx) const;
void push (const T&);
void truncate (int len);
private:
int m_num;
T m_embedded[NUM_EMBEDDED];
int m_alloc;
T *m_extra;
};
template <typename T, int NUM_EMBEDDED>
semi_embedded_vec<T, NUM_EMBEDDED>::semi_embedded_vec ()
: m_num (0), m_alloc (0), m_extra (nullptr)
{
}
template <typename T, int NUM_EMBEDDED>
semi_embedded_vec<T, NUM_EMBEDDED>::~semi_embedded_vec ()
{
free ((void*) (m_extra));
}
template <typename T, int NUM_EMBEDDED>
T&
semi_embedded_vec<T, NUM_EMBEDDED>::operator[] (int idx)
{
do { if (! (idx < m_num)) fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/../libcpp/include/line-map.h", 1364, __FUNCTION__); } while (0);
if (idx < NUM_EMBEDDED)
return m_embedded[idx];
else
{
do { if (! (m_extra != nullptr)) fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/../libcpp/include/line-map.h", 1369, __FUNCTION__); } while (0);
return m_extra[idx - NUM_EMBEDDED];
}
}
template <typename T, int NUM_EMBEDDED>
const T&
semi_embedded_vec<T, NUM_EMBEDDED>::operator[] (int idx) const
{
do { if (! (idx < m_num)) fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/../libcpp/include/line-map.h", 1380, __FUNCTION__); } while (0);
if (idx < NUM_EMBEDDED)
return m_embedded[idx];
else
{
do { if (! (m_extra != nullptr)) fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/../libcpp/include/line-map.h", 1385, __FUNCTION__); } while (0);
return m_extra[idx - NUM_EMBEDDED];
}
}
template <typename T, int NUM_EMBEDDED>
void
semi_embedded_vec<T, NUM_EMBEDDED>::push (const T& value)
{
int idx = m_num++;
if (idx < NUM_EMBEDDED)
m_embedded[idx] = value;
else
{
idx -= NUM_EMBEDDED;
if (nullptr == m_extra)
{
do { if (! (m_alloc == 0)) fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/../libcpp/include/line-map.h", 1405, __FUNCTION__); } while (0);
m_alloc = 16;
m_extra = ((T *) xmalloc (sizeof (T) * (m_alloc)));
}
else if (idx >= m_alloc)
{
do { if (! (m_alloc > 0)) fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/../libcpp/include/line-map.h", 1411, __FUNCTION__); } while (0);
m_alloc *= 2;
m_extra = ((T *) xrealloc ((void *) (m_extra), sizeof (T) * (m_alloc)));
}
do { if (! (m_extra)) fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/../libcpp/include/line-map.h", 1415, __FUNCTION__); } while (0);
do { if (! (idx < m_alloc)) fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/../libcpp/include/line-map.h", 1416, __FUNCTION__); } while (0);
m_extra[idx] = value;
}
}
template <typename T, int NUM_EMBEDDED>
void
semi_embedded_vec<T, NUM_EMBEDDED>::truncate (int len)
{
do { if (! (len <= m_num)) fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/../libcpp/include/line-map.h", 1427, __FUNCTION__); } while (0);
m_num = len;
}
class fixit_hint;
class diagnostic_path;
# 1609 "/home/giulianob/gcc_git_gnu/gcc/gcc/../libcpp/include/line-map.h"
class rich_location
{
public:
rich_location (line_maps *set, location_t loc,
const range_label *label = nullptr);
~rich_location ();
location_t get_loc () const { return get_loc (0); }
location_t get_loc (unsigned int idx) const;
void
add_range (location_t loc,
enum range_display_kind range_display_kind
= SHOW_RANGE_WITHOUT_CARET,
const range_label *label = nullptr);
void
set_range (unsigned int idx, location_t loc,
enum range_display_kind range_display_kind);
unsigned int get_num_locations () const { return m_ranges.count (); }
const location_range *get_range (unsigned int idx) const;
location_range *get_range (unsigned int idx);
expanded_location get_expanded_location (unsigned int idx);
void
override_column (int column);
void
add_fixit_insert_before (const char *new_content);
void
add_fixit_insert_before (location_t where,
const char *new_content);
void
add_fixit_insert_after (const char *new_content);
void
add_fixit_insert_after (location_t where,
const char *new_content);
void
add_fixit_remove ();
void
add_fixit_remove (location_t where);
void
add_fixit_remove (source_range src_range);
void
add_fixit_replace (const char *new_content);
void
add_fixit_replace (location_t where,
const char *new_content);
void
add_fixit_replace (source_range src_range,
const char *new_content);
unsigned int get_num_fixit_hints () const { return m_fixit_hints.count (); }
fixit_hint *get_fixit_hint (int idx) const { return m_fixit_hints[idx]; }
fixit_hint *get_last_fixit_hint () const;
bool seen_impossible_fixit_p () const { return m_seen_impossible_fixit; }
# 1718 "/home/giulianob/gcc_git_gnu/gcc/gcc/../libcpp/include/line-map.h"
void fixits_cannot_be_auto_applied ()
{
m_fixits_cannot_be_auto_applied = true;
}
bool fixits_can_be_auto_applied_p () const
{
return !m_fixits_cannot_be_auto_applied;
}
const diagnostic_path *get_path () const { return m_path; }
void set_path (const diagnostic_path *path) { m_path = path; }
private:
bool reject_impossible_fixit (location_t where);
void stop_supporting_fixits ();
void maybe_add_fixit (location_t start,
location_t next_loc,
const char *new_content);
public:
static const int STATICALLY_ALLOCATED_RANGES = 3;
protected:
line_maps *m_line_table;
semi_embedded_vec <location_range, STATICALLY_ALLOCATED_RANGES> m_ranges;
int m_column_override;
bool m_have_expanded_location;
expanded_location m_expanded_location;
static const int MAX_STATIC_FIXIT_HINTS = 2;
semi_embedded_vec <fixit_hint *, MAX_STATIC_FIXIT_HINTS> m_fixit_hints;
bool m_seen_impossible_fixit;
bool m_fixits_cannot_be_auto_applied;
const diagnostic_path *m_path;
};
class label_text
{
public:
label_text ()
: m_buffer (nullptr), m_caller_owned (false)
{}
void maybe_free ()
{
if (m_caller_owned)
free (m_buffer);
}
static label_text borrow (const char *buffer)
{
return label_text (const_cast <char *> (buffer), false);
}
static label_text take (char *buffer)
{
return label_text (buffer, true);
}
char *take_or_copy ()
{
if (m_caller_owned)
return m_buffer;
else
return xstrdup (m_buffer);
}
char *m_buffer;
bool m_caller_owned;
private:
label_text (char *buffer, bool owned)
: m_buffer (buffer), m_caller_owned (owned)
{}
};
# 1823 "/home/giulianob/gcc_git_gnu/gcc/gcc/../libcpp/include/line-map.h"
class range_label
{
public:
virtual ~range_label () {}
virtual label_text get_text (unsigned range_idx) const = 0;
};
# 1848 "/home/giulianob/gcc_git_gnu/gcc/gcc/../libcpp/include/line-map.h"
class fixit_hint
{
public:
fixit_hint (location_t start,
location_t next_loc,
const char *new_content);
~fixit_hint () { free (m_bytes); }
bool affects_line_p (const char *file, int line) const;
location_t get_start_loc () const { return m_start; }
location_t get_next_loc () const { return m_next_loc; }
bool maybe_append (location_t start,
location_t next_loc,
const char *new_content);
const char *get_string () const { return m_bytes; }
size_t get_length () const { return m_len; }
bool insertion_p () const { return m_start == m_next_loc; }
bool ends_with_newline_p () const;
private:
location_t m_start;
location_t m_next_loc;
char *m_bytes;
size_t m_len;
};
enum location_resolution_kind
{
LRK_MACRO_EXPANSION_POINT,
LRK_SPELLING_LOCATION,
LRK_MACRO_DEFINITION_LOCATION
};
# 1940 "/home/giulianob/gcc_git_gnu/gcc/gcc/../libcpp/include/line-map.h"
location_t linemap_resolve_location (class line_maps *,
location_t loc,
enum location_resolution_kind lrk,
const line_map_ordinary **loc_map);
# 1952 "/home/giulianob/gcc_git_gnu/gcc/gcc/../libcpp/include/line-map.h"
location_t linemap_unwind_toward_expansion (class line_maps *,
location_t loc,
const line_map **loc_map);
# 1970 "/home/giulianob/gcc_git_gnu/gcc/gcc/../libcpp/include/line-map.h"
location_t linemap_unwind_to_first_non_reserved_loc (class line_maps *,
location_t loc,
const line_map **map);
expanded_location linemap_expand_location (class line_maps *,
const line_map *,
location_t loc);
struct linemap_stats
{
long num_ordinary_maps_allocated;
long num_ordinary_maps_used;
long ordinary_maps_allocated_size;
long ordinary_maps_used_size;
long num_expanded_macros;
long num_macro_tokens;
long num_macro_maps_used;
long macro_maps_allocated_size;
long macro_maps_used_size;
long macro_maps_locations_size;
long duplicated_macro_maps_locations_size;
long adhoc_table_size;
long adhoc_table_entries_used;
};
bool linemap_get_file_highest_location (class line_maps * set,
const char *file_name,
location_t *loc);
void linemap_get_statistics (line_maps *, struct linemap_stats *);
void linemap_dump_location (line_maps *, location_t, FILE *);
void linemap_dump (FILE *, line_maps *, unsigned, bool);
void line_table_dump (FILE *, line_maps *, unsigned int, unsigned int);
enum location_aspect
{
LOCATION_ASPECT_CARET,
LOCATION_ASPECT_START,
LOCATION_ASPECT_FINISH
};
extern expanded_location
linemap_client_expand_location_to_spelling_point (location_t,
enum location_aspect);
# 25 "/home/giulianob/gcc_git_gnu/gcc/gcc/input.h" 2
extern class line_maps *line_table;
extern class line_maps *saved_line_table;
# 37 "/home/giulianob/gcc_git_gnu/gcc/gcc/input.h"
static_assert ((((location_t) 1) < RESERVED_LOCATION_COUNT), "BUILTINS_LOCATION < RESERVED_LOCATION_COUNT");
extern bool is_location_from_builtin_token (location_t);
extern expanded_location expand_location (location_t);
extern int location_compute_display_column (expanded_location exploc,
int tabstop);
class char_span
{
public:
char_span (const char *ptr, size_t n_elts) : m_ptr (ptr), m_n_elts (n_elts) {}
operator bool() const { return m_ptr; }
size_t length () const { return m_n_elts; }
const char *get_buffer () const { return m_ptr; }
char operator[] (int idx) const
{
((void)(!(idx >= 0) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/input.h", 64, __FUNCTION__), 0 : 0));
((void)(!((size_t)idx < m_n_elts) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/input.h", 65, __FUNCTION__), 0 : 0));
return m_ptr[idx];
}
char_span subspan (int offset, int n_elts) const
{
((void)(!(offset >= 0) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/input.h", 71, __FUNCTION__), 0 : 0));
((void)(!(offset < (int)m_n_elts) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/input.h", 72, __FUNCTION__), 0 : 0));
((void)(!(n_elts >= 0) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/input.h", 73, __FUNCTION__), 0 : 0));
((void)(!(offset + n_elts <= (int)m_n_elts) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/input.h", 74, __FUNCTION__), 0 : 0));
return char_span (m_ptr + offset, n_elts);
}
char *xstrdup () const
{
return ::xstrndup (m_ptr, m_n_elts);
}
private:
const char *m_ptr;
size_t m_n_elts;
};
extern char_span location_get_source_line (const char *file_path, int line);
extern bool location_missing_trailing_newline (const char *file_path);
extern expanded_location
expand_location_to_spelling_point (location_t,
enum location_aspect aspect
= LOCATION_ASPECT_CARET);
extern location_t expansion_point_location_if_in_system_header (location_t);
extern location_t expansion_point_location (location_t);
extern location_t input_location;
# 122 "/home/giulianob/gcc_git_gnu/gcc/gcc/input.h"
static inline int
in_system_header_at (location_t loc)
{
return linemap_location_in_system_header_p (line_table, loc);
}
static inline bool
from_macro_expansion_at (location_t loc)
{
return linemap_location_from_macro_expansion_p (line_table, loc);
}
static inline bool
from_macro_definition_at (location_t loc)
{
return linemap_location_from_macro_definition_p (line_table, loc);
}
static inline location_t
get_pure_location (location_t loc)
{
return get_pure_location (line_table, loc);
}
static inline location_t
get_start (location_t loc)
{
return get_range_from_loc (line_table, loc).m_start;
}
static inline location_t
get_finish (location_t loc)
{
return get_range_from_loc (line_table, loc).m_finish;
}
extern location_t make_location (location_t caret,
location_t start, location_t finish);
extern location_t make_location (location_t caret, source_range src_range);
void dump_line_table_statistics (void);
void dump_location_info (FILE *stream);
void diagnostics_file_cache_fini (void);
void diagnostics_file_cache_forcibly_evict_file (const char *file_path);
class string_concat
{
public:
string_concat (int num, location_t *locs);
int m_num;
location_t * m_locs;
};
struct location_hash : int_hash <location_t, ((location_t) 0)> { };
class string_concat_db
{
public:
string_concat_db ();
void record_string_concatenation (int num, location_t *locs);
bool get_string_concatenation (location_t loc,
int *out_num,
location_t **out_locs);
private:
static location_t get_key_loc (location_t loc);
friend void ::gt_ggc_mx_string_concat_db (void *x_p);
friend void ::gt_pch_nx_string_concat_db (void *x_p);
friend void ::gt_pch_p_16string_concat_db (void *this_obj, void *x_p,
gt_pointer_operator op,
void *cookie);
hash_map <location_hash, string_concat *> *m_table;
};
# 479 "/home/giulianob/gcc_git_gnu/gcc/gcc/coretypes.h" 2
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/is-a.h" 1
# 150 "/home/giulianob/gcc_git_gnu/gcc/gcc/is-a.h"
template <typename T>
struct is_a_helper
{
template <typename U>
static inline bool test (U *p);
template <typename U>
static inline T cast (U *p);
};
# 168 "/home/giulianob/gcc_git_gnu/gcc/gcc/is-a.h"
template <typename T>
template <typename U>
inline T
is_a_helper <T>::cast (U *p)
{
return reinterpret_cast <T> (p);
}
# 183 "/home/giulianob/gcc_git_gnu/gcc/gcc/is-a.h"
template <typename T, typename U>
inline bool
is_a (U *p)
{
return is_a_helper<T>::test (p);
}
template <typename T, typename U>
inline T
as_a (U *p)
{
((void)(!(is_a <T> (p)) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/is-a.h", 197, __FUNCTION__), 0 : 0));
return is_a_helper <T>::cast (p);
}
template <typename T, typename U>
inline T
safe_as_a (U *p)
{
if (p)
{
((void)(!(is_a <T> (p)) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/is-a.h", 210, __FUNCTION__), 0 : 0));
return is_a_helper <T>::cast (p);
}
else
return nullptr;
}
template <typename T, typename U>
inline T
dyn_cast (U *p)
{
if (is_a <T> (p))
return is_a_helper <T>::cast (p);
else
return static_cast <T> (0);
}
template <typename T, typename U>
inline T
safe_dyn_cast (U *p)
{
return p ? dyn_cast <T> (p) : 0;
}
# 480 "/home/giulianob/gcc_git_gnu/gcc/gcc/coretypes.h" 2
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/memory-block.h" 1
# 26 "/home/giulianob/gcc_git_gnu/gcc/gcc/memory-block.h"
class memory_block_pool
{
public:
static const size_t block_size = 64 * 1024;
static const size_t freelist_size = 1024 * 1024 / block_size;
memory_block_pool ();
static inline void *allocate () __attribute__ ((__malloc__));
static inline void release (void *);
static void trim (int nblocks = freelist_size);
void reduce_free_list (int);
private:
static memory_block_pool instance;
struct block_list
{
block_list *m_next;
};
block_list *m_blocks;
};
inline void *
memory_block_pool::allocate ()
{
if (instance.m_blocks == nullptr)
return ((char *) xmalloc (sizeof (char) * (block_size)));
void *result = instance.m_blocks;
instance.m_blocks = instance.m_blocks->m_next;
;
return result;
}
inline void
memory_block_pool::release (void *uncast_block)
{
block_list *block = new (uncast_block) block_list;
block->m_next = instance.m_blocks;
instance.m_blocks = block;
;
}
extern void *mempool_obstack_chunk_alloc (size_t) __attribute__ ((__malloc__));
extern void mempool_obstack_chunk_free (void *);
# 481 "/home/giulianob/gcc_git_gnu/gcc/gcc/coretypes.h" 2
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/dumpfile.h" 1
# 24 "/home/giulianob/gcc_git_gnu/gcc/gcc/dumpfile.h"
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/profile-count.h" 1
# 24 "/home/giulianob/gcc_git_gnu/gcc/gcc/profile-count.h"
struct function;
struct profile_count;
class sreal;
enum profile_quality {
UNINITIALIZED_PROFILE,
GUESSED_LOCAL,
GUESSED_GLOBAL0,
GUESSED_GLOBAL0_ADJUSTED,
GUESSED,
AFDO,
ADJUSTED,
PRECISE
};
extern const char *profile_quality_as_string (enum profile_quality);
extern bool parse_profile_quality (const char *value,
profile_quality *quality);
bool slow_safe_scale_64bit (uint64_t a, uint64_t b, uint64_t c, uint64_t *res);
inline bool
safe_scale_64bit (uint64_t a, uint64_t b, uint64_t c, uint64_t *res)
{
uint64_t tmp;
if (!__builtin_mul_overflow (a, b, &tmp)
&& !__builtin_add_overflow (tmp, c/2, &tmp))
{
*res = tmp / c;
return true;
}
if (c == 1)
{
*res = (uint64_t) -1;
return false;
}
# 106 "/home/giulianob/gcc_git_gnu/gcc/gcc/profile-count.h"
return slow_safe_scale_64bit (a, b, c, res);
}
# 146 "/home/giulianob/gcc_git_gnu/gcc/gcc/profile-count.h"
class profile_probability
{
static const int n_bits = 29;
static const uint32_t max_probability = (uint32_t) 1 << (n_bits - 2);
static const uint32_t uninitialized_probability
= ((uint32_t) 1 << (n_bits - 1)) - 1;
uint32_t m_val : 29;
enum profile_quality m_quality : 3;
friend struct profile_count;
public:
profile_probability (): m_val (uninitialized_probability),
m_quality (GUESSED)
{}
profile_probability (uint32_t val, profile_quality quality):
m_val (val), m_quality (quality)
{}
static profile_probability never ()
{
profile_probability ret;
ret.m_val = 0;
ret.m_quality = PRECISE;
return ret;
}
static profile_probability guessed_never ()
{
profile_probability ret;
ret.m_val = 0;
ret.m_quality = GUESSED;
return ret;
}
static profile_probability very_unlikely ()
{
profile_probability r = guessed_always ().apply_scale (1, 2000);
r.m_val--;
return r;
}
static profile_probability unlikely ()
{
profile_probability r = guessed_always ().apply_scale (1, 5);
r.m_val--;
return r;
}
static profile_probability even ()
{
return guessed_always ().apply_scale (1, 2);
}
static profile_probability very_likely ()
{
return always () - very_unlikely ();
}
static profile_probability likely ()
{
return always () - unlikely ();
}
static profile_probability guessed_always ()
{
profile_probability ret;
ret.m_val = max_probability;
ret.m_quality = GUESSED;
return ret;
}
static profile_probability always ()
{
profile_probability ret;
ret.m_val = max_probability;
ret.m_quality = PRECISE;
return ret;
}
static profile_probability uninitialized ()
{
profile_probability c;
c.m_val = uninitialized_probability;
c.m_quality = GUESSED;
return c;
}
bool initialized_p () const
{
return m_val != uninitialized_probability;
}
bool reliable_p () const
{
return m_quality >= ADJUSTED;
}
static profile_probability from_reg_br_prob_base (int v)
{
profile_probability ret;
((void)(!(v >= 0 && v <= 10000) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/profile-count.h", 259, __FUNCTION__), 0 : 0));
ret.m_val = (((v * (uint64_t) max_probability) + (10000) / 2) / (10000));
ret.m_quality = GUESSED;
return ret;
}
profile_probability adjusted () const
{
profile_probability ret = *this;
if (!initialized_p ())
return *this;
ret.m_quality = ADJUSTED;
return ret;
}
int to_reg_br_prob_base () const
{
((void)(!(initialized_p ()) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/profile-count.h", 277, __FUNCTION__), 0 : 0));
return (((m_val * (uint64_t) 10000) + (max_probability) / 2) / (max_probability));
}
static profile_probability from_reg_br_prob_note (int v)
{
profile_probability ret;
ret.m_val = ((unsigned int)v) / 8;
ret.m_quality = (enum profile_quality)(v & 7);
return ret;
}
int to_reg_br_prob_note () const
{
((void)(!(initialized_p ()) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/profile-count.h", 292, __FUNCTION__), 0 : 0));
int ret = m_val * 8 + m_quality;
((void)(!(from_reg_br_prob_note (ret) == *this) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/profile-count.h", 294, __FUNCTION__), 0 : 0));
return ret;
}
static profile_probability probability_in_gcov_type
(gcov_type val1, gcov_type val2)
{
profile_probability ret;
((void)(!(val1 >= 0 && val2 > 0) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/profile-count.h", 303, __FUNCTION__), 0 : 0));
if (val1 > val2)
ret.m_val = max_probability;
else
{
uint64_t tmp;
safe_scale_64bit (val1, max_probability, val2, &tmp);
((void)(!(tmp <= max_probability) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/profile-count.h", 310, __FUNCTION__), 0 : 0));
ret.m_val = tmp;
}
ret.m_quality = PRECISE;
return ret;
}
bool operator== (const profile_probability &other) const
{
return m_val == other.m_val && m_quality == other.m_quality;
}
profile_probability operator+ (const profile_probability &other) const
{
if (other == never ())
return *this;
if (*this == never ())
return other;
if (!initialized_p () || !other.initialized_p ())
return uninitialized ();
profile_probability ret;
ret.m_val = (((uint32_t)(m_val + other.m_val)) < (max_probability) ? ((uint32_t)(m_val + other.m_val)) : (max_probability));
ret.m_quality = ((m_quality) < (other.m_quality) ? (m_quality) : (other.m_quality));
return ret;
}
profile_probability &operator+= (const profile_probability &other)
{
if (other == never ())
return *this;
if (*this == never ())
{
*this = other;
return *this;
}
if (!initialized_p () || !other.initialized_p ())
return *this = uninitialized ();
else
{
m_val = (((uint32_t)(m_val + other.m_val)) < (max_probability) ? ((uint32_t)(m_val + other.m_val)) : (max_probability));
m_quality = ((m_quality) < (other.m_quality) ? (m_quality) : (other.m_quality));
}
return *this;
}
profile_probability operator- (const profile_probability &other) const
{
if (*this == never ()
|| other == never ())
return *this;
if (!initialized_p () || !other.initialized_p ())
return uninitialized ();
profile_probability ret;
ret.m_val = m_val >= other.m_val ? m_val - other.m_val : 0;
ret.m_quality = ((m_quality) < (other.m_quality) ? (m_quality) : (other.m_quality));
return ret;
}
profile_probability &operator-= (const profile_probability &other)
{
if (*this == never ()
|| other == never ())
return *this;
if (!initialized_p () || !other.initialized_p ())
return *this = uninitialized ();
else
{
m_val = m_val >= other.m_val ? m_val - other.m_val : 0;
m_quality = ((m_quality) < (other.m_quality) ? (m_quality) : (other.m_quality));
}
return *this;
}
profile_probability operator* (const profile_probability &other) const
{
if (*this == never ()
|| other == never ())
return never ();
if (!initialized_p () || !other.initialized_p ())
return uninitialized ();
profile_probability ret;
ret.m_val = ((((uint64_t)m_val * other.m_val) + (max_probability) / 2) / (max_probability));
ret.m_quality = ((((m_quality) < (other.m_quality) ? (m_quality) : (other.m_quality))) < (ADJUSTED) ? (((m_quality) < (other.m_quality) ? (m_quality) : (other.m_quality))) : (ADJUSTED));
return ret;
}
profile_probability &operator*= (const profile_probability &other)
{
if (*this == never ()
|| other == never ())
return *this = never ();
if (!initialized_p () || !other.initialized_p ())
return *this = uninitialized ();
else
{
m_val = ((((uint64_t)m_val * other.m_val) + (max_probability) / 2) / (max_probability));
m_quality = ((((m_quality) < (other.m_quality) ? (m_quality) : (other.m_quality))) < (ADJUSTED) ? (((m_quality) < (other.m_quality) ? (m_quality) : (other.m_quality))) : (ADJUSTED));
}
return *this;
}
profile_probability operator/ (const profile_probability &other) const
{
if (*this == never ())
return never ();
if (!initialized_p () || !other.initialized_p ())
return uninitialized ();
profile_probability ret;
if (m_val >= other.m_val)
{
ret.m_val = max_probability;
ret.m_quality = ((((m_quality) < (other.m_quality) ? (m_quality) : (other.m_quality))) < (GUESSED) ? (((m_quality) < (other.m_quality) ? (m_quality) : (other.m_quality))) : (GUESSED))
;
return ret;
}
else if (!m_val)
ret.m_val = 0;
else
{
((void)(!(other.m_val) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/profile-count.h", 432, __FUNCTION__), 0 : 0));
ret.m_val = ((((((uint64_t)m_val * max_probability) + (other.m_val) / 2) / (other.m_val))) < (max_probability) ? (((((uint64_t)m_val * max_probability) + (other.m_val) / 2) / (other.m_val))) : (max_probability))
;
}
ret.m_quality = ((((m_quality) < (other.m_quality) ? (m_quality) : (other.m_quality))) < (ADJUSTED) ? (((m_quality) < (other.m_quality) ? (m_quality) : (other.m_quality))) : (ADJUSTED));
return ret;
}
profile_probability &operator/= (const profile_probability &other)
{
if (*this == never ())
return *this = never ();
if (!initialized_p () || !other.initialized_p ())
return *this = uninitialized ();
else
{
if (m_val > other.m_val)
{
m_val = max_probability;
m_quality = ((((m_quality) < (other.m_quality) ? (m_quality) : (other.m_quality))) < (GUESSED) ? (((m_quality) < (other.m_quality) ? (m_quality) : (other.m_quality))) : (GUESSED))
;
return *this;
}
else if (!m_val)
;
else
{
((void)(!(other.m_val) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/profile-count.h", 462, __FUNCTION__), 0 : 0));
m_val = ((((((uint64_t)m_val * max_probability) + (other.m_val) / 2) / (other.m_val))) < (max_probability) ? (((((uint64_t)m_val * max_probability) + (other.m_val) / 2) / (other.m_val))) : (max_probability))
;
}
m_quality = ((((m_quality) < (other.m_quality) ? (m_quality) : (other.m_quality))) < (ADJUSTED) ? (((m_quality) < (other.m_quality) ? (m_quality) : (other.m_quality))) : (ADJUSTED));
}
return *this;
}
# 487 "/home/giulianob/gcc_git_gnu/gcc/gcc/profile-count.h"
profile_probability split (const profile_probability &cprob)
{
profile_probability ret = *this * cprob;
if (!(*this == always ()))
*this = (*this - ret) / ret.invert ();
return ret;
}
gcov_type apply (gcov_type val) const
{
if (*this == uninitialized ())
return val / 2;
return (((val * m_val) + (max_probability) / 2) / (max_probability));
}
profile_probability invert () const
{
return always() - *this;
}
profile_probability guessed () const
{
profile_probability ret = *this;
ret.m_quality = GUESSED;
return ret;
}
profile_probability afdo () const
{
profile_probability ret = *this;
ret.m_quality = AFDO;
return ret;
}
profile_probability apply_scale (int64_t num, int64_t den) const
{
if (*this == never ())
return *this;
if (!initialized_p ())
return uninitialized ();
profile_probability ret;
uint64_t tmp;
safe_scale_64bit (m_val, num, den, &tmp);
ret.m_val = ((tmp) < (max_probability) ? (tmp) : (max_probability));
ret.m_quality = ((m_quality) < (ADJUSTED) ? (m_quality) : (ADJUSTED));
return ret;
}
# 560 "/home/giulianob/gcc_git_gnu/gcc/gcc/profile-count.h"
bool probably_reliable_p () const
{
if (m_quality >= ADJUSTED)
return true;
if (!initialized_p ())
return false;
return m_val < max_probability / 100
|| m_val > max_probability - max_probability / 100;
}
bool verify () const
{
((void)(!(m_quality != UNINITIALIZED_PROFILE) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/profile-count.h", 573, __FUNCTION__), 0 : 0));
if (m_val == uninitialized_probability)
return m_quality == GUESSED;
else if (m_quality < GUESSED)
return false;
return m_val <= max_probability;
}
bool operator< (const profile_probability &other) const
{
return initialized_p () && other.initialized_p () && m_val < other.m_val;
}
bool operator> (const profile_probability &other) const
{
return initialized_p () && other.initialized_p () && m_val > other.m_val;
}
bool operator<= (const profile_probability &other) const
{
return initialized_p () && other.initialized_p () && m_val <= other.m_val;
}
bool operator>= (const profile_probability &other) const
{
return initialized_p () && other.initialized_p () && m_val >= other.m_val;
}
uint32_t value () const { return m_val; }
enum profile_quality quality () const { return m_quality; }
void dump (FILE *f) const;
void debug () const;
bool differs_from_p (profile_probability other) const;
bool differs_lot_from_p (profile_probability other) const;
profile_probability combine_with_count (profile_count count1,
profile_probability other,
profile_count count2) const;
sreal to_sreal () const;
static profile_probability stream_in (class lto_input_block *);
void stream_out (struct output_block *);
void stream_out (struct lto_output_stream *);
};
# 690 "/home/giulianob/gcc_git_gnu/gcc/gcc/profile-count.h"
struct profile_count
{
public:
static const int n_bits = 61;
static const uint64_t max_count = ((uint64_t) 1 << n_bits) - 2;
private:
static const uint64_t uninitialized_count = ((uint64_t) 1 << n_bits) - 1;
# 711 "/home/giulianob/gcc_git_gnu/gcc/gcc/profile-count.h"
uint64_t m_val : n_bits;
enum profile_quality m_quality : 3;
public:
bool compatible_p (const profile_count other) const
{
if (!initialized_p () || !other.initialized_p ())
return true;
if (*this == zero ()
|| other == zero ())
return true;
if (ipa ().nonzero_p ()
&& !(other.ipa () == other))
return false;
if (other.ipa ().nonzero_p ()
&& !(ipa () == *this))
return false;
return ipa_p () == other.ipa_p ();
}
static profile_count zero ()
{
return from_gcov_type (0);
}
static profile_count adjusted_zero ()
{
profile_count c;
c.m_val = 0;
c.m_quality = ADJUSTED;
return c;
}
static profile_count guessed_zero ()
{
profile_count c;
c.m_val = 0;
c.m_quality = GUESSED;
return c;
}
static profile_count one ()
{
return from_gcov_type (1);
}
static profile_count uninitialized ()
{
profile_count c;
c.m_val = uninitialized_count;
c.m_quality = GUESSED_LOCAL;
return c;
}
gcov_type to_gcov_type () const
{
((void)(!(initialized_p ()) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/profile-count.h", 778, __FUNCTION__), 0 : 0));
return m_val;
}
bool initialized_p () const
{
return m_val != uninitialized_count;
}
bool reliable_p () const
{
return m_quality >= ADJUSTED;
}
bool ipa_p () const
{
return !initialized_p () || m_quality >= GUESSED_GLOBAL0;
}
bool precise_p () const
{
return m_quality == PRECISE;
}
uint32_t value () const { return m_val; }
enum profile_quality quality () const { return m_quality; }
bool ok_for_merging (profile_count other) const
{
if (m_quality < ADJUSTED
|| other.m_quality < ADJUSTED)
return true;
return !(other < *this);
}
profile_count merge (profile_count other) const
{
if (*this == other || !other.initialized_p ()
|| m_quality > other.m_quality)
return *this;
if (other.m_quality > m_quality
|| other > *this)
return other;
return *this;
}
bool operator== (const profile_count &other) const
{
return m_val == other.m_val && m_quality == other.m_quality;
}
profile_count operator+ (const profile_count &other) const
{
if (other == zero ())
return *this;
if (*this == zero ())
return other;
if (!initialized_p () || !other.initialized_p ())
return uninitialized ();
profile_count ret;
((void)(!(compatible_p (other)) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/profile-count.h", 853, __FUNCTION__), 0 : 0));
ret.m_val = m_val + other.m_val;
ret.m_quality = ((m_quality) < (other.m_quality) ? (m_quality) : (other.m_quality));
return ret;
}
profile_count &operator+= (const profile_count &other)
{
if (other == zero ())
return *this;
if (*this == zero ())
{
*this = other;
return *this;
}
if (!initialized_p () || !other.initialized_p ())
return *this = uninitialized ();
else
{
((void)(!(compatible_p (other)) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/profile-count.h", 872, __FUNCTION__), 0 : 0));
m_val += other.m_val;
m_quality = ((m_quality) < (other.m_quality) ? (m_quality) : (other.m_quality));
}
return *this;
}
profile_count operator- (const profile_count &other) const
{
if (*this == zero () || other == zero ())
return *this;
if (!initialized_p () || !other.initialized_p ())
return uninitialized ();
((void)(!(compatible_p (other)) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/profile-count.h", 885, __FUNCTION__), 0 : 0));
profile_count ret;
ret.m_val = m_val >= other.m_val ? m_val - other.m_val : 0;
ret.m_quality = ((m_quality) < (other.m_quality) ? (m_quality) : (other.m_quality));
return ret;
}
profile_count &operator-= (const profile_count &other)
{
if (*this == zero () || other == zero ())
return *this;
if (!initialized_p () || !other.initialized_p ())
return *this = uninitialized ();
else
{
((void)(!(compatible_p (other)) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/profile-count.h", 900, __FUNCTION__), 0 : 0));
m_val = m_val >= other.m_val ? m_val - other.m_val: 0;
m_quality = ((m_quality) < (other.m_quality) ? (m_quality) : (other.m_quality));
}
return *this;
}
bool verify () const
{
((void)(!(m_quality != UNINITIALIZED_PROFILE) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/profile-count.h", 910, __FUNCTION__), 0 : 0));
return m_val != uninitialized_count || m_quality == GUESSED_LOCAL;
}
bool operator< (const profile_count &other) const
{
if (!initialized_p () || !other.initialized_p ())
return false;
if (*this == zero ())
return !(other == zero ());
if (other == zero ())
return false;
((void)(!(compatible_p (other)) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/profile-count.h", 924, __FUNCTION__), 0 : 0));
return m_val < other.m_val;
}
bool operator> (const profile_count &other) const
{
if (!initialized_p () || !other.initialized_p ())
return false;
if (*this == zero ())
return false;
if (other == zero ())
return !(*this == zero ());
((void)(!(compatible_p (other)) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/profile-count.h", 936, __FUNCTION__), 0 : 0));
return initialized_p () && other.initialized_p () && m_val > other.m_val;
}
bool operator< (const gcov_type other) const
{
((void)(!(ipa_p ()) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/profile-count.h", 942, __FUNCTION__), 0 : 0));
((void)(!(other >= 0) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/profile-count.h", 943, __FUNCTION__), 0 : 0));
return ipa ().initialized_p () && ipa ().m_val < (uint64_t) other;
}
bool operator> (const gcov_type other) const
{
((void)(!(ipa_p ()) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/profile-count.h", 949, __FUNCTION__), 0 : 0));
((void)(!(other >= 0) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/profile-count.h", 950, __FUNCTION__), 0 : 0));
return ipa ().initialized_p () && ipa ().m_val > (uint64_t) other;
}
bool operator<= (const profile_count &other) const
{
if (!initialized_p () || !other.initialized_p ())
return false;
if (*this == zero ())
return true;
if (other == zero ())
return (*this == zero ());
((void)(!(compatible_p (other)) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/profile-count.h", 962, __FUNCTION__), 0 : 0));
return m_val <= other.m_val;
}
bool operator>= (const profile_count &other) const
{
if (!initialized_p () || !other.initialized_p ())
return false;
if (other == zero ())
return true;
if (*this == zero ())
return (other == zero ());
((void)(!(compatible_p (other)) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/profile-count.h", 974, __FUNCTION__), 0 : 0));
return m_val >= other.m_val;
}
bool operator<= (const gcov_type other) const
{
((void)(!(ipa_p ()) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/profile-count.h", 980, __FUNCTION__), 0 : 0));
((void)(!(other >= 0) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/profile-count.h", 981, __FUNCTION__), 0 : 0));
return ipa ().initialized_p () && ipa ().m_val <= (uint64_t) other;
}
bool operator>= (const gcov_type other) const
{
((void)(!(ipa_p ()) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/profile-count.h", 987, __FUNCTION__), 0 : 0));
((void)(!(other >= 0) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/profile-count.h", 988, __FUNCTION__), 0 : 0));
return ipa ().initialized_p () && ipa ().m_val >= (uint64_t) other;
}
bool nonzero_p () const
{
return initialized_p () && m_val != 0;
}
profile_count force_nonzero () const
{
if (!initialized_p ())
return *this;
profile_count ret = *this;
if (ret.m_val == 0)
{
ret.m_val = 1;
ret.m_quality = ((m_quality) < (ADJUSTED) ? (m_quality) : (ADJUSTED));
}
return ret;
}
profile_count max (profile_count other) const
{
profile_count val = *this;
if (ipa ().nonzero_p () || other.ipa ().nonzero_p ())
{
val = ipa ();
other = other.ipa ();
}
if (!initialized_p ())
return other;
if (!other.initialized_p ())
return *this;
if (*this == zero ())
return other;
if (other == zero ())
return *this;
((void)(!(compatible_p (other)) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/profile-count.h", 1032, __FUNCTION__), 0 : 0));
if (val.m_val < other.m_val || (m_val == other.m_val
&& val.m_quality < other.m_quality))
return other;
return *this;
}
profile_count apply_probability (int prob) const
{
((void)(!(prob >= 0 && prob <= 10000) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/profile-count.h", 1043, __FUNCTION__), 0 : 0));
if (m_val == 0)
return *this;
if (!initialized_p ())
return uninitialized ();
profile_count ret;
ret.m_val = (((m_val * prob) + (10000) / 2) / (10000));
ret.m_quality = ((m_quality) < (ADJUSTED) ? (m_quality) : (ADJUSTED));
return ret;
}
profile_count apply_probability (profile_probability prob) const
{
if (*this == zero ())
return *this;
if (prob == profile_probability::never ())
return zero ();
if (!initialized_p ())
return uninitialized ();
profile_count ret;
uint64_t tmp;
safe_scale_64bit (m_val, prob.m_val, profile_probability::max_probability,
&tmp);
ret.m_val = tmp;
ret.m_quality = ((m_quality) < (prob.m_quality) ? (m_quality) : (prob.m_quality));
return ret;
}
profile_count apply_scale (int64_t num, int64_t den) const
{
if (m_val == 0)
return *this;
if (!initialized_p ())
return uninitialized ();
profile_count ret;
uint64_t tmp;
((void)(!(num >= 0 && den > 0) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/profile-count.h", 1082, __FUNCTION__), 0 : 0));
safe_scale_64bit (m_val, num, den, &tmp);
ret.m_val = ((tmp) < (max_count) ? (tmp) : (max_count));
ret.m_quality = ((m_quality) < (ADJUSTED) ? (m_quality) : (ADJUSTED));
return ret;
}
profile_count apply_scale (profile_count num, profile_count den) const
{
if (*this == zero ())
return *this;
if (num == zero ())
return num;
if (!initialized_p () || !num.initialized_p () || !den.initialized_p ())
return uninitialized ();
if (num == den)
return *this;
((void)(!(den.m_val) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/profile-count.h", 1099, __FUNCTION__), 0 : 0));
profile_count ret;
uint64_t val;
safe_scale_64bit (m_val, num.m_val, den.m_val, &val);
ret.m_val = ((val) < (max_count) ? (val) : (max_count));
ret.m_quality = ((((((m_quality) < (ADJUSTED) ? (m_quality) : (ADJUSTED))) < (num.m_quality) ? (((m_quality) < (ADJUSTED) ? (m_quality) : (ADJUSTED))) : (num.m_quality))) < (den.m_quality) ? (((((m_quality) < (ADJUSTED) ? (m_quality) : (ADJUSTED))) < (num.m_quality) ? (((m_quality) < (ADJUSTED) ? (m_quality) : (ADJUSTED))) : (num.m_quality))) : (den.m_quality))
;
if (num.ipa_p ())
ret.m_quality = ((ret.m_quality) > (num == num.ipa () ? GUESSED : num.m_quality) ? (ret.m_quality) : (num == num.ipa () ? GUESSED : num.m_quality))
;
return ret;
}
profile_count guessed_local () const
{
profile_count ret = *this;
if (!initialized_p ())
return *this;
ret.m_quality = GUESSED_LOCAL;
return ret;
}
profile_count global0 () const
{
profile_count ret = *this;
if (!initialized_p ())
return *this;
ret.m_quality = GUESSED_GLOBAL0;
return ret;
}
profile_count global0adjusted () const
{
profile_count ret = *this;
if (!initialized_p ())
return *this;
ret.m_quality = GUESSED_GLOBAL0_ADJUSTED;
return ret;
}
profile_count guessed () const
{
profile_count ret = *this;
ret.m_quality = ((ret.m_quality) < (GUESSED) ? (ret.m_quality) : (GUESSED));
return ret;
}
profile_count ipa () const
{
if (m_quality > GUESSED_GLOBAL0_ADJUSTED)
return *this;
if (m_quality == GUESSED_GLOBAL0)
return zero ();
if (m_quality == GUESSED_GLOBAL0_ADJUSTED)
return adjusted_zero ();
return uninitialized ();
}
profile_count afdo () const
{
profile_count ret = *this;
ret.m_quality = AFDO;
return ret;
}
profile_probability probability_in (const profile_count overall) const
{
if (*this == zero ()
&& !(overall == zero ()))
return profile_probability::never ();
if (!initialized_p () || !overall.initialized_p ()
|| !overall.m_val)
return profile_probability::uninitialized ();
if (*this == overall && m_quality == PRECISE)
return profile_probability::always ();
profile_probability ret;
((void)(!(compatible_p (overall)) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/profile-count.h", 1188, __FUNCTION__), 0 : 0));
if (overall.m_val < m_val)
{
ret.m_val = profile_probability::max_probability;
ret.m_quality = GUESSED;
return ret;
}
else
ret.m_val = (((m_val * profile_probability::max_probability) + (overall.m_val) / 2) / (overall.m_val))
;
ret.m_quality = ((((((m_quality) < (overall.m_quality) ? (m_quality) : (overall.m_quality))) > (GUESSED) ? (((m_quality) < (overall.m_quality) ? (m_quality) : (overall.m_quality))) : (GUESSED))) < (ADJUSTED) ? (((((m_quality) < (overall.m_quality) ? (m_quality) : (overall.m_quality))) > (GUESSED) ? (((m_quality) < (overall.m_quality) ? (m_quality) : (overall.m_quality))) : (GUESSED))) : (ADJUSTED))
;
return ret;
}
int to_frequency (struct function *fun) const;
int to_cgraph_frequency (profile_count entry_bb_count) const;
sreal to_sreal_scale (profile_count in, bool *known = nullptr) const;
void dump (FILE *f) const;
void debug () const;
bool differs_from_p (profile_count other) const;
static void adjust_for_ipa_scaling (profile_count *num, profile_count *den);
profile_count combine_with_ipa_count (profile_count ipa);
profile_count combine_with_ipa_count_within
(profile_count ipa, profile_count ipa2);
static profile_count from_gcov_type (gcov_type v,
profile_quality quality = PRECISE);
static profile_count stream_in (class lto_input_block *);
void stream_out (struct output_block *);
void stream_out (struct lto_output_stream *);
};
# 25 "/home/giulianob/gcc_git_gnu/gcc/gcc/dumpfile.h" 2
# 41 "/home/giulianob/gcc_git_gnu/gcc/gcc/dumpfile.h"
enum tree_dump_index
{
TDI_none,
TDI_cgraph,
TDI_inheritance,
TDI_clones,
TDI_original,
TDI_gimple,
TDI_nested,
TDI_lto_stream_out,
TDI_profile_report,
TDI_lang_all,
TDI_tree_all,
TDI_rtl_all,
TDI_ipa_all,
TDI_end
};
enum dump_kind
{
DK_none,
DK_lang,
DK_tree,
DK_rtl,
DK_ipa
};
enum dump_flag
{
TDF_NONE = 0,
TDF_ADDRESS = (1 << 0),
TDF_SLIM = (1 << 1),
TDF_RAW = (1 << 2),
TDF_DETAILS = (1 << 3),
TDF_STATS = (1 << 4),
TDF_BLOCKS = (1 << 5),
TDF_VOPS = (1 << 6),
TDF_LINENO = (1 << 7),
TDF_UID = (1 << 8),
TDF_STMTADDR = (1 << 9),
TDF_GRAPH = (1 << 10),
TDF_MEMSYMS = (1 << 11),
TDF_RHS_ONLY = (1 << 12),
TDF_ASMNAME = (1 << 13),
TDF_EH = (1 << 14),
TDF_NOUID = (1 << 15),
TDF_ALIAS = (1 << 16),
TDF_ENUMERATE_LOCALS = (1 << 17),
TDF_CSELIB = (1 << 18),
TDF_SCEV = (1 << 19),
TDF_GIMPLE = (1 << 20),
TDF_FOLDING = (1 << 21),
MSG_OPTIMIZED_LOCATIONS = (1 << 22),
MSG_MISSED_OPTIMIZATION = (1 << 23),
MSG_NOTE = (1 << 24),
MSG_ALL_KINDS = (MSG_OPTIMIZED_LOCATIONS
| MSG_MISSED_OPTIMIZATION
| MSG_NOTE),
# 178 "/home/giulianob/gcc_git_gnu/gcc/gcc/dumpfile.h"
MSG_PRIORITY_USER_FACING = (1 << 25),
MSG_PRIORITY_INTERNALS = (1 << 26),
MSG_PRIORITY_REEMITTED = (1 << 27),
MSG_ALL_PRIORITIES = (MSG_PRIORITY_USER_FACING
| MSG_PRIORITY_INTERNALS
| MSG_PRIORITY_REEMITTED),
TDF_COMPARE_DEBUG = (1 << 28),
TDF_ERROR = (1 << 26),
TDF_ALL_VALUES = (1 << 29) - 1
};
typedef enum dump_flag dump_flags_t;
static inline dump_flags_t
operator| (dump_flags_t lhs, dump_flags_t rhs)
{
return (dump_flags_t)((int)lhs | (int)rhs);
}
static inline dump_flags_t
operator& (dump_flags_t lhs, dump_flags_t rhs)
{
return (dump_flags_t)((int)lhs & (int)rhs);
}
static inline dump_flags_t
operator~ (dump_flags_t flags)
{
return (dump_flags_t)~((int)flags);
}
static inline dump_flags_t &
operator|= (dump_flags_t &lhs, dump_flags_t rhs)
{
lhs = (dump_flags_t)((int)lhs | (int)rhs);
return lhs;
}
static inline dump_flags_t &
operator&= (dump_flags_t &lhs, dump_flags_t rhs)
{
lhs = (dump_flags_t)((int)lhs & (int)rhs);
return lhs;
}
enum optgroup_flag
{
OPTGROUP_NONE = 0,
OPTGROUP_IPA = (1 << 1),
OPTGROUP_LOOP = (1 << 2),
OPTGROUP_INLINE = (1 << 3),
OPTGROUP_OMP = (1 << 4),
OPTGROUP_VEC = (1 << 5),
OPTGROUP_OTHER = (1 << 6),
OPTGROUP_ALL = (OPTGROUP_IPA | OPTGROUP_LOOP | OPTGROUP_INLINE
| OPTGROUP_OMP | OPTGROUP_VEC | OPTGROUP_OTHER)
};
typedef enum optgroup_flag optgroup_flags_t;
static inline optgroup_flags_t
operator| (optgroup_flags_t lhs, optgroup_flags_t rhs)
{
return (optgroup_flags_t)((int)lhs | (int)rhs);
}
static inline optgroup_flags_t &
operator|= (optgroup_flags_t &lhs, optgroup_flags_t rhs)
{
lhs = (optgroup_flags_t)((int)lhs | (int)rhs);
return lhs;
}
struct dump_file_info
{
const char *suffix;
const char *swtch;
const char *glob;
const char *pfilename;
const char *alt_filename;
FILE *pstream;
FILE *alt_stream;
dump_kind dkind;
dump_flags_t pflags;
dump_flags_t alt_flags;
optgroup_flags_t optgroup_flags;
int pstate;
int alt_state;
int num;
bool owns_strings;
bool graph_dump_initialized;
};
class dump_user_location_t
{
public:
dump_user_location_t () : m_count (), m_loc (((location_t) 0)) {}
dump_user_location_t (const gimple *stmt);
dump_user_location_t (const rtx_insn *insn);
static dump_user_location_t
from_location_t (location_t loc)
{
return dump_user_location_t (profile_count (), loc);
}
static dump_user_location_t
from_function_decl (tree fndecl);
profile_count get_count () const { return m_count; }
location_t get_location_t () const { return m_loc; }
private:
dump_user_location_t (profile_count count, location_t loc)
: m_count (count), m_loc (loc)
{}
profile_count m_count;
location_t m_loc;
};
class dump_impl_location_t
{
public:
dump_impl_location_t (
const char *file = __builtin_FILE (),
int line = __builtin_LINE (),
const char *function = __builtin_FUNCTION ()
)
: m_file (file), m_line (line), m_function (function)
{}
const char *m_file;
int m_line;
const char *m_function;
};
# 404 "/home/giulianob/gcc_git_gnu/gcc/gcc/dumpfile.h"
class dump_metadata_t
{
public:
dump_metadata_t (dump_flags_t dump_flags,
const dump_impl_location_t &impl_location
= dump_impl_location_t ())
: m_dump_flags (dump_flags),
m_impl_location (impl_location)
{
}
dump_flags_t get_dump_flags () const { return m_dump_flags; }
const dump_impl_location_t &
get_impl_location () const { return m_impl_location; }
private:
dump_flags_t m_dump_flags;
dump_impl_location_t m_impl_location;
};
# 436 "/home/giulianob/gcc_git_gnu/gcc/gcc/dumpfile.h"
class dump_location_t
{
public:
dump_location_t (const dump_impl_location_t &impl_location
= dump_impl_location_t ())
: m_user_location (dump_user_location_t ()),
m_impl_location (impl_location)
{
}
dump_location_t (const gimple *stmt,
const dump_impl_location_t &impl_location
= dump_impl_location_t ())
: m_user_location (dump_user_location_t (stmt)),
m_impl_location (impl_location)
{
}
dump_location_t (const rtx_insn *insn,
const dump_impl_location_t &impl_location
= dump_impl_location_t ())
: m_user_location (dump_user_location_t (insn)),
m_impl_location (impl_location)
{
}
dump_location_t (const dump_user_location_t &user_location,
const dump_impl_location_t &impl_location
= dump_impl_location_t ())
: m_user_location (user_location),
m_impl_location (impl_location)
{
}
static dump_location_t
from_location_t (location_t loc,
const dump_impl_location_t &impl_location
= dump_impl_location_t ())
{
return dump_location_t (dump_user_location_t::from_location_t (loc),
impl_location);
}
const dump_user_location_t &
get_user_location () const { return m_user_location; }
const dump_impl_location_t &
get_impl_location () const { return m_impl_location; }
location_t get_location_t () const
{
return m_user_location.get_location_t ();
}
profile_count get_count () const { return m_user_location.get_count (); }
private:
dump_user_location_t m_user_location;
dump_impl_location_t m_impl_location;
};
extern FILE *dump_begin (int, dump_flags_t *, int part=-1);
extern void dump_end (int, FILE *);
extern int opt_info_switch_p (const char *);
extern const char *dump_flag_name (int);
extern const kv_pair<optgroup_flags_t> optgroup_options[];
extern dump_flags_t
parse_dump_option (const char *, const char **);
extern FILE *dump_file;
extern dump_flags_t dump_flags;
extern const char *dump_file_name;
extern bool dumps_are_enabled;
extern void set_dump_file (FILE *new_dump_file);
static inline bool
dump_enabled_p (void)
{
return dumps_are_enabled;
}
# 563 "/home/giulianob/gcc_git_gnu/gcc/gcc/dumpfile.h"
extern void dump_printf (const dump_metadata_t &, const char *, ...)
__attribute__ ((__format__ (__gcc_dump_printf__, 2 ,3))) __attribute__ ((__nonnull__ (2)));
extern void dump_printf_loc (const dump_metadata_t &, const dump_user_location_t &,
const char *, ...)
__attribute__ ((__format__ (__gcc_dump_printf__, 3 ,0))) __attribute__ ((__nonnull__ (3)));
extern void dump_function (int phase, tree fn);
extern void dump_basic_block (dump_flags_t, basic_block, int);
extern void dump_generic_expr_loc (const dump_metadata_t &,
const dump_user_location_t &,
dump_flags_t, tree);
extern void dump_generic_expr (const dump_metadata_t &, dump_flags_t, tree);
extern void dump_gimple_stmt_loc (const dump_metadata_t &,
const dump_user_location_t &,
dump_flags_t, gimple *, int);
extern void dump_gimple_stmt (const dump_metadata_t &, dump_flags_t, gimple *, int);
extern void dump_gimple_expr_loc (const dump_metadata_t &,
const dump_user_location_t &,
dump_flags_t, gimple *, int);
extern void dump_gimple_expr (const dump_metadata_t &, dump_flags_t, gimple *, int);
extern void dump_symtab_node (const dump_metadata_t &, symtab_node *);
template<unsigned int N, typename C>
void dump_dec (const dump_metadata_t &, const poly_int<N, C> &);
extern void dump_dec (dump_flags_t, const poly_wide_int &, signop);
extern void dump_hex (dump_flags_t, const poly_wide_int &);
extern void dumpfile_ensure_any_optinfo_are_flushed ();
extern unsigned int get_dump_scope_depth ();
extern void dump_begin_scope (const char *name,
const dump_user_location_t &user_location,
const dump_impl_location_t &impl_location);
extern void dump_end_scope ();
class auto_dump_scope
{
public:
auto_dump_scope (const char *name,
const dump_user_location_t &user_location,
const dump_impl_location_t &impl_location
= dump_impl_location_t ())
{
if (dump_enabled_p ())
dump_begin_scope (name, user_location, impl_location);
}
~auto_dump_scope ()
{
if (dump_enabled_p ())
dump_end_scope ();
}
};
# 640 "/home/giulianob/gcc_git_gnu/gcc/gcc/dumpfile.h"
extern void dump_function (int phase, tree fn);
extern void print_combine_total_stats (void);
extern bool enable_rtl_dump_file (void);
extern void dump_node (const_tree, dump_flags_t, FILE *);
extern void dump_combine_total_stats (FILE *);
extern void dump_bb (FILE *, basic_block, int, dump_flags_t);
class opt_pass;
namespace gcc {
class dump_manager
{
public:
dump_manager ();
~dump_manager ();
unsigned int
dump_register (const char *suffix, const char *swtch, const char *glob,
dump_kind dkind, optgroup_flags_t optgroup_flags,
bool take_ownership);
void
register_dumps ();
struct dump_file_info *
get_dump_file_info (int phase) const;
struct dump_file_info *
get_dump_file_info_by_switch (const char *swtch) const;
char *
get_dump_file_name (int phase, int part = -1) const;
char *
get_dump_file_name (struct dump_file_info *dfi, int part = -1) const;
void
dump_switch_p (const char *arg);
int
dump_start (int phase, dump_flags_t *flag_ptr);
void
dump_finish (int phase);
FILE *
dump_begin (int phase, dump_flags_t *flag_ptr, int part);
int
dump_initialized_p (int phase) const;
const char *
dump_flag_name (int phase) const;
void register_pass (opt_pass *pass);
private:
int
dump_phase_enabled_p (int phase) const;
int
dump_switch_p_1 (const char *arg, struct dump_file_info *dfi, bool doglob);
int
dump_enable_all (dump_kind dkind, dump_flags_t flags, const char *filename);
int
opt_info_enable_passes (optgroup_flags_t optgroup_flags, dump_flags_t flags,
const char *filename);
bool update_dfi_for_opt_info (dump_file_info *dfi) const;
private:
int m_next_dump;
struct dump_file_info *m_extra_dump_files;
size_t m_extra_dump_files_in_use;
size_t m_extra_dump_files_alloced;
optgroup_flags_t m_optgroup_flags;
dump_flags_t m_optinfo_flags;
char *m_optinfo_filename;
friend bool ::enable_rtl_dump_file (void);
friend int ::opt_info_switch_p (const char *arg);
};
}
# 482 "/home/giulianob/gcc_git_gnu/gcc/gcc/coretypes.h" 2
# 29 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 2
# 1 "./options.h" 1
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/flag-types.h" 1
# 23 "/home/giulianob/gcc_git_gnu/gcc/gcc/flag-types.h"
enum debug_info_type
{
NO_DEBUG,
DBX_DEBUG,
DWARF2_DEBUG,
XCOFF_DEBUG,
VMS_DEBUG,
VMS_AND_DWARF2_DEBUG
};
enum debug_info_levels
{
DINFO_LEVEL_NONE,
DINFO_LEVEL_TERSE,
DINFO_LEVEL_NORMAL,
DINFO_LEVEL_VERBOSE
};
# 50 "/home/giulianob/gcc_git_gnu/gcc/gcc/flag-types.h"
enum debug_info_usage
{
DINFO_USAGE_DFN,
DINFO_USAGE_DIR_USE,
DINFO_USAGE_IND_USE,
DINFO_USAGE_NUM_ENUMS
};
# 83 "/home/giulianob/gcc_git_gnu/gcc/gcc/flag-types.h"
enum debug_struct_file
{
DINFO_STRUCT_FILE_NONE,
DINFO_STRUCT_FILE_BASE,
DINFO_STRUCT_FILE_SYS,
DINFO_STRUCT_FILE_ANY
};
enum dwarf_gnat_encodings
{
DWARF_GNAT_ENCODINGS_ALL = 0,
DWARF_GNAT_ENCODINGS_GDB = 1,
DWARF_GNAT_ENCODINGS_MINIMAL = 2
};
enum ivar_visibility
{
IVAR_VISIBILITY_PRIVATE,
IVAR_VISIBILITY_PROTECTED,
IVAR_VISIBILITY_PUBLIC,
IVAR_VISIBILITY_PACKAGE
};
enum stack_reuse_level
{
SR_NONE,
SR_NAMED_VARS,
SR_ALL
};
enum live_patching_level
{
LIVE_PATCHING_NONE = 0,
LIVE_PATCHING_INLINE_ONLY_STATIC,
LIVE_PATCHING_INLINE_CLONE
};
enum reorder_blocks_algorithm
{
REORDER_BLOCKS_ALGORITHM_SIMPLE,
REORDER_BLOCKS_ALGORITHM_STC
};
enum ira_algorithm
{
IRA_ALGORITHM_CB,
IRA_ALGORITHM_PRIORITY
};
enum ira_region
{
IRA_REGION_ONE,
IRA_REGION_ALL,
IRA_REGION_MIXED,
IRA_REGION_AUTODETECT
};
enum excess_precision
{
EXCESS_PRECISION_DEFAULT,
EXCESS_PRECISION_FAST,
EXCESS_PRECISION_STANDARD
};
enum permitted_flt_eval_methods
{
PERMITTED_FLT_EVAL_METHODS_DEFAULT,
PERMITTED_FLT_EVAL_METHODS_TS_18661,
PERMITTED_FLT_EVAL_METHODS_C11
};
# 184 "/home/giulianob/gcc_git_gnu/gcc/gcc/flag-types.h"
enum stack_check_type
{
NO_STACK_CHECK = 0,
GENERIC_STACK_CHECK,
STATIC_BUILTIN_STACK_CHECK,
FULL_BUILTIN_STACK_CHECK
};
enum callgraph_info_type
{
NO_CALLGRAPH_INFO = 0,
CALLGRAPH_INFO_NAKED = 1,
CALLGRAPH_INFO_STACK_USAGE = 2,
CALLGRAPH_INFO_DYNAMIC_ALLOC = 4
};
enum fp_contract_mode {
FP_CONTRACT_OFF = 0,
FP_CONTRACT_ON = 1,
FP_CONTRACT_FAST = 2
};
enum scalar_storage_order_kind {
SSO_NATIVE = 0,
SSO_BIG_ENDIAN,
SSO_LITTLE_ENDIAN
};
enum vect_cost_model {
VECT_COST_MODEL_UNLIMITED = 0,
VECT_COST_MODEL_CHEAP = 1,
VECT_COST_MODEL_DYNAMIC = 2,
VECT_COST_MODEL_DEFAULT = 3
};
enum sanitize_code {
SANITIZE_ADDRESS = 1UL << 0,
SANITIZE_USER_ADDRESS = 1UL << 1,
SANITIZE_KERNEL_ADDRESS = 1UL << 2,
SANITIZE_THREAD = 1UL << 3,
SANITIZE_LEAK = 1UL << 4,
SANITIZE_SHIFT_BASE = 1UL << 5,
SANITIZE_SHIFT_EXPONENT = 1UL << 6,
SANITIZE_DIVIDE = 1UL << 7,
SANITIZE_UNREACHABLE = 1UL << 8,
SANITIZE_VLA = 1UL << 9,
SANITIZE_NULL = 1UL << 10,
SANITIZE_RETURN = 1UL << 11,
SANITIZE_SI_OVERFLOW = 1UL << 12,
SANITIZE_BOOL = 1UL << 13,
SANITIZE_ENUM = 1UL << 14,
SANITIZE_FLOAT_DIVIDE = 1UL << 15,
SANITIZE_FLOAT_CAST = 1UL << 16,
SANITIZE_BOUNDS = 1UL << 17,
SANITIZE_ALIGNMENT = 1UL << 18,
SANITIZE_NONNULL_ATTRIBUTE = 1UL << 19,
SANITIZE_RETURNS_NONNULL_ATTRIBUTE = 1UL << 20,
SANITIZE_OBJECT_SIZE = 1UL << 21,
SANITIZE_VPTR = 1UL << 22,
SANITIZE_BOUNDS_STRICT = 1UL << 23,
SANITIZE_POINTER_OVERFLOW = 1UL << 24,
SANITIZE_BUILTIN = 1UL << 25,
SANITIZE_POINTER_COMPARE = 1UL << 26,
SANITIZE_POINTER_SUBTRACT = 1UL << 27,
SANITIZE_SHIFT = SANITIZE_SHIFT_BASE | SANITIZE_SHIFT_EXPONENT,
SANITIZE_UNDEFINED = SANITIZE_SHIFT | SANITIZE_DIVIDE | SANITIZE_UNREACHABLE
| SANITIZE_VLA | SANITIZE_NULL | SANITIZE_RETURN
| SANITIZE_SI_OVERFLOW | SANITIZE_BOOL | SANITIZE_ENUM
| SANITIZE_BOUNDS | SANITIZE_ALIGNMENT
| SANITIZE_NONNULL_ATTRIBUTE
| SANITIZE_RETURNS_NONNULL_ATTRIBUTE
| SANITIZE_OBJECT_SIZE | SANITIZE_VPTR
| SANITIZE_POINTER_OVERFLOW | SANITIZE_BUILTIN,
SANITIZE_UNDEFINED_NONDEFAULT = SANITIZE_FLOAT_DIVIDE | SANITIZE_FLOAT_CAST
| SANITIZE_BOUNDS_STRICT
};
enum incremental_link {
INCREMENTAL_LINK_NONE,
INCREMENTAL_LINK_NOLTO,
INCREMENTAL_LINK_LTO
};
enum sanitize_coverage_code {
SANITIZE_COV_TRACE_PC = 1 << 0,
SANITIZE_COV_TRACE_CMP = 1 << 1
};
enum vtv_priority {
VTV_NO_PRIORITY = 0,
VTV_STANDARD_PRIORITY = 1,
VTV_PREINIT_PRIORITY = 2
};
enum lto_partition_model {
LTO_PARTITION_NONE = 0,
LTO_PARTITION_ONE = 1,
LTO_PARTITION_BALANCED = 2,
LTO_PARTITION_1TO1 = 3,
LTO_PARTITION_MAX = 4
};
enum lto_linker_output {
LTO_LINKER_OUTPUT_UNKNOWN,
LTO_LINKER_OUTPUT_REL,
LTO_LINKER_OUTPUT_NOLTOREL,
LTO_LINKER_OUTPUT_DYN,
LTO_LINKER_OUTPUT_PIE,
LTO_LINKER_OUTPUT_EXEC
};
enum gfc_init_local_real
{
GFC_INIT_REAL_OFF = 0,
GFC_INIT_REAL_ZERO,
GFC_INIT_REAL_NAN,
GFC_INIT_REAL_SNAN,
GFC_INIT_REAL_INF,
GFC_INIT_REAL_NEG_INF
};
enum gfc_fcoarray
{
GFC_FCOARRAY_NONE = 0,
GFC_FCOARRAY_SINGLE,
GFC_FCOARRAY_LIB
};
enum gfc_convert
{
GFC_FLAG_CONVERT_NATIVE = 0,
GFC_FLAG_CONVERT_SWAP,
GFC_FLAG_CONVERT_BIG,
GFC_FLAG_CONVERT_LITTLE
};
enum cf_protection_level
{
CF_NONE = 0,
CF_BRANCH = 1 << 0,
CF_RETURN = 1 << 1,
CF_FULL = CF_BRANCH | CF_RETURN,
CF_SET = 1 << 2,
CF_CHECK = 1 << 3
};
enum parloops_schedule_type
{
PARLOOPS_SCHEDULE_STATIC = 0,
PARLOOPS_SCHEDULE_DYNAMIC,
PARLOOPS_SCHEDULE_GUIDED,
PARLOOPS_SCHEDULE_AUTO,
PARLOOPS_SCHEDULE_RUNTIME
};
# 7 "./options.h" 2
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/config/i386/i386-opts.h" 1
# 29 "/home/giulianob/gcc_git_gnu/gcc/gcc/config/i386/i386-opts.h"
enum stringop_alg
{
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/config/i386/stringop.def" 1
# 20 "/home/giulianob/gcc_git_gnu/gcc/gcc/config/i386/stringop.def"
no_stringop,
libcall,
rep_prefix_1_byte,
rep_prefix_4_byte,
rep_prefix_8_byte,
loop_1_byte,
loop,
unrolled_loop,
vector_loop,
# 38 "/home/giulianob/gcc_git_gnu/gcc/gcc/config/i386/i386-opts.h" 2
last_alg
};
enum calling_abi
{
SYSV_ABI = 0,
MS_ABI = 1
};
enum fpmath_unit
{
FPMATH_387 = 1,
FPMATH_SSE = 2
};
enum tls_dialect
{
TLS_DIALECT_GNU,
TLS_DIALECT_GNU2,
TLS_DIALECT_SUN
};
enum cmodel {
CM_32,
CM_SMALL,
CM_KERNEL,
CM_MEDIUM,
CM_LARGE,
CM_SMALL_PIC,
CM_MEDIUM_PIC,
CM_LARGE_PIC
};
enum pmode {
PMODE_SI,
PMODE_DI
};
enum ix86_align_data {
ix86_align_data_type_compat,
ix86_align_data_type_abi,
ix86_align_data_type_cacheline
};
enum asm_dialect {
ASM_ATT,
ASM_INTEL
};
enum ix86_veclibabi {
ix86_veclibabi_type_none,
ix86_veclibabi_type_svml,
ix86_veclibabi_type_acml
};
enum stack_protector_guard {
SSP_TLS,
SSP_GLOBAL
};
enum prefer_vector_width {
PVW_NONE,
PVW_AVX128,
PVW_AVX256,
PVW_AVX512
};
enum indirect_branch {
indirect_branch_unset = 0,
indirect_branch_keep,
indirect_branch_thunk,
indirect_branch_thunk_inline,
indirect_branch_thunk_extern
};
enum instrument_return {
instrument_return_none = 0,
instrument_return_call,
instrument_return_nop5
};
# 9 "./options.h" 2
struct gcc_options
{
long x_ix86_stack_protector_guard_offset;
addr_space_t x_ix86_stack_protector_guard_reg;
int x_recip_mask;
long x_function_entry_patch_area_size;
long x_function_entry_patch_area_start;
long x_ix86_isa_flags;
long x_ix86_isa_flags2;
long x_ix86_isa_flags2_explicit;
long x_ix86_isa_flags_explicit;
bool x_dump_base_name_prefixed;
bool x_exit_after_options;
bool x_flag_disable_hsa;
bool x_flag_dump_all_passed;
bool x_flag_opts_finished;
bool x_flag_stack_usage_info;
bool x_flag_warn_unused_result;
bool x_in_lto_p;
bool x_use_gnu_debug_info_extensions;
char * x_help_enum_printed;
char * x_help_printed;
const char * x_aux_base_name;
const char * x_flag_parallel_jobs;
const char * x_main_input_basename;
const char * x_main_input_filename;
const char * x_split_outputs;
enum debug_info_levels x_debug_info_level;
enum debug_info_type x_write_symbols;
enum debug_struct_file x_debug_struct_generic[DINFO_USAGE_NUM_ENUMS];
enum debug_struct_file x_debug_struct_ordinary[DINFO_USAGE_NUM_ENUMS];
enum dwarf_gnat_encodings x_gnat_encodings;
enum incremental_link x_flag_incremental_link;
enum stack_check_type x_flag_stack_check;
int x_flag_complex_method;
int x_flag_debug_asm;
int x_flag_dump_rtl_in_asm;
int x_flag_gen_aux_info;
int x_flag_generate_lto;
int x_flag_generate_offload;
int x_flag_print_asm_name;
int x_flag_shlib;
int x_ix86_target_flags;
int x_main_input_baselength;
int x_optimize;
int x_optimize_debug;
int x_optimize_fast;
int x_optimize_size;
int x_recip_mask_explicit;
int x_rtl_dump_and_exit;
int x_target_flags;
unsigned int x_flag_sanitize;
unsigned int x_flag_sanitize_coverage;
unsigned int x_flag_sanitize_recover;
unsigned int x_help_columns;
unsigned int x_initial_max_fld_align;
void * x_flag_instrument_functions_exclude_files;
void * x_flag_instrument_functions_exclude_functions;
int x_help_flag;
int x_no_sysroot_suffix;
int x_param_align_loop_iterations;
int x_param_align_threshold;
int x_param_analyzer_bb_explosion_factor;
int x_param_analyzer_max_enodes_for_full_dump;
int x_param_analyzer_max_enodes_per_program_point;
int x_param_analyzer_max_recursion_depth;
int x_param_analyzer_max_svalue_depth;
int x_param_analyzer_min_snodes_for_call_summary;
int x_param_asan_globals;
int x_param_asan_protect_allocas;
int x_param_asan_instrument_reads;
int x_param_asan_instrument_writes;
int x_param_asan_instrumentation_with_call_threshold;
int x_param_asan_memintrin;
int x_param_asan_stack;
int x_param_asan_use_after_return;
int x_param_avg_loop_niter;
int x_param_avoid_fma_max_bits;
int x_param_balance_partitions;
int x_param_builtin_expect_probability;
int x_param_builtin_string_cmp_inline_length;
int x_param_case_values_threshold;
int x_param_comdat_sharing_probability;
int x_param_cxx_max_namespaces_for_diagnostic_help;
int x_param_dse_max_alias_queries_per_store;
int x_param_dse_max_object_size;
int x_param_early_inlining_insns;
int x_param_fsm_maximum_phi_arguments;
int x_param_fsm_scale_path_blocks;
int x_param_fsm_scale_path_stmts;
int x_param_gcse_after_reload_critical_fraction;
int x_param_gcse_after_reload_partial_fraction;
int x_param_gcse_cost_distance_ratio;
int x_param_gcse_unrestricted_cost;
int x_param_ggc_min_expand;
int x_param_ggc_min_heapsize;
int x_param_gimple_fe_computed_hot_bb_threshold;
int x_param_graphite_allow_codegen_errors;
int x_param_graphite_max_arrays_per_scop;
int x_param_graphite_max_nb_scop_params;
int x_param_hash_table_verification_limit;
int x_param_hot_bb_count_fraction;
int x_param_hot_bb_count_ws_permille;
int x_param_hot_bb_frequency_fraction;
int x_param_inline_heuristics_hint_percent;
int x_param_inline_min_speedup;
int x_param_inline_unit_growth;
int x_param_integer_share_limit;
int x_param_ipa_cp_eval_threshold;
int x_param_ipa_cp_loop_hint_bonus;
int x_param_ipa_cp_max_recursive_depth;
int x_param_ipa_cp_min_recursive_probability;
int x_param_ipa_cp_recursion_penalty;
int x_param_ipa_cp_single_call_penalty;
int x_param_ipa_cp_unit_growth;
int x_param_ipa_cp_value_list_size;
int x_param_ipa_max_aa_steps;
int x_param_ipa_max_agg_items;
int x_param_ipa_max_param_expr_ops;
int x_param_ipa_max_switch_predicate_bounds;
int x_param_ipa_sra_max_replacements;
int x_param_ipa_sra_ptr_growth_factor;
int x_param_ira_loop_reserved_regs;
int x_param_ira_max_conflict_table_size;
int x_param_ira_max_loops_num;
int x_param_iv_always_prune_cand_set_bound;
int x_param_iv_consider_all_candidates_bound;
int x_param_iv_max_considered_uses;
int x_param_jump_table_max_growth_ratio_for_size;
int x_param_jump_table_max_growth_ratio_for_speed;
int x_param_l1_cache_line_size;
int x_param_l1_cache_size;
int x_param_l2_cache_size;
int x_param_large_function_growth;
int x_param_large_function_insns;
int x_param_stack_frame_growth;
int x_param_large_stack_frame;
int x_param_large_unit_insns;
int x_param_lim_expensive;
int x_param_logical_op_non_short_circuit;
int x_param_loop_block_tile_size;
int x_param_loop_interchange_max_num_stmts;
int x_param_loop_interchange_stride_ratio;
int x_param_loop_invariant_max_bbs_in_loop;
int x_param_loop_max_datarefs_for_datadeps;
int x_param_loop_versioning_max_inner_insns;
int x_param_loop_versioning_max_outer_insns;
int x_param_lra_inheritance_ebb_probability_cutoff;
int x_param_lra_max_considered_reload_pseudos;
int x_param_max_partition_size;
int x_param_max_lto_streaming_parallelism;
int x_param_min_partition_size;
int x_param_lto_partitions;
int x_param_max_average_unrolled_insns;
int x_param_max_combine_insns;
int x_param_max_unroll_iterations;
int x_param_max_completely_peel_times;
int x_param_max_completely_peeled_insns;
int x_param_max_crossjump_edges;
int x_param_max_cse_insns;
int x_param_max_cse_path_length;
int x_param_max_cselib_memory_locations;
int x_param_max_debug_marker_count;
int x_param_max_delay_slot_insn_search;
int x_param_max_delay_slot_live_search;
int x_param_max_dse_active_local_stores;
int x_param_early_inliner_max_iterations;
int x_param_max_fields_for_field_sensitive;
int x_param_max_find_base_term_values;
int x_param_max_fsm_thread_length;
int x_param_max_fsm_thread_path_insns;
int x_param_max_fsm_thread_paths;
int x_param_max_gcse_insertion_ratio;
int x_param_max_gcse_memory;
int x_param_max_goto_duplication_insns;
int x_param_max_grow_copy_bb_insns;
int x_param_max_hoist_depth;
int x_param_max_inline_insns_auto;
int x_param_max_inline_insns_recursive_auto;
int x_param_max_inline_insns_recursive;
int x_param_max_inline_insns_single;
int x_param_max_inline_insns_size;
int x_param_max_inline_insns_small;
int x_param_max_inline_recursive_depth_auto;
int x_param_max_inline_recursive_depth;
int x_param_max_isl_operations;
int x_param_max_iterations_computation_cost;
int x_param_max_iterations_to_track;
int x_param_max_jump_thread_duplication_stmts;
int x_param_max_last_value_rtl;
int x_param_max_loop_header_insns;
int x_param_max_modulo_backtrack_attempts;
int x_param_max_partial_antic_length;
int x_param_max_peel_branches;
int x_param_max_peel_times;
int x_param_max_peeled_insns;
int x_param_max_pending_list_length;
int x_param_max_pipeline_region_blocks;
int x_param_max_pipeline_region_insns;
int x_param_max_pow_sqrt_depth;
int x_param_max_predicted_iterations;
int x_param_max_reload_search_insns;
int x_param_max_rtl_if_conversion_insns;
int x_param_max_rtl_if_conversion_predictable_cost;
int x_param_max_rtl_if_conversion_unpredictable_cost;
int x_param_max_sched_extend_regions_iters;
int x_param_max_sched_insn_conflict_delay;
int x_param_max_sched_ready_insns;
int x_param_max_sched_region_blocks;
int x_param_max_sched_region_insns;
int x_param_max_slsr_candidate_scan;
int x_param_max_speculative_devirt_maydefs;
int x_param_max_ssa_name_query_depth;
int x_param_max_stores_to_merge;
int x_param_max_stores_to_sink;
int x_param_max_tail_merge_comparisons;
int x_param_max_tail_merge_iterations;
int x_param_max_tracked_strlens;
int x_param_max_tree_if_conversion_phi_args;
int x_param_max_unroll_times;
int x_param_max_unrolled_insns;
int x_param_max_unswitch_insns;
int x_param_max_unswitch_level;
int x_param_max_variable_expansions;
int x_param_max_vartrack_expr_depth;
int x_param_max_vartrack_reverse_op_size;
int x_param_max_vartrack_size;
int x_param_max_vrp_switch_assertions;
int x_param_min_crossjump_insns;
int x_param_min_inline_recursive_probability;
int x_param_min_insn_to_prefetch_ratio;
int x_param_min_loop_cond_split_prob;
int x_param_min_nondebug_insn_uid;
int x_param_min_size_for_stack_sharing;
int x_param_min_spec_prob;
int x_param_min_vect_loop_bound;
int x_param_parloops_chunk_size;
int x_param_parloops_min_per_thread;
int x_param_parloops_schedule;
int x_param_partial_inlining_entry_probability;
int x_param_predictable_branch_outcome;
int x_param_prefetch_dynamic_strides;
int x_param_prefetch_latency;
int x_param_prefetch_min_insn_to_mem_ratio;
int x_param_prefetch_minimum_stride;
int x_param_profile_func_internal_id;
int x_param_promote_statics;
int x_param_rpo_vn_max_loop_depth;
int x_param_sccvn_max_alias_queries_per_access;
int x_param_scev_max_expr_complexity;
int x_param_scev_max_expr_size;
int x_param_sched_autopref_queue_depth;
int x_param_sched_mem_true_dep_cost;
int x_param_sched_pressure_algorithm;
int x_param_sched_spec_prob_cutoff;
int x_param_sched_state_edge_prob_cutoff;
int x_param_selsched_insns_to_rename;
int x_param_selsched_max_lookahead;
int x_param_selsched_max_sched_times;
int x_param_simultaneous_prefetches;
int x_param_sink_frequency_threshold;
int x_param_slp_max_insns_in_bb;
int x_param_sms_dfa_history;
int x_param_sms_loop_average_count_threshold;
int x_param_sms_max_ii_factor;
int x_param_sms_min_sc;
int x_param_sra_max_propagations;
int x_param_sra_max_scalarization_size_size;
int x_param_sra_max_scalarization_size_speed;
int x_param_ssa_name_def_chain_limit;
int x_param_ssp_buffer_size;
int x_param_stack_clash_protection_guard_size;
int x_param_stack_clash_protection_probe_interval;
int x_param_store_merging_allow_unaligned;
int x_param_store_merging_max_size;
int x_param_switch_conversion_branch_ratio;
int x_param_tm_max_aggregate_size;
int x_param_tracer_dynamic_coverage_feedback;
int x_param_tracer_dynamic_coverage;
int x_param_tracer_max_code_growth;
int x_param_tracer_min_branch_probability_feedback;
int x_param_tracer_min_branch_probability;
int x_param_tracer_min_branch_ratio;
int x_param_tree_reassoc_width;
int x_param_tsan_distinguish_volatile;
int x_param_tsan_instrument_func_entry_exit;
int x_param_uninit_control_dep_attempts;
int x_param_uninlined_function_insns;
int x_param_uninlined_function_time;
int x_param_uninlined_function_thunk_insns;
int x_param_uninlined_function_thunk_time;
int x_param_unlikely_bb_count_fraction;
int x_param_unroll_jam_max_unroll;
int x_param_unroll_jam_min_percent;
int x_param_use_after_scope_direct_emission_threshold;
int x_param_use_canonical_types;
int x_param_vect_epilogues_nomask;
int x_param_vect_max_peeling_for_alignment;
int x_param_vect_max_version_for_alias_checks;
int x_param_vect_max_version_for_alignment_checks;
int x_param_vect_partial_vector_usage;
int x_flag_preprocess_only;
int x_warn_abi;
int x_warn_abi_tag;
int x_warn_absolute_value;
int x_warn_address;
int x_warn_address_of_packed_member;
int x_warn_aggregate_return;
int x_warn_aggressive_loop_optimizations;
int x_warn_aliasing;
int x_warn_align_commons;
int x_warn_aligned_new;
long x_warn_alloc_size_limit;
int x_warn_alloc_zero;
int x_warn_alloca;
long x_warn_alloca_limit;
int x_warn_ampersand;
int x_warn_analyzer_double_fclose;
int x_warn_analyzer_double_free;
int x_warn_analyzer_exposure_through_output_file;
int x_warn_analyzer_file_leak;
int x_warn_analyzer_free_of_non_heap;
int x_warn_analyzer_malloc_leak;
int x_warn_analyzer_null_argument;
int x_warn_analyzer_null_dereference;
int x_warn_analyzer_possible_null_argument;
int x_warn_analyzer_possible_null_dereference;
int x_warn_analyzer_stale_setjmp_buffer;
int x_warn_analyzer_tainted_array_index;
int x_warn_analyzer_too_complex;
int x_warn_analyzer_unsafe_call_within_signal_handler;
int x_warn_analyzer_use_after_free;
int x_warn_analyzer_use_of_pointer_in_stale_stack_frame;
int x_warn_arith_conv;
int x_warn_array_bounds;
int x_warn_array_temporaries;
int x_warn_assign_intercept;
int x_warn_attribute_alias;
int x_warn_attribute_warning;
int x_warn_attributes;
int x_warn_bad_function_cast;
int x_warn_bool_compare;
int x_warn_bool_op;
int x_warn_builtin_declaraion_mismatch;
int x_cpp_warn_builtin_macro_redefined;
int x_warn_cxx_compat;
int x_warn_cxx11_compat;
int x_warn_cxx14_compat;
int x_warn_cxx17_compat;
int x_warn_cxx20_compat;
int x_warn_c_binding_type;
int x_warn_c11_c2x_compat;
int x_warn_c90_c99_compat;
int x_warn_c99_c11_compat;
int x_warn_cannot_profile;
int x_warn_cast_align;
int x_warn_cast_function_type;
int x_warn_cast_qual;
int x_warn_cast_result;
int x_warn_catch_value;
int x_warn_char_subscripts;
int x_warn_character_truncation;
int x_warn_class_conversion;
int x_warn_class_memaccess;
int x_warn_clobbered;
int x_warn_comma_subscript;
int x_cpp_warn_comment;
int x_warn_compare_reals;
int x_warn_conditionally_supported;
int x_warn_conversion;
int x_warn_conversion_extra;
int x_warn_conversion_null;
int x_warn_coverage_mismatch;
int x_warn_cpp;
int x_warn_ctor_dtor_privacy;
int x_warn_dangling_else;
int x_cpp_warn_date_time;
int x_warn_declaration_after_statement;
int x_warn_delete_incomplete;
int x_warn_delnonvdtor;
int x_warn_deprecated;
int x_warn_deprecated_copy;
int x_warn_deprecated_decl;
int x_warn_designated_init;
int x_warn_disabled_optimization;
int x_warn_discarded_array_qualifiers;
int x_warn_discarded_qualifiers;
int x_warn_div_by_zero;
int x_warn_do_subscript;
int x_warn_double_promotion;
int x_warn_duplicate_decl_specifier;
int x_warn_duplicated_branches;
int x_warn_duplicated_cond;
int x_warn_ecpp;
int x_warn_empty_body;
int x_cpp_warn_endif_labels;
int x_warn_enum_compare;
int x_warn_enum_conversion;
int x_warnings_are_errors;
int x_cpp_warn_expansion_to_defined;
int x_extra_warnings;
int x_warn_extra_semi;
int x_flag_fatal_errors;
int x_warn_float_conversion;
int x_warn_float_equal;
int x_warn_format_contains_nul;
int x_warn_format_diag;
int x_warn_format_extra_args;
int x_warn_format_nonliteral;
int x_warn_format_overflow;
int x_warn_format_security;
int x_warn_format_signedness;
int x_warn_format_trunc;
int x_warn_format_y2k;
int x_warn_format_zero_length;
int x_warn_format;
int x_warn_frame_address;
long x_warn_frame_larger_than_size;
int x_warn_free_nonheap_object;
int x_flag_warn_frontend_loop_interchange;
int x_warn_function_elimination;
int x_warn_if_not_aligned;
int x_warn_ignored_attributes;
int x_warn_ignored_qualifiers;
int x_warn_implicit;
int x_warn_implicit_fallthrough;
int x_warn_implicit_function_declaration;
int x_warn_implicit_int;
int x_warn_implicit_interface;
int x_warn_implicit_procedure;
int x_warn_inaccessible_base;
int x_warn_incompatible_pointer_types;
int x_warn_inh_var_ctor;
int x_warn_init_list;
int x_warn_init_self;
int x_warn_inline;
int x_warn_int_conversion;
int x_warn_int_in_bool_context;
int x_warn_int_to_pointer_cast;
int x_warn_integer_division;
int x_warn_intrinsic_shadow;
int x_warn_intrinsics_std;
int x_warn_invalid_memory_model;
int x_warn_invalid_offsetof;
int x_cpp_warn_invalid_pch;
int x_warn_jump_misses_init;
long x_warn_larger_than_size;
int x_warn_line_truncation;
int x_cpp_warn_literal_suffix;
int x_warn_logical_not_paren;
int x_warn_logical_op;
int x_warn_long_long;
int x_warn_lto_type_mismatch;
int x_warn_main;
int x_warn_maybe_uninitialized;
int x_warn_memset_elt_size;
int x_warn_memset_transposed_args;
int x_warn_misleading_indentation;
int x_warn_mismatched_tags;
int x_warn_missing_attributes;
int x_warn_missing_braces;
int x_warn_missing_declarations;
int x_warn_missing_field_initializers;
int x_cpp_warn_missing_include_dirs;
int x_warn_missing_parameter_type;
int x_warn_missing_profile;
int x_warn_missing_prototypes;
int x_cpp_warn_multichar;
int x_warn_multiple_inheritance;
int x_warn_multistatement_macros;
int x_warn_namespaces;
int x_warn_narrowing;
int x_warn_nested_externs;
int x_warn_noexcept;
int x_warn_noexcept_type;
int x_warn_nontemplate_friend;
int x_warn_nonvdtor;
int x_warn_nonnull;
int x_warn_nonnull_compare;
int x_cpp_warn_normalize;
int x_warn_null_dereference;
int x_warn_odr_violations;
int x_warn_old_style_cast;
int x_warn_old_style_declaration;
int x_warn_old_style_definition;
int x_warn_openmp_simd;
int x_warn_overflow;
int x_warn_overlength_strings;
int x_warn_overloaded_virtual;
int x_warn_override_init;
int x_warn_override_init_side_effects;
int x_warn_overwrite_recursive;
int x_warn_packed;
int x_warn_packed_bitfield_compat;
int x_warn_packed_not_aligned;
int x_warn_padded;
int x_warn_parentheses;
int x_pedantic;
int x_warn_pessimizing_move;
int x_warn_placement_new;
int x_warn_pmf2ptr;
int x_warn_pointer_arith;
int x_warn_pointer_compare;
int x_warn_pointer_sign;
int x_warn_pointer_to_int_cast;
int x_warn_pragmas;
int x_warn_prio_ctor_dtor;
int x_warn_property_assign_default;
int x_warn_protocol;
int x_warn_psabi;
int x_warn_real_q_constant;
int x_warn_realloc_lhs;
int x_warn_realloc_lhs_all;
int x_warn_redundant_decls;
int x_warn_redundant_move;
int x_warn_redundant_tags;
int x_warn_register;
int x_warn_reorder;
int x_warn_restrict;
int x_warn_return_local_addr;
int x_warn_return_type;
int x_warn_scalar_storage_order;
int x_warn_selector;
int x_warn_sequence_point;
int x_warn_shadow;
int x_warn_shadow_ivar;
int x_warn_shadow_compatible_local;
int x_warn_shadow_local;
int x_warn_shift_count_negative;
int x_warn_shift_count_overflow;
int x_warn_shift_negative_value;
int x_warn_shift_overflow;
int x_warn_sign_compare;
int x_warn_sign_conversion;
int x_warn_sign_promo;
int x_warn_sized_deallocation;
int x_warn_sizeof_array_argument;
int x_warn_sizeof_pointer_div;
int x_warn_sizeof_pointer_memaccess;
int x_warn_stack_protect;
long x_warn_stack_usage;
int x_warn_strict_aliasing;
int x_warn_strict_null_sentinel;
int x_warn_strict_overflow;
int x_warn_strict_prototypes;
int x_warn_strict_selector_match;
int x_warn_string_compare;
int x_warn_stringop_overflow;
int x_warn_stringop_truncation;
int x_warn_subobject_linkage;
int x_warn_suggest_attribute_cold;
int x_warn_suggest_attribute_const;
int x_warn_suggest_attribute_format;
int x_warn_suggest_attribute_malloc;
int x_warn_suggest_attribute_noreturn;
int x_warn_suggest_attribute_pure;
int x_warn_suggest_final_methods;
int x_warn_suggest_final_types;
int x_warn_override;
int x_warn_surprising;
int x_warn_switch;
int x_warn_switch_bool;
int x_warn_switch_default;
int x_warn_switch_enum;
int x_warn_switch_outside_range;
int x_warn_switch_unreachable;
int x_warn_sync_nand;
int x_warn_synth;
int x_warn_system_headers;
int x_warn_tabs;
int x_warn_target_lifetime;
int x_warn_tautological_compare;
int x_warn_templates;
int x_warn_terminate;
int x_warn_traditional;
int x_warn_traditional_conversion;
int x_warn_trampolines;
int x_cpp_warn_trigraphs;
int x_warn_type_limits;
int x_warn_undeclared_selector;
int x_cpp_warn_undef;
int x_warn_undefined_do_loop;
int x_warn_underflow;
int x_warn_uninitialized;
int x_warn_unknown_pragmas;
int x_warn_unsuffixed_float_constants;
int x_warn_unused;
int x_warn_unused_but_set_parameter;
int x_warn_unused_but_set_variable;
int x_warn_unused_const_variable;
int x_warn_unused_dummy_argument;
int x_warn_unused_function;
int x_warn_unused_label;
int x_warn_unused_local_typedefs;
int x_cpp_warn_unused_macros;
int x_warn_unused_parameter;
int x_warn_unused_result;
int x_warn_unused_value;
int x_warn_unused_variable;
int x_warn_use_without_only;
int x_warn_useless_cast;
int x_warn_varargs;
int x_cpp_warn_variadic_macros;
int x_warn_vector_operation_performance;
int x_warn_virtual_inheritance;
int x_warn_virtual_move_assign;
int x_warn_vla;
long x_warn_vla_limit;
int x_warn_volatile;
int x_warn_volatile_register_var;
int x_warn_write_strings;
int x_warn_zero_as_null_pointer_constant;
int x_warn_zero_length_bounds;
int x_warn_zerotrip;
const char *x_aux_info_file_name;
int x_flag_dump_callgraph;
int x_flag_lto_dump_defined;
int x_flag_lto_dump_demangle;
const char *x_flag_dump_body;
const char *x_flag_dump_level;
const char *x_dump_base_name;
const char *x_dump_base_ext;
const char *x_dump_dir_name;
int x_flag_pic;
int x_flag_pie;
int x_flag_abi_compat_version;
int x_flag_abi_version;
int x_flag_access_control;
const char *x_ada_specs_parent;
int x_flag_aggressive_function_elimination;
int x_flag_aggressive_loop_optimizations;
int x_flag_align_commons;
int x_flag_align_functions;
const char *x_str_align_functions;
int x_flag_align_jumps;
const char *x_str_align_jumps;
int x_flag_align_labels;
const char *x_str_align_labels;
int x_flag_align_loops;
const char *x_str_align_loops;
int x_aligned_new_threshold;
int x_flag_all_intrinsics;
int x_flag_allocation_dce;
int x_flag_allow_argument_mismatch;
int x_flag_allow_invalid_boz;
int x_flag_allow_leading_underscore;
int x_flag_allow_parameterless_variadic_functions;
int x_flag_store_data_races;
int x_flag_analyzer;
int x_flag_analyzer_call_summaries;
const char *x_flag_analyzer_checker;
int x_flag_analyzer_fine_grained;
int x_flag_analyzer_show_duplicate_count;
int x_flag_analyzer_state_merge;
int x_flag_analyzer_state_purge;
int x_flag_analyzer_transitivity;
int x_flag_analyzer_verbose_edges;
int x_flag_analyzer_verbose_state_changes;
int x_analyzer_verbosity;
void *x_common_deferred_options;
int x_flag_no_asm;
int x_flag_assert;
int x_flag_associative_math;
int x_flag_assume_phsa;
int x_flag_asynchronous_unwind_tables;
int x_flag_auto_inc_dec;
int x_flag_auto_profile;
const char *x_auto_profile_file;
int x_flag_automatic;
int x_flag_backslash;
int x_flag_backtrace;
int x_flag_blas_matmul_limit;
int x_flag_bounds_check;
int x_flag_branch_on_count_reg;
int x_flag_branch_probabilities;
int x_flag_building_libgcc;
int x_flag_building_libphobos_tests;
int x_flag_no_builtin;
int x_flag_c_prototypes;
int x_flag_c_prototypes_external;
int x_flag_caller_saves;
int x_flag_callgraph_info;
enum cf_protection_level x_flag_cf_protection;
int x_flag_char8_t;
int x_flag_check_new;
int x_flag_checking;
enum gfc_fcoarray x_flag_coarray;
int x_flag_code_hoisting;
int x_flag_combine_stack_adjustments;
int x_flag_no_common;
int x_flag_compare_debug;
const char *x_flag_compare_debug_opt;
int x_flag_compare_elim_after_reload;
int x_flag_concepts;
int x_concepts_diagnostics_max_depth;
int x_flag_concepts_ts;
int x_flag_conserve_stack;
int x_constexpr_cache_depth;
int x_max_constexpr_depth;
int x_constexpr_loop_limit;
long x_constexpr_ops_limit;
enum gfc_convert x_flag_convert;
int x_flag_coroutines;
int x_flag_cprop_registers;
int x_flag_cray_pointer;
int x_flag_crossjumping;
int x_flag_cse_follow_jumps;
int x_flag_cx_fortran_rules;
int x_flag_cx_limited_range;
int x_flag_data_sections;
int x_flag_dce;
int x_flag_debug_types_section;
int x_flag_dec;
int x_flag_dec_blank_format_item;
int x_flag_dec_char_conversions;
int x_flag_dec_format_defaults;
int x_flag_dec_include;
int x_flag_dec_intrinsic_ints;
int x_flag_dec_math;
int x_flag_dec_static;
int x_flag_dec_structure;
int x_flag_declone_ctor_dtor;
int x_flag_default_double;
int x_flag_default_integer;
int x_flag_default_real_10;
int x_flag_default_real_16;
int x_flag_default_real_8;
int x_flag_defer_pop;
int x_flag_delayed_branch;
int x_flag_delete_dead_exceptions;
int x_flag_delete_null_pointer_checks;
int x_flag_devirtualize;
int x_flag_ltrans_devirtualize;
int x_flag_devirtualize_speculatively;
int x_flag_diagnostics_show_color;
int x_flag_diagnostics_generate_patch;
int x_diagnostics_minimum_margin_width;
int x_flag_diagnostics_parseable_fixits;
int x_flag_diagnostics_path_format;
int x_flag_diagnostics_show_caret;
int x_flag_diagnostics_show_cwe;
int x_flag_diagnostics_show_labels;
int x_flag_diagnostics_show_line_numbers;
int x_flag_diagnostics_show_option;
int x_flag_diagnostics_show_path_depths;
int x_flag_diagnostics_show_template_tree;
int x_flag_diagnostics_show_urls;
int x_flag_dollar_ok;
int x_flag_dse;
int x_flag_dump_ada_spec;
int x_flag_dump_ada_spec_slim;
int x_flag_dump_analyzer;
int x_flag_dump_analyzer_callgraph;
int x_flag_dump_analyzer_exploded_graph;
int x_flag_dump_analyzer_exploded_nodes;
int x_flag_dump_analyzer_exploded_nodes_2;
int x_flag_dump_analyzer_exploded_nodes_3;
int x_flag_dump_analyzer_state_purge;
int x_flag_dump_analyzer_stderr;
int x_flag_dump_analyzer_supergraph;
const char *x_flag_dump_final_insns;
int x_flag_dump_fortran_global;
int x_flag_dump_fortran_optimized;
int x_flag_dump_fortran_original;
const char *x_flag_dump_go_spec;
int x_flag_dump_locations;
int x_flag_dump_noaddr;
int x_flag_dump_passes;
int x_flag_dump_scos;
int x_flag_dump_unnumbered;
int x_flag_dump_unnumbered_links;
int x_flag_dwarf2_cfi_asm;
int x_flag_early_inlining;
int x_flag_elide_constructors;
int x_flag_elide_type;
int x_flag_debug_only_used_symbols;
int x_flag_eliminate_unused_debug_types;
int x_flag_emit_class_debug_always;
int x_flag_enforce_eh_specs;
int x_flag_exceptions;
enum excess_precision x_flag_excess_precision;
int x_flag_expensive_optimizations;
int x_flag_ext_numeric_literals;
int x_flag_extern_tls_init;
int x_flag_external_blas;
int x_flag_f2c;
int x_flag_fat_lto_objects;
int x_flag_finite_loops;
int x_flag_finite_math_only;
int x_flag_fixed_line_length;
int x_flag_float_store;
int x_flag_forward_propagate;
enum fp_contract_mode x_flag_fp_contract_mode;
int x_flag_fp_int_builtin_inexact;
int x_flag_free_line_length;
int x_flag_frontend_loop_interchange;
int x_flag_frontend_optimize;
int x_flag_no_function_cse;
int x_flag_function_sections;
int x_flag_gcse;
int x_flag_gcse_after_reload;
int x_flag_gcse_las;
int x_flag_gcse_lm;
int x_flag_gcse_sm;
int x_flag_gimple;
int x_flag_no_gnu_keywords;
int x_flag_next_runtime;
int x_flag_tm;
int x_flag_gnu_unique;
int x_flag_gnu89_inline;
int x_go_check_divide_overflow;
int x_go_check_divide_zero;
int x_go_compiling_runtime;
int x_go_debug_escape_level;
const char *x_go_debug_escape_hash;
int x_go_debug_optimization;
int x_flag_graphite;
int x_flag_graphite_identity;
int x_flag_guess_branch_prob;
int x_flag_hoist_adjacent_loads;
int x_flag_no_ident;
int x_flag_if_conversion;
int x_flag_if_conversion2;
int x_flag_implement_inlines;
int x_flag_implicit_inline_templates;
int x_flag_implicit_none;
int x_flag_implicit_templates;
int x_flag_indirect_inlining;
int x_flag_inhibit_size_directive;
int x_flag_init_derived;
enum gfc_init_local_real x_flag_init_real;
int x_flag_no_inline;
int x_flag_inline_arg_packing;
int x_flag_inline_atomics;
int x_flag_inline_functions;
int x_flag_inline_functions_called_once;
int x_flag_inline_matmul_limit;
int x_flag_inline_small_functions;
int x_flag_instrument_function_entry_exit;
int x_flag_integer4_kind;
int x_flag_invariants;
int x_flag_ipa_bit_cp;
int x_flag_ipa_cp;
int x_flag_ipa_cp_clone;
int x_flag_ipa_icf;
int x_flag_ipa_icf_functions;
int x_flag_ipa_icf_variables;
int x_flag_ipa_profile;
int x_flag_ipa_pta;
int x_flag_ipa_pure_const;
int x_flag_ipa_ra;
int x_flag_ipa_reference;
int x_flag_ipa_reference_addressable;
int x_flag_ipa_sra;
int x_flag_ipa_stack_alignment;
int x_flag_ipa_vrp;
enum ira_algorithm x_flag_ira_algorithm;
int x_flag_ira_hoist_pressure;
int x_flag_ira_loop_pressure;
enum ira_region x_flag_ira_region;
int x_flag_ira_share_save_slots;
int x_flag_ira_share_spill_slots;
int x_flag_ira_verbose;
int x_flag_isolate_erroneous_paths_attribute;
int x_flag_isolate_erroneous_paths_dereference;
enum ivar_visibility x_default_ivar_visibility;
int x_flag_ivopts;
int x_flag_jump_tables;
int x_flag_keep_gc_roots_live;
int x_flag_keep_inline_dllexport;
int x_flag_keep_inline_functions;
int x_flag_keep_static_consts;
int x_flag_keep_static_functions;
int x_flag_large_source_files;
int x_flag_lax_vector_conversions;
int x_flag_leading_underscore;
int x_flag_lifetime_dse;
int x_flag_limit_function_alignment;
enum lto_linker_output x_flag_lto_linker_output;
enum live_patching_level x_flag_live_patching;
int x_flag_live_range_shrinkage;
int x_flag_local_ivars;
int x_flag_loop_interchange;
int x_flag_loop_nest_optimize;
int x_flag_loop_parallelize_all;
int x_flag_unroll_jam;
int x_flag_lra_remat;
int x_flag_lto_compression_level;
enum lto_partition_model x_flag_lto_partition;
int x_flag_lto_report;
int x_flag_lto_report_wpa;
const char *x_flag_lto;
int x_flag_ltrans;
const char *x_ltrans_output_list;
int x_flag_errno_math;
int x_flag_max_array_constructor;
int x_flag_max_errors;
int x_flag_max_stack_var_size;
int x_flag_max_subrecord_length;
int x_mem_report;
int x_mem_report_wpa;
int x_flag_merge_constants;
int x_flag_merge_debug_strings;
int x_flag_module_private;
int x_flag_moduleinfo;
int x_flag_modulo_sched;
int x_flag_modulo_sched_allow_regmoves;
int x_flag_move_loop_invariants;
int x_flag_ms_extensions;
int x_flag_new_inheriting_ctors;
int x_flag_new_ttp;
int x_flag_nil_receivers;
int x_flag_non_call_exceptions;
int x_flag_no_nonansi_builtin;
int x_flag_nothrow_opt;
int x_flag_objc_abi;
int x_flag_objc_call_cxx_cdtors;
int x_flag_objc_direct_dispatch;
int x_flag_objc_exceptions;
int x_flag_objc_gc;
int x_flag_objc_nilcheck;
int x_flag_objc_sjlj_exceptions;
int x_flag_objc1_only;
enum offload_abi x_flag_offload_abi;
int x_flag_omit_frame_pointer;
int x_flag_openacc;
const char *x_flag_openacc_dims;
int x_flag_openmp;
int x_flag_openmp_simd;
int x_flag_opt_info;
int x_flag_optimize_sibling_calls;
int x_flag_optimize_strlen;
int x_flag_pack_derived;
int x_flag_pack_struct;
int x_flag_pad_source;
int x_flag_partial_inlining;
int x_flag_pcc_struct_return;
int x_flag_peel_loops;
int x_flag_no_peephole;
int x_flag_peephole2;
int x_flag_permissive;
enum permitted_flt_eval_methods x_flag_permitted_flt_eval_methods;
int x_flag_plan9_extensions;
int x_flag_plt;
int x_post_ipa_mem_report;
int x_flag_postconditions;
const char *x_flag_pre_include;
int x_pre_ipa_mem_report;
int x_flag_preconditions;
int x_flag_predictive_commoning;
int x_flag_prefetch_loop_arrays;
int x_flag_pretty_templates;
int x_flag_printf_return_value;
int x_profile_flag;
int x_profile_abs_path_flag;
int x_profile_arc_flag;
int x_flag_profile_correction;
const char *x_profile_data_prefix;
const char *x_flag_profile_exclude_files;
const char *x_flag_profile_filter_files;
const char *x_profile_note_location;
int x_flag_profile_partial_training;
const char *x_profile_prefix_path;
int x_flag_profile_reorder_functions;
int x_profile_report;
enum profile_reproducibility x_flag_profile_reproducible;
enum profile_update x_flag_profile_update;
int x_flag_profile_use;
int x_flag_profile_values;
int x_flag_protect_parens;
int x_flag_range_check;
int x_flag_real4_kind;
int x_flag_real8_kind;
int x_flag_realloc_lhs;
int x_flag_reciprocal_math;
int x_flag_record_gcc_switches;
int x_flag_record_marker;
int x_flag_recursive;
int x_flag_ree;
int x_flag_rename_registers;
int x_flag_reorder_blocks;
enum reorder_blocks_algorithm x_flag_reorder_blocks_algorithm;
int x_flag_reorder_blocks_and_partition;
int x_flag_reorder_functions;
int x_flag_repack_arrays;
int x_flag_replace_objc_classes;
int x_flag_report_bug;
int x_go_require_return_statement;
int x_flag_rerun_cse_after_loop;
int x_flag_resched_modulo_sched;
int x_flag_rounding_math;
int x_flag_rtti;
int x_flag_sanitize_address_use_after_scope;
int x_flag_sanitize_undefined_trap_on_error;
int x_flag_save_optimization_record;
int x_flag_sched_critical_path_heuristic;
int x_flag_sched_dep_count_heuristic;
int x_flag_sched_group_heuristic;
int x_flag_schedule_interblock;
int x_flag_sched_last_insn_heuristic;
int x_flag_sched_pressure;
int x_flag_sched_rank_heuristic;
int x_flag_schedule_speculative;
int x_flag_sched_spec_insn_heuristic;
int x_flag_schedule_speculative_load;
int x_flag_schedule_speculative_load_dangerous;
int x_flag_sched_stalled_insns;
int x_flag_sched_stalled_insns_dep;
int x_sched_verbose_param;
int x_flag_sched2_use_superblocks;
int x_flag_schedule_fusion;
int x_flag_schedule_insns;
int x_flag_schedule_insns_after_reload;
int x_flag_second_underscore;
int x_flag_section_anchors;
int x_flag_sel_sched_pipelining;
int x_flag_sel_sched_pipelining_outer_loops;
int x_flag_sel_sched_reschedule_pipelined;
int x_flag_selective_scheduling;
int x_flag_selective_scheduling2;
const char *x_flag_self_test;
int x_flag_semantic_interposition;
int x_flag_short_enums;
int x_flag_short_wchar;
int x_flag_show_column;
int x_flag_shrink_wrap;
int x_flag_shrink_wrap_separate;
int x_flag_sign_zero;
int x_flag_signaling_nans;
int x_flag_signed_bitfields;
int x_flag_signed_char;
int x_flag_signed_zeros;
enum vect_cost_model x_flag_simd_cost_model;
int x_flag_single_precision_constant;
int x_flag_sized_deallocation;
int x_flag_split_ivs_in_unroller;
int x_flag_split_loops;
int x_flag_split_paths;
int x_flag_split_stack;
int x_flag_split_wide_types;
int x_flag_split_wide_types_early;
int x_flag_ssa_backprop;
int x_flag_ssa_phiopt;
enum scalar_storage_order_kind x_default_sso;
int x_flag_stack_arrays;
int x_flag_stack_clash_protection;
int x_flag_stack_protect;
enum stack_reuse_level x_flag_stack_reuse;
int x_flag_stack_usage;
int x_flag_detailed_statistics;
int x_flag_stdarg_opt;
int x_flag_store_merging;
int x_flag_strict_aliasing;
int x_flag_strict_enums;
int x_flag_strict_volatile_bitfields;
int x_flag_strong_eval_order;
int x_flag_switch_errors;
int x_flag_sync_libcalls;
int x_flag_syntax_only;
int x_flag_tail_call_workaround;
int x_template_backtrace_limit;
int x_flag_test_coverage;
int x_flag_test_forall_temp;
int x_flag_thread_jumps;
int x_flag_threadsafe_statics;
int x_time_report;
int x_time_report_details;
enum tls_model x_flag_tls_default;
int x_flag_toplevel_reorder;
int x_flag_tracer;
int x_flag_trampolines;
int x_flag_trapping_math;
int x_flag_trapv;
int x_flag_tree_bit_ccp;
int x_flag_tree_builtin_call_dce;
int x_flag_tree_ccp;
int x_flag_tree_ch;
int x_flag_tree_coalesce_vars;
int x_flag_tree_copy_prop;
int x_flag_tree_cselim;
int x_flag_tree_dce;
int x_flag_tree_dom;
int x_flag_tree_dse;
int x_flag_tree_forwprop;
int x_flag_tree_fre;
int x_flag_tree_loop_distribute_patterns;
int x_flag_tree_loop_distribution;
int x_flag_tree_loop_if_convert;
int x_flag_tree_loop_im;
int x_flag_tree_loop_ivcanon;
int x_flag_tree_loop_optimize;
int x_flag_tree_loop_vectorize;
int x_flag_tree_live_range_split;
int x_flag_tree_parallelize_loops;
int x_flag_tree_partial_pre;
int x_flag_tree_phiprop;
int x_flag_tree_pre;
int x_flag_tree_pta;
int x_flag_tree_reassoc;
int x_flag_tree_scev_cprop;
int x_flag_tree_sink;
int x_flag_tree_slp_vectorize;
int x_flag_tree_slsr;
int x_flag_tree_sra;
int x_flag_tree_switch_conversion;
int x_flag_tree_tail_merge;
int x_flag_tree_ter;
int x_flag_tree_vrp;
int x_flag_unconstrained_commons;
int x_flag_underscoring;
int x_flag_unit_at_a_time;
int x_flag_unroll_all_loops;
int x_flag_cunroll_grow_size;
int x_flag_unroll_loops;
int x_flag_unsafe_math_optimizations;
int x_flag_unswitch_loops;
int x_flag_unwind_tables;
int x_flag_use_cxa_atexit;
int x_flag_use_cxa_get_exception_ptr;
int x_flag_use_linker_plugin;
int x_flag_var_tracking;
int x_flag_var_tracking_assignments;
int x_flag_var_tracking_assignments_toggle;
int x_flag_var_tracking_uninit;
int x_flag_variable_expansion_in_unroller;
enum vect_cost_model x_flag_vect_cost_model;
int x_flag_verbose_asm;
int x_flag_version_loops_for_strides;
int x_flag_visibility_ms_compat;
enum symbol_visibility x_default_visibility;
int x_flag_value_profile_transformations;
enum vtv_priority x_flag_vtable_verify;
int x_flag_vtv_counts;
int x_flag_vtv_debug;
int x_flag_weak;
int x_flag_web;
int x_flag_whole_program;
int x_flag_working_directory;
const char *x_flag_wpa;
int x_flag_wrapv;
int x_flag_wrapv_pointer;
int x_flag_zero_initialized_in_bss;
int x_flag_zero_link;
int x_dwarf2out_as_loc_support;
int x_dwarf2out_as_locview_support;
int x_debug_column_info;
int x_flag_describe_dies;
int x_dwarf_version;
int x_flag_gen_declaration;
int x_debug_generate_pub_sections;
int x_flag_lto_gimple_stats;
int x_debug_inline_points;
int x_debug_internal_reset_location_views;
int x_dwarf_record_gcc_switches;
int x_dwarf_split_debug_info;
int x_debug_nonbind_markers_p;
int x_dwarf_strict;
int x_flag_gtoggle;
int x_debug_variable_location_views;
int x_flag_lto_dump_tool_help;
const char *x_imultiarch;
const char *x_plugindir_string;
int x_flag_lto_dump_list;
enum calling_abi x_ix86_abi;
enum pmode x_ix86_pmode;
enum ix86_align_data x_ix86_align_data_type;
int x_flag_android;
const char *x_ix86_arch_string;
enum asm_dialect x_ix86_asm_dialect;
int x_linux_libc;
int x_ix86_branch_cost;
int x_flag_cet_switch;
enum cmodel x_ix86_cmodel;
int x_flag_dispatch_scheduler;
int x_ix86_dump_tunes;
int x_flag_fentry;
const char *x_fentry_name;
const char *x_fentry_section;
int x_ix86_force_drap;
int x_flag_force_indirect_call;
enum fpmath_unit x_ix86_fpmath;
enum indirect_branch x_ix86_function_return;
int x_ix86_incoming_stack_boundary_arg;
int x_ix86_indirect_branch_register;
enum indirect_branch x_ix86_indirect_branch;
enum instrument_return x_ix86_instrument_return;
int x_ix86_section_threshold;
int x_flag_manual_endbr;
const char *x_ix86_tune_memcpy_strategy;
const char *x_ix86_tune_memset_strategy;
int x_ix86_tune_no_default;
int x_flag_nop_mcount;
enum prefer_vector_width x_prefer_vector_width_type;
int x_ix86_preferred_stack_boundary_arg;
const char *x_ix86_recip_name;
int x_flag_record_mcount;
int x_ix86_flag_record_return;
int x_ix86_regparm;
int x_flag_skip_rax_setup;
int x_ix86_sse2avx;
const char *x_ix86_stack_protector_guard_offset_str;
const char *x_ix86_stack_protector_guard_reg_str;
const char *x_ix86_stack_protector_guard_symbol_str;
enum stack_protector_guard x_ix86_stack_protector_guard;
int x_ix86_force_align_arg_pointer;
enum stringop_alg x_ix86_stringop_alg;
enum tls_dialect x_ix86_tls_dialect;
const char *x_ix86_tune_ctrl_string;
const char *x_ix86_tune_string;
enum ix86_veclibabi x_ix86_veclibabi_type;
int x_flag_lto_name_sort;
const char *x_asm_file_name;
int x_flag_lto_dump_objects;
int x_pass_exit_codes;
int x_flag_pedantic_errors;
int x_use_pipes;
const char *x_print_file_name;
int x_print_multi_directory;
int x_print_multi_lib;
int x_print_multi_os_directory;
int x_print_multiarch;
const char *x_print_prog_name;
int x_print_search_dirs;
int x_print_sysroot;
int x_print_sysroot_headers_suffix;
int x_flag_lto_print_value;
int x_quiet_flag;
int x_flag_lto_reverse_sort;
int x_flag_lto_size_sort;
const char *x_flag_lto_dump_symbol;
int x_report_times;
int x_flag_lto_tree_stats;
int x_flag_lto_dump_type_stats;
int x_flag_undef;
int x_verbose_flag;
int x_version_flag;
int x_inhibit_warnings;
const char *x_wrapper_string;
int x_VAR_malign_functions_;
int x_VAR_malign_jumps_;
int x_VAR_malign_loops_;
int x_VAR_mmitigate_rop;
int x_VAR_mmpx;
int x_VAR_mpc32;
int x_VAR_mpc64;
int x_VAR_mpc80;
int x_VAR_mpcommit;
bool frontend_set_flag_associative_math;
bool frontend_set_flag_cx_limited_range;
bool frontend_set_flag_excess_precision;
bool frontend_set_flag_finite_math_only;
bool frontend_set_flag_errno_math;
bool frontend_set_flag_reciprocal_math;
bool frontend_set_flag_rounding_math;
bool frontend_set_flag_signaling_nans;
bool frontend_set_flag_signed_zeros;
bool frontend_set_flag_trapping_math;
bool frontend_set_flag_unsafe_math_optimizations;
};
extern struct gcc_options global_options;
extern const struct gcc_options global_options_init;
extern struct gcc_options global_options_set;
struct cl_optimization
{
const char *x_str_align_functions;
const char *x_str_align_jumps;
const char *x_str_align_labels;
const char *x_str_align_loops;
int x_param_align_loop_iterations;
int x_param_align_threshold;
int x_param_asan_protect_allocas;
int x_param_asan_instrument_reads;
int x_param_asan_instrument_writes;
int x_param_asan_instrumentation_with_call_threshold;
int x_param_asan_memintrin;
int x_param_asan_stack;
int x_param_asan_use_after_return;
int x_param_avg_loop_niter;
int x_param_avoid_fma_max_bits;
int x_param_builtin_expect_probability;
int x_param_builtin_string_cmp_inline_length;
int x_param_case_values_threshold;
int x_param_comdat_sharing_probability;
int x_param_dse_max_alias_queries_per_store;
int x_param_dse_max_object_size;
int x_param_early_inlining_insns;
int x_param_fsm_maximum_phi_arguments;
int x_param_fsm_scale_path_blocks;
int x_param_fsm_scale_path_stmts;
int x_param_gcse_after_reload_critical_fraction;
int x_param_gcse_after_reload_partial_fraction;
int x_param_gcse_cost_distance_ratio;
int x_param_gcse_unrestricted_cost;
int x_param_graphite_max_arrays_per_scop;
int x_param_graphite_max_nb_scop_params;
int x_param_inline_heuristics_hint_percent;
int x_param_inline_min_speedup;
int x_param_inline_unit_growth;
int x_param_ipa_cp_eval_threshold;
int x_param_ipa_cp_loop_hint_bonus;
int x_param_ipa_cp_max_recursive_depth;
int x_param_ipa_cp_min_recursive_probability;
int x_param_ipa_cp_recursion_penalty;
int x_param_ipa_cp_single_call_penalty;
int x_param_ipa_cp_unit_growth;
int x_param_ipa_cp_value_list_size;
int x_param_ipa_max_aa_steps;
int x_param_ipa_max_agg_items;
int x_param_ipa_max_param_expr_ops;
int x_param_ipa_max_switch_predicate_bounds;
int x_param_ipa_sra_max_replacements;
int x_param_ipa_sra_ptr_growth_factor;
int x_param_ira_loop_reserved_regs;
int x_param_ira_max_conflict_table_size;
int x_param_ira_max_loops_num;
int x_param_iv_always_prune_cand_set_bound;
int x_param_iv_consider_all_candidates_bound;
int x_param_iv_max_considered_uses;
int x_param_jump_table_max_growth_ratio_for_size;
int x_param_jump_table_max_growth_ratio_for_speed;
int x_param_l1_cache_line_size;
int x_param_l1_cache_size;
int x_param_l2_cache_size;
int x_param_large_function_growth;
int x_param_large_function_insns;
int x_param_stack_frame_growth;
int x_param_large_stack_frame;
int x_param_large_unit_insns;
int x_param_lim_expensive;
int x_param_loop_block_tile_size;
int x_param_loop_interchange_max_num_stmts;
int x_param_loop_interchange_stride_ratio;
int x_param_loop_invariant_max_bbs_in_loop;
int x_param_loop_max_datarefs_for_datadeps;
int x_param_loop_versioning_max_inner_insns;
int x_param_loop_versioning_max_outer_insns;
int x_param_lra_inheritance_ebb_probability_cutoff;
int x_param_lra_max_considered_reload_pseudos;
int x_param_max_average_unrolled_insns;
int x_param_max_combine_insns;
int x_param_max_unroll_iterations;
int x_param_max_completely_peel_times;
int x_param_max_completely_peeled_insns;
int x_param_max_crossjump_edges;
int x_param_max_cse_insns;
int x_param_max_cse_path_length;
int x_param_max_cselib_memory_locations;
int x_param_max_debug_marker_count;
int x_param_max_delay_slot_insn_search;
int x_param_max_delay_slot_live_search;
int x_param_max_dse_active_local_stores;
int x_param_early_inliner_max_iterations;
int x_param_max_find_base_term_values;
int x_param_max_fsm_thread_length;
int x_param_max_fsm_thread_path_insns;
int x_param_max_fsm_thread_paths;
int x_param_max_gcse_insertion_ratio;
int x_param_max_gcse_memory;
int x_param_max_goto_duplication_insns;
int x_param_max_grow_copy_bb_insns;
int x_param_max_hoist_depth;
int x_param_max_inline_insns_auto;
int x_param_max_inline_insns_recursive_auto;
int x_param_max_inline_insns_recursive;
int x_param_max_inline_insns_single;
int x_param_max_inline_insns_size;
int x_param_max_inline_insns_small;
int x_param_max_inline_recursive_depth_auto;
int x_param_max_inline_recursive_depth;
int x_param_max_isl_operations;
int x_param_max_iterations_computation_cost;
int x_param_max_iterations_to_track;
int x_param_max_jump_thread_duplication_stmts;
int x_param_max_last_value_rtl;
int x_param_max_loop_header_insns;
int x_param_max_modulo_backtrack_attempts;
int x_param_max_partial_antic_length;
int x_param_max_peel_branches;
int x_param_max_peel_times;
int x_param_max_peeled_insns;
int x_param_max_pending_list_length;
int x_param_max_pipeline_region_blocks;
int x_param_max_pipeline_region_insns;
int x_param_max_pow_sqrt_depth;
int x_param_max_predicted_iterations;
int x_param_max_reload_search_insns;
int x_param_max_rtl_if_conversion_insns;
int x_param_max_rtl_if_conversion_predictable_cost;
int x_param_max_rtl_if_conversion_unpredictable_cost;
int x_param_max_sched_extend_regions_iters;
int x_param_max_sched_insn_conflict_delay;
int x_param_max_sched_ready_insns;
int x_param_max_sched_region_blocks;
int x_param_max_sched_region_insns;
int x_param_max_slsr_candidate_scan;
int x_param_max_speculative_devirt_maydefs;
int x_param_max_stores_to_merge;
int x_param_max_stores_to_sink;
int x_param_max_tail_merge_comparisons;
int x_param_max_tail_merge_iterations;
int x_param_max_tracked_strlens;
int x_param_max_tree_if_conversion_phi_args;
int x_param_max_unroll_times;
int x_param_max_unrolled_insns;
int x_param_max_unswitch_insns;
int x_param_max_unswitch_level;
int x_param_max_variable_expansions;
int x_param_max_vartrack_expr_depth;
int x_param_max_vartrack_reverse_op_size;
int x_param_max_vartrack_size;
int x_param_max_vrp_switch_assertions;
int x_param_min_crossjump_insns;
int x_param_min_inline_recursive_probability;
int x_param_min_insn_to_prefetch_ratio;
int x_param_min_loop_cond_split_prob;
int x_param_min_size_for_stack_sharing;
int x_param_min_spec_prob;
int x_param_min_vect_loop_bound;
int x_param_parloops_chunk_size;
int x_param_parloops_min_per_thread;
int x_param_parloops_schedule;
int x_param_partial_inlining_entry_probability;
int x_param_predictable_branch_outcome;
int x_param_prefetch_dynamic_strides;
int x_param_prefetch_latency;
int x_param_prefetch_min_insn_to_mem_ratio;
int x_param_prefetch_minimum_stride;
int x_param_rpo_vn_max_loop_depth;
int x_param_sccvn_max_alias_queries_per_access;
int x_param_scev_max_expr_complexity;
int x_param_scev_max_expr_size;
int x_param_sched_autopref_queue_depth;
int x_param_sched_mem_true_dep_cost;
int x_param_sched_pressure_algorithm;
int x_param_sched_spec_prob_cutoff;
int x_param_sched_state_edge_prob_cutoff;
int x_param_selsched_insns_to_rename;
int x_param_selsched_max_lookahead;
int x_param_selsched_max_sched_times;
int x_param_simultaneous_prefetches;
int x_param_sink_frequency_threshold;
int x_param_slp_max_insns_in_bb;
int x_param_sms_dfa_history;
int x_param_sms_loop_average_count_threshold;
int x_param_sms_max_ii_factor;
int x_param_sms_min_sc;
int x_param_sra_max_propagations;
int x_param_sra_max_scalarization_size_size;
int x_param_sra_max_scalarization_size_speed;
int x_param_ssa_name_def_chain_limit;
int x_param_ssp_buffer_size;
int x_param_stack_clash_protection_guard_size;
int x_param_stack_clash_protection_probe_interval;
int x_param_store_merging_allow_unaligned;
int x_param_store_merging_max_size;
int x_param_switch_conversion_branch_ratio;
int x_param_tm_max_aggregate_size;
int x_param_tracer_dynamic_coverage_feedback;
int x_param_tracer_dynamic_coverage;
int x_param_tracer_max_code_growth;
int x_param_tracer_min_branch_probability_feedback;
int x_param_tracer_min_branch_probability;
int x_param_tracer_min_branch_ratio;
int x_param_tree_reassoc_width;
int x_param_uninit_control_dep_attempts;
int x_param_uninlined_function_insns;
int x_param_uninlined_function_time;
int x_param_uninlined_function_thunk_insns;
int x_param_uninlined_function_thunk_time;
int x_param_unlikely_bb_count_fraction;
int x_param_unroll_jam_max_unroll;
int x_param_unroll_jam_min_percent;
int x_param_use_after_scope_direct_emission_threshold;
int x_param_vect_epilogues_nomask;
int x_param_vect_max_peeling_for_alignment;
int x_param_vect_max_version_for_alias_checks;
int x_param_vect_max_version_for_alignment_checks;
int x_param_vect_partial_vector_usage;
int x_flag_sched_stalled_insns;
int x_flag_sched_stalled_insns_dep;
int x_flag_tree_parallelize_loops;
enum excess_precision x_flag_excess_precision;
enum fp_contract_mode x_flag_fp_contract_mode;
enum ira_algorithm x_flag_ira_algorithm;
enum ira_region x_flag_ira_region;
enum live_patching_level x_flag_live_patching;
enum reorder_blocks_algorithm x_flag_reorder_blocks_algorithm;
enum vect_cost_model x_flag_simd_cost_model;
enum stack_reuse_level x_flag_stack_reuse;
enum vect_cost_model x_flag_vect_cost_model;
unsigned char x_optimize;
unsigned char x_optimize_size;
unsigned char x_optimize_debug;
unsigned char x_optimize_fast;
signed char x_warn_inline;
signed char x_flag_aggressive_loop_optimizations;
signed char x_flag_align_functions;
signed char x_flag_align_jumps;
signed char x_flag_align_labels;
signed char x_flag_align_loops;
signed char x_flag_allocation_dce;
signed char x_flag_store_data_races;
signed char x_flag_associative_math;
signed char x_flag_assume_phsa;
signed char x_flag_asynchronous_unwind_tables;
signed char x_flag_auto_inc_dec;
signed char x_flag_branch_on_count_reg;
signed char x_flag_branch_probabilities;
signed char x_flag_caller_saves;
signed char x_flag_code_hoisting;
signed char x_flag_combine_stack_adjustments;
signed char x_flag_compare_elim_after_reload;
signed char x_flag_conserve_stack;
signed char x_flag_cprop_registers;
signed char x_flag_crossjumping;
signed char x_flag_cse_follow_jumps;
signed char x_flag_cx_fortran_rules;
signed char x_flag_cx_limited_range;
signed char x_flag_dce;
signed char x_flag_defer_pop;
signed char x_flag_delayed_branch;
signed char x_flag_delete_dead_exceptions;
signed char x_flag_delete_null_pointer_checks;
signed char x_flag_devirtualize;
signed char x_flag_devirtualize_speculatively;
signed char x_flag_dse;
signed char x_flag_early_inlining;
signed char x_flag_exceptions;
signed char x_flag_expensive_optimizations;
signed char x_flag_finite_loops;
signed char x_flag_finite_math_only;
signed char x_flag_float_store;
signed char x_flag_forward_propagate;
signed char x_flag_fp_int_builtin_inexact;
signed char x_flag_no_function_cse;
signed char x_flag_gcse;
signed char x_flag_gcse_after_reload;
signed char x_flag_gcse_las;
signed char x_flag_gcse_lm;
signed char x_flag_gcse_sm;
signed char x_flag_graphite;
signed char x_flag_graphite_identity;
signed char x_flag_guess_branch_prob;
signed char x_flag_hoist_adjacent_loads;
signed char x_flag_if_conversion;
signed char x_flag_if_conversion2;
signed char x_flag_indirect_inlining;
signed char x_flag_no_inline;
signed char x_flag_inline_atomics;
signed char x_flag_inline_functions;
signed char x_flag_inline_functions_called_once;
signed char x_flag_inline_small_functions;
signed char x_flag_ipa_bit_cp;
signed char x_flag_ipa_cp;
signed char x_flag_ipa_cp_clone;
signed char x_flag_ipa_icf;
signed char x_flag_ipa_icf_functions;
signed char x_flag_ipa_icf_variables;
signed char x_flag_ipa_profile;
signed char x_flag_ipa_pta;
signed char x_flag_ipa_pure_const;
signed char x_flag_ipa_ra;
signed char x_flag_ipa_reference;
signed char x_flag_ipa_reference_addressable;
signed char x_flag_ipa_sra;
signed char x_flag_ipa_stack_alignment;
signed char x_flag_ipa_vrp;
signed char x_flag_ira_hoist_pressure;
signed char x_flag_ira_loop_pressure;
signed char x_flag_ira_share_save_slots;
signed char x_flag_ira_share_spill_slots;
signed char x_flag_isolate_erroneous_paths_attribute;
signed char x_flag_isolate_erroneous_paths_dereference;
signed char x_flag_ivopts;
signed char x_flag_jump_tables;
signed char x_flag_keep_gc_roots_live;
signed char x_flag_lifetime_dse;
signed char x_flag_limit_function_alignment;
signed char x_flag_live_range_shrinkage;
signed char x_flag_loop_interchange;
signed char x_flag_loop_nest_optimize;
signed char x_flag_loop_parallelize_all;
signed char x_flag_unroll_jam;
signed char x_flag_lra_remat;
signed char x_flag_errno_math;
signed char x_flag_modulo_sched;
signed char x_flag_modulo_sched_allow_regmoves;
signed char x_flag_move_loop_invariants;
signed char x_flag_non_call_exceptions;
signed char x_flag_nothrow_opt;
signed char x_flag_omit_frame_pointer;
signed char x_flag_opt_info;
signed char x_flag_optimize_sibling_calls;
signed char x_flag_optimize_strlen;
signed char x_flag_pack_struct;
signed char x_flag_partial_inlining;
signed char x_flag_peel_loops;
signed char x_flag_no_peephole;
signed char x_flag_peephole2;
signed char x_flag_plt;
signed char x_flag_predictive_commoning;
signed char x_flag_prefetch_loop_arrays;
signed char x_flag_printf_return_value;
signed char x_flag_profile_partial_training;
signed char x_flag_profile_reorder_functions;
signed char x_flag_reciprocal_math;
signed char x_flag_ree;
signed char x_flag_pcc_struct_return;
signed char x_flag_rename_registers;
signed char x_flag_reorder_blocks;
signed char x_flag_reorder_blocks_and_partition;
signed char x_flag_reorder_functions;
signed char x_flag_rerun_cse_after_loop;
signed char x_flag_resched_modulo_sched;
signed char x_flag_rounding_math;
signed char x_flag_rtti;
signed char x_flag_save_optimization_record;
signed char x_flag_sched_critical_path_heuristic;
signed char x_flag_sched_dep_count_heuristic;
signed char x_flag_sched_group_heuristic;
signed char x_flag_schedule_interblock;
signed char x_flag_sched_last_insn_heuristic;
signed char x_flag_sched_pressure;
signed char x_flag_sched_rank_heuristic;
signed char x_flag_schedule_speculative;
signed char x_flag_sched_spec_insn_heuristic;
signed char x_flag_schedule_speculative_load;
signed char x_flag_schedule_speculative_load_dangerous;
signed char x_flag_sched2_use_superblocks;
signed char x_flag_schedule_fusion;
signed char x_flag_schedule_insns;
signed char x_flag_schedule_insns_after_reload;
signed char x_flag_section_anchors;
signed char x_flag_sel_sched_pipelining;
signed char x_flag_sel_sched_pipelining_outer_loops;
signed char x_flag_sel_sched_reschedule_pipelined;
signed char x_flag_selective_scheduling;
signed char x_flag_selective_scheduling2;
signed char x_flag_short_enums;
signed char x_flag_short_wchar;
signed char x_flag_shrink_wrap;
signed char x_flag_shrink_wrap_separate;
signed char x_flag_signaling_nans;
signed char x_flag_signed_zeros;
signed char x_flag_single_precision_constant;
signed char x_flag_split_ivs_in_unroller;
signed char x_flag_split_loops;
signed char x_flag_split_paths;
signed char x_flag_split_wide_types;
signed char x_flag_split_wide_types_early;
signed char x_flag_ssa_backprop;
signed char x_flag_ssa_phiopt;
signed char x_flag_stack_clash_protection;
signed char x_flag_stack_protect;
signed char x_flag_stdarg_opt;
signed char x_flag_store_merging;
signed char x_flag_strict_aliasing;
signed char x_flag_strict_enums;
signed char x_flag_strict_volatile_bitfields;
signed char x_flag_thread_jumps;
signed char x_flag_threadsafe_statics;
signed char x_flag_toplevel_reorder;
signed char x_flag_tracer;
signed char x_flag_trapping_math;
signed char x_flag_trapv;
signed char x_flag_tree_bit_ccp;
signed char x_flag_tree_builtin_call_dce;
signed char x_flag_tree_ccp;
signed char x_flag_tree_ch;
signed char x_flag_tree_coalesce_vars;
signed char x_flag_tree_copy_prop;
signed char x_flag_tree_cselim;
signed char x_flag_tree_dce;
signed char x_flag_tree_dom;
signed char x_flag_tree_dse;
signed char x_flag_tree_forwprop;
signed char x_flag_tree_fre;
signed char x_flag_tree_loop_distribute_patterns;
signed char x_flag_tree_loop_distribution;
signed char x_flag_tree_loop_if_convert;
signed char x_flag_tree_loop_im;
signed char x_flag_tree_loop_ivcanon;
signed char x_flag_tree_loop_optimize;
signed char x_flag_tree_loop_vectorize;
signed char x_flag_tree_live_range_split;
signed char x_flag_tree_partial_pre;
signed char x_flag_tree_phiprop;
signed char x_flag_tree_pre;
signed char x_flag_tree_pta;
signed char x_flag_tree_reassoc;
signed char x_flag_tree_scev_cprop;
signed char x_flag_tree_sink;
signed char x_flag_tree_slp_vectorize;
signed char x_flag_tree_slsr;
signed char x_flag_tree_sra;
signed char x_flag_tree_switch_conversion;
signed char x_flag_tree_tail_merge;
signed char x_flag_tree_ter;
signed char x_flag_tree_vrp;
signed char x_flag_unconstrained_commons;
signed char x_flag_unroll_all_loops;
signed char x_flag_cunroll_grow_size;
signed char x_flag_unroll_loops;
signed char x_flag_unsafe_math_optimizations;
signed char x_flag_unswitch_loops;
signed char x_flag_unwind_tables;
signed char x_flag_var_tracking;
signed char x_flag_var_tracking_assignments;
signed char x_flag_var_tracking_assignments_toggle;
signed char x_flag_var_tracking_uninit;
signed char x_flag_variable_expansion_in_unroller;
signed char x_flag_version_loops_for_strides;
signed char x_flag_value_profile_transformations;
signed char x_flag_web;
signed char x_flag_wrapv;
signed char x_flag_wrapv_pointer;
};
struct cl_target_option
{
long x_ix86_isa_flags2_explicit;
long x_ix86_isa_flags_explicit;
const char *x_ix86_arch_string;
const char *x_ix86_recip_name;
const char *x_ix86_tune_ctrl_string;
const char *x_ix86_tune_memcpy_strategy;
const char *x_ix86_tune_memset_strategy;
const char *x_ix86_tune_string;
long x_ix86_stack_protector_guard_offset;
addr_space_t x_ix86_stack_protector_guard_reg;
int x_target_flags;
long x_ix86_isa_flags;
long x_ix86_isa_flags2;
enum fpmath_unit x_ix86_fpmath;
int x_ix86_target_flags;
enum prefer_vector_width x_prefer_vector_width_type;
enum asm_dialect x_ix86_asm_dialect;
enum calling_abi x_ix86_abi;
enum cmodel x_ix86_cmodel;
enum ix86_veclibabi x_ix86_veclibabi_type;
enum pmode x_ix86_pmode;
enum stack_protector_guard x_ix86_stack_protector_guard;
enum stringop_alg x_ix86_stringop_alg;
enum tls_dialect x_ix86_tls_dialect;
int x_ix86_branch_cost;
int x_ix86_dump_tunes;
int x_ix86_force_align_arg_pointer;
int x_ix86_force_drap;
int x_ix86_incoming_stack_boundary_arg;
int x_ix86_preferred_stack_boundary_arg;
int x_ix86_regparm;
int x_ix86_section_threshold;
int x_ix86_sse2avx;
int x_ix86_tune_no_default;
int x_recip_mask_explicit;
int x_recip_mask;
unsigned char arch;
unsigned char arch_specified;
unsigned char branch_cost;
unsigned char prefetch_sse;
unsigned char schedule;
unsigned char tune;
unsigned char tune_defaulted;
};
extern void cl_optimization_save (struct cl_optimization *, struct gcc_options *);
extern void cl_optimization_restore (struct gcc_options *, struct cl_optimization *);
extern void cl_optimization_print (FILE *, int, struct cl_optimization *);
extern void cl_optimization_print_diff (FILE *, int, cl_optimization *ptr1, cl_optimization *ptr2);
extern void cl_target_option_save (struct cl_target_option *, struct gcc_options *);
extern void cl_target_option_restore (struct gcc_options *, struct cl_target_option *);
extern void cl_target_option_print (FILE *, int, struct cl_target_option *);
extern void cl_target_option_print_diff (FILE *, int, cl_target_option *ptr1, cl_target_option *ptr2);
extern bool cl_target_option_eq (const struct cl_target_option *, const struct cl_target_option *);
extern void cl_target_option_free (struct cl_target_option *);
extern hashval_t cl_target_option_hash (const struct cl_target_option *);
extern hashval_t cl_optimization_hash (const struct cl_optimization *);
extern bool cl_optimization_option_eq (cl_optimization const *ptr1, cl_optimization const *ptr2);
extern void cl_optimization_option_free (cl_optimization *ptr1);
extern void cl_optimization_compare (gcc_options *ptr1, gcc_options *ptr2);
bool
common_handle_option_auto (struct gcc_options *opts,
struct gcc_options *opts_set,
const struct cl_decoded_option *decoded,
unsigned int lang_mask, int kind,
location_t loc,
const struct cl_option_handlers *handlers,
diagnostic_context *dc);
bool
Ada_handle_option_auto (struct gcc_options *opts,
struct gcc_options *opts_set,
size_t scode, const char *arg,
long value,
unsigned int lang_mask, int kind,
location_t loc,
const struct cl_option_handlers *handlers,
diagnostic_context *dc);
bool
AdaSCIL_handle_option_auto (struct gcc_options *opts,
struct gcc_options *opts_set,
size_t scode, const char *arg,
long value,
unsigned int lang_mask, int kind,
location_t loc,
const struct cl_option_handlers *handlers,
diagnostic_context *dc);
bool
AdaWhy_handle_option_auto (struct gcc_options *opts,
struct gcc_options *opts_set,
size_t scode, const char *arg,
long value,
unsigned int lang_mask, int kind,
location_t loc,
const struct cl_option_handlers *handlers,
diagnostic_context *dc);
bool
BRIG_handle_option_auto (struct gcc_options *opts,
struct gcc_options *opts_set,
size_t scode, const char *arg,
long value,
unsigned int lang_mask, int kind,
location_t loc,
const struct cl_option_handlers *handlers,
diagnostic_context *dc);
bool
C_handle_option_auto (struct gcc_options *opts,
struct gcc_options *opts_set,
size_t scode, const char *arg,
long value,
unsigned int lang_mask, int kind,
location_t loc,
const struct cl_option_handlers *handlers,
diagnostic_context *dc);
bool
CXX_handle_option_auto (struct gcc_options *opts,
struct gcc_options *opts_set,
size_t scode, const char *arg,
long value,
unsigned int lang_mask, int kind,
location_t loc,
const struct cl_option_handlers *handlers,
diagnostic_context *dc);
bool
D_handle_option_auto (struct gcc_options *opts,
struct gcc_options *opts_set,
size_t scode, const char *arg,
long value,
unsigned int lang_mask, int kind,
location_t loc,
const struct cl_option_handlers *handlers,
diagnostic_context *dc);
bool
Fortran_handle_option_auto (struct gcc_options *opts,
struct gcc_options *opts_set,
size_t scode, const char *arg,
long value,
unsigned int lang_mask, int kind,
location_t loc,
const struct cl_option_handlers *handlers,
diagnostic_context *dc);
bool
Go_handle_option_auto (struct gcc_options *opts,
struct gcc_options *opts_set,
size_t scode, const char *arg,
long value,
unsigned int lang_mask, int kind,
location_t loc,
const struct cl_option_handlers *handlers,
diagnostic_context *dc);
bool
LTO_handle_option_auto (struct gcc_options *opts,
struct gcc_options *opts_set,
size_t scode, const char *arg,
long value,
unsigned int lang_mask, int kind,
location_t loc,
const struct cl_option_handlers *handlers,
diagnostic_context *dc);
bool
LTODump_handle_option_auto (struct gcc_options *opts,
struct gcc_options *opts_set,
size_t scode, const char *arg,
long value,
unsigned int lang_mask, int kind,
location_t loc,
const struct cl_option_handlers *handlers,
diagnostic_context *dc);
bool
ObjC_handle_option_auto (struct gcc_options *opts,
struct gcc_options *opts_set,
size_t scode, const char *arg,
long value,
unsigned int lang_mask, int kind,
location_t loc,
const struct cl_option_handlers *handlers,
diagnostic_context *dc);
bool
ObjCXX_handle_option_auto (struct gcc_options *opts,
struct gcc_options *opts_set,
size_t scode, const char *arg,
long value,
unsigned int lang_mask, int kind,
location_t loc,
const struct cl_option_handlers *handlers,
diagnostic_context *dc);
void cpp_handle_option_auto (const struct gcc_options * opts, size_t scode,
struct cpp_options * cpp_opts);
void init_global_opts_from_cpp(struct gcc_options * opts,
const struct cpp_options * cpp_opts);
# 8579 "./options.h"
enum opt_code
{
OPT____ = 0,
# 8590 "./options.h"
OPT__completion_ = 9,
# 8610 "./options.h"
OPT__help = 29,
OPT__help_ = 30,
# 8638 "./options.h"
OPT__no_sysroot_suffix = 57,
OPT__output_pch_ = 61,
OPT__param_align_loop_iterations_ = 63,
OPT__param_align_threshold_ = 64,
OPT__param_analyzer_bb_explosion_factor_ = 65,
OPT__param_analyzer_max_enodes_for_full_dump_ = 66,
OPT__param_analyzer_max_enodes_per_program_point_ = 67,
OPT__param_analyzer_max_recursion_depth_ = 68,
OPT__param_analyzer_max_svalue_depth_ = 69,
OPT__param_analyzer_min_snodes_for_call_summary_ = 70,
OPT__param_asan_globals_ = 71,
OPT__param_asan_instrument_allocas_ = 72,
OPT__param_asan_instrument_reads_ = 73,
OPT__param_asan_instrument_writes_ = 74,
OPT__param_asan_instrumentation_with_call_threshold_ = 75,
OPT__param_asan_memintrin_ = 76,
OPT__param_asan_stack_ = 77,
OPT__param_asan_use_after_return_ = 78,
OPT__param_avg_loop_niter_ = 79,
OPT__param_avoid_fma_max_bits_ = 80,
OPT__param_balance_partitions_ = 81,
OPT__param_builtin_expect_probability_ = 82,
OPT__param_builtin_string_cmp_inline_length_ = 83,
OPT__param_case_values_threshold_ = 84,
OPT__param_comdat_sharing_probability_ = 85,
OPT__param_cxx_max_namespaces_for_diagnostic_help_ = 86,
OPT__param_dse_max_alias_queries_per_store_ = 87,
OPT__param_dse_max_object_size_ = 88,
OPT__param_early_inlining_insns_ = 89,
OPT__param_fsm_maximum_phi_arguments_ = 90,
OPT__param_fsm_scale_path_blocks_ = 91,
OPT__param_fsm_scale_path_stmts_ = 92,
OPT__param_gcse_after_reload_critical_fraction_ = 93,
OPT__param_gcse_after_reload_partial_fraction_ = 94,
OPT__param_gcse_cost_distance_ratio_ = 95,
OPT__param_gcse_unrestricted_cost_ = 96,
OPT__param_ggc_min_expand_ = 97,
OPT__param_ggc_min_heapsize_ = 98,
OPT__param_gimple_fe_computed_hot_bb_threshold_ = 99,
OPT__param_graphite_allow_codegen_errors_ = 100,
OPT__param_graphite_max_arrays_per_scop_ = 101,
OPT__param_graphite_max_nb_scop_params_ = 102,
OPT__param_hash_table_verification_limit_ = 103,
OPT__param_hot_bb_count_fraction_ = 104,
OPT__param_hot_bb_count_ws_permille_ = 105,
OPT__param_hot_bb_frequency_fraction_ = 106,
OPT__param_inline_heuristics_hint_percent_ = 107,
OPT__param_inline_min_speedup_ = 108,
OPT__param_inline_unit_growth_ = 109,
OPT__param_integer_share_limit_ = 110,
OPT__param_ipa_cp_eval_threshold_ = 111,
OPT__param_ipa_cp_loop_hint_bonus_ = 112,
OPT__param_ipa_cp_max_recursive_depth_ = 113,
OPT__param_ipa_cp_min_recursive_probability_ = 114,
OPT__param_ipa_cp_recursion_penalty_ = 115,
OPT__param_ipa_cp_single_call_penalty_ = 116,
OPT__param_ipa_cp_unit_growth_ = 117,
OPT__param_ipa_cp_value_list_size_ = 118,
OPT__param_ipa_max_aa_steps_ = 119,
OPT__param_ipa_max_agg_items_ = 120,
OPT__param_ipa_max_param_expr_ops_ = 121,
OPT__param_ipa_max_switch_predicate_bounds_ = 122,
OPT__param_ipa_sra_max_replacements_ = 123,
OPT__param_ipa_sra_ptr_growth_factor_ = 124,
OPT__param_ira_loop_reserved_regs_ = 125,
OPT__param_ira_max_conflict_table_size_ = 126,
OPT__param_ira_max_loops_num_ = 127,
OPT__param_iv_always_prune_cand_set_bound_ = 128,
OPT__param_iv_consider_all_candidates_bound_ = 129,
OPT__param_iv_max_considered_uses_ = 130,
OPT__param_jump_table_max_growth_ratio_for_size_ = 131,
OPT__param_jump_table_max_growth_ratio_for_speed_ = 132,
OPT__param_l1_cache_line_size_ = 133,
OPT__param_l1_cache_size_ = 134,
OPT__param_l2_cache_size_ = 135,
OPT__param_large_function_growth_ = 136,
OPT__param_large_function_insns_ = 137,
OPT__param_large_stack_frame_growth_ = 138,
OPT__param_large_stack_frame_ = 139,
OPT__param_large_unit_insns_ = 140,
OPT__param_lim_expensive_ = 141,
OPT__param_logical_op_non_short_circuit_ = 142,
OPT__param_loop_block_tile_size_ = 143,
OPT__param_loop_interchange_max_num_stmts_ = 144,
OPT__param_loop_interchange_stride_ratio_ = 145,
OPT__param_loop_invariant_max_bbs_in_loop_ = 146,
OPT__param_loop_max_datarefs_for_datadeps_ = 147,
OPT__param_loop_versioning_max_inner_insns_ = 148,
OPT__param_loop_versioning_max_outer_insns_ = 149,
OPT__param_lra_inheritance_ebb_probability_cutoff_ = 150,
OPT__param_lra_max_considered_reload_pseudos_ = 151,
OPT__param_lto_max_partition_ = 152,
OPT__param_lto_max_streaming_parallelism_ = 153,
OPT__param_lto_min_partition_ = 154,
OPT__param_lto_partitions_ = 155,
OPT__param_max_average_unrolled_insns_ = 156,
OPT__param_max_combine_insns_ = 157,
OPT__param_max_completely_peel_loop_nest_depth_ = 158,
OPT__param_max_completely_peel_times_ = 159,
OPT__param_max_completely_peeled_insns_ = 160,
OPT__param_max_crossjump_edges_ = 161,
OPT__param_max_cse_insns_ = 162,
OPT__param_max_cse_path_length_ = 163,
OPT__param_max_cselib_memory_locations_ = 164,
OPT__param_max_debug_marker_count_ = 165,
OPT__param_max_delay_slot_insn_search_ = 166,
OPT__param_max_delay_slot_live_search_ = 167,
OPT__param_max_dse_active_local_stores_ = 168,
OPT__param_max_early_inliner_iterations_ = 169,
OPT__param_max_fields_for_field_sensitive_ = 170,
OPT__param_max_find_base_term_values_ = 171,
OPT__param_max_fsm_thread_length_ = 172,
OPT__param_max_fsm_thread_path_insns_ = 173,
OPT__param_max_fsm_thread_paths_ = 174,
OPT__param_max_gcse_insertion_ratio_ = 175,
OPT__param_max_gcse_memory_ = 176,
OPT__param_max_goto_duplication_insns_ = 177,
OPT__param_max_grow_copy_bb_insns_ = 178,
OPT__param_max_hoist_depth_ = 179,
OPT__param_max_inline_insns_auto_ = 180,
OPT__param_max_inline_insns_recursive_auto_ = 181,
OPT__param_max_inline_insns_recursive_ = 182,
OPT__param_max_inline_insns_single_ = 183,
OPT__param_max_inline_insns_size_ = 184,
OPT__param_max_inline_insns_small_ = 185,
OPT__param_max_inline_recursive_depth_auto_ = 186,
OPT__param_max_inline_recursive_depth_ = 187,
OPT__param_max_isl_operations_ = 188,
OPT__param_max_iterations_computation_cost_ = 189,
OPT__param_max_iterations_to_track_ = 190,
OPT__param_max_jump_thread_duplication_stmts_ = 191,
OPT__param_max_last_value_rtl_ = 192,
OPT__param_max_loop_header_insns_ = 193,
OPT__param_max_modulo_backtrack_attempts_ = 194,
OPT__param_max_partial_antic_length_ = 195,
OPT__param_max_peel_branches_ = 196,
OPT__param_max_peel_times_ = 197,
OPT__param_max_peeled_insns_ = 198,
OPT__param_max_pending_list_length_ = 199,
OPT__param_max_pipeline_region_blocks_ = 200,
OPT__param_max_pipeline_region_insns_ = 201,
OPT__param_max_pow_sqrt_depth_ = 202,
OPT__param_max_predicted_iterations_ = 203,
OPT__param_max_reload_search_insns_ = 204,
OPT__param_max_rtl_if_conversion_insns_ = 205,
OPT__param_max_rtl_if_conversion_predictable_cost_ = 206,
OPT__param_max_rtl_if_conversion_unpredictable_cost_ = 207,
OPT__param_max_sched_extend_regions_iters_ = 208,
OPT__param_max_sched_insn_conflict_delay_ = 209,
OPT__param_max_sched_ready_insns_ = 210,
OPT__param_max_sched_region_blocks_ = 211,
OPT__param_max_sched_region_insns_ = 212,
OPT__param_max_slsr_cand_scan_ = 213,
OPT__param_max_speculative_devirt_maydefs_ = 214,
OPT__param_max_ssa_name_query_depth_ = 215,
OPT__param_max_stores_to_merge_ = 216,
OPT__param_max_stores_to_sink_ = 217,
OPT__param_max_tail_merge_comparisons_ = 218,
OPT__param_max_tail_merge_iterations_ = 219,
OPT__param_max_tracked_strlens_ = 220,
OPT__param_max_tree_if_conversion_phi_args_ = 221,
OPT__param_max_unroll_times_ = 222,
OPT__param_max_unrolled_insns_ = 223,
OPT__param_max_unswitch_insns_ = 224,
OPT__param_max_unswitch_level_ = 225,
OPT__param_max_variable_expansions_in_unroller_ = 226,
OPT__param_max_vartrack_expr_depth_ = 227,
OPT__param_max_vartrack_reverse_op_size_ = 228,
OPT__param_max_vartrack_size_ = 229,
OPT__param_max_vrp_switch_assertions_ = 230,
OPT__param_min_crossjump_insns_ = 231,
OPT__param_min_inline_recursive_probability_ = 232,
OPT__param_min_insn_to_prefetch_ratio_ = 233,
OPT__param_min_loop_cond_split_prob_ = 234,
OPT__param_min_nondebug_insn_uid_ = 235,
OPT__param_min_size_for_stack_sharing_ = 236,
OPT__param_min_spec_prob_ = 237,
OPT__param_min_vect_loop_bound_ = 238,
OPT__param_parloops_chunk_size_ = 239,
OPT__param_parloops_min_per_thread_ = 240,
OPT__param_parloops_schedule_ = 241,
OPT__param_partial_inlining_entry_probability_ = 242,
OPT__param_predictable_branch_outcome_ = 243,
OPT__param_prefetch_dynamic_strides_ = 244,
OPT__param_prefetch_latency_ = 245,
OPT__param_prefetch_min_insn_to_mem_ratio_ = 246,
OPT__param_prefetch_minimum_stride_ = 247,
OPT__param_profile_func_internal_id_ = 248,
OPT__param_promote_statics_ = 249,
OPT__param_rpo_vn_max_loop_depth_ = 250,
OPT__param_sccvn_max_alias_queries_per_access_ = 251,
OPT__param_scev_max_expr_complexity_ = 252,
OPT__param_scev_max_expr_size_ = 253,
OPT__param_sched_autopref_queue_depth_ = 254,
OPT__param_sched_mem_true_dep_cost_ = 255,
OPT__param_sched_pressure_algorithm_ = 256,
OPT__param_sched_spec_prob_cutoff_ = 257,
OPT__param_sched_state_edge_prob_cutoff_ = 258,
OPT__param_selsched_insns_to_rename_ = 259,
OPT__param_selsched_max_lookahead_ = 260,
OPT__param_selsched_max_sched_times_ = 261,
OPT__param_simultaneous_prefetches_ = 262,
OPT__param_sink_frequency_threshold_ = 263,
OPT__param_slp_max_insns_in_bb_ = 264,
OPT__param_sms_dfa_history_ = 265,
OPT__param_sms_loop_average_count_threshold_ = 266,
OPT__param_sms_max_ii_factor_ = 267,
OPT__param_sms_min_sc_ = 268,
OPT__param_sra_max_propagations_ = 269,
OPT__param_sra_max_scalarization_size_Osize_ = 270,
OPT__param_sra_max_scalarization_size_Ospeed_ = 271,
OPT__param_ssa_name_def_chain_limit_ = 272,
OPT__param_ssp_buffer_size_ = 273,
OPT__param_stack_clash_protection_guard_size_ = 274,
OPT__param_stack_clash_protection_probe_interval_ = 275,
OPT__param_store_merging_allow_unaligned_ = 276,
OPT__param_store_merging_max_size_ = 277,
OPT__param_switch_conversion_max_branch_ratio_ = 278,
OPT__param_tm_max_aggregate_size_ = 279,
OPT__param_tracer_dynamic_coverage_feedback_ = 280,
OPT__param_tracer_dynamic_coverage_ = 281,
OPT__param_tracer_max_code_growth_ = 282,
OPT__param_tracer_min_branch_probability_feedback_ = 283,
OPT__param_tracer_min_branch_probability_ = 284,
OPT__param_tracer_min_branch_ratio_ = 285,
OPT__param_tree_reassoc_width_ = 286,
OPT__param_tsan_distinguish_volatile_ = 287,
OPT__param_tsan_instrument_func_entry_exit_ = 288,
OPT__param_uninit_control_dep_attempts_ = 289,
OPT__param_uninlined_function_insns_ = 290,
OPT__param_uninlined_function_time_ = 291,
OPT__param_uninlined_thunk_insns_ = 292,
OPT__param_uninlined_thunk_time_ = 293,
OPT__param_unlikely_bb_count_fraction_ = 294,
OPT__param_unroll_jam_max_unroll_ = 295,
OPT__param_unroll_jam_min_percent_ = 296,
OPT__param_use_after_scope_direct_emission_threshold_ = 297,
OPT__param_use_canonical_types_ = 298,
OPT__param_vect_epilogues_nomask_ = 299,
OPT__param_vect_max_peeling_for_alignment_ = 300,
OPT__param_vect_max_version_for_alias_checks_ = 301,
OPT__param_vect_max_version_for_alignment_checks_ = 302,
OPT__param_vect_partial_vector_usage_ = 303,
# 8915 "./options.h"
OPT__sysroot_ = 334,
OPT__target_help = 335,
# 8926 "./options.h"
OPT__version = 345,
OPT_A = 348,
OPT_B = 349,
OPT_C = 350,
OPT_CC = 351,
OPT_D = 352,
OPT_E = 353,
OPT_F = 354,
OPT_H = 355,
OPT_Hd = 356,
OPT_Hf = 357,
OPT_I = 358,
OPT_J = 359,
OPT_L = 360,
OPT_M = 361,
OPT_MD = 362,
OPT_MF = 363,
OPT_MG = 364,
OPT_MM = 365,
OPT_MMD = 366,
OPT_MP = 367,
OPT_MQ = 368,
OPT_MT = 369,
OPT_N = 370,
OPT_O = 371,
OPT_Ofast = 372,
OPT_Og = 373,
OPT_Os = 374,
OPT_P = 375,
OPT_Q = 376,
OPT_Qn = 377,
OPT_Qy = 378,
OPT_R = 379,
OPT_S = 380,
OPT_T = 381,
OPT_Tbss = 382,
OPT_Tbss_ = 383,
OPT_Tdata = 384,
OPT_Tdata_ = 385,
OPT_Ttext = 386,
OPT_Ttext_ = 387,
OPT_U = 388,
OPT_Wa_ = 390,
OPT_Wabi = 391,
OPT_Wabi_tag = 392,
OPT_Wabi_ = 393,
OPT_Wabsolute_value = 394,
OPT_Waddress = 395,
OPT_Waddress_of_packed_member = 396,
OPT_Waggregate_return = 397,
OPT_Waggressive_loop_optimizations = 398,
OPT_Waliasing = 399,
OPT_Walign_commons = 400,
OPT_Waligned_new_ = 402,
OPT_Wall = 403,
OPT_Walloc_size_larger_than_ = 404,
OPT_Walloc_zero = 405,
OPT_Walloca = 406,
OPT_Walloca_larger_than_ = 407,
OPT_Wampersand = 408,
OPT_Wanalyzer_double_fclose = 409,
OPT_Wanalyzer_double_free = 410,
OPT_Wanalyzer_exposure_through_output_file = 411,
OPT_Wanalyzer_file_leak = 412,
OPT_Wanalyzer_free_of_non_heap = 413,
OPT_Wanalyzer_malloc_leak = 414,
OPT_Wanalyzer_null_argument = 415,
OPT_Wanalyzer_null_dereference = 416,
OPT_Wanalyzer_possible_null_argument = 417,
OPT_Wanalyzer_possible_null_dereference = 418,
OPT_Wanalyzer_stale_setjmp_buffer = 419,
OPT_Wanalyzer_tainted_array_index = 420,
OPT_Wanalyzer_too_complex = 421,
OPT_Wanalyzer_unsafe_call_within_signal_handler = 422,
OPT_Wanalyzer_use_after_free = 423,
OPT_Wanalyzer_use_of_pointer_in_stale_stack_frame = 424,
OPT_Wargument_mismatch = 425,
OPT_Warith_conversion = 426,
OPT_Warray_bounds = 427,
OPT_Warray_bounds_ = 428,
OPT_Warray_temporaries = 429,
OPT_Wassign_intercept = 430,
OPT_Wattribute_alias_ = 432,
OPT_Wattribute_warning = 433,
OPT_Wattributes = 434,
OPT_Wbad_function_cast = 435,
OPT_Wbool_compare = 436,
OPT_Wbool_operation = 437,
OPT_Wbuiltin_declaration_mismatch = 438,
OPT_Wbuiltin_macro_redefined = 439,
OPT_Wc___compat = 440,
OPT_Wc__11_compat = 442,
OPT_Wc__14_compat = 443,
OPT_Wc__17_compat = 444,
OPT_Wc__20_compat = 446,
OPT_Wc_binding_type = 448,
OPT_Wc11_c2x_compat = 449,
OPT_Wc90_c99_compat = 450,
OPT_Wc99_c11_compat = 451,
OPT_Wcannot_profile = 452,
OPT_Wcast_align = 453,
OPT_Wcast_align_strict = 454,
OPT_Wcast_function_type = 455,
OPT_Wcast_qual = 456,
OPT_Wcast_result = 457,
OPT_Wcatch_value_ = 459,
OPT_Wchar_subscripts = 460,
OPT_Wcharacter_truncation = 461,
OPT_Wchkp = 462,
OPT_Wclass_conversion = 463,
OPT_Wclass_memaccess = 464,
OPT_Wclobbered = 465,
OPT_Wcomma_subscript = 466,
OPT_Wcomment = 467,
OPT_Wcompare_reals = 469,
OPT_Wconditionally_supported = 470,
OPT_Wconversion = 471,
OPT_Wconversion_extra = 472,
OPT_Wconversion_null = 473,
OPT_Wcoverage_mismatch = 474,
OPT_Wcpp = 475,
OPT_Wctor_dtor_privacy = 476,
OPT_Wdangling_else = 477,
OPT_Wdate_time = 478,
OPT_Wdeclaration_after_statement = 479,
OPT_Wdelete_incomplete = 480,
OPT_Wdelete_non_virtual_dtor = 481,
OPT_Wdeprecated = 482,
OPT_Wdeprecated_copy = 483,
OPT_Wdeprecated_copy_dtor = 484,
OPT_Wdeprecated_declarations = 485,
OPT_Wdesignated_init = 486,
OPT_Wdisabled_optimization = 487,
OPT_Wdiscarded_array_qualifiers = 488,
OPT_Wdiscarded_qualifiers = 489,
OPT_Wdiv_by_zero = 490,
OPT_Wdo_subscript = 491,
OPT_Wdouble_promotion = 492,
OPT_Wduplicate_decl_specifier = 493,
OPT_Wduplicated_branches = 494,
OPT_Wduplicated_cond = 495,
OPT_Weffc__ = 496,
OPT_Wempty_body = 497,
OPT_Wendif_labels = 498,
OPT_Wenum_compare = 499,
OPT_Wenum_conversion = 500,
OPT_Werror = 501,
OPT_Werror_ = 503,
OPT_Wexpansion_to_defined = 504,
OPT_Wextra = 505,
OPT_Wextra_semi = 506,
OPT_Wfatal_errors = 507,
OPT_Wfloat_conversion = 508,
OPT_Wfloat_equal = 509,
OPT_Wformat_contains_nul = 511,
OPT_Wformat_diag = 512,
OPT_Wformat_extra_args = 513,
OPT_Wformat_nonliteral = 514,
OPT_Wformat_overflow_ = 516,
OPT_Wformat_security = 517,
OPT_Wformat_signedness = 518,
OPT_Wformat_truncation_ = 520,
OPT_Wformat_y2k = 521,
OPT_Wformat_zero_length = 522,
OPT_Wformat_ = 523,
OPT_Wframe_address = 524,
OPT_Wframe_larger_than_ = 525,
OPT_Wfree_nonheap_object = 526,
OPT_Wfrontend_loop_interchange = 527,
OPT_Wfunction_elimination = 528,
OPT_Wif_not_aligned = 530,
OPT_Wignored_attributes = 531,
OPT_Wignored_qualifiers = 532,
OPT_Wimplicit = 533,
OPT_Wimplicit_fallthrough_ = 535,
OPT_Wimplicit_function_declaration = 536,
OPT_Wimplicit_int = 537,
OPT_Wimplicit_interface = 538,
OPT_Wimplicit_procedure = 539,
OPT_Winaccessible_base = 541,
OPT_Wincompatible_pointer_types = 542,
OPT_Winherited_variadic_ctor = 543,
OPT_Winit_list_lifetime = 544,
OPT_Winit_self = 545,
OPT_Winline = 546,
OPT_Wint_conversion = 547,
OPT_Wint_in_bool_context = 548,
OPT_Wint_to_pointer_cast = 549,
OPT_Winteger_division = 550,
OPT_Wintrinsic_shadow = 551,
OPT_Wintrinsics_std = 552,
OPT_Winvalid_memory_model = 553,
OPT_Winvalid_offsetof = 554,
OPT_Winvalid_pch = 555,
OPT_Wjump_misses_init = 556,
OPT_Wl_ = 557,
OPT_Wlarger_than_ = 559,
OPT_Wline_truncation = 560,
OPT_Wliteral_suffix = 561,
OPT_Wlogical_not_parentheses = 562,
OPT_Wlogical_op = 563,
OPT_Wlong_long = 564,
OPT_Wlto_type_mismatch = 565,
OPT_Wmain = 566,
OPT_Wmaybe_uninitialized = 567,
OPT_Wmemset_elt_size = 568,
OPT_Wmemset_transposed_args = 569,
OPT_Wmisleading_indentation = 570,
OPT_Wmismatched_tags = 571,
OPT_Wmissing_attributes = 572,
OPT_Wmissing_braces = 573,
OPT_Wmissing_declarations = 574,
OPT_Wmissing_field_initializers = 575,
OPT_Wmissing_include_dirs = 577,
OPT_Wmissing_parameter_type = 579,
OPT_Wmissing_profile = 580,
OPT_Wmissing_prototypes = 581,
OPT_Wmudflap = 582,
OPT_Wmultichar = 583,
OPT_Wmultiple_inheritance = 584,
OPT_Wmultistatement_macros = 585,
OPT_Wnamespaces = 586,
OPT_Wnarrowing = 587,
OPT_Wnested_externs = 588,
OPT_Wnoexcept = 595,
OPT_Wnoexcept_type = 596,
OPT_Wnon_template_friend = 597,
OPT_Wnon_virtual_dtor = 598,
OPT_Wnonnull = 599,
OPT_Wnonnull_compare = 600,
OPT_Wnormalized_ = 602,
OPT_Wnull_dereference = 603,
OPT_Wodr = 604,
OPT_Wold_style_cast = 605,
OPT_Wold_style_declaration = 606,
OPT_Wold_style_definition = 607,
OPT_Wopenmp_simd = 608,
OPT_Woverflow = 609,
OPT_Woverlength_strings = 610,
OPT_Woverloaded_virtual = 611,
OPT_Woverride_init = 612,
OPT_Woverride_init_side_effects = 613,
OPT_Woverwrite_recursive = 614,
OPT_Wp_ = 615,
OPT_Wpacked = 616,
OPT_Wpacked_bitfield_compat = 617,
OPT_Wpacked_not_aligned = 618,
OPT_Wpadded = 619,
OPT_Wparentheses = 620,
OPT_Wpedantic = 621,
OPT_Wpessimizing_move = 622,
OPT_Wplacement_new_ = 624,
OPT_Wpmf_conversions = 625,
OPT_Wpointer_arith = 626,
OPT_Wpointer_compare = 627,
OPT_Wpointer_sign = 628,
OPT_Wpointer_to_int_cast = 629,
OPT_Wpragmas = 630,
OPT_Wprio_ctor_dtor = 631,
OPT_Wproperty_assign_default = 632,
OPT_Wprotocol = 633,
OPT_Wpsabi = 634,
OPT_Wreal_q_constant = 635,
OPT_Wrealloc_lhs = 636,
OPT_Wrealloc_lhs_all = 637,
OPT_Wredundant_decls = 638,
OPT_Wredundant_move = 639,
OPT_Wredundant_tags = 640,
OPT_Wregister = 641,
OPT_Wreorder = 642,
OPT_Wrestrict = 643,
OPT_Wreturn_local_addr = 644,
OPT_Wreturn_type = 645,
OPT_Wscalar_storage_order = 646,
OPT_Wselector = 647,
OPT_Wsequence_point = 648,
OPT_Wshadow = 649,
OPT_Wshadow_ivar = 651,
OPT_Wshadow_compatible_local = 653,
OPT_Wshadow_local = 655,
OPT_Wshift_count_negative = 656,
OPT_Wshift_count_overflow = 657,
OPT_Wshift_negative_value = 658,
OPT_Wshift_overflow_ = 660,
OPT_Wsign_compare = 661,
OPT_Wsign_conversion = 662,
OPT_Wsign_promo = 663,
OPT_Wsized_deallocation = 664,
OPT_Wsizeof_array_argument = 665,
OPT_Wsizeof_pointer_div = 666,
OPT_Wsizeof_pointer_memaccess = 667,
OPT_Wspeculative = 668,
OPT_Wstack_protector = 669,
OPT_Wstack_usage_ = 670,
OPT_Wstrict_aliasing = 671,
OPT_Wstrict_aliasing_ = 672,
OPT_Wstrict_null_sentinel = 673,
OPT_Wstrict_overflow = 674,
OPT_Wstrict_overflow_ = 675,
OPT_Wstrict_prototypes = 676,
OPT_Wstrict_selector_match = 677,
OPT_Wstring_compare = 678,
OPT_Wstringop_overflow_ = 680,
OPT_Wstringop_truncation = 681,
OPT_Wsubobject_linkage = 682,
OPT_Wsuggest_attribute_cold = 683,
OPT_Wsuggest_attribute_const = 684,
OPT_Wsuggest_attribute_format = 685,
OPT_Wsuggest_attribute_malloc = 686,
OPT_Wsuggest_attribute_noreturn = 687,
OPT_Wsuggest_attribute_pure = 688,
OPT_Wsuggest_final_methods = 689,
OPT_Wsuggest_final_types = 690,
OPT_Wsuggest_override = 691,
OPT_Wsurprising = 692,
OPT_Wswitch = 693,
OPT_Wswitch_bool = 694,
OPT_Wswitch_default = 695,
OPT_Wswitch_enum = 696,
OPT_Wswitch_outside_range = 697,
OPT_Wswitch_unreachable = 698,
OPT_Wsync_nand = 699,
OPT_Wsynth = 700,
OPT_Wsystem_headers = 701,
OPT_Wtabs = 702,
OPT_Wtarget_lifetime = 703,
OPT_Wtautological_compare = 704,
OPT_Wtemplates = 705,
OPT_Wterminate = 706,
OPT_Wtraditional = 707,
OPT_Wtraditional_conversion = 708,
OPT_Wtrampolines = 709,
OPT_Wtrigraphs = 710,
OPT_Wtype_limits = 711,
OPT_Wundeclared_selector = 712,
OPT_Wundef = 713,
OPT_Wundefined_do_loop = 714,
OPT_Wunderflow = 715,
OPT_Wuninitialized = 716,
OPT_Wunknown_pragmas = 717,
OPT_Wunsuffixed_float_constants = 720,
OPT_Wunused = 721,
OPT_Wunused_but_set_parameter = 722,
OPT_Wunused_but_set_variable = 723,
OPT_Wunused_const_variable_ = 725,
OPT_Wunused_dummy_argument = 726,
OPT_Wunused_function = 727,
OPT_Wunused_label = 728,
OPT_Wunused_local_typedefs = 729,
OPT_Wunused_macros = 730,
OPT_Wunused_parameter = 731,
OPT_Wunused_result = 732,
OPT_Wunused_value = 733,
OPT_Wunused_variable = 734,
OPT_Wuse_without_only = 735,
OPT_Wuseless_cast = 736,
OPT_Wvarargs = 737,
OPT_Wvariadic_macros = 738,
OPT_Wvector_operation_performance = 739,
OPT_Wvirtual_inheritance = 740,
OPT_Wvirtual_move_assign = 741,
OPT_Wvla = 742,
OPT_Wvla_larger_than_ = 743,
OPT_Wvolatile = 744,
OPT_Wvolatile_register_var = 745,
OPT_Wwrite_strings = 746,
OPT_Wzero_as_null_pointer_constant = 747,
OPT_Wzero_length_bounds = 748,
OPT_Wzerotrip = 749,
OPT_X = 750,
OPT_Xassembler = 751,
OPT_Xf = 752,
OPT_Xlinker = 753,
OPT_Xpreprocessor = 754,
OPT_Z = 755,
OPT_ansi = 756,
OPT_aux_info = 757,
OPT_c = 759,
OPT_callgraph = 760,
OPT_coverage = 761,
OPT_cpp = 762,
OPT_cpp_ = 763,
OPT_d = 764,
OPT_debuglib_ = 765,
OPT_defaultlib_ = 766,
OPT_defined_only = 767,
OPT_demangle = 768,
OPT_dstartfiles = 769,
OPT_dump_body_ = 770,
OPT_dump_level_ = 771,
OPT_dumpbase = 772,
OPT_dumpbase_ext = 773,
OPT_dumpdir = 774,
OPT_dumpfullversion = 775,
OPT_dumpmachine = 776,
OPT_dumpspecs = 777,
OPT_dumpversion = 778,
OPT_e = 779,
OPT_export_dynamic = 780,
OPT_fPIC = 781,
OPT_fPIE = 782,
OPT_fRTS_ = 783,
OPT_fabi_compat_version_ = 784,
OPT_fabi_version_ = 785,
OPT_faccess_control = 786,
OPT_fada_spec_parent_ = 787,
OPT_faggressive_function_elimination = 788,
OPT_faggressive_loop_optimizations = 789,
OPT_falign_commons = 790,
OPT_falign_functions = 791,
OPT_falign_functions_ = 792,
OPT_falign_jumps = 793,
OPT_falign_jumps_ = 794,
OPT_falign_labels = 795,
OPT_falign_labels_ = 796,
OPT_falign_loops = 797,
OPT_falign_loops_ = 798,
OPT_faligned_new_ = 800,
OPT_fall_instantiations = 801,
OPT_fall_intrinsics = 802,
OPT_fall_virtual = 803,
OPT_fallocation_dce = 804,
OPT_fallow_argument_mismatch = 805,
OPT_fallow_invalid_boz = 806,
OPT_fallow_leading_underscore = 807,
OPT_fallow_parameterless_variadic_functions = 808,
OPT_fallow_store_data_races = 809,
OPT_falt_external_templates = 810,
OPT_fanalyzer = 811,
OPT_fanalyzer_call_summaries = 812,
OPT_fanalyzer_checker_ = 813,
OPT_fanalyzer_fine_grained = 814,
OPT_fanalyzer_show_duplicate_count = 815,
OPT_fanalyzer_state_merge = 816,
OPT_fanalyzer_state_purge = 817,
OPT_fanalyzer_transitivity = 818,
OPT_fanalyzer_verbose_edges = 819,
OPT_fanalyzer_verbose_state_changes = 820,
OPT_fanalyzer_verbosity_ = 821,
OPT_fasan_shadow_offset_ = 826,
OPT_fasm = 827,
OPT_fassert = 828,
OPT_fassociative_math = 829,
OPT_fassume_phsa = 830,
OPT_fasynchronous_unwind_tables = 831,
OPT_fauto_inc_dec = 832,
OPT_fauto_profile = 833,
OPT_fauto_profile_ = 834,
OPT_fautomatic = 835,
OPT_fbackslash = 836,
OPT_fbacktrace = 837,
OPT_fblas_matmul_limit_ = 838,
OPT_fbounds_check = 839,
OPT_fbounds_check_ = 840,
OPT_fbranch_count_reg = 841,
OPT_fbranch_probabilities = 842,
OPT_fbuilding_libgcc = 846,
OPT_fbuilding_libphobos_tests = 847,
OPT_fbuiltin = 848,
OPT_fbuiltin_ = 849,
OPT_fbuiltin_printf = 850,
OPT_fc_prototypes = 851,
OPT_fc_prototypes_external = 852,
OPT_fcall_saved_ = 853,
OPT_fcall_used_ = 854,
OPT_fcaller_saves = 855,
OPT_fcallgraph_info = 856,
OPT_fcallgraph_info_ = 857,
OPT_fcanonical_system_headers = 858,
OPT_fcf_protection_ = 860,
OPT_fchar8_t = 861,
OPT_fcheck_array_temporaries = 862,
OPT_fcheck_new = 864,
OPT_fcheck_pointer_bounds = 865,
OPT_fcheck_ = 866,
OPT_fchecking = 867,
OPT_fchecking_ = 868,
OPT_fchkp_check_incomplete_type = 869,
OPT_fchkp_check_read = 870,
OPT_fchkp_check_write = 871,
OPT_fchkp_first_field_has_own_bounds = 872,
OPT_fchkp_flexible_struct_trailing_arrays = 873,
OPT_fchkp_instrument_calls = 874,
OPT_fchkp_instrument_marked_only = 875,
OPT_fchkp_narrow_bounds = 876,
OPT_fchkp_narrow_to_innermost_array = 877,
OPT_fchkp_optimize = 878,
OPT_fchkp_store_bounds = 879,
OPT_fchkp_treat_zero_dynamic_size_as_infinite = 880,
OPT_fchkp_use_fast_string_functions = 881,
OPT_fchkp_use_nochk_string_functions = 882,
OPT_fchkp_use_static_bounds = 883,
OPT_fchkp_use_static_const_bounds = 884,
OPT_fchkp_use_wrappers = 885,
OPT_fchkp_zero_input_bounds_for_main = 886,
OPT_fcoarray_ = 888,
OPT_fcode_hoisting = 889,
OPT_fcombine_stack_adjustments = 890,
OPT_fcommon = 891,
OPT_fcompare_debug = 892,
OPT_fcompare_debug_second = 893,
OPT_fcompare_debug_ = 894,
OPT_fcompare_elim = 895,
OPT_fconcepts = 896,
OPT_fconcepts_diagnostics_depth_ = 897,
OPT_fconcepts_ts = 898,
OPT_fcond_mismatch = 899,
OPT_fconserve_stack = 901,
OPT_fconstant_string_class_ = 902,
OPT_fconstexpr_cache_depth_ = 903,
OPT_fconstexpr_depth_ = 904,
OPT_fconstexpr_loop_limit_ = 905,
OPT_fconstexpr_ops_limit_ = 906,
OPT_fconvert_ = 907,
OPT_fcoroutines = 908,
OPT_fcprop_registers = 909,
OPT_fcray_pointer = 910,
OPT_fcrossjumping = 911,
OPT_fcse_follow_jumps = 912,
OPT_fcx_fortran_rules = 914,
OPT_fcx_limited_range = 915,
OPT_fd_lines_as_code = 916,
OPT_fd_lines_as_comments = 917,
OPT_fdata_sections = 918,
OPT_fdbg_cnt_list = 919,
OPT_fdbg_cnt_ = 920,
OPT_fdce = 921,
OPT_fdebug = 922,
OPT_fdebug_cpp = 923,
OPT_fdebug_prefix_map_ = 924,
OPT_fdebug_types_section = 925,
OPT_fdebug_ = 926,
OPT_fdec = 927,
OPT_fdec_blank_format_item = 928,
OPT_fdec_char_conversions = 929,
OPT_fdec_format_defaults = 930,
OPT_fdec_include = 931,
OPT_fdec_intrinsic_ints = 932,
OPT_fdec_math = 933,
OPT_fdec_static = 934,
OPT_fdec_structure = 935,
OPT_fdeclone_ctor_dtor = 936,
OPT_fdefault_double_8 = 938,
OPT_fdefault_integer_8 = 940,
OPT_fdefault_real_10 = 941,
OPT_fdefault_real_16 = 942,
OPT_fdefault_real_8 = 943,
OPT_fdefer_pop = 944,
OPT_fdelayed_branch = 945,
OPT_fdelete_dead_exceptions = 946,
OPT_fdelete_null_pointer_checks = 947,
OPT_fdevirtualize = 948,
OPT_fdevirtualize_at_ltrans = 949,
OPT_fdevirtualize_speculatively = 950,
OPT_fdiagnostics_color_ = 952,
OPT_fdiagnostics_column_origin_ = 953,
OPT_fdiagnostics_column_unit_ = 954,
OPT_fdiagnostics_format_ = 955,
OPT_fdiagnostics_generate_patch = 956,
OPT_fdiagnostics_minimum_margin_width_ = 957,
OPT_fdiagnostics_parseable_fixits = 958,
OPT_fdiagnostics_path_format_ = 959,
OPT_fdiagnostics_plain_output = 960,
OPT_fdiagnostics_show_caret = 961,
OPT_fdiagnostics_show_cwe = 962,
OPT_fdiagnostics_show_labels = 963,
OPT_fdiagnostics_show_line_numbers = 964,
OPT_fdiagnostics_show_location_ = 965,
OPT_fdiagnostics_show_option = 966,
OPT_fdiagnostics_show_path_depths = 967,
OPT_fdiagnostics_show_template_tree = 968,
OPT_fdiagnostics_urls_ = 969,
OPT_fdirectives_only = 970,
OPT_fdisable_ = 971,
OPT_fdoc = 972,
OPT_fdoc_dir_ = 973,
OPT_fdoc_file_ = 974,
OPT_fdoc_inc_ = 975,
OPT_fdollar_ok = 976,
OPT_fdollars_in_identifiers = 977,
OPT_fdruntime = 978,
OPT_fdse = 979,
OPT_fdump_ = 980,
OPT_fdump_ada_spec = 981,
OPT_fdump_ada_spec_slim = 982,
OPT_fdump_analyzer = 983,
OPT_fdump_analyzer_callgraph = 984,
OPT_fdump_analyzer_exploded_graph = 985,
OPT_fdump_analyzer_exploded_nodes = 986,
OPT_fdump_analyzer_exploded_nodes_2 = 987,
OPT_fdump_analyzer_exploded_nodes_3 = 988,
OPT_fdump_analyzer_state_purge = 989,
OPT_fdump_analyzer_stderr = 990,
OPT_fdump_analyzer_supergraph = 991,
OPT_fdump_d_original = 993,
OPT_fdump_final_insns = 994,
OPT_fdump_final_insns_ = 995,
OPT_fdump_fortran_global = 996,
OPT_fdump_fortran_optimized = 997,
OPT_fdump_fortran_original = 998,
OPT_fdump_go_spec_ = 999,
OPT_fdump_internal_locations = 1000,
OPT_fdump_noaddr = 1001,
OPT_fdump_passes = 1003,
OPT_fdump_scos = 1004,
OPT_fdump_unnumbered = 1005,
OPT_fdump_unnumbered_links = 1006,
OPT_fdwarf2_cfi_asm = 1007,
OPT_fearly_inlining = 1008,
OPT_felide_constructors = 1009,
OPT_felide_type = 1010,
OPT_feliminate_unused_debug_symbols = 1012,
OPT_feliminate_unused_debug_types = 1013,
OPT_femit_class_debug_always = 1014,
OPT_femit_struct_debug_baseonly = 1015,
OPT_femit_struct_debug_detailed_ = 1016,
OPT_femit_struct_debug_reduced = 1017,
OPT_fenable_ = 1018,
OPT_fenforce_eh_specs = 1019,
OPT_fenum_int_equiv = 1020,
OPT_fexceptions = 1021,
OPT_fexcess_precision_ = 1022,
OPT_fexec_charset_ = 1023,
OPT_fexpensive_optimizations = 1024,
OPT_fext_numeric_literals = 1025,
OPT_fextended_identifiers = 1026,
OPT_fextern_tls_init = 1027,
OPT_fexternal_blas = 1028,
OPT_fexternal_templates = 1029,
OPT_ff2c = 1030,
OPT_ffast_math = 1031,
OPT_ffat_lto_objects = 1032,
OPT_ffile_prefix_map_ = 1033,
OPT_ffinite_loops = 1034,
OPT_ffinite_math_only = 1035,
OPT_ffixed_ = 1036,
OPT_ffixed_form = 1037,
OPT_ffixed_line_length_ = 1038,
OPT_ffixed_line_length_none = 1039,
OPT_ffloat_store = 1040,
OPT_ffor_scope = 1041,
OPT_fforward_propagate = 1043,
OPT_ffp_contract_ = 1044,
OPT_ffp_int_builtin_inexact = 1045,
OPT_ffpe_summary_ = 1046,
OPT_ffpe_trap_ = 1047,
OPT_ffree_form = 1048,
OPT_ffree_line_length_ = 1049,
OPT_ffree_line_length_none = 1050,
OPT_ffreestanding = 1051,
OPT_ffriend_injection = 1052,
OPT_ffrontend_loop_interchange = 1053,
OPT_ffrontend_optimize = 1054,
OPT_ffunction_cse = 1055,
OPT_ffunction_sections = 1056,
OPT_fgcse = 1057,
OPT_fgcse_after_reload = 1058,
OPT_fgcse_las = 1059,
OPT_fgcse_lm = 1060,
OPT_fgcse_sm = 1061,
OPT_fgimple = 1062,
OPT_fgnat_encodings_ = 1063,
OPT_fgnu_keywords = 1064,
OPT_fgnu_runtime = 1065,
OPT_fgnu_tm = 1066,
OPT_fgnu_unique = 1067,
OPT_fgnu89_inline = 1068,
OPT_fgo_c_header_ = 1069,
OPT_fgo_check_divide_overflow = 1070,
OPT_fgo_check_divide_zero = 1071,
OPT_fgo_compiling_runtime = 1072,
OPT_fgo_debug_escape = 1073,
OPT_fgo_debug_escape_hash_ = 1074,
OPT_fgo_debug_optimization = 1075,
OPT_fgo_dump_ = 1076,
OPT_fgo_optimize_ = 1077,
OPT_fgo_pkgpath_ = 1078,
OPT_fgo_prefix_ = 1079,
OPT_fgo_relative_import_path_ = 1080,
OPT_fgraphite = 1081,
OPT_fgraphite_identity = 1082,
OPT_fguess_branch_probability = 1083,
OPT_fguiding_decls = 1084,
OPT_fhoist_adjacent_loads = 1088,
OPT_fhonor_std = 1089,
OPT_fhosted = 1090,
OPT_fhuge_objects = 1091,
OPT_fident = 1092,
OPT_fif_conversion = 1093,
OPT_fif_conversion2 = 1094,
OPT_fignore_unknown_pragmas = 1095,
OPT_fimplement_inlines = 1096,
OPT_fimplicit_inline_templates = 1097,
OPT_fimplicit_none = 1098,
OPT_fimplicit_templates = 1099,
OPT_findirect_inlining = 1100,
OPT_finhibit_size_directive = 1101,
OPT_finit_character_ = 1102,
OPT_finit_derived = 1103,
OPT_finit_integer_ = 1104,
OPT_finit_local_zero = 1105,
OPT_finit_logical_ = 1106,
OPT_finit_real_ = 1107,
OPT_finline = 1108,
OPT_finline_arg_packing = 1109,
OPT_finline_atomics = 1110,
OPT_finline_functions = 1111,
OPT_finline_functions_called_once = 1112,
OPT_finline_limit_ = 1114,
OPT_finline_matmul_limit_ = 1115,
OPT_finline_small_functions = 1116,
OPT_finput_charset_ = 1117,
OPT_finstrument_functions = 1118,
OPT_finstrument_functions_exclude_file_list_ = 1119,
OPT_finstrument_functions_exclude_function_list_ = 1120,
OPT_finteger_4_integer_8 = 1121,
OPT_fintrinsic_modules_path = 1122,
OPT_fintrinsic_modules_path_ = 1123,
OPT_finvariants = 1124,
OPT_fipa_bit_cp = 1125,
OPT_fipa_cp = 1126,
OPT_fipa_cp_clone = 1128,
OPT_fipa_icf = 1129,
OPT_fipa_icf_functions = 1130,
OPT_fipa_icf_variables = 1131,
OPT_fipa_profile = 1133,
OPT_fipa_pta = 1134,
OPT_fipa_pure_const = 1135,
OPT_fipa_ra = 1136,
OPT_fipa_reference = 1137,
OPT_fipa_reference_addressable = 1138,
OPT_fipa_sra = 1139,
OPT_fipa_stack_alignment = 1140,
OPT_fipa_vrp = 1142,
OPT_fira_algorithm_ = 1143,
OPT_fira_hoist_pressure = 1144,
OPT_fira_loop_pressure = 1145,
OPT_fira_region_ = 1146,
OPT_fira_share_save_slots = 1147,
OPT_fira_share_spill_slots = 1148,
OPT_fira_verbose_ = 1149,
OPT_fisolate_erroneous_paths_attribute = 1150,
OPT_fisolate_erroneous_paths_dereference = 1151,
OPT_fivar_visibility_ = 1152,
OPT_fivopts = 1153,
OPT_fjump_tables = 1154,
OPT_fkeep_gc_roots_live = 1155,
OPT_fkeep_inline_dllexport = 1156,
OPT_fkeep_inline_functions = 1157,
OPT_fkeep_static_consts = 1158,
OPT_fkeep_static_functions = 1159,
OPT_flabels_ok = 1160,
OPT_flarge_source_files = 1161,
OPT_flax_vector_conversions = 1162,
OPT_fleading_underscore = 1163,
OPT_flifetime_dse = 1164,
OPT_flifetime_dse_ = 1165,
OPT_flimit_function_alignment = 1166,
OPT_flinker_output_ = 1167,
OPT_flive_patching_ = 1169,
OPT_flive_range_shrinkage = 1170,
OPT_flocal_ivars = 1171,
OPT_floop_interchange = 1174,
OPT_floop_nest_optimize = 1175,
OPT_floop_parallelize_all = 1177,
OPT_floop_unroll_and_jam = 1179,
OPT_flra_remat = 1180,
OPT_flto = 1181,
OPT_flto_compression_level_ = 1182,
OPT_flto_partition_ = 1184,
OPT_flto_report = 1185,
OPT_flto_report_wpa = 1186,
OPT_flto_ = 1187,
OPT_fltrans = 1188,
OPT_fltrans_output_list_ = 1189,
OPT_fmacro_prefix_map_ = 1190,
OPT_fmain = 1191,
OPT_fmath_errno = 1192,
OPT_fmax_array_constructor_ = 1193,
OPT_fmax_errors_ = 1194,
OPT_fmax_identifier_length_ = 1195,
OPT_fmax_include_depth_ = 1196,
OPT_fmax_stack_var_size_ = 1197,
OPT_fmax_subrecord_length_ = 1198,
OPT_fmem_report = 1199,
OPT_fmem_report_wpa = 1200,
OPT_fmerge_all_constants = 1201,
OPT_fmerge_constants = 1202,
OPT_fmerge_debug_strings = 1203,
OPT_fmessage_length_ = 1204,
OPT_fmodule_file_ = 1205,
OPT_fmodule_private = 1206,
OPT_fmoduleinfo = 1207,
OPT_fmodulo_sched = 1208,
OPT_fmodulo_sched_allow_regmoves = 1209,
OPT_fmove_loop_invariants = 1210,
OPT_fms_extensions = 1211,
OPT_fmudflap = 1212,
OPT_fmudflapir = 1213,
OPT_fmudflapth = 1214,
OPT_fname_mangling_version_ = 1215,
OPT_fnew_abi = 1216,
OPT_fnew_inheriting_ctors = 1217,
OPT_fnew_ttp_matching = 1218,
OPT_fnext_runtime = 1219,
OPT_fnil_receivers = 1220,
OPT_fnon_call_exceptions = 1221,
OPT_fnonansi_builtins = 1222,
OPT_fnonnull_objects = 1223,
OPT_fnothrow_opt = 1224,
OPT_fobjc_abi_version_ = 1225,
OPT_fobjc_call_cxx_cdtors = 1226,
OPT_fobjc_direct_dispatch = 1227,
OPT_fobjc_exceptions = 1228,
OPT_fobjc_gc = 1229,
OPT_fobjc_nilcheck = 1230,
OPT_fobjc_sjlj_exceptions = 1231,
OPT_fobjc_std_objc1 = 1232,
OPT_foffload_abi_ = 1233,
OPT_foffload_ = 1234,
OPT_fomit_frame_pointer = 1235,
OPT_fonly_ = 1236,
OPT_fopenacc = 1237,
OPT_fopenacc_dim_ = 1238,
OPT_fopenmp = 1239,
OPT_fopenmp_simd = 1240,
OPT_foperator_names = 1241,
OPT_fopt_info = 1242,
OPT_fopt_info_ = 1243,
OPT_foptimize_sibling_calls = 1245,
OPT_foptimize_strlen = 1246,
OPT_fpack_derived = 1248,
OPT_fpack_struct = 1249,
OPT_fpack_struct_ = 1250,
OPT_fpad_source = 1251,
OPT_fparallel_jobs_ = 1252,
OPT_fpartial_inlining = 1253,
OPT_fpatchable_function_entry_ = 1254,
OPT_fpcc_struct_return = 1255,
OPT_fpch_deps = 1256,
OPT_fpch_preprocess = 1257,
OPT_fpeel_loops = 1258,
OPT_fpeephole = 1259,
OPT_fpeephole2 = 1260,
OPT_fpermissive = 1261,
OPT_fpermitted_flt_eval_methods_ = 1262,
OPT_fpic = 1263,
OPT_fpie = 1264,
OPT_fplan9_extensions = 1265,
OPT_fplt = 1266,
OPT_fplugin_arg_ = 1267,
OPT_fplugin_ = 1268,
OPT_fpost_ipa_mem_report = 1269,
OPT_fpostconditions = 1270,
OPT_fpre_include_ = 1271,
OPT_fpre_ipa_mem_report = 1272,
OPT_fpreconditions = 1273,
OPT_fpredictive_commoning = 1274,
OPT_fprefetch_loop_arrays = 1275,
OPT_fpreprocessed = 1276,
OPT_fpretty_templates = 1277,
OPT_fprintf_return_value = 1278,
OPT_fprofile = 1279,
OPT_fprofile_abs_path = 1280,
OPT_fprofile_arcs = 1281,
OPT_fprofile_correction = 1282,
OPT_fprofile_dir_ = 1283,
OPT_fprofile_exclude_files_ = 1284,
OPT_fprofile_filter_files_ = 1285,
OPT_fprofile_generate = 1286,
OPT_fprofile_generate_ = 1287,
OPT_fprofile_note_ = 1288,
OPT_fprofile_partial_training = 1289,
OPT_fprofile_prefix_path_ = 1290,
OPT_fprofile_reorder_functions = 1291,
OPT_fprofile_report = 1292,
OPT_fprofile_reproducible = 1293,
OPT_fprofile_update_ = 1294,
OPT_fprofile_use = 1295,
OPT_fprofile_use_ = 1296,
OPT_fprofile_values = 1297,
OPT_fprotect_parens = 1298,
OPT_frandom_seed = 1299,
OPT_frandom_seed_ = 1300,
OPT_frange_check = 1301,
OPT_freal_4_real_10 = 1302,
OPT_freal_4_real_16 = 1303,
OPT_freal_4_real_8 = 1304,
OPT_freal_8_real_10 = 1305,
OPT_freal_8_real_16 = 1306,
OPT_freal_8_real_4 = 1307,
OPT_frealloc_lhs = 1308,
OPT_freciprocal_math = 1309,
OPT_frecord_gcc_switches = 1310,
OPT_frecord_marker_4 = 1311,
OPT_frecord_marker_8 = 1312,
OPT_frecursive = 1313,
OPT_free = 1314,
OPT_freg_struct_return = 1315,
OPT_frelease = 1317,
OPT_frename_registers = 1318,
OPT_freorder_blocks = 1319,
OPT_freorder_blocks_algorithm_ = 1320,
OPT_freorder_blocks_and_partition = 1321,
OPT_freorder_functions = 1322,
OPT_frepack_arrays = 1323,
OPT_freplace_objc_classes = 1324,
OPT_frepo = 1325,
OPT_freport_bug = 1326,
OPT_frequire_return_statement = 1327,
OPT_frerun_cse_after_loop = 1328,
OPT_freschedule_modulo_scheduled_loops = 1330,
OPT_fresolution_ = 1331,
OPT_frounding_math = 1332,
OPT_frtti = 1333,
OPT_fsanitize_address_use_after_scope = 1334,
OPT_fsanitize_coverage_ = 1335,
OPT_fsanitize_recover = 1336,
OPT_fsanitize_recover_ = 1337,
OPT_fsanitize_sections_ = 1338,
OPT_fsanitize_undefined_trap_on_error = 1339,
OPT_fsanitize_ = 1340,
OPT_fsave_optimization_record = 1341,
OPT_fsched_critical_path_heuristic = 1342,
OPT_fsched_dep_count_heuristic = 1343,
OPT_fsched_group_heuristic = 1344,
OPT_fsched_interblock = 1345,
OPT_fsched_last_insn_heuristic = 1346,
OPT_fsched_pressure = 1347,
OPT_fsched_rank_heuristic = 1348,
OPT_fsched_spec = 1349,
OPT_fsched_spec_insn_heuristic = 1350,
OPT_fsched_spec_load = 1351,
OPT_fsched_spec_load_dangerous = 1352,
OPT_fsched_stalled_insns = 1353,
OPT_fsched_stalled_insns_dep = 1354,
OPT_fsched_stalled_insns_dep_ = 1355,
OPT_fsched_stalled_insns_ = 1356,
OPT_fsched_verbose_ = 1357,
OPT_fsched2_use_superblocks = 1358,
OPT_fschedule_fusion = 1360,
OPT_fschedule_insns = 1361,
OPT_fschedule_insns2 = 1362,
OPT_fsecond_underscore = 1363,
OPT_fsection_anchors = 1364,
OPT_fsel_sched_pipelining = 1366,
OPT_fsel_sched_pipelining_outer_loops = 1367,
OPT_fsel_sched_reschedule_pipelined = 1368,
OPT_fselective_scheduling = 1369,
OPT_fselective_scheduling2 = 1370,
OPT_fself_test_ = 1371,
OPT_fsemantic_interposition = 1372,
OPT_fshort_enums = 1373,
OPT_fshort_wchar = 1374,
OPT_fshow_column = 1375,
OPT_fshrink_wrap = 1376,
OPT_fshrink_wrap_separate = 1377,
OPT_fsign_zero = 1378,
OPT_fsignaling_nans = 1379,
OPT_fsigned_bitfields = 1380,
OPT_fsigned_char = 1381,
OPT_fsigned_zeros = 1382,
OPT_fsimd_cost_model_ = 1383,
OPT_fsingle_precision_constant = 1384,
OPT_fsized_deallocation = 1385,
OPT_fsplit_ivs_in_unroller = 1386,
OPT_fsplit_loops = 1387,
OPT_fsplit_outputs_ = 1388,
OPT_fsplit_paths = 1389,
OPT_fsplit_stack = 1390,
OPT_fsplit_wide_types = 1391,
OPT_fsplit_wide_types_early = 1392,
OPT_fsquangle = 1393,
OPT_fssa_backprop = 1394,
OPT_fssa_phiopt = 1395,
OPT_fsso_struct_ = 1396,
OPT_fstack_arrays = 1397,
OPT_fstack_check_ = 1399,
OPT_fstack_clash_protection = 1400,
OPT_fstack_limit = 1401,
OPT_fstack_limit_register_ = 1402,
OPT_fstack_limit_symbol_ = 1403,
OPT_fstack_protector = 1404,
OPT_fstack_protector_all = 1405,
OPT_fstack_protector_explicit = 1406,
OPT_fstack_protector_strong = 1407,
OPT_fstack_reuse_ = 1408,
OPT_fstack_usage = 1409,
OPT_fstats = 1410,
OPT_fstdarg_opt = 1411,
OPT_fstore_merging = 1412,
OPT_fstrict_aliasing = 1414,
OPT_fstrict_enums = 1415,
OPT_fstrict_overflow = 1416,
OPT_fstrict_prototype = 1417,
OPT_fstrict_volatile_bitfields = 1418,
OPT_fstrong_eval_order_ = 1420,
OPT_fswitch_errors = 1421,
OPT_fsync_libcalls = 1422,
OPT_fsyntax_only = 1423,
OPT_ftabstop_ = 1424,
OPT_ftail_call_workaround_ = 1426,
OPT_ftemplate_backtrace_limit_ = 1428,
OPT_ftemplate_depth_ = 1430,
OPT_ftest_coverage = 1431,
OPT_ftest_forall_temp = 1432,
OPT_fthis_is_variable = 1433,
OPT_fthread_jumps = 1434,
OPT_fthreadsafe_statics = 1435,
OPT_ftime_report = 1436,
OPT_ftime_report_details = 1437,
OPT_ftls_model_ = 1438,
OPT_ftoplevel_reorder = 1439,
OPT_ftracer = 1440,
OPT_ftrack_macro_expansion = 1441,
OPT_ftrack_macro_expansion_ = 1442,
OPT_ftrampolines = 1443,
OPT_ftransition_all = 1444,
OPT_ftransition_checkimports = 1445,
OPT_ftransition_complex = 1446,
OPT_ftransition_dip1000 = 1447,
OPT_ftransition_dip25 = 1448,
OPT_ftransition_field = 1449,
OPT_ftransition_import = 1450,
OPT_ftransition_nogc = 1451,
OPT_ftransition_tls = 1452,
OPT_ftrapping_math = 1453,
OPT_ftrapv = 1454,
OPT_ftree_bit_ccp = 1455,
OPT_ftree_builtin_call_dce = 1456,
OPT_ftree_ccp = 1457,
OPT_ftree_ch = 1458,
OPT_ftree_coalesce_vars = 1460,
OPT_ftree_copy_prop = 1461,
OPT_ftree_cselim = 1463,
OPT_ftree_dce = 1464,
OPT_ftree_dominator_opts = 1465,
OPT_ftree_dse = 1466,
OPT_ftree_forwprop = 1467,
OPT_ftree_fre = 1468,
OPT_ftree_loop_distribute_patterns = 1469,
OPT_ftree_loop_distribution = 1470,
OPT_ftree_loop_if_convert = 1471,
OPT_ftree_loop_im = 1473,
OPT_ftree_loop_ivcanon = 1474,
OPT_ftree_loop_optimize = 1476,
OPT_ftree_loop_vectorize = 1477,
OPT_ftree_lrs = 1478,
OPT_ftree_parallelize_loops_ = 1479,
OPT_ftree_partial_pre = 1480,
OPT_ftree_phiprop = 1481,
OPT_ftree_pre = 1482,
OPT_ftree_pta = 1483,
OPT_ftree_reassoc = 1484,
OPT_ftree_scev_cprop = 1486,
OPT_ftree_sink = 1487,
OPT_ftree_slp_vectorize = 1488,
OPT_ftree_slsr = 1489,
OPT_ftree_sra = 1490,
OPT_ftree_switch_conversion = 1493,
OPT_ftree_tail_merge = 1494,
OPT_ftree_ter = 1495,
OPT_ftree_vectorize = 1497,
OPT_ftree_vrp = 1499,
OPT_funconstrained_commons = 1500,
OPT_funderscoring = 1501,
OPT_funit_at_a_time = 1502,
OPT_funittest = 1503,
OPT_funroll_all_loops = 1504,
OPT_funroll_completely_grow_size = 1505,
OPT_funroll_loops = 1506,
OPT_funsafe_math_optimizations = 1508,
OPT_funsigned_bitfields = 1509,
OPT_funsigned_char = 1510,
OPT_funswitch_loops = 1511,
OPT_funwind_tables = 1512,
OPT_fuse_cxa_atexit = 1513,
OPT_fuse_cxa_get_exception_ptr = 1514,
OPT_fuse_ld_bfd = 1515,
OPT_fuse_ld_gold = 1516,
OPT_fuse_ld_lld = 1517,
OPT_fuse_linker_plugin = 1518,
OPT_fvar_tracking = 1519,
OPT_fvar_tracking_assignments = 1520,
OPT_fvar_tracking_assignments_toggle = 1521,
OPT_fvar_tracking_uninit = 1522,
OPT_fvariable_expansion_in_unroller = 1523,
OPT_fvect_cost_model_ = 1525,
OPT_fverbose_asm = 1526,
OPT_fversion_loops_for_strides = 1528,
OPT_fversion_ = 1529,
OPT_fvisibility_inlines_hidden = 1530,
OPT_fvisibility_ms_compat = 1531,
OPT_fvisibility_ = 1532,
OPT_fvpt = 1533,
OPT_fvtable_gc = 1534,
OPT_fvtable_thunks = 1535,
OPT_fvtable_verify_ = 1536,
OPT_fvtv_counts = 1537,
OPT_fvtv_debug = 1538,
OPT_fweak = 1539,
OPT_fweb = 1540,
OPT_fwhole_program = 1542,
OPT_fwide_exec_charset_ = 1543,
OPT_fworking_directory = 1544,
OPT_fwpa = 1545,
OPT_fwpa_ = 1546,
OPT_fwrapv = 1547,
OPT_fwrapv_pointer = 1548,
OPT_fxref = 1549,
OPT_fzero_initialized_in_bss = 1551,
OPT_fzero_link = 1552,
OPT_g = 1553,
OPT_gant = 1554,
OPT_gas_loc_support = 1555,
OPT_gas_locview_support = 1556,
OPT_gcoff = 1557,
OPT_gcoff1 = 1558,
OPT_gcoff2 = 1559,
OPT_gcoff3 = 1560,
OPT_gcolumn_info = 1561,
OPT_gdescribe_dies = 1562,
OPT_gdwarf = 1563,
OPT_gdwarf_ = 1564,
OPT_gen_decls = 1565,
OPT_ggdb = 1566,
OPT_ggnu_pubnames = 1567,
OPT_gimple_stats = 1568,
OPT_ginline_points = 1569,
OPT_ginternal_reset_location_views = 1570,
OPT_gnat = 1571,
OPT_gnatO = 1572,
OPT_gno_ = 1573,
OPT_gno_pubnames = 1574,
OPT_gpubnames = 1575,
OPT_grecord_gcc_switches = 1576,
OPT_gsplit_dwarf = 1577,
OPT_gstabs = 1578,
OPT_gstabs_ = 1579,
OPT_gstatement_frontiers = 1580,
OPT_gstrict_dwarf = 1581,
OPT_gtoggle = 1582,
OPT_gvariable_location_views = 1583,
OPT_gvariable_location_views_incompat5 = 1584,
OPT_gvms = 1585,
OPT_gxcoff = 1586,
OPT_gxcoff_ = 1587,
OPT_gz = 1588,
OPT_gz_ = 1589,
OPT_h = 1590,
OPT_help = 1591,
OPT_idirafter = 1592,
OPT_imacros = 1593,
OPT_imultiarch = 1594,
OPT_imultilib = 1595,
OPT_include = 1596,
OPT_iplugindir_ = 1597,
OPT_iprefix = 1598,
OPT_iquote = 1599,
OPT_isysroot = 1600,
OPT_isystem = 1601,
OPT_iwithprefix = 1602,
OPT_iwithprefixbefore = 1603,
OPT_k8 = 1604,
OPT_l = 1605,
OPT_lang_asm = 1606,
OPT_list = 1607,
OPT_m128bit_long_double = 1608,
OPT_m16 = 1609,
OPT_m32 = 1610,
OPT_m3dnow = 1611,
OPT_m3dnowa = 1612,
OPT_m64 = 1613,
OPT_m80387 = 1614,
OPT_m8bit_idiv = 1615,
OPT_m96bit_long_double = 1616,
OPT_mabi_ = 1617,
OPT_mabm = 1618,
OPT_maccumulate_outgoing_args = 1619,
OPT_maddress_mode_ = 1620,
OPT_madx = 1621,
OPT_maes = 1622,
OPT_malign_data_ = 1623,
OPT_malign_double = 1624,
OPT_malign_functions_ = 1625,
OPT_malign_jumps_ = 1626,
OPT_malign_loops_ = 1627,
OPT_malign_stringops = 1628,
OPT_mandroid = 1629,
OPT_march_ = 1630,
OPT_masm_ = 1631,
OPT_mavx = 1632,
OPT_mavx2 = 1633,
OPT_mavx256_split_unaligned_load = 1634,
OPT_mavx256_split_unaligned_store = 1635,
OPT_mavx5124fmaps = 1636,
OPT_mavx5124vnniw = 1637,
OPT_mavx512bf16 = 1638,
OPT_mavx512bitalg = 1639,
OPT_mavx512bw = 1640,
OPT_mavx512cd = 1641,
OPT_mavx512dq = 1642,
OPT_mavx512er = 1643,
OPT_mavx512f = 1644,
OPT_mavx512ifma = 1645,
OPT_mavx512pf = 1646,
OPT_mavx512vbmi = 1647,
OPT_mavx512vbmi2 = 1648,
OPT_mavx512vl = 1649,
OPT_mavx512vnni = 1650,
OPT_mavx512vp2intersect = 1651,
OPT_mavx512vpopcntdq = 1652,
OPT_mbionic = 1653,
OPT_mbmi = 1654,
OPT_mbmi2 = 1655,
OPT_mbranch_cost_ = 1656,
OPT_mcall_ms2sysv_xlogues = 1657,
OPT_mcet_switch = 1658,
OPT_mcld = 1659,
OPT_mcldemote = 1660,
OPT_mclflushopt = 1661,
OPT_mclwb = 1662,
OPT_mclzero = 1663,
OPT_mcmodel_ = 1664,
OPT_mcrc32 = 1666,
OPT_mcx16 = 1667,
OPT_mdispatch_scheduler = 1668,
OPT_mdump_tune_features = 1669,
OPT_menqcmd = 1670,
OPT_mf16c = 1671,
OPT_mfancy_math_387 = 1672,
OPT_mfentry = 1673,
OPT_mfentry_name_ = 1674,
OPT_mfentry_section_ = 1675,
OPT_mfma = 1676,
OPT_mfma4 = 1677,
OPT_mforce_drap = 1678,
OPT_mforce_indirect_call = 1679,
OPT_mfp_ret_in_387 = 1680,
OPT_mfpmath_ = 1681,
OPT_mfsgsbase = 1682,
OPT_mfunction_return_ = 1683,
OPT_mfxsr = 1685,
OPT_mgeneral_regs_only = 1686,
OPT_mgfni = 1687,
OPT_mglibc = 1688,
OPT_mhard_float = 1689,
OPT_mhle = 1690,
OPT_miamcu = 1691,
OPT_mieee_fp = 1692,
OPT_mincoming_stack_boundary_ = 1693,
OPT_mindirect_branch_register = 1694,
OPT_mindirect_branch_ = 1695,
OPT_minline_all_stringops = 1696,
OPT_minline_stringops_dynamically = 1697,
OPT_minstrument_return_ = 1698,
OPT_mlarge_data_threshold_ = 1700,
OPT_mlong_double_128 = 1701,
OPT_mlong_double_64 = 1702,
OPT_mlong_double_80 = 1703,
OPT_mlwp = 1704,
OPT_mlzcnt = 1705,
OPT_mmanual_endbr = 1706,
OPT_mmemcpy_strategy_ = 1707,
OPT_mmemset_strategy_ = 1708,
OPT_mmitigate_rop = 1709,
OPT_mmmx = 1710,
OPT_mmovbe = 1711,
OPT_mmovdir64b = 1712,
OPT_mmovdiri = 1713,
OPT_mmpx = 1714,
OPT_mms_bitfields = 1715,
OPT_mmusl = 1716,
OPT_mmwaitx = 1717,
OPT_mno_align_stringops = 1718,
OPT_mno_default = 1719,
OPT_mno_fancy_math_387 = 1720,
OPT_mno_push_args = 1721,
OPT_mno_red_zone = 1722,
OPT_mno_sse4 = 1723,
OPT_mnop_mcount = 1724,
OPT_momit_leaf_frame_pointer = 1725,
OPT_mpc32 = 1726,
OPT_mpc64 = 1727,
OPT_mpc80 = 1728,
OPT_mpclmul = 1729,
OPT_mpcommit = 1730,
OPT_mpconfig = 1731,
OPT_mpku = 1732,
OPT_mpopcnt = 1733,
OPT_mprefer_vector_width_ = 1735,
OPT_mpreferred_stack_boundary_ = 1736,
OPT_mprefetchwt1 = 1737,
OPT_mprfchw = 1738,
OPT_mptwrite = 1739,
OPT_mpush_args = 1740,
OPT_mrdpid = 1741,
OPT_mrdrnd = 1742,
OPT_mrdseed = 1743,
OPT_mrecip = 1744,
OPT_mrecip_ = 1745,
OPT_mrecord_mcount = 1746,
OPT_mrecord_return = 1747,
OPT_mred_zone = 1748,
OPT_mregparm_ = 1749,
OPT_mrtd = 1750,
OPT_mrtm = 1751,
OPT_msahf = 1752,
OPT_mserialize = 1753,
OPT_msgx = 1754,
OPT_msha = 1755,
OPT_mshstk = 1756,
OPT_mskip_rax_setup = 1757,
OPT_msoft_float = 1758,
OPT_msse = 1759,
OPT_msse2 = 1760,
OPT_msse2avx = 1761,
OPT_msse3 = 1762,
OPT_msse4 = 1763,
OPT_msse4_1 = 1764,
OPT_msse4_2 = 1765,
OPT_msse4a = 1766,
OPT_msseregparm = 1768,
OPT_mssse3 = 1769,
OPT_mstack_arg_probe = 1770,
OPT_mstack_protector_guard_offset_ = 1771,
OPT_mstack_protector_guard_reg_ = 1772,
OPT_mstack_protector_guard_symbol_ = 1773,
OPT_mstack_protector_guard_ = 1774,
OPT_mstackrealign = 1775,
OPT_mstringop_strategy_ = 1776,
OPT_mstv = 1777,
OPT_mtbm = 1778,
OPT_mtls_dialect_ = 1779,
OPT_mtls_direct_seg_refs = 1780,
OPT_mtsxldtrk = 1781,
OPT_mtune_ctrl_ = 1782,
OPT_mtune_ = 1783,
OPT_muclibc = 1784,
OPT_mvaes = 1785,
OPT_mveclibabi_ = 1786,
OPT_mvect8_ret_in_mem = 1787,
OPT_mvpclmulqdq = 1788,
OPT_mvzeroupper = 1789,
OPT_mwaitpkg = 1790,
OPT_mwbnoinvd = 1791,
OPT_mx32 = 1792,
OPT_mxop = 1793,
OPT_mxsave = 1794,
OPT_mxsavec = 1795,
OPT_mxsaveopt = 1796,
OPT_mxsaves = 1797,
OPT_n = 1798,
OPT_name_sort = 1799,
OPT_no_canonical_prefixes = 1800,
OPT_no_integrated_cpp = 1801,
OPT_no_pie = 1802,
OPT_nocpp = 1803,
OPT_nodefaultlibs = 1804,
OPT_nolibc = 1805,
OPT_nophoboslib = 1806,
OPT_nostartfiles = 1807,
OPT_nostdinc = 1808,
OPT_nostdinc__ = 1809,
OPT_nostdlib = 1810,
OPT_o = 1811,
OPT_objects = 1812,
OPT_p = 1813,
OPT_pass_exit_codes = 1814,
OPT_pedantic_errors = 1816,
OPT_pg = 1817,
OPT_pie = 1818,
OPT_pipe = 1819,
OPT_posix = 1820,
OPT_print_file_name_ = 1821,
OPT_print_libgcc_file_name = 1822,
OPT_print_multi_directory = 1823,
OPT_print_multi_lib = 1824,
OPT_print_multi_os_directory = 1825,
OPT_print_multiarch = 1826,
OPT_print_objc_runtime_info = 1827,
OPT_print_prog_name_ = 1828,
OPT_print_search_dirs = 1829,
OPT_print_sysroot = 1830,
OPT_print_sysroot_headers_suffix = 1831,
OPT_print_value = 1832,
OPT_profile = 1833,
OPT_pthread = 1834,
OPT_quiet = 1835,
OPT_r = 1836,
OPT_rdynamic = 1837,
OPT_remap = 1838,
OPT_reverse_sort = 1839,
OPT_s = 1840,
OPT_save_temps = 1841,
OPT_save_temps_ = 1842,
OPT_shared = 1843,
OPT_shared_libgcc = 1844,
OPT_shared_libphobos = 1845,
OPT_size_sort = 1846,
OPT_specs_ = 1848,
OPT_static = 1849,
OPT_static_libasan = 1850,
OPT_static_libgcc = 1851,
OPT_static_libgfortran = 1852,
OPT_static_libgo = 1853,
OPT_static_liblsan = 1854,
OPT_static_libmpx = 1855,
OPT_static_libmpxwrappers = 1856,
OPT_static_libphobos = 1857,
OPT_static_libstdc__ = 1858,
OPT_static_libtsan = 1859,
OPT_static_libubsan = 1860,
OPT_static_pie = 1861,
OPT_std_c__11 = 1864,
OPT_std_c__14 = 1865,
OPT_std_c__17 = 1866,
OPT_std_c__20 = 1869,
OPT_std_c__98 = 1871,
OPT_std_c11 = 1872,
OPT_std_c17 = 1873,
OPT_std_c2x = 1876,
OPT_std_c90 = 1878,
OPT_std_c99 = 1879,
OPT_std_f2003 = 1881,
OPT_std_f2008 = 1882,
OPT_std_f2008ts = 1883,
OPT_std_f2018 = 1884,
OPT_std_f95 = 1885,
OPT_std_gnu = 1886,
OPT_std_gnu__11 = 1889,
OPT_std_gnu__14 = 1890,
OPT_std_gnu__17 = 1891,
OPT_std_gnu__20 = 1894,
OPT_std_gnu__98 = 1896,
OPT_std_gnu11 = 1897,
OPT_std_gnu17 = 1898,
OPT_std_gnu2x = 1901,
OPT_std_gnu90 = 1903,
OPT_std_gnu99 = 1904,
OPT_std_iso9899_199409 = 1907,
OPT_std_legacy = 1913,
OPT_symbol_ = 1914,
OPT_symbolic = 1915,
OPT_t = 1916,
OPT_time = 1917,
OPT_time_ = 1918,
OPT_tno_android_cc = 1919,
OPT_tno_android_ld = 1920,
OPT_traditional = 1921,
OPT_traditional_cpp = 1922,
OPT_tree_stats = 1923,
OPT_trigraphs = 1924,
OPT_type_stats = 1925,
OPT_u = 1926,
OPT_undef = 1927,
OPT_v = 1928,
OPT_version = 1929,
OPT_w = 1930,
OPT_wrapper = 1931,
OPT_x = 1932,
OPT_z = 1933,
N_OPTS,
OPT_SPECIAL_unknown,
OPT_SPECIAL_ignore,
OPT_SPECIAL_warn_removed,
OPT_SPECIAL_program_name,
OPT_SPECIAL_input_file
};
# 30 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 2
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/gfortran.h" 1
# 49 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/gfortran.h"
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/libgfortran.h" 1
# 90 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/libgfortran.h"
typedef enum
{
GFC_CONVERT_NONE = -1,
GFC_CONVERT_NATIVE = 0,
GFC_CONVERT_SWAP,
GFC_CONVERT_BIG,
GFC_CONVERT_LITTLE
}
unit_convert;
typedef enum
{
LIBERROR_FIRST = -3,
LIBERROR_EOR = -2,
LIBERROR_END = -1,
LIBERROR_OK = 0,
LIBERROR_OS = 5000,
LIBERROR_OPTION_CONFLICT,
LIBERROR_BAD_OPTION,
LIBERROR_MISSING_OPTION,
LIBERROR_ALREADY_OPEN,
LIBERROR_BAD_UNIT,
LIBERROR_FORMAT,
LIBERROR_BAD_ACTION,
LIBERROR_ENDFILE,
LIBERROR_BAD_US,
LIBERROR_READ_VALUE,
LIBERROR_READ_OVERFLOW,
LIBERROR_INTERNAL,
LIBERROR_INTERNAL_UNIT,
LIBERROR_ALLOCATION,
LIBERROR_DIRECT_EOR,
LIBERROR_SHORT_RECORD,
LIBERROR_CORRUPT_FILE,
LIBERROR_INQUIRE_INTERNAL_UNIT,
LIBERROR_BAD_WAIT_ID,
LIBERROR_LAST
}
libgfortran_error_codes;
typedef enum
{
GFC_STAT_UNLOCKED = 0,
GFC_STAT_LOCKED,
GFC_STAT_LOCKED_OTHER_IMAGE,
GFC_STAT_STOPPED_IMAGE = 6000,
GFC_STAT_FAILED_IMAGE = 6001
}
libgfortran_stat_codes;
typedef enum
{
GFC_CAF_ATOMIC_ADD = 1,
GFC_CAF_ATOMIC_AND,
GFC_CAF_ATOMIC_OR,
GFC_CAF_ATOMIC_XOR
} libcaf_atomic_codes;
# 175 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/libgfortran.h"
typedef enum
{ BT_UNKNOWN = 0, BT_INTEGER, BT_LOGICAL, BT_REAL, BT_COMPLEX,
BT_DERIVED, BT_CHARACTER, BT_CLASS, BT_PROCEDURE, BT_HOLLERITH, BT_VOID,
BT_ASSUMED, BT_UNION, BT_BOZ
}
bt;
# 50 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/gfortran.h" 2
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/intl.h" 1
# 22 "/home/giulianob/gcc_git_gnu/gcc/gcc/intl.h"
# 1 "/usr/include/locale.h" 1 3 4
# 28 "/usr/include/locale.h" 3 4
# 1 "/usr/lib/gcc/x86_64-linux-gnu/10/include/stddef.h" 1 3 4
# 29 "/usr/include/locale.h" 2 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/locale.h" 1 3 4
# 30 "/usr/include/locale.h" 2 3 4
# 31 "/usr/include/locale.h" 3 4
extern "C" {
# 51 "/usr/include/locale.h" 3 4
struct lconv
{
char *decimal_point;
char *thousands_sep;
char *grouping;
char *int_curr_symbol;
char *currency_symbol;
char *mon_decimal_point;
char *mon_thousands_sep;
char *mon_grouping;
char *positive_sign;
char *negative_sign;
char int_frac_digits;
char frac_digits;
char p_cs_precedes;
char p_sep_by_space;
char n_cs_precedes;
char n_sep_by_space;
char p_sign_posn;
char n_sign_posn;
char int_p_cs_precedes;
char int_p_sep_by_space;
char int_n_cs_precedes;
char int_n_sep_by_space;
char int_p_sign_posn;
char int_n_sign_posn;
# 118 "/usr/include/locale.h" 3 4
};
extern char *setlocale (int __category, const char *__locale) throw ();
extern struct lconv *localeconv (void) throw ();
# 141 "/usr/include/locale.h" 3 4
extern locale_t newlocale (int __category_mask, const char *__locale,
locale_t __base) throw ();
# 176 "/usr/include/locale.h" 3 4
extern locale_t duplocale (locale_t __dataset) throw ();
extern void freelocale (locale_t __dataset) throw ();
extern locale_t uselocale (locale_t __dataset) throw ();
}
# 23 "/home/giulianob/gcc_git_gnu/gcc/gcc/intl.h" 2
# 1 "/usr/include/libintl.h" 1 3 4
# 34 "/usr/include/libintl.h" 3 4
extern "C" {
extern char *gettext (const char *__msgid)
throw () __attribute__ ((__format_arg__ (1)));
extern char *dgettext (const char *__domainname, const char *__msgid)
throw () __attribute__ ((__format_arg__ (2)));
extern char *__dgettext (const char *__domainname, const char *__msgid)
throw () __attribute__ ((__format_arg__ (2)));
extern char *dcgettext (const char *__domainname,
const char *__msgid, int __category)
throw () __attribute__ ((__format_arg__ (2)));
extern char *__dcgettext (const char *__domainname,
const char *__msgid, int __category)
throw () __attribute__ ((__format_arg__ (2)));
extern char *ngettext (const char *__msgid1, const char *__msgid2,
unsigned long int __n)
throw () __attribute__ ((__format_arg__ (1))) __attribute__ ((__format_arg__ (2)));
extern char *dngettext (const char *__domainname, const char *__msgid1,
const char *__msgid2, unsigned long int __n)
throw () __attribute__ ((__format_arg__ (2))) __attribute__ ((__format_arg__ (3)));
extern char *dcngettext (const char *__domainname, const char *__msgid1,
const char *__msgid2, unsigned long int __n,
int __category)
throw () __attribute__ ((__format_arg__ (2))) __attribute__ ((__format_arg__ (3)));
extern char *textdomain (const char *__domainname) throw ();
extern char *bindtextdomain (const char *__domainname,
const char *__dirname) throw ();
extern char *bind_textdomain_codeset (const char *__domainname,
const char *__codeset) throw ();
# 121 "/usr/include/libintl.h" 3 4
}
# 31 "/home/giulianob/gcc_git_gnu/gcc/gcc/intl.h" 2
# 31 "/home/giulianob/gcc_git_gnu/gcc/gcc/intl.h"
extern void gcc_init_libintl (void);
extern size_t gcc_gettext_width (const char *);
# 62 "/home/giulianob/gcc_git_gnu/gcc/gcc/intl.h"
extern char *get_spaces (const char *);
extern const char *open_quote;
extern const char *close_quote;
extern const char *locale_encoding;
extern bool locale_utf8;
# 53 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/gfortran.h" 2
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/../include/splay-tree.h" 1
# 34 "/home/giulianob/gcc_git_gnu/gcc/gcc/../include/splay-tree.h"
extern "C" {
# 50 "/home/giulianob/gcc_git_gnu/gcc/gcc/../include/splay-tree.h"
typedef uintptr_t splay_tree_key;
typedef uintptr_t splay_tree_value;
typedef struct splay_tree_node_s *splay_tree_node;
typedef int (*splay_tree_compare_fn) (splay_tree_key, splay_tree_key);
# 67 "/home/giulianob/gcc_git_gnu/gcc/gcc/../include/splay-tree.h"
typedef void (*splay_tree_delete_key_fn) (splay_tree_key);
typedef void (*splay_tree_delete_value_fn) (splay_tree_value);
typedef int (*splay_tree_foreach_fn) (splay_tree_node, void*);
typedef void *(*splay_tree_allocate_fn) (int, void *);
typedef void (*splay_tree_deallocate_fn) (void *, void *);
struct splay_tree_node_s {
splay_tree_key key;
splay_tree_value value;
splay_tree_node left;
splay_tree_node right;
};
struct splay_tree_s {
splay_tree_node root;
splay_tree_compare_fn comp;
splay_tree_delete_key_fn delete_key;
splay_tree_delete_value_fn delete_value;
splay_tree_allocate_fn allocate;
splay_tree_deallocate_fn deallocate;
void *allocate_data;
};
typedef struct splay_tree_s *splay_tree;
extern splay_tree splay_tree_new (splay_tree_compare_fn,
splay_tree_delete_key_fn,
splay_tree_delete_value_fn);
extern splay_tree splay_tree_new_with_allocator (splay_tree_compare_fn,
splay_tree_delete_key_fn,
splay_tree_delete_value_fn,
splay_tree_allocate_fn,
splay_tree_deallocate_fn,
void *);
extern splay_tree splay_tree_new_typed_alloc (splay_tree_compare_fn,
splay_tree_delete_key_fn,
splay_tree_delete_value_fn,
splay_tree_allocate_fn,
splay_tree_allocate_fn,
splay_tree_deallocate_fn,
void *);
extern void splay_tree_delete (splay_tree);
extern splay_tree_node splay_tree_insert (splay_tree,
splay_tree_key,
splay_tree_value);
extern void splay_tree_remove (splay_tree, splay_tree_key);
extern splay_tree_node splay_tree_lookup (splay_tree, splay_tree_key);
extern splay_tree_node splay_tree_predecessor (splay_tree, splay_tree_key);
extern splay_tree_node splay_tree_successor (splay_tree, splay_tree_key);
extern splay_tree_node splay_tree_max (splay_tree);
extern splay_tree_node splay_tree_min (splay_tree);
extern int splay_tree_foreach (splay_tree, splay_tree_foreach_fn, void*);
extern int splay_tree_compare_ints (splay_tree_key, splay_tree_key);
extern int splay_tree_compare_pointers (splay_tree_key, splay_tree_key);
extern int splay_tree_compare_strings (splay_tree_key, splay_tree_key);
extern void splay_tree_delete_pointers (splay_tree_value);
}
# 54 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/gfortran.h" 2
# 100 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/gfortran.h"
typedef struct
{
const char *string;
const char *mp;
int tag;
}
mstring;
enum io_kind
{ M_READ, M_WRITE, M_PRINT, M_INQUIRE };
enum gfc_instring
{ NONSTRING = 0, INSTRING_WARN, INSTRING_NOWARN };
enum notification
{ SILENT, WARNING, ERROR };
enum match
{ MATCH_NO = 1, MATCH_YES, MATCH_ERROR };
enum gfc_source_form
{ FORM_FREE, FORM_FIXED, FORM_UNKNOWN };
enum expr_t
{ EXPR_UNKNOWN = 0, EXPR_OP = 1, EXPR_FUNCTION, EXPR_CONSTANT, EXPR_VARIABLE,
EXPR_SUBSTRING, EXPR_STRUCTURE, EXPR_ARRAY, EXPR_NULL, EXPR_COMPCALL, EXPR_PPC
};
enum array_type
{ AS_EXPLICIT = 1, AS_ASSUMED_SHAPE, AS_DEFERRED,
AS_ASSUMED_SIZE, AS_IMPLIED_SHAPE, AS_ASSUMED_RANK,
AS_UNKNOWN
};
enum ar_type
{ AR_FULL = 1, AR_ELEMENT, AR_SECTION, AR_UNKNOWN };
enum gfc_sl_type
{ ST_LABEL_UNKNOWN = 1, ST_LABEL_TARGET, ST_LABEL_DO_TARGET,
ST_LABEL_BAD_TARGET, ST_LABEL_FORMAT
};
enum gfc_intrinsic_op
{ GFC_INTRINSIC_BEGIN = 0,
INTRINSIC_NONE = -1, INTRINSIC_UPLUS = GFC_INTRINSIC_BEGIN,
INTRINSIC_UMINUS, INTRINSIC_PLUS, INTRINSIC_MINUS, INTRINSIC_TIMES,
INTRINSIC_DIVIDE, INTRINSIC_POWER, INTRINSIC_CONCAT,
INTRINSIC_AND, INTRINSIC_OR, INTRINSIC_EQV, INTRINSIC_NEQV,
INTRINSIC_EQ, INTRINSIC_NE, INTRINSIC_GT, INTRINSIC_GE,
INTRINSIC_LT, INTRINSIC_LE,
INTRINSIC_EQ_OS, INTRINSIC_NE_OS, INTRINSIC_GT_OS, INTRINSIC_GE_OS,
INTRINSIC_LT_OS, INTRINSIC_LE_OS,
INTRINSIC_NOT, INTRINSIC_USER, INTRINSIC_ASSIGN, INTRINSIC_PARENTHESES,
GFC_INTRINSIC_END,
INTRINSIC_FORMATTED, INTRINSIC_UNFORMATTED
};
enum arith
{ ARITH_OK = 1, ARITH_OVERFLOW, ARITH_UNDERFLOW, ARITH_NAN,
ARITH_DIV0, ARITH_INCOMMENSURATE, ARITH_ASYMMETRIC, ARITH_PROHIBIT,
ARITH_WRONGCONCAT
};
enum gfc_statement
{
ST_ARITHMETIC_IF, ST_ALLOCATE, ST_ATTR_DECL, ST_ASSOCIATE,
ST_BACKSPACE, ST_BLOCK, ST_BLOCK_DATA,
ST_CALL, ST_CASE, ST_CLOSE, ST_COMMON, ST_CONTINUE, ST_CONTAINS, ST_CYCLE,
ST_DATA, ST_DATA_DECL, ST_DEALLOCATE, ST_DO, ST_ELSE, ST_ELSEIF,
ST_ELSEWHERE, ST_END_ASSOCIATE, ST_END_BLOCK, ST_END_BLOCK_DATA,
ST_ENDDO, ST_IMPLIED_ENDDO, ST_END_FILE, ST_FINAL, ST_FLUSH, ST_END_FORALL,
ST_END_FUNCTION, ST_ENDIF, ST_END_INTERFACE, ST_END_MODULE, ST_END_SUBMODULE,
ST_END_PROGRAM, ST_END_SELECT, ST_END_SUBROUTINE, ST_END_WHERE, ST_END_TYPE,
ST_ENTRY, ST_EQUIVALENCE, ST_ERROR_STOP, ST_EXIT, ST_FORALL, ST_FORALL_BLOCK,
ST_FORMAT, ST_FUNCTION, ST_GOTO, ST_IF_BLOCK, ST_IMPLICIT, ST_IMPLICIT_NONE,
ST_IMPORT, ST_INQUIRE, ST_INTERFACE, ST_SYNC_ALL, ST_SYNC_MEMORY,
ST_SYNC_IMAGES, ST_PARAMETER, ST_MODULE, ST_SUBMODULE, ST_MODULE_PROC,
ST_NAMELIST, ST_NULLIFY, ST_OPEN, ST_PAUSE, ST_PRIVATE, ST_PROGRAM, ST_PUBLIC,
ST_READ, ST_RETURN, ST_REWIND, ST_STOP, ST_SUBROUTINE, ST_TYPE, ST_USE,
ST_WHERE_BLOCK, ST_WHERE, ST_WAIT, ST_WRITE, ST_ASSIGNMENT,
ST_POINTER_ASSIGNMENT, ST_SELECT_CASE, ST_SEQUENCE, ST_SIMPLE_IF,
ST_STATEMENT_FUNCTION, ST_DERIVED_DECL, ST_LABEL_ASSIGNMENT, ST_ENUM,
ST_ENUMERATOR, ST_END_ENUM, ST_SELECT_TYPE, ST_TYPE_IS, ST_CLASS_IS,
ST_SELECT_RANK, ST_RANK, ST_STRUCTURE_DECL, ST_END_STRUCTURE,
ST_UNION, ST_END_UNION, ST_MAP, ST_END_MAP,
ST_OACC_PARALLEL_LOOP, ST_OACC_END_PARALLEL_LOOP, ST_OACC_PARALLEL,
ST_OACC_END_PARALLEL, ST_OACC_KERNELS, ST_OACC_END_KERNELS, ST_OACC_DATA,
ST_OACC_END_DATA, ST_OACC_HOST_DATA, ST_OACC_END_HOST_DATA, ST_OACC_LOOP,
ST_OACC_END_LOOP, ST_OACC_DECLARE, ST_OACC_UPDATE, ST_OACC_WAIT,
ST_OACC_CACHE, ST_OACC_KERNELS_LOOP, ST_OACC_END_KERNELS_LOOP,
ST_OACC_SERIAL_LOOP, ST_OACC_END_SERIAL_LOOP, ST_OACC_SERIAL,
ST_OACC_END_SERIAL, ST_OACC_ENTER_DATA, ST_OACC_EXIT_DATA, ST_OACC_ROUTINE,
ST_OACC_ATOMIC, ST_OACC_END_ATOMIC,
ST_OMP_ATOMIC, ST_OMP_BARRIER, ST_OMP_CRITICAL, ST_OMP_END_ATOMIC,
ST_OMP_END_CRITICAL, ST_OMP_END_DO, ST_OMP_END_MASTER, ST_OMP_END_ORDERED,
ST_OMP_END_PARALLEL, ST_OMP_END_PARALLEL_DO, ST_OMP_END_PARALLEL_SECTIONS,
ST_OMP_END_PARALLEL_WORKSHARE, ST_OMP_END_SECTIONS, ST_OMP_END_SINGLE,
ST_OMP_END_WORKSHARE, ST_OMP_DO, ST_OMP_FLUSH, ST_OMP_MASTER, ST_OMP_ORDERED,
ST_OMP_PARALLEL, ST_OMP_PARALLEL_DO, ST_OMP_PARALLEL_SECTIONS,
ST_OMP_PARALLEL_WORKSHARE, ST_OMP_SECTIONS, ST_OMP_SECTION, ST_OMP_SINGLE,
ST_OMP_THREADPRIVATE, ST_OMP_WORKSHARE, ST_OMP_TASK, ST_OMP_END_TASK,
ST_OMP_TASKWAIT, ST_OMP_TASKYIELD, ST_OMP_CANCEL, ST_OMP_CANCELLATION_POINT,
ST_OMP_TASKGROUP, ST_OMP_END_TASKGROUP, ST_OMP_SIMD, ST_OMP_END_SIMD,
ST_OMP_DO_SIMD, ST_OMP_END_DO_SIMD, ST_OMP_PARALLEL_DO_SIMD,
ST_OMP_END_PARALLEL_DO_SIMD, ST_OMP_DECLARE_SIMD, ST_OMP_DECLARE_REDUCTION,
ST_OMP_TARGET, ST_OMP_END_TARGET, ST_OMP_TARGET_DATA, ST_OMP_END_TARGET_DATA,
ST_OMP_TARGET_UPDATE, ST_OMP_DECLARE_TARGET,
ST_OMP_TEAMS, ST_OMP_END_TEAMS, ST_OMP_DISTRIBUTE, ST_OMP_END_DISTRIBUTE,
ST_OMP_DISTRIBUTE_SIMD, ST_OMP_END_DISTRIBUTE_SIMD,
ST_OMP_DISTRIBUTE_PARALLEL_DO, ST_OMP_END_DISTRIBUTE_PARALLEL_DO,
ST_OMP_DISTRIBUTE_PARALLEL_DO_SIMD, ST_OMP_END_DISTRIBUTE_PARALLEL_DO_SIMD,
ST_OMP_TARGET_TEAMS, ST_OMP_END_TARGET_TEAMS, ST_OMP_TEAMS_DISTRIBUTE,
ST_OMP_END_TEAMS_DISTRIBUTE, ST_OMP_TEAMS_DISTRIBUTE_SIMD,
ST_OMP_END_TEAMS_DISTRIBUTE_SIMD, ST_OMP_TARGET_TEAMS_DISTRIBUTE,
ST_OMP_END_TARGET_TEAMS_DISTRIBUTE, ST_OMP_TARGET_TEAMS_DISTRIBUTE_SIMD,
ST_OMP_END_TARGET_TEAMS_DISTRIBUTE_SIMD, ST_OMP_TEAMS_DISTRIBUTE_PARALLEL_DO,
ST_OMP_END_TEAMS_DISTRIBUTE_PARALLEL_DO,
ST_OMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_DO,
ST_OMP_END_TARGET_TEAMS_DISTRIBUTE_PARALLEL_DO,
ST_OMP_TEAMS_DISTRIBUTE_PARALLEL_DO_SIMD,
ST_OMP_END_TEAMS_DISTRIBUTE_PARALLEL_DO_SIMD,
ST_OMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_DO_SIMD,
ST_OMP_END_TARGET_TEAMS_DISTRIBUTE_PARALLEL_DO_SIMD,
ST_OMP_TARGET_PARALLEL, ST_OMP_END_TARGET_PARALLEL,
ST_OMP_TARGET_PARALLEL_DO, ST_OMP_END_TARGET_PARALLEL_DO,
ST_OMP_TARGET_PARALLEL_DO_SIMD, ST_OMP_END_TARGET_PARALLEL_DO_SIMD,
ST_OMP_TARGET_ENTER_DATA, ST_OMP_TARGET_EXIT_DATA,
ST_OMP_TARGET_SIMD, ST_OMP_END_TARGET_SIMD,
ST_OMP_TASKLOOP, ST_OMP_END_TASKLOOP,
ST_OMP_TASKLOOP_SIMD, ST_OMP_END_TASKLOOP_SIMD, ST_OMP_ORDERED_DEPEND,
ST_OMP_REQUIRES, ST_PROCEDURE, ST_GENERIC, ST_CRITICAL, ST_END_CRITICAL,
ST_GET_FCN_CHARACTERISTICS, ST_LOCK, ST_UNLOCK, ST_EVENT_POST,
ST_EVENT_WAIT, ST_FAIL_IMAGE, ST_FORM_TEAM, ST_CHANGE_TEAM,
ST_END_TEAM, ST_SYNC_TEAM, ST_NONE
};
enum interface_type
{
INTERFACE_NAMELESS = 1, INTERFACE_GENERIC,
INTERFACE_INTRINSIC_OP, INTERFACE_USER_OP, INTERFACE_ABSTRACT,
INTERFACE_DTIO
};
enum sym_flavor
{
FL_UNKNOWN = 0, FL_PROGRAM, FL_BLOCK_DATA, FL_MODULE, FL_VARIABLE,
FL_PARAMETER, FL_LABEL, FL_PROCEDURE, FL_DERIVED, FL_NAMELIST,
FL_UNION, FL_STRUCT, FL_VOID
};
enum procedure_type
{ PROC_UNKNOWN, PROC_MODULE, PROC_INTERNAL, PROC_DUMMY,
PROC_INTRINSIC, PROC_ST_FUNCTION, PROC_EXTERNAL
};
enum sym_intent
{ INTENT_UNKNOWN = 0, INTENT_IN, INTENT_OUT, INTENT_INOUT
};
enum gfc_access
{ ACCESS_UNKNOWN = 0, ACCESS_PUBLIC, ACCESS_PRIVATE
};
enum ifsrc
{ IFSRC_UNKNOWN = 0,
IFSRC_DECL,
IFSRC_IFBODY
};
enum save_state
{ SAVE_NONE = 0, SAVE_EXPLICIT, SAVE_IMPLICIT
};
enum oacc_routine_lop
{ OACC_ROUTINE_LOP_NONE = 0,
OACC_ROUTINE_LOP_GANG,
OACC_ROUTINE_LOP_WORKER,
OACC_ROUTINE_LOP_VECTOR,
OACC_ROUTINE_LOP_SEQ,
OACC_ROUTINE_LOP_ERROR
};
extern const mstring flavors[];
extern const mstring procedures[];
extern const mstring intents[];
extern const mstring access_types[];
extern const mstring ifsrc_types[];
extern const mstring save_status[];
extern const mstring dtio_procs[];
enum dtio_codes
{ DTIO_RF = 0, DTIO_WF, DTIO_RUF, DTIO_WUF };
enum gfc_isym_id
{
GFC_ISYM_NONE = 0,
GFC_ISYM_ABORT,
GFC_ISYM_ABS,
GFC_ISYM_ACCESS,
GFC_ISYM_ACHAR,
GFC_ISYM_ACOS,
GFC_ISYM_ACOSD,
GFC_ISYM_ACOSH,
GFC_ISYM_ADJUSTL,
GFC_ISYM_ADJUSTR,
GFC_ISYM_AIMAG,
GFC_ISYM_AINT,
GFC_ISYM_ALARM,
GFC_ISYM_ALL,
GFC_ISYM_ALLOCATED,
GFC_ISYM_AND,
GFC_ISYM_ANINT,
GFC_ISYM_ANY,
GFC_ISYM_ASIN,
GFC_ISYM_ASIND,
GFC_ISYM_ASINH,
GFC_ISYM_ASSOCIATED,
GFC_ISYM_ATAN,
GFC_ISYM_ATAN2,
GFC_ISYM_ATAN2D,
GFC_ISYM_ATAND,
GFC_ISYM_ATANH,
GFC_ISYM_ATOMIC_ADD,
GFC_ISYM_ATOMIC_AND,
GFC_ISYM_ATOMIC_CAS,
GFC_ISYM_ATOMIC_DEF,
GFC_ISYM_ATOMIC_FETCH_ADD,
GFC_ISYM_ATOMIC_FETCH_AND,
GFC_ISYM_ATOMIC_FETCH_OR,
GFC_ISYM_ATOMIC_FETCH_XOR,
GFC_ISYM_ATOMIC_OR,
GFC_ISYM_ATOMIC_REF,
GFC_ISYM_ATOMIC_XOR,
GFC_ISYM_BGE,
GFC_ISYM_BGT,
GFC_ISYM_BIT_SIZE,
GFC_ISYM_BLE,
GFC_ISYM_BLT,
GFC_ISYM_BTEST,
GFC_ISYM_CAF_GET,
GFC_ISYM_CAF_SEND,
GFC_ISYM_CEILING,
GFC_ISYM_CHAR,
GFC_ISYM_CHDIR,
GFC_ISYM_CHMOD,
GFC_ISYM_CMPLX,
GFC_ISYM_CO_BROADCAST,
GFC_ISYM_CO_MAX,
GFC_ISYM_CO_MIN,
GFC_ISYM_CO_REDUCE,
GFC_ISYM_CO_SUM,
GFC_ISYM_COMMAND_ARGUMENT_COUNT,
GFC_ISYM_COMPILER_OPTIONS,
GFC_ISYM_COMPILER_VERSION,
GFC_ISYM_COMPLEX,
GFC_ISYM_CONJG,
GFC_ISYM_CONVERSION,
GFC_ISYM_COS,
GFC_ISYM_COSD,
GFC_ISYM_COSH,
GFC_ISYM_COTAN,
GFC_ISYM_COTAND,
GFC_ISYM_COUNT,
GFC_ISYM_CPU_TIME,
GFC_ISYM_CSHIFT,
GFC_ISYM_CTIME,
GFC_ISYM_C_ASSOCIATED,
GFC_ISYM_C_F_POINTER,
GFC_ISYM_C_F_PROCPOINTER,
GFC_ISYM_C_FUNLOC,
GFC_ISYM_C_LOC,
GFC_ISYM_C_SIZEOF,
GFC_ISYM_DATE_AND_TIME,
GFC_ISYM_DBLE,
GFC_ISYM_DFLOAT,
GFC_ISYM_DIGITS,
GFC_ISYM_DIM,
GFC_ISYM_DOT_PRODUCT,
GFC_ISYM_DPROD,
GFC_ISYM_DSHIFTL,
GFC_ISYM_DSHIFTR,
GFC_ISYM_DTIME,
GFC_ISYM_EOSHIFT,
GFC_ISYM_EPSILON,
GFC_ISYM_ERF,
GFC_ISYM_ERFC,
GFC_ISYM_ERFC_SCALED,
GFC_ISYM_ETIME,
GFC_ISYM_EVENT_QUERY,
GFC_ISYM_EXECUTE_COMMAND_LINE,
GFC_ISYM_EXIT,
GFC_ISYM_EXP,
GFC_ISYM_EXPONENT,
GFC_ISYM_EXTENDS_TYPE_OF,
GFC_ISYM_FAILED_IMAGES,
GFC_ISYM_FDATE,
GFC_ISYM_FE_RUNTIME_ERROR,
GFC_ISYM_FGET,
GFC_ISYM_FGETC,
GFC_ISYM_FINDLOC,
GFC_ISYM_FLOAT,
GFC_ISYM_FLOOR,
GFC_ISYM_FLUSH,
GFC_ISYM_FNUM,
GFC_ISYM_FPUT,
GFC_ISYM_FPUTC,
GFC_ISYM_FRACTION,
GFC_ISYM_FREE,
GFC_ISYM_FSEEK,
GFC_ISYM_FSTAT,
GFC_ISYM_FTELL,
GFC_ISYM_TGAMMA,
GFC_ISYM_GERROR,
GFC_ISYM_GETARG,
GFC_ISYM_GET_COMMAND,
GFC_ISYM_GET_COMMAND_ARGUMENT,
GFC_ISYM_GETCWD,
GFC_ISYM_GETENV,
GFC_ISYM_GET_ENVIRONMENT_VARIABLE,
GFC_ISYM_GETGID,
GFC_ISYM_GETLOG,
GFC_ISYM_GETPID,
GFC_ISYM_GET_TEAM,
GFC_ISYM_GETUID,
GFC_ISYM_GMTIME,
GFC_ISYM_HOSTNM,
GFC_ISYM_HUGE,
GFC_ISYM_HYPOT,
GFC_ISYM_IACHAR,
GFC_ISYM_IALL,
GFC_ISYM_IAND,
GFC_ISYM_IANY,
GFC_ISYM_IARGC,
GFC_ISYM_IBCLR,
GFC_ISYM_IBITS,
GFC_ISYM_IBSET,
GFC_ISYM_ICHAR,
GFC_ISYM_IDATE,
GFC_ISYM_IEOR,
GFC_ISYM_IERRNO,
GFC_ISYM_IMAGE_INDEX,
GFC_ISYM_IMAGE_STATUS,
GFC_ISYM_INDEX,
GFC_ISYM_INT,
GFC_ISYM_INT2,
GFC_ISYM_INT8,
GFC_ISYM_IOR,
GFC_ISYM_IPARITY,
GFC_ISYM_IRAND,
GFC_ISYM_ISATTY,
GFC_ISYM_IS_CONTIGUOUS,
GFC_ISYM_IS_IOSTAT_END,
GFC_ISYM_IS_IOSTAT_EOR,
GFC_ISYM_ISNAN,
GFC_ISYM_ISHFT,
GFC_ISYM_ISHFTC,
GFC_ISYM_ITIME,
GFC_ISYM_J0,
GFC_ISYM_J1,
GFC_ISYM_JN,
GFC_ISYM_JN2,
GFC_ISYM_KILL,
GFC_ISYM_KIND,
GFC_ISYM_LBOUND,
GFC_ISYM_LCOBOUND,
GFC_ISYM_LEADZ,
GFC_ISYM_LEN,
GFC_ISYM_LEN_TRIM,
GFC_ISYM_LGAMMA,
GFC_ISYM_LGE,
GFC_ISYM_LGT,
GFC_ISYM_LINK,
GFC_ISYM_LLE,
GFC_ISYM_LLT,
GFC_ISYM_LOC,
GFC_ISYM_LOG,
GFC_ISYM_LOG10,
GFC_ISYM_LOGICAL,
GFC_ISYM_LONG,
GFC_ISYM_LSHIFT,
GFC_ISYM_LSTAT,
GFC_ISYM_LTIME,
GFC_ISYM_MALLOC,
GFC_ISYM_MASKL,
GFC_ISYM_MASKR,
GFC_ISYM_MATMUL,
GFC_ISYM_MAX,
GFC_ISYM_MAXEXPONENT,
GFC_ISYM_MAXLOC,
GFC_ISYM_MAXVAL,
GFC_ISYM_MCLOCK,
GFC_ISYM_MCLOCK8,
GFC_ISYM_MERGE,
GFC_ISYM_MERGE_BITS,
GFC_ISYM_MIN,
GFC_ISYM_MINEXPONENT,
GFC_ISYM_MINLOC,
GFC_ISYM_MINVAL,
GFC_ISYM_MOD,
GFC_ISYM_MODULO,
GFC_ISYM_MOVE_ALLOC,
GFC_ISYM_MVBITS,
GFC_ISYM_NEAREST,
GFC_ISYM_NEW_LINE,
GFC_ISYM_NINT,
GFC_ISYM_NORM2,
GFC_ISYM_NOT,
GFC_ISYM_NULL,
GFC_ISYM_NUM_IMAGES,
GFC_ISYM_OR,
GFC_ISYM_PACK,
GFC_ISYM_PARITY,
GFC_ISYM_PERROR,
GFC_ISYM_POPCNT,
GFC_ISYM_POPPAR,
GFC_ISYM_PRECISION,
GFC_ISYM_PRESENT,
GFC_ISYM_PRODUCT,
GFC_ISYM_RADIX,
GFC_ISYM_RAND,
GFC_ISYM_RANDOM_INIT,
GFC_ISYM_RANDOM_NUMBER,
GFC_ISYM_RANDOM_SEED,
GFC_ISYM_RANGE,
GFC_ISYM_RANK,
GFC_ISYM_REAL,
GFC_ISYM_REALPART,
GFC_ISYM_RENAME,
GFC_ISYM_REPEAT,
GFC_ISYM_RESHAPE,
GFC_ISYM_RRSPACING,
GFC_ISYM_RSHIFT,
GFC_ISYM_SAME_TYPE_AS,
GFC_ISYM_SC_KIND,
GFC_ISYM_SCALE,
GFC_ISYM_SCAN,
GFC_ISYM_SECNDS,
GFC_ISYM_SECOND,
GFC_ISYM_SET_EXPONENT,
GFC_ISYM_SHAPE,
GFC_ISYM_SHIFTA,
GFC_ISYM_SHIFTL,
GFC_ISYM_SHIFTR,
GFC_ISYM_BACKTRACE,
GFC_ISYM_SIGN,
GFC_ISYM_SIGNAL,
GFC_ISYM_SI_KIND,
GFC_ISYM_SIN,
GFC_ISYM_SIND,
GFC_ISYM_SINH,
GFC_ISYM_SIZE,
GFC_ISYM_SLEEP,
GFC_ISYM_SIZEOF,
GFC_ISYM_SNGL,
GFC_ISYM_SPACING,
GFC_ISYM_SPREAD,
GFC_ISYM_SQRT,
GFC_ISYM_SRAND,
GFC_ISYM_SR_KIND,
GFC_ISYM_STAT,
GFC_ISYM_STOPPED_IMAGES,
GFC_ISYM_STORAGE_SIZE,
GFC_ISYM_STRIDE,
GFC_ISYM_SUM,
GFC_ISYM_SYMLINK,
GFC_ISYM_SYMLNK,
GFC_ISYM_SYSTEM,
GFC_ISYM_SYSTEM_CLOCK,
GFC_ISYM_TAN,
GFC_ISYM_TAND,
GFC_ISYM_TANH,
GFC_ISYM_TEAM_NUMBER,
GFC_ISYM_THIS_IMAGE,
GFC_ISYM_TIME,
GFC_ISYM_TIME8,
GFC_ISYM_TINY,
GFC_ISYM_TRAILZ,
GFC_ISYM_TRANSFER,
GFC_ISYM_TRANSPOSE,
GFC_ISYM_TRIM,
GFC_ISYM_TTYNAM,
GFC_ISYM_UBOUND,
GFC_ISYM_UCOBOUND,
GFC_ISYM_UMASK,
GFC_ISYM_UNLINK,
GFC_ISYM_UNPACK,
GFC_ISYM_VERIFY,
GFC_ISYM_XOR,
GFC_ISYM_Y0,
GFC_ISYM_Y1,
GFC_ISYM_YN,
GFC_ISYM_YN2
};
enum init_local_logical
{
GFC_INIT_LOGICAL_OFF = 0,
GFC_INIT_LOGICAL_FALSE,
GFC_INIT_LOGICAL_TRUE
};
enum init_local_character
{
GFC_INIT_CHARACTER_OFF = 0,
GFC_INIT_CHARACTER_ON
};
enum init_local_integer
{
GFC_INIT_INTEGER_OFF = 0,
GFC_INIT_INTEGER_ON
};
enum gfc_reverse
{
GFC_ENABLE_REVERSE,
GFC_FORWARD_SET,
GFC_REVERSE_SET,
GFC_INHIBIT_REVERSE
};
enum gfc_param_spec_type
{
SPEC_EXPLICIT,
SPEC_ASSUMED,
SPEC_DEFERRED
};
# 697 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/gfortran.h"
enum iso_fortran_env_symbol
{
ISOFORTRANENV_INVALID = -1,
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/iso-fortran-env.def" 1
# 44 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/iso-fortran-env.def"
ISOFORTRANENV_FILE_ATOMIC_INT_KIND,
ISOFORTRANENV_FILE_ATOMIC_LOGICAL_KIND,
ISOFORTRANENV_CHARACTER_STORAGE_SIZE,
ISOFORTRANENV_ERROR_UNIT,
ISOFORTRANENV_FILE_STORAGE_SIZE,
ISOFORTRANENV_INPUT_UNIT,
ISOFORTRANENV_INT8,
ISOFORTRANENV_INT16,
ISOFORTRANENV_INT32,
ISOFORTRANENV_INT64,
ISOFORTRANENV_IOSTAT_END,
ISOFORTRANENV_IOSTAT_EOR,
ISOFORTRANENV_IOSTAT_INQUIRE_INTERNAL_UNIT,
ISOFORTRANENV_NUMERIC_STORAGE_SIZE,
ISOFORTRANENV_OUTPUT_UNIT,
ISOFORTRANENV_REAL32,
ISOFORTRANENV_REAL64,
ISOFORTRANENV_REAL128,
ISOFORTRANENV_FILE_STAT_LOCKED,
ISOFORTRANENV_FILE_STAT_LOCKED_OTHER_IMAGE,
ISOFORTRANENV_FILE_STAT_STOPPED_IMAGE,
ISOFORTRANENV_FILE_STAT_FAILED_IMAGE,
ISOFORTRANENV_FILE_STAT_UNLOCKED,
# 100 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/iso-fortran-env.def"
ISOFORTRAN_CHARACTER_KINDS,
ISOFORTRAN_INTEGER_KINDS,
ISOFORTRAN_LOGICAL_KINDS,
ISOFORTRAN_REAL_KINDS,
ISOFORTRAN_COMPILER_OPTIONS,
ISOFORTRAN_COMPILER_VERSION,
ISOFORTRAN_LOCK_TYPE,
ISOFORTRAN_EVENT_TYPE,
ISOFORTRAN_TEAM_TYPE,
# 701 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/gfortran.h" 2
ISOFORTRANENV_LAST, ISOFORTRANENV_NUMBER = ISOFORTRANENV_LAST
};
# 718 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/gfortran.h"
enum iso_c_binding_symbol
{
ISOCBINDING_INVALID = -1,
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/iso-c-binding.def" 1
# 56 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/iso-c-binding.def"
ISOCBINDING_INT,
ISOCBINDING_SHORT,
ISOCBINDING_LONG,
ISOCBINDING_LONG_LONG,
ISOCBINDING_INTMAX_T,
ISOCBINDING_INTPTR_T,
ISOCBINDING_PTRDIFF_T,
ISOCBINDING_SIZE_T,
ISOCBINDING_SIGNED_CHAR,
ISOCBINDING_INT8_T,
ISOCBINDING_INT16_T,
ISOCBINDING_INT32_T,
ISOCBINDING_INT64_T,
ISOCBINDING_INT128_T,
ISOCBINDING_INT_LEAST8_T,
ISOCBINDING_INT_LEAST16_T,
ISOCBINDING_INT_LEAST32_T,
ISOCBINDING_INT_LEAST64_T,
ISOCBINDING_INT_LEAST128_T,
ISOCBINDING_INT_FAST8_T,
ISOCBINDING_INT_FAST16_T,
ISOCBINDING_INT_FAST32_T,
ISOCBINDING_INT_FAST64_T,
ISOCBINDING_INT_FAST128_T,
ISOCBINDING_FLOAT,
ISOCBINDING_DOUBLE,
ISOCBINDING_LONG_DOUBLE,
ISOCBINDING_FLOAT128,
ISOCBINDING_FLOAT_COMPLEX,
ISOCBINDING_DOUBLE_COMPLEX,
ISOCBINDING_LONG_DOUBLE_COMPLEX,
ISOCBINDING_FLOAT128_COMPLEX,
ISOCBINDING_BOOL,
ISOCBINDING_CHAR,
ISOCBINDING_NULL_CHAR,
ISOCBINDING_ALERT,
ISOCBINDING_BACKSPACE,
ISOCBINDING_FORM_FEED,
ISOCBINDING_NEW_LINE,
ISOCBINDING_CARRIAGE_RETURN,
ISOCBINDING_HORIZONTAL_TAB,
ISOCBINDING_VERTICAL_TAB,
ISOCBINDING_PTR,
ISOCBINDING_NULL_PTR,
ISOCBINDING_FUNPTR,
ISOCBINDING_NULL_FUNPTR,
ISOCBINDING_F_POINTER,
ISOCBINDING_F_PROCPOINTER,
ISOCBINDING_ASSOCIATED,
ISOCBINDING_FUNLOC,
ISOCBINDING_LOC,
ISOCBINDING_C_SIZEOF,
# 722 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/gfortran.h" 2
ISOCBINDING_LAST,
ISOCBINDING_NUMBER = ISOCBINDING_LAST
};
# 735 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/gfortran.h"
enum intmod_id
{
INTMOD_NONE = 0, INTMOD_ISO_FORTRAN_ENV, INTMOD_ISO_C_BINDING,
INTMOD_IEEE_FEATURES, INTMOD_IEEE_EXCEPTIONS, INTMOD_IEEE_ARITHMETIC
};
typedef struct
{
char name[63 + 1];
int value;
bt f90_type;
}
CInteropKind_t;
extern CInteropKind_t c_interop_kinds_table[];
typedef enum
{
EXT_ATTR_DLLIMPORT = 0,
EXT_ATTR_DLLEXPORT,
EXT_ATTR_STDCALL,
EXT_ATTR_CDECL,
EXT_ATTR_FASTCALL,
EXT_ATTR_NO_ARG_CHECK,
EXT_ATTR_LAST, EXT_ATTR_NUM = EXT_ATTR_LAST
}
ext_attr_id_t;
typedef struct
{
const char *name;
unsigned id;
const char *middle_end_name;
}
ext_attr_t;
extern const ext_attr_t ext_attr_list[];
typedef struct
{
unsigned allocatable:1, dimension:1, codimension:1, external:1, intrinsic:1,
optional:1, pointer:1, target:1, value:1, volatile_:1, temporary:1,
dummy:1, result:1, assign:1, threadprivate:1, not_always_present:1,
implied_index:1, subref_array_pointer:1, proc_pointer:1, asynchronous:1,
contiguous:1, fe_temp: 1, automatic: 1;
unsigned class_pointer:1;
enum save_state save:2;
unsigned data:1,
is_protected:1,
use_assoc:1,
used_in_submodule:1,
use_only:1,
use_rename:1,
imported:1,
host_assoc:1;
unsigned in_namelist:1, in_common:1, in_equivalence:1;
unsigned function:1, subroutine:1, procedure:1;
unsigned generic:1, generic_copy:1;
unsigned implicit_type:1;
unsigned untyped:1;
unsigned is_bind_c:1;
unsigned extension:8;
unsigned is_class:1;
unsigned class_ok:1;
unsigned vtab:1;
unsigned vtype:1;
unsigned is_c_interop:1;
unsigned is_iso_c:1;
unsigned sequence:1, elemental:1, pure:1, recursive:1;
unsigned unmaskable:1, masked:1, contained:1, mod_proc:1, abstract:1;
unsigned module_procedure:1;
unsigned public_used:1;
unsigned implicit_pure:1;
unsigned array_outer_dependency:1;
unsigned noreturn:1;
unsigned entry:1;
unsigned entry_master:1;
unsigned mixed_entry_master:1;
unsigned always_explicit:1;
unsigned artificial:1;
unsigned referenced:1;
unsigned is_main_program:1;
enum gfc_access access:2;
enum sym_intent intent:2;
enum sym_flavor flavor:4;
enum ifsrc if_source:2;
enum procedure_type proc:3;
unsigned cray_pointer:1, cray_pointee:1;
# 901 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/gfortran.h"
unsigned alloc_comp:1, pointer_comp:1, proc_pointer_comp:1,
private_comp:1, zero_comp:1, coarray_comp:1, lock_comp:1,
event_comp:1, defined_assign_comp:1, unlimited_polymorphic:1,
has_dtio_procs:1, caf_token:1;
unsigned select_type_temporary:1, select_rank_temporary:1, associate_var:1;
unsigned pdt_kind:1, pdt_len:1, pdt_type:1, pdt_template:1,
pdt_array:1, pdt_string:1;
unsigned omp_udr_artificial_var:1;
unsigned omp_declare_target:1;
unsigned omp_declare_target_link:1;
unsigned oacc_declare_create:1;
unsigned oacc_declare_copyin:1;
unsigned oacc_declare_deviceptr:1;
unsigned oacc_declare_device_resident:1;
unsigned oacc_declare_link:1;
enum oacc_routine_lop oacc_routine_lop:3;
unsigned ext_attr:EXT_ATTR_NUM;
struct gfc_namespace *volatile_ns, *asynchronous_ns;
}
symbol_attribute;
typedef unsigned int gfc_char_t;
# 970 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/gfortran.h"
typedef struct gfc_file
{
struct gfc_file *next, *up;
int inclusion_line, line;
char *filename;
} gfc_file;
typedef struct gfc_linebuf
{
location_t location;
struct gfc_file *file;
struct gfc_linebuf *next;
int truncated;
bool dbg_emitted;
gfc_char_t line[1];
} gfc_linebuf;
typedef struct
{
gfc_char_t *nextc;
gfc_linebuf *lb;
} locus;
# 1010 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/gfortran.h"
void gfc_push_suppress_errors (void);
void gfc_pop_suppress_errors (void);
# 1025 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/gfortran.h"
typedef struct gfc_charlen
{
struct gfc_expr *length;
struct gfc_charlen *next;
bool length_from_typespec;
tree backend_decl;
tree passed_length;
int resolved;
}
gfc_charlen;
typedef struct
{
bt type;
int kind;
union
{
struct gfc_symbol *derived;
gfc_charlen *cl;
int pad;
}
u;
struct gfc_symbol *interface;
int is_c_interop;
int is_iso_c;
bt f90_type;
bool deferred;
gfc_symbol *interop_kind;
}
gfc_typespec;
typedef struct
{
int rank;
int corank;
array_type type, cotype;
struct gfc_expr *lower[15], *upper[15];
bool cray_pointee;
bool cp_was_assumed;
bool resolved;
}
gfc_array_spec;
typedef struct gfc_component
{
const char *name;
gfc_typespec ts;
symbol_attribute attr;
gfc_array_spec *as;
tree backend_decl;
tree norestrict_decl;
locus loc;
struct gfc_expr *initializer;
struct gfc_expr *kind_expr;
struct gfc_actual_arglist *param_list;
struct gfc_component *next;
struct gfc_typebound_proc *tb;
tree caf_token;
}
gfc_component;
typedef struct gfc_formal_arglist
{
struct gfc_symbol *sym;
struct gfc_formal_arglist *next;
}
gfc_formal_arglist;
typedef struct gfc_actual_arglist
{
const char *name;
struct gfc_st_label *label;
bt missing_arg_type;
gfc_param_spec_type spec_type;
struct gfc_expr *expr;
struct gfc_actual_arglist *next;
}
gfc_actual_arglist;
typedef struct gfc_namelist
{
struct gfc_symbol *sym;
struct gfc_namelist *next;
}
gfc_namelist;
typedef struct gfc_expr_list
{
struct gfc_expr *expr;
struct gfc_expr_list *next;
}
gfc_expr_list;
enum gfc_omp_reduction_op
{
OMP_REDUCTION_NONE = -1,
OMP_REDUCTION_PLUS = INTRINSIC_PLUS,
OMP_REDUCTION_MINUS = INTRINSIC_MINUS,
OMP_REDUCTION_TIMES = INTRINSIC_TIMES,
OMP_REDUCTION_AND = INTRINSIC_AND,
OMP_REDUCTION_OR = INTRINSIC_OR,
OMP_REDUCTION_EQV = INTRINSIC_EQV,
OMP_REDUCTION_NEQV = INTRINSIC_NEQV,
OMP_REDUCTION_MAX = GFC_INTRINSIC_END,
OMP_REDUCTION_MIN,
OMP_REDUCTION_IAND,
OMP_REDUCTION_IOR,
OMP_REDUCTION_IEOR,
OMP_REDUCTION_USER
};
enum gfc_omp_depend_op
{
OMP_DEPEND_IN,
OMP_DEPEND_OUT,
OMP_DEPEND_INOUT,
OMP_DEPEND_SINK_FIRST,
OMP_DEPEND_SINK
};
enum gfc_omp_map_op
{
OMP_MAP_ALLOC,
OMP_MAP_IF_PRESENT,
OMP_MAP_ATTACH,
OMP_MAP_TO,
OMP_MAP_FROM,
OMP_MAP_TOFROM,
OMP_MAP_DELETE,
OMP_MAP_DETACH,
OMP_MAP_FORCE_ALLOC,
OMP_MAP_FORCE_TO,
OMP_MAP_FORCE_FROM,
OMP_MAP_FORCE_TOFROM,
OMP_MAP_FORCE_PRESENT,
OMP_MAP_FORCE_DEVICEPTR,
OMP_MAP_DEVICE_RESIDENT,
OMP_MAP_LINK,
OMP_MAP_RELEASE,
OMP_MAP_ALWAYS_TO,
OMP_MAP_ALWAYS_FROM,
OMP_MAP_ALWAYS_TOFROM
};
enum gfc_omp_linear_op
{
OMP_LINEAR_DEFAULT,
OMP_LINEAR_REF,
OMP_LINEAR_VAL,
OMP_LINEAR_UVAL
};
typedef struct gfc_omp_namelist
{
struct gfc_symbol *sym;
struct gfc_expr *expr;
union
{
gfc_omp_reduction_op reduction_op;
gfc_omp_depend_op depend_op;
gfc_omp_map_op map_op;
gfc_omp_linear_op linear_op;
struct gfc_common_head *common;
bool lastprivate_conditional;
} u;
struct gfc_omp_namelist_udr *udr;
struct gfc_omp_namelist *next;
locus where;
}
gfc_omp_namelist;
enum
{
OMP_LIST_FIRST,
OMP_LIST_PRIVATE = OMP_LIST_FIRST,
OMP_LIST_FIRSTPRIVATE,
OMP_LIST_LASTPRIVATE,
OMP_LIST_COPYPRIVATE,
OMP_LIST_SHARED,
OMP_LIST_COPYIN,
OMP_LIST_UNIFORM,
OMP_LIST_ALIGNED,
OMP_LIST_LINEAR,
OMP_LIST_DEPEND,
OMP_LIST_MAP,
OMP_LIST_TO,
OMP_LIST_FROM,
OMP_LIST_REDUCTION,
OMP_LIST_DEVICE_RESIDENT,
OMP_LIST_LINK,
OMP_LIST_USE_DEVICE,
OMP_LIST_CACHE,
OMP_LIST_IS_DEVICE_PTR,
OMP_LIST_USE_DEVICE_PTR,
OMP_LIST_USE_DEVICE_ADDR,
OMP_LIST_NONTEMPORAL,
OMP_LIST_NUM
};
enum gfc_omp_sched_kind
{
OMP_SCHED_NONE,
OMP_SCHED_STATIC,
OMP_SCHED_DYNAMIC,
OMP_SCHED_GUIDED,
OMP_SCHED_RUNTIME,
OMP_SCHED_AUTO
};
enum gfc_omp_default_sharing
{
OMP_DEFAULT_UNKNOWN,
OMP_DEFAULT_NONE,
OMP_DEFAULT_PRIVATE,
OMP_DEFAULT_SHARED,
OMP_DEFAULT_FIRSTPRIVATE,
OMP_DEFAULT_PRESENT
};
enum gfc_omp_proc_bind_kind
{
OMP_PROC_BIND_UNKNOWN,
OMP_PROC_BIND_MASTER,
OMP_PROC_BIND_SPREAD,
OMP_PROC_BIND_CLOSE
};
enum gfc_omp_cancel_kind
{
OMP_CANCEL_UNKNOWN,
OMP_CANCEL_PARALLEL,
OMP_CANCEL_SECTIONS,
OMP_CANCEL_DO,
OMP_CANCEL_TASKGROUP
};
enum gfc_omp_if_kind
{
OMP_IF_CANCEL,
OMP_IF_PARALLEL,
OMP_IF_SIMD,
OMP_IF_TASK,
OMP_IF_TASKLOOP,
OMP_IF_TARGET,
OMP_IF_TARGET_DATA,
OMP_IF_TARGET_UPDATE,
OMP_IF_TARGET_ENTER_DATA,
OMP_IF_TARGET_EXIT_DATA,
OMP_IF_LAST
};
enum gfc_omp_requires_kind
{
OMP_REQ_ATOMIC_MEM_ORDER_SEQ_CST = 1,
OMP_REQ_ATOMIC_MEM_ORDER_ACQ_REL = 2,
OMP_REQ_ATOMIC_MEM_ORDER_RELAXED = 3,
OMP_REQ_REVERSE_OFFLOAD = (1 << 2),
OMP_REQ_UNIFIED_ADDRESS = (1 << 3),
OMP_REQ_UNIFIED_SHARED_MEMORY = (1 << 4),
OMP_REQ_DYNAMIC_ALLOCATORS = (1 << 5),
OMP_REQ_TARGET_MASK = (OMP_REQ_REVERSE_OFFLOAD
| OMP_REQ_UNIFIED_ADDRESS
| OMP_REQ_UNIFIED_SHARED_MEMORY),
OMP_REQ_ATOMIC_MEM_ORDER_MASK = (OMP_REQ_ATOMIC_MEM_ORDER_SEQ_CST
| OMP_REQ_ATOMIC_MEM_ORDER_ACQ_REL
| OMP_REQ_ATOMIC_MEM_ORDER_RELAXED)
};
typedef struct gfc_omp_clauses
{
struct gfc_expr *if_expr;
struct gfc_expr *final_expr;
struct gfc_expr *num_threads;
gfc_omp_namelist *lists[OMP_LIST_NUM];
enum gfc_omp_sched_kind sched_kind;
struct gfc_expr *chunk_size;
enum gfc_omp_default_sharing default_sharing;
int collapse, orderedc;
bool nowait, ordered, untied, mergeable;
bool inbranch, notinbranch, defaultmap, nogroup;
bool sched_simd, sched_monotonic, sched_nonmonotonic;
bool simd, threads, depend_source, order_concurrent;
enum gfc_omp_cancel_kind cancel;
enum gfc_omp_proc_bind_kind proc_bind;
struct gfc_expr *safelen_expr;
struct gfc_expr *simdlen_expr;
struct gfc_expr *num_teams;
struct gfc_expr *device;
struct gfc_expr *thread_limit;
struct gfc_expr *grainsize;
struct gfc_expr *hint;
struct gfc_expr *num_tasks;
struct gfc_expr *priority;
struct gfc_expr *if_exprs[OMP_IF_LAST];
enum gfc_omp_sched_kind dist_sched_kind;
struct gfc_expr *dist_chunk_size;
const char *critical_name;
struct gfc_expr *async_expr;
struct gfc_expr *gang_static_expr;
struct gfc_expr *gang_num_expr;
struct gfc_expr *worker_expr;
struct gfc_expr *vector_expr;
struct gfc_expr *num_gangs_expr;
struct gfc_expr *num_workers_expr;
struct gfc_expr *vector_length_expr;
gfc_expr_list *wait_list;
gfc_expr_list *tile_list;
unsigned async:1, gang:1, worker:1, vector:1, seq:1, independent:1;
unsigned par_auto:1, gang_static:1;
unsigned if_present:1, finalize:1;
locus loc;
}
gfc_omp_clauses;
typedef struct gfc_oacc_declare
{
struct gfc_oacc_declare *next;
bool module_var;
gfc_omp_clauses *clauses;
locus loc;
}
gfc_oacc_declare;
typedef struct gfc_omp_declare_simd
{
struct gfc_omp_declare_simd *next;
locus where;
gfc_symbol *proc_name;
gfc_omp_clauses *clauses;
}
gfc_omp_declare_simd;
typedef struct gfc_omp_udr
{
struct gfc_omp_udr *next;
locus where;
const char *name;
gfc_typespec ts;
gfc_omp_reduction_op rop;
struct gfc_symbol *omp_out;
struct gfc_symbol *omp_in;
struct gfc_namespace *combiner_ns;
struct gfc_symbol *omp_priv;
struct gfc_symbol *omp_orig;
struct gfc_namespace *initializer_ns;
}
gfc_omp_udr;
typedef struct gfc_omp_namelist_udr
{
struct gfc_omp_udr *udr;
struct gfc_code *combiner;
struct gfc_code *initializer;
}
gfc_omp_namelist_udr;
typedef struct gfc_st_label
{
int priority; struct gfc_st_label *left, *right;
int value;
gfc_sl_type defined, referenced;
struct gfc_expr *format;
tree backend_decl;
locus where;
gfc_namespace *ns;
}
gfc_st_label;
typedef struct gfc_interface
{
struct gfc_symbol *sym;
locus where;
struct gfc_interface *next;
}
gfc_interface;
typedef struct
{
const char *name;
gfc_interface *op;
struct gfc_namespace *ns;
gfc_access access;
}
gfc_user_op;
typedef struct gfc_tbp_generic
{
struct gfc_symtree* specific_st;
struct gfc_typebound_proc* specific;
struct gfc_tbp_generic* next;
bool is_operator;
}
gfc_tbp_generic;
typedef struct gfc_typebound_proc
{
locus where;
union
{
struct gfc_symtree* specific;
gfc_tbp_generic* generic;
}
u;
gfc_access access;
const char* pass_arg;
struct gfc_typebound_proc* overridden;
unsigned pass_arg_num;
unsigned nopass:1;
unsigned non_overridable:1;
unsigned deferred:1;
unsigned is_generic:1;
unsigned function:1, subroutine:1;
unsigned error:1;
unsigned ppc:1;
}
gfc_typebound_proc;
# 1567 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/gfortran.h"
typedef struct gfc_symbol
{
const char *name;
const char *module;
locus declared_at;
gfc_typespec ts;
symbol_attribute attr;
gfc_interface *generic;
gfc_access component_access;
gfc_formal_arglist *formal;
struct gfc_namespace *formal_ns;
struct gfc_namespace *f2k_derived;
struct gfc_actual_arglist *param_list;
struct gfc_expr *value;
gfc_array_spec *as;
struct gfc_symbol *result;
gfc_component *components;
struct gfc_symbol *cp_pointer;
int entry_id;
int hash_value;
struct gfc_symbol *common_next;
struct gfc_common_head* common_head;
int dummy_order;
gfc_namelist *namelist, *namelist_tail;
# 1627 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/gfortran.h"
struct gfc_symbol *old_symbol;
unsigned mark:1, comp_mark:1, gfc_new:1;
struct gfc_symbol *tlink;
unsigned equiv_built:1;
unsigned forall_index:1;
unsigned fn_result_spec:1;
unsigned resolve_symbol_called:2;
unsigned abr_modproc_decl:1;
unsigned error:1;
unsigned maybe_array:1;
int refs;
struct gfc_namespace *ns;
tree backend_decl;
intmod_id from_intmod;
int intmod_sym_id;
const char* binding_label;
struct gfc_common_head *common_block;
struct gfc_association_list *assoc;
struct gfc_symbol *dt_next;
}
gfc_symbol;
struct gfc_undo_change_set
{
vec<gfc_symbol *> syms;
vec<gfc_typebound_proc *> tbps;
gfc_undo_change_set *previous;
};
typedef struct gfc_common_head
{
locus where;
char use_assoc, saved, threadprivate;
unsigned char omp_declare_target : 1;
unsigned char omp_declare_target_link : 1;
char name[2*63 + 1 + 14 + 1];
struct gfc_symbol *head;
const char* binding_label;
int is_bind_c;
int refs;
}
gfc_common_head;
typedef struct gfc_entry_list
{
gfc_symbol *sym;
int id;
tree label;
struct gfc_entry_list *next;
}
gfc_entry_list;
typedef struct gfc_use_rename
{
char local_name[63 + 1], use_name[63 + 1];
struct gfc_use_rename *next;
int found;
gfc_intrinsic_op op;
locus where;
}
gfc_use_rename;
typedef struct gfc_use_list
{
const char *module_name;
const char *submodule_name;
bool intrinsic;
bool non_intrinsic;
bool only_flag;
struct gfc_use_rename *rename;
locus where;
struct gfc_use_list *next;
}
gfc_use_list;
# 1768 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/gfortran.h"
typedef struct gfc_symtree
{
int priority; struct gfc_symtree *left, *right;
const char *name;
int ambiguous;
union
{
gfc_symbol *sym;
gfc_user_op *uop;
gfc_common_head *common;
gfc_typebound_proc *tb;
gfc_omp_udr *omp_udr;
}
n;
}
gfc_symtree;
extern gfc_symbol *gfc_derived_types;
typedef struct gfc_oacc_routine_name
{
struct gfc_symbol *sym;
struct gfc_omp_clauses *clauses;
struct gfc_oacc_routine_name *next;
locus loc;
}
gfc_oacc_routine_name;
typedef struct gfc_was_finalized {
gfc_expr *e;
gfc_component *c;
struct gfc_was_finalized *next;
}
gfc_was_finalized;
typedef struct gfc_namespace
{
gfc_symtree *sym_root;
gfc_symtree *uop_root;
gfc_symtree *common_root;
gfc_symtree *omp_udr_root;
gfc_symtree *tb_sym_root;
gfc_symtree *tb_uop_root;
gfc_typebound_proc *tb_op[GFC_INTRINSIC_END];
struct gfc_finalizer *finalizers;
int set_flag[26];
gfc_typespec default_type[26];
locus implicit_loc[26];
struct gfc_symbol *proc_name;
struct gfc_code *code;
struct gfc_equiv *equiv, *old_equiv;
struct gfc_equiv_list *equiv_lists;
gfc_interface *op[GFC_INTRINSIC_END];
struct gfc_namespace *parent;
struct gfc_namespace *contained, *sibling;
gfc_common_head blank_common;
gfc_access default_access, operator_access[GFC_INTRINSIC_END];
gfc_st_label *st_labels;
struct gfc_data *data, *old_data;
gfc_oacc_declare *oacc_declare;
gfc_omp_clauses *oacc_routine_clauses;
gfc_oacc_routine_name *oacc_routine_names;
gfc_charlen *cl_list;
gfc_symbol *derived_types;
int save_all, seen_save, seen_implicit_none;
int refs;
gfc_entry_list *entries;
gfc_use_list *use_stmts;
struct gfc_omp_declare_simd *omp_declare_simd;
gfc_was_finalized *was_finalized;
unsigned is_block_data:1;
unsigned has_import_set:1;
unsigned has_implicit_none_export:1;
signed resolved:2;
unsigned types_resolved:1;
unsigned translated:1;
unsigned construct_entities:1;
unsigned omp_udr_ns:1;
unsigned oacc_routine:1;
unsigned implicit_interface_calls:1;
unsigned omp_requires:6;
unsigned omp_target_seen:1;
}
gfc_namespace;
extern gfc_namespace *gfc_current_ns;
extern gfc_namespace *gfc_global_ns_list;
enum gfc_symbol_type
{
GSYM_UNKNOWN=1, GSYM_PROGRAM, GSYM_FUNCTION, GSYM_SUBROUTINE,
GSYM_MODULE, GSYM_COMMON, GSYM_BLOCK_DATA
};
typedef struct gfc_gsymbol
{
int priority; struct gfc_gsymbol *left, *right;
const char *name;
const char *sym_name;
const char *mod_name;
const char *binding_label;
enum gfc_symbol_type type;
int defined, used;
bool bind_c;
locus where;
gfc_namespace *ns;
}
gfc_gsymbol;
extern gfc_gsymbol *gfc_gsym_root;
typedef struct
{
interface_type type;
gfc_symbol *sym;
gfc_namespace *ns;
gfc_user_op *uop;
gfc_intrinsic_op op;
}
gfc_interface_info;
extern gfc_interface_info current_interface;
enum gfc_array_ref_dimen_type
{
DIMEN_ELEMENT = 1, DIMEN_RANGE, DIMEN_VECTOR, DIMEN_STAR, DIMEN_THIS_IMAGE, DIMEN_UNKNOWN
};
typedef struct gfc_array_ref
{
ar_type type;
int dimen;
int codimen;
bool in_allocate;
gfc_expr *team;
gfc_expr *stat;
locus where;
gfc_array_spec *as;
locus c_where[15];
struct gfc_expr *start[15], *end[15],
*stride[15];
enum gfc_array_ref_dimen_type dimen_type[15];
}
gfc_array_ref;
# 2025 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/gfortran.h"
enum ref_type
{ REF_ARRAY, REF_COMPONENT, REF_SUBSTRING, REF_INQUIRY };
enum inquiry_type
{ INQUIRY_RE, INQUIRY_IM, INQUIRY_KIND, INQUIRY_LEN };
typedef struct gfc_ref
{
ref_type type;
union
{
struct gfc_array_ref ar;
struct
{
gfc_component *component;
gfc_symbol *sym;
}
c;
struct
{
struct gfc_expr *start, *end;
gfc_charlen *length;
}
ss;
inquiry_type i;
}
u;
struct gfc_ref *next;
}
gfc_ref;
typedef struct gfc_intrinsic_arg
{
char name[63 + 1];
gfc_typespec ts;
unsigned optional:1, value:1;
enum sym_intent intent:2;
gfc_actual_arglist *actual;
struct gfc_intrinsic_arg *next;
}
gfc_intrinsic_arg;
# 2088 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/gfortran.h"
typedef union
{
bool (*f0)(void);
bool (*f1)(struct gfc_expr *);
bool (*f1m)(gfc_actual_arglist *);
bool (*f2)(struct gfc_expr *, struct gfc_expr *);
bool (*f3)(struct gfc_expr *, struct gfc_expr *, struct gfc_expr *);
bool (*f5ml)(gfc_actual_arglist *);
bool (*f6fl)(gfc_actual_arglist *);
bool (*f3red)(gfc_actual_arglist *);
bool (*f4)(struct gfc_expr *, struct gfc_expr *, struct gfc_expr *,
struct gfc_expr *);
bool (*f5)(struct gfc_expr *, struct gfc_expr *, struct gfc_expr *,
struct gfc_expr *, struct gfc_expr *);
}
gfc_check_f;
typedef union
{
struct gfc_expr *(*f0)(void);
struct gfc_expr *(*f1)(struct gfc_expr *);
struct gfc_expr *(*f2)(struct gfc_expr *, struct gfc_expr *);
struct gfc_expr *(*f3)(struct gfc_expr *, struct gfc_expr *,
struct gfc_expr *);
struct gfc_expr *(*f4)(struct gfc_expr *, struct gfc_expr *,
struct gfc_expr *, struct gfc_expr *);
struct gfc_expr *(*f5)(struct gfc_expr *, struct gfc_expr *,
struct gfc_expr *, struct gfc_expr *,
struct gfc_expr *);
struct gfc_expr *(*f6)(struct gfc_expr *, struct gfc_expr *,
struct gfc_expr *, struct gfc_expr *,
struct gfc_expr *, struct gfc_expr *);
struct gfc_expr *(*cc)(struct gfc_expr *, bt, int);
}
gfc_simplify_f;
typedef union
{
void (*f0)(struct gfc_expr *);
void (*f1)(struct gfc_expr *, struct gfc_expr *);
void (*f1m)(struct gfc_expr *, struct gfc_actual_arglist *);
void (*f2)(struct gfc_expr *, struct gfc_expr *, struct gfc_expr *);
void (*f3)(struct gfc_expr *, struct gfc_expr *, struct gfc_expr *,
struct gfc_expr *);
void (*f4)(struct gfc_expr *, struct gfc_expr *, struct gfc_expr *,
struct gfc_expr *, struct gfc_expr *);
void (*f5)(struct gfc_expr *, struct gfc_expr *, struct gfc_expr *,
struct gfc_expr *, struct gfc_expr *, struct gfc_expr *);
void (*f6)(struct gfc_expr *, struct gfc_expr *, struct gfc_expr *,
struct gfc_expr *, struct gfc_expr *, struct gfc_expr *,
struct gfc_expr *);
void (*s1)(struct gfc_code *);
}
gfc_resolve_f;
typedef struct gfc_intrinsic_sym
{
const char *name, *lib_name;
gfc_intrinsic_arg *formal;
gfc_typespec ts;
unsigned elemental:1, inquiry:1, transformational:1, pure:1,
generic:1, specific:1, actual_ok:1, noreturn:1, conversion:1,
from_module:1, vararg:1;
int standard;
gfc_simplify_f simplify;
gfc_check_f check;
gfc_resolve_f resolve;
struct gfc_intrinsic_sym *specific_head, *next;
gfc_isym_id id;
}
gfc_intrinsic_sym;
# 2188 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/gfortran.h"
# 1 "/usr/include/mpfr.h" 1 3 4
# 61 "/usr/include/mpfr.h" 3 4
# 61 "/usr/include/mpfr.h" 3 4
typedef void mpfr_void;
typedef int mpfr_int;
typedef unsigned int mpfr_uint;
typedef long mpfr_long;
typedef unsigned long mpfr_ulong;
typedef size_t mpfr_size_t;
typedef unsigned int mpfr_flags_t;
# 102 "/usr/include/mpfr.h" 3 4
typedef enum {
MPFR_RNDN=0,
MPFR_RNDZ,
MPFR_RNDU,
MPFR_RNDD,
MPFR_RNDA,
MPFR_RNDF,
MPFR_RNDNA=-1
} mpfr_rnd_t;
# 168 "/usr/include/mpfr.h" 3 4
typedef long mpfr_prec_t;
typedef unsigned long mpfr_uprec_t;
# 184 "/usr/include/mpfr.h" 3 4
typedef int mpfr_sign_t;
# 195 "/usr/include/mpfr.h" 3 4
typedef long mpfr_exp_t;
typedef unsigned long mpfr_uexp_t;
# 224 "/usr/include/mpfr.h" 3 4
typedef struct {
mpfr_prec_t _mpfr_prec;
mpfr_sign_t _mpfr_sign;
mpfr_exp_t _mpfr_exp;
mp_limb_t *_mpfr_d;
} __mpfr_struct;
# 250 "/usr/include/mpfr.h" 3 4
typedef __mpfr_struct mpfr_t[1];
typedef __mpfr_struct *mpfr_ptr;
typedef const __mpfr_struct *mpfr_srcptr;
# 263 "/usr/include/mpfr.h" 3 4
typedef enum {
MPFR_NAN_KIND = 0,
MPFR_INF_KIND = 1,
MPFR_ZERO_KIND = 2,
MPFR_REGULAR_KIND = 3
} mpfr_kind_t;
typedef enum {
MPFR_FREE_LOCAL_CACHE = 1,
MPFR_FREE_GLOBAL_CACHE = 2
} mpfr_free_cache_t;
# 375 "/usr/include/mpfr.h" 3 4
extern "C" {
__attribute__ ((__returns_nonnull__)) const char * mpfr_get_version (void);
__attribute__ ((__returns_nonnull__)) const char * mpfr_get_patches (void);
int mpfr_buildopt_tls_p (void);
int mpfr_buildopt_float128_p (void);
int mpfr_buildopt_decimal_p (void);
int mpfr_buildopt_gmpinternals_p (void);
int mpfr_buildopt_sharedcache_p (void);
__attribute__ ((__returns_nonnull__)) const char *
mpfr_buildopt_tune_case (void);
mpfr_exp_t mpfr_get_emin (void);
int mpfr_set_emin (mpfr_exp_t);
mpfr_exp_t mpfr_get_emin_min (void);
mpfr_exp_t mpfr_get_emin_max (void);
mpfr_exp_t mpfr_get_emax (void);
int mpfr_set_emax (mpfr_exp_t);
mpfr_exp_t mpfr_get_emax_min (void);
mpfr_exp_t mpfr_get_emax_max (void);
void mpfr_set_default_rounding_mode (mpfr_rnd_t);
mpfr_rnd_t mpfr_get_default_rounding_mode (void);
const char * mpfr_print_rnd_mode (mpfr_rnd_t);
void mpfr_clear_flags (void);
void mpfr_clear_underflow (void);
void mpfr_clear_overflow (void);
void mpfr_clear_divby0 (void);
void mpfr_clear_nanflag (void);
void mpfr_clear_inexflag (void);
void mpfr_clear_erangeflag (void);
void mpfr_set_underflow (void);
void mpfr_set_overflow (void);
void mpfr_set_divby0 (void);
void mpfr_set_nanflag (void);
void mpfr_set_inexflag (void);
void mpfr_set_erangeflag (void);
int mpfr_underflow_p (void);
int mpfr_overflow_p (void);
int mpfr_divby0_p (void);
int mpfr_nanflag_p (void);
int mpfr_inexflag_p (void);
int mpfr_erangeflag_p (void);
void mpfr_flags_clear (mpfr_flags_t);
void mpfr_flags_set (mpfr_flags_t);
mpfr_flags_t mpfr_flags_test (mpfr_flags_t);
mpfr_flags_t mpfr_flags_save (void);
void mpfr_flags_restore (mpfr_flags_t,
mpfr_flags_t);
int mpfr_check_range (mpfr_ptr, int, mpfr_rnd_t);
void mpfr_init2 (mpfr_ptr, mpfr_prec_t);
void mpfr_init (mpfr_ptr);
void mpfr_clear (mpfr_ptr);
void
mpfr_inits2 (mpfr_prec_t, mpfr_ptr, ...) __attribute__ ((__sentinel__));
void
mpfr_inits (mpfr_ptr, ...) __attribute__ ((__sentinel__));
void
mpfr_clears (mpfr_ptr, ...) __attribute__ ((__sentinel__));
int mpfr_prec_round (mpfr_ptr, mpfr_prec_t, mpfr_rnd_t);
int mpfr_can_round (mpfr_srcptr, mpfr_exp_t, mpfr_rnd_t,
mpfr_rnd_t, mpfr_prec_t);
mpfr_prec_t mpfr_min_prec (mpfr_srcptr);
mpfr_exp_t mpfr_get_exp (mpfr_srcptr);
int mpfr_set_exp (mpfr_ptr, mpfr_exp_t);
mpfr_prec_t mpfr_get_prec (mpfr_srcptr);
void mpfr_set_prec (mpfr_ptr, mpfr_prec_t);
void mpfr_set_prec_raw (mpfr_ptr, mpfr_prec_t);
void mpfr_set_default_prec (mpfr_prec_t);
mpfr_prec_t mpfr_get_default_prec (void);
int mpfr_set_d (mpfr_ptr, double, mpfr_rnd_t);
int mpfr_set_flt (mpfr_ptr, float, mpfr_rnd_t);
int mpfr_set_ld (mpfr_ptr, long double, mpfr_rnd_t);
int mpfr_set_z (mpfr_ptr, mpz_srcptr, mpfr_rnd_t);
int mpfr_set_z_2exp (mpfr_ptr, mpz_srcptr, mpfr_exp_t,
mpfr_rnd_t);
void mpfr_set_nan (mpfr_ptr);
void mpfr_set_inf (mpfr_ptr, int);
void mpfr_set_zero (mpfr_ptr, int);
int mpfr_set_f (mpfr_ptr, mpf_srcptr, mpfr_rnd_t);
int mpfr_cmp_f (mpfr_srcptr, mpf_srcptr);
int mpfr_get_f (mpf_ptr, mpfr_srcptr, mpfr_rnd_t);
int mpfr_set_si (mpfr_ptr, long, mpfr_rnd_t);
int mpfr_set_ui (mpfr_ptr, unsigned long, mpfr_rnd_t);
int mpfr_set_si_2exp (mpfr_ptr, long, mpfr_exp_t, mpfr_rnd_t);
int mpfr_set_ui_2exp (mpfr_ptr, unsigned long, mpfr_exp_t,
mpfr_rnd_t);
int mpfr_set_q (mpfr_ptr, mpq_srcptr, mpfr_rnd_t);
int mpfr_mul_q (mpfr_ptr, mpfr_srcptr, mpq_srcptr, mpfr_rnd_t);
int mpfr_div_q (mpfr_ptr, mpfr_srcptr, mpq_srcptr, mpfr_rnd_t);
int mpfr_add_q (mpfr_ptr, mpfr_srcptr, mpq_srcptr, mpfr_rnd_t);
int mpfr_sub_q (mpfr_ptr, mpfr_srcptr, mpq_srcptr, mpfr_rnd_t);
int mpfr_cmp_q (mpfr_srcptr, mpq_srcptr);
void mpfr_get_q (mpq_ptr q, mpfr_srcptr f);
int mpfr_set_str (mpfr_ptr, const char *, int, mpfr_rnd_t);
int mpfr_init_set_str (mpfr_ptr, const char *, int,
mpfr_rnd_t);
int mpfr_set4 (mpfr_ptr, mpfr_srcptr, mpfr_rnd_t, int);
int mpfr_abs (mpfr_ptr, mpfr_srcptr, mpfr_rnd_t);
int mpfr_set (mpfr_ptr, mpfr_srcptr, mpfr_rnd_t);
int mpfr_neg (mpfr_ptr, mpfr_srcptr, mpfr_rnd_t);
int mpfr_signbit (mpfr_srcptr);
int mpfr_setsign (mpfr_ptr, mpfr_srcptr, int, mpfr_rnd_t);
int mpfr_copysign (mpfr_ptr, mpfr_srcptr, mpfr_srcptr,
mpfr_rnd_t);
mpfr_exp_t mpfr_get_z_2exp (mpz_ptr, mpfr_srcptr);
float mpfr_get_flt (mpfr_srcptr, mpfr_rnd_t);
double mpfr_get_d (mpfr_srcptr, mpfr_rnd_t);
long double mpfr_get_ld (mpfr_srcptr, mpfr_rnd_t);
double mpfr_get_d1 (mpfr_srcptr);
double mpfr_get_d_2exp (long*, mpfr_srcptr, mpfr_rnd_t);
long double mpfr_get_ld_2exp (long*, mpfr_srcptr, mpfr_rnd_t);
int mpfr_frexp (mpfr_exp_t*, mpfr_ptr, mpfr_srcptr, mpfr_rnd_t);
long mpfr_get_si (mpfr_srcptr, mpfr_rnd_t);
unsigned long mpfr_get_ui (mpfr_srcptr, mpfr_rnd_t);
size_t mpfr_get_str_ndigits (int, mpfr_prec_t);
char * mpfr_get_str (char*, mpfr_exp_t*, int, size_t,
mpfr_srcptr, mpfr_rnd_t);
int mpfr_get_z (mpz_ptr z, mpfr_srcptr f, mpfr_rnd_t);
void mpfr_free_str (char *);
int mpfr_urandom (mpfr_ptr, gmp_randstate_t, mpfr_rnd_t);
__attribute__ ((__deprecated__))
int mpfr_grandom (mpfr_ptr, mpfr_ptr, gmp_randstate_t,
mpfr_rnd_t);
int mpfr_nrandom (mpfr_ptr, gmp_randstate_t, mpfr_rnd_t);
int mpfr_erandom (mpfr_ptr, gmp_randstate_t, mpfr_rnd_t);
int mpfr_urandomb (mpfr_ptr, gmp_randstate_t);
void mpfr_nextabove (mpfr_ptr);
void mpfr_nextbelow (mpfr_ptr);
void mpfr_nexttoward (mpfr_ptr, mpfr_srcptr);
int mpfr_printf (const char*, ...);
int mpfr_asprintf (char**, const char*, ...);
int mpfr_sprintf (char*, const char*, ...);
int mpfr_snprintf (char*, size_t, const char*, ...);
int mpfr_pow (mpfr_ptr, mpfr_srcptr, mpfr_srcptr, mpfr_rnd_t);
int mpfr_pow_si (mpfr_ptr, mpfr_srcptr, long, mpfr_rnd_t);
int mpfr_pow_ui (mpfr_ptr, mpfr_srcptr, unsigned long,
mpfr_rnd_t);
int mpfr_ui_pow_ui (mpfr_ptr, unsigned long, unsigned long,
mpfr_rnd_t);
int mpfr_ui_pow (mpfr_ptr, unsigned long, mpfr_srcptr,
mpfr_rnd_t);
int mpfr_pow_z (mpfr_ptr, mpfr_srcptr, mpz_srcptr, mpfr_rnd_t);
int mpfr_sqrt (mpfr_ptr, mpfr_srcptr, mpfr_rnd_t);
int mpfr_sqrt_ui (mpfr_ptr, unsigned long, mpfr_rnd_t);
int mpfr_rec_sqrt (mpfr_ptr, mpfr_srcptr, mpfr_rnd_t);
int mpfr_add (mpfr_ptr, mpfr_srcptr, mpfr_srcptr, mpfr_rnd_t);
int mpfr_sub (mpfr_ptr, mpfr_srcptr, mpfr_srcptr, mpfr_rnd_t);
int mpfr_mul (mpfr_ptr, mpfr_srcptr, mpfr_srcptr, mpfr_rnd_t);
int mpfr_div (mpfr_ptr, mpfr_srcptr, mpfr_srcptr, mpfr_rnd_t);
int mpfr_add_ui (mpfr_ptr, mpfr_srcptr, unsigned long,
mpfr_rnd_t);
int mpfr_sub_ui (mpfr_ptr, mpfr_srcptr, unsigned long,
mpfr_rnd_t);
int mpfr_ui_sub (mpfr_ptr, unsigned long, mpfr_srcptr,
mpfr_rnd_t);
int mpfr_mul_ui (mpfr_ptr, mpfr_srcptr, unsigned long,
mpfr_rnd_t);
int mpfr_div_ui (mpfr_ptr, mpfr_srcptr, unsigned long,
mpfr_rnd_t);
int mpfr_ui_div (mpfr_ptr, unsigned long, mpfr_srcptr,
mpfr_rnd_t);
int mpfr_add_si (mpfr_ptr, mpfr_srcptr, long, mpfr_rnd_t);
int mpfr_sub_si (mpfr_ptr, mpfr_srcptr, long, mpfr_rnd_t);
int mpfr_si_sub (mpfr_ptr, long, mpfr_srcptr, mpfr_rnd_t);
int mpfr_mul_si (mpfr_ptr, mpfr_srcptr, long, mpfr_rnd_t);
int mpfr_div_si (mpfr_ptr, mpfr_srcptr, long, mpfr_rnd_t);
int mpfr_si_div (mpfr_ptr, long, mpfr_srcptr, mpfr_rnd_t);
int mpfr_add_d (mpfr_ptr, mpfr_srcptr, double, mpfr_rnd_t);
int mpfr_sub_d (mpfr_ptr, mpfr_srcptr, double, mpfr_rnd_t);
int mpfr_d_sub (mpfr_ptr, double, mpfr_srcptr, mpfr_rnd_t);
int mpfr_mul_d (mpfr_ptr, mpfr_srcptr, double, mpfr_rnd_t);
int mpfr_div_d (mpfr_ptr, mpfr_srcptr, double, mpfr_rnd_t);
int mpfr_d_div (mpfr_ptr, double, mpfr_srcptr, mpfr_rnd_t);
int mpfr_sqr (mpfr_ptr, mpfr_srcptr, mpfr_rnd_t);
int mpfr_const_pi (mpfr_ptr, mpfr_rnd_t);
int mpfr_const_log2 (mpfr_ptr, mpfr_rnd_t);
int mpfr_const_euler (mpfr_ptr, mpfr_rnd_t);
int mpfr_const_catalan (mpfr_ptr, mpfr_rnd_t);
int mpfr_agm (mpfr_ptr, mpfr_srcptr, mpfr_srcptr, mpfr_rnd_t);
int mpfr_log (mpfr_ptr, mpfr_srcptr, mpfr_rnd_t);
int mpfr_log2 (mpfr_ptr, mpfr_srcptr, mpfr_rnd_t);
int mpfr_log10 (mpfr_ptr, mpfr_srcptr, mpfr_rnd_t);
int mpfr_log1p (mpfr_ptr, mpfr_srcptr, mpfr_rnd_t);
int mpfr_log_ui (mpfr_ptr, unsigned long, mpfr_rnd_t);
int mpfr_exp (mpfr_ptr, mpfr_srcptr, mpfr_rnd_t);
int mpfr_exp2 (mpfr_ptr, mpfr_srcptr, mpfr_rnd_t);
int mpfr_exp10 (mpfr_ptr, mpfr_srcptr, mpfr_rnd_t);
int mpfr_expm1 (mpfr_ptr, mpfr_srcptr, mpfr_rnd_t);
int mpfr_eint (mpfr_ptr, mpfr_srcptr, mpfr_rnd_t);
int mpfr_li2 (mpfr_ptr, mpfr_srcptr, mpfr_rnd_t);
int mpfr_cmp (mpfr_srcptr, mpfr_srcptr);
int mpfr_cmp3 (mpfr_srcptr, mpfr_srcptr, int);
int mpfr_cmp_d (mpfr_srcptr, double);
int mpfr_cmp_ld (mpfr_srcptr, long double);
int mpfr_cmp_ui (mpfr_srcptr, unsigned long);
int mpfr_cmp_si (mpfr_srcptr, long);
int mpfr_cmp_ui_2exp (mpfr_srcptr, unsigned long, mpfr_exp_t);
int mpfr_cmp_si_2exp (mpfr_srcptr, long, mpfr_exp_t);
int mpfr_cmpabs (mpfr_srcptr, mpfr_srcptr);
int mpfr_cmpabs_ui (mpfr_srcptr, unsigned long);
void mpfr_reldiff (mpfr_ptr, mpfr_srcptr, mpfr_srcptr,
mpfr_rnd_t);
int mpfr_eq (mpfr_srcptr, mpfr_srcptr, unsigned long);
int mpfr_sgn (mpfr_srcptr);
int mpfr_mul_2exp (mpfr_ptr, mpfr_srcptr, unsigned long,
mpfr_rnd_t);
int mpfr_div_2exp (mpfr_ptr, mpfr_srcptr, unsigned long,
mpfr_rnd_t);
int mpfr_mul_2ui (mpfr_ptr, mpfr_srcptr, unsigned long,
mpfr_rnd_t);
int mpfr_div_2ui (mpfr_ptr, mpfr_srcptr, unsigned long,
mpfr_rnd_t);
int mpfr_mul_2si (mpfr_ptr, mpfr_srcptr, long, mpfr_rnd_t);
int mpfr_div_2si (mpfr_ptr, mpfr_srcptr, long, mpfr_rnd_t);
int mpfr_rint (mpfr_ptr, mpfr_srcptr, mpfr_rnd_t);
int mpfr_roundeven (mpfr_ptr, mpfr_srcptr);
int mpfr_round (mpfr_ptr, mpfr_srcptr);
int mpfr_trunc (mpfr_ptr, mpfr_srcptr);
int mpfr_ceil (mpfr_ptr, mpfr_srcptr);
int mpfr_floor (mpfr_ptr, mpfr_srcptr);
int mpfr_rint_roundeven (mpfr_ptr, mpfr_srcptr, mpfr_rnd_t);
int mpfr_rint_round (mpfr_ptr, mpfr_srcptr, mpfr_rnd_t);
int mpfr_rint_trunc (mpfr_ptr, mpfr_srcptr, mpfr_rnd_t);
int mpfr_rint_ceil (mpfr_ptr, mpfr_srcptr, mpfr_rnd_t);
int mpfr_rint_floor (mpfr_ptr, mpfr_srcptr, mpfr_rnd_t);
int mpfr_frac (mpfr_ptr, mpfr_srcptr, mpfr_rnd_t);
int mpfr_modf (mpfr_ptr, mpfr_ptr, mpfr_srcptr, mpfr_rnd_t);
int mpfr_remquo (mpfr_ptr, long*, mpfr_srcptr, mpfr_srcptr,
mpfr_rnd_t);
int mpfr_remainder (mpfr_ptr, mpfr_srcptr, mpfr_srcptr,
mpfr_rnd_t);
int mpfr_fmod (mpfr_ptr, mpfr_srcptr, mpfr_srcptr, mpfr_rnd_t);
int mpfr_fmodquo (mpfr_ptr, long*, mpfr_srcptr, mpfr_srcptr,
mpfr_rnd_t);
int mpfr_fits_ulong_p (mpfr_srcptr, mpfr_rnd_t);
int mpfr_fits_slong_p (mpfr_srcptr, mpfr_rnd_t);
int mpfr_fits_uint_p (mpfr_srcptr, mpfr_rnd_t);
int mpfr_fits_sint_p (mpfr_srcptr, mpfr_rnd_t);
int mpfr_fits_ushort_p (mpfr_srcptr, mpfr_rnd_t);
int mpfr_fits_sshort_p (mpfr_srcptr, mpfr_rnd_t);
int mpfr_fits_uintmax_p (mpfr_srcptr, mpfr_rnd_t);
int mpfr_fits_intmax_p (mpfr_srcptr, mpfr_rnd_t);
void mpfr_extract (mpz_ptr, mpfr_srcptr, unsigned int);
void mpfr_swap (mpfr_ptr, mpfr_ptr);
void mpfr_dump (mpfr_srcptr);
int mpfr_nan_p (mpfr_srcptr);
int mpfr_inf_p (mpfr_srcptr);
int mpfr_number_p (mpfr_srcptr);
int mpfr_integer_p (mpfr_srcptr);
int mpfr_zero_p (mpfr_srcptr);
int mpfr_regular_p (mpfr_srcptr);
int mpfr_greater_p (mpfr_srcptr, mpfr_srcptr);
int mpfr_greaterequal_p (mpfr_srcptr, mpfr_srcptr);
int mpfr_less_p (mpfr_srcptr, mpfr_srcptr);
int mpfr_lessequal_p (mpfr_srcptr, mpfr_srcptr);
int mpfr_lessgreater_p (mpfr_srcptr, mpfr_srcptr);
int mpfr_equal_p (mpfr_srcptr, mpfr_srcptr);
int mpfr_unordered_p (mpfr_srcptr, mpfr_srcptr);
int mpfr_atanh (mpfr_ptr, mpfr_srcptr, mpfr_rnd_t);
int mpfr_acosh (mpfr_ptr, mpfr_srcptr, mpfr_rnd_t);
int mpfr_asinh (mpfr_ptr, mpfr_srcptr, mpfr_rnd_t);
int mpfr_cosh (mpfr_ptr, mpfr_srcptr, mpfr_rnd_t);
int mpfr_sinh (mpfr_ptr, mpfr_srcptr, mpfr_rnd_t);
int mpfr_tanh (mpfr_ptr, mpfr_srcptr, mpfr_rnd_t);
int mpfr_sinh_cosh (mpfr_ptr, mpfr_ptr, mpfr_srcptr,
mpfr_rnd_t);
int mpfr_sech (mpfr_ptr, mpfr_srcptr, mpfr_rnd_t);
int mpfr_csch (mpfr_ptr, mpfr_srcptr, mpfr_rnd_t);
int mpfr_coth (mpfr_ptr, mpfr_srcptr, mpfr_rnd_t);
int mpfr_acos (mpfr_ptr, mpfr_srcptr, mpfr_rnd_t);
int mpfr_asin (mpfr_ptr, mpfr_srcptr, mpfr_rnd_t);
int mpfr_atan (mpfr_ptr, mpfr_srcptr, mpfr_rnd_t);
int mpfr_sin (mpfr_ptr, mpfr_srcptr, mpfr_rnd_t);
int mpfr_sin_cos (mpfr_ptr, mpfr_ptr, mpfr_srcptr, mpfr_rnd_t);
int mpfr_cos (mpfr_ptr, mpfr_srcptr, mpfr_rnd_t);
int mpfr_tan (mpfr_ptr, mpfr_srcptr, mpfr_rnd_t);
int mpfr_atan2 (mpfr_ptr, mpfr_srcptr, mpfr_srcptr, mpfr_rnd_t);
int mpfr_sec (mpfr_ptr, mpfr_srcptr, mpfr_rnd_t);
int mpfr_csc (mpfr_ptr, mpfr_srcptr, mpfr_rnd_t);
int mpfr_cot (mpfr_ptr, mpfr_srcptr, mpfr_rnd_t);
int mpfr_hypot (mpfr_ptr, mpfr_srcptr, mpfr_srcptr, mpfr_rnd_t);
int mpfr_erf (mpfr_ptr, mpfr_srcptr, mpfr_rnd_t);
int mpfr_erfc (mpfr_ptr, mpfr_srcptr, mpfr_rnd_t);
int mpfr_cbrt (mpfr_ptr, mpfr_srcptr, mpfr_rnd_t);
__attribute__ ((__deprecated__))
int mpfr_root (mpfr_ptr, mpfr_srcptr, unsigned long,
mpfr_rnd_t);
int mpfr_rootn_ui (mpfr_ptr, mpfr_srcptr, unsigned long,
mpfr_rnd_t);
int mpfr_gamma (mpfr_ptr, mpfr_srcptr, mpfr_rnd_t);
int mpfr_gamma_inc (mpfr_ptr, mpfr_srcptr, mpfr_srcptr,
mpfr_rnd_t);
int mpfr_beta (mpfr_ptr, mpfr_srcptr, mpfr_srcptr, mpfr_rnd_t);
int mpfr_lngamma (mpfr_ptr, mpfr_srcptr, mpfr_rnd_t);
int mpfr_lgamma (mpfr_ptr, int *, mpfr_srcptr, mpfr_rnd_t);
int mpfr_digamma (mpfr_ptr, mpfr_srcptr, mpfr_rnd_t);
int mpfr_zeta (mpfr_ptr, mpfr_srcptr, mpfr_rnd_t);
int mpfr_zeta_ui (mpfr_ptr, unsigned long, mpfr_rnd_t);
int mpfr_fac_ui (mpfr_ptr, unsigned long, mpfr_rnd_t);
int mpfr_j0 (mpfr_ptr, mpfr_srcptr, mpfr_rnd_t);
int mpfr_j1 (mpfr_ptr, mpfr_srcptr, mpfr_rnd_t);
int mpfr_jn (mpfr_ptr, long, mpfr_srcptr, mpfr_rnd_t);
int mpfr_y0 (mpfr_ptr, mpfr_srcptr, mpfr_rnd_t);
int mpfr_y1 (mpfr_ptr, mpfr_srcptr, mpfr_rnd_t);
int mpfr_yn (mpfr_ptr, long, mpfr_srcptr, mpfr_rnd_t);
int mpfr_ai (mpfr_ptr, mpfr_srcptr, mpfr_rnd_t);
int mpfr_min (mpfr_ptr, mpfr_srcptr, mpfr_srcptr, mpfr_rnd_t);
int mpfr_max (mpfr_ptr, mpfr_srcptr, mpfr_srcptr, mpfr_rnd_t);
int mpfr_dim (mpfr_ptr, mpfr_srcptr, mpfr_srcptr, mpfr_rnd_t);
int mpfr_mul_z (mpfr_ptr, mpfr_srcptr, mpz_srcptr, mpfr_rnd_t);
int mpfr_div_z (mpfr_ptr, mpfr_srcptr, mpz_srcptr, mpfr_rnd_t);
int mpfr_add_z (mpfr_ptr, mpfr_srcptr, mpz_srcptr, mpfr_rnd_t);
int mpfr_sub_z (mpfr_ptr, mpfr_srcptr, mpz_srcptr, mpfr_rnd_t);
int mpfr_z_sub (mpfr_ptr, mpz_srcptr, mpfr_srcptr, mpfr_rnd_t);
int mpfr_cmp_z (mpfr_srcptr, mpz_srcptr);
int mpfr_fma (mpfr_ptr, mpfr_srcptr, mpfr_srcptr, mpfr_srcptr,
mpfr_rnd_t);
int mpfr_fms (mpfr_ptr, mpfr_srcptr, mpfr_srcptr, mpfr_srcptr,
mpfr_rnd_t);
int mpfr_fmma (mpfr_ptr, mpfr_srcptr, mpfr_srcptr, mpfr_srcptr,
mpfr_srcptr, mpfr_rnd_t);
int mpfr_fmms (mpfr_ptr, mpfr_srcptr, mpfr_srcptr, mpfr_srcptr,
mpfr_srcptr, mpfr_rnd_t);
int mpfr_sum (mpfr_ptr, const mpfr_ptr *, unsigned long,
mpfr_rnd_t);
int mpfr_dot (mpfr_ptr, const mpfr_ptr *, const mpfr_ptr *,
unsigned long, mpfr_rnd_t);
void mpfr_free_cache (void);
void mpfr_free_cache2 (mpfr_free_cache_t);
void mpfr_free_pool (void);
int mpfr_mp_memory_cleanup (void);
int mpfr_subnormalize (mpfr_ptr, int, mpfr_rnd_t);
int mpfr_strtofr (mpfr_ptr, const char *, char **, int,
mpfr_rnd_t);
void mpfr_round_nearest_away_begin (mpfr_t);
int mpfr_round_nearest_away_end (mpfr_t, int);
size_t mpfr_custom_get_size (mpfr_prec_t);
void mpfr_custom_init (void *, mpfr_prec_t);
__attribute__ ((__returns_nonnull__)) void *
mpfr_custom_get_significand (mpfr_srcptr);
mpfr_exp_t mpfr_custom_get_exp (mpfr_srcptr);
void mpfr_custom_move (mpfr_ptr, void *);
void mpfr_custom_init_set (mpfr_ptr, int, mpfr_exp_t,
mpfr_prec_t, void *);
int mpfr_custom_get_kind (mpfr_srcptr);
int mpfr_total_order_p (mpfr_srcptr, mpfr_srcptr);
}
# 1074 "/usr/include/mpfr.h" 3 4
extern "C" {
# 1083 "/usr/include/mpfr.h" 3 4
int __gmpfr_set_sj (mpfr_t, intmax_t, mpfr_rnd_t);
int __gmpfr_set_sj_2exp (mpfr_t, intmax_t, intmax_t, mpfr_rnd_t);
int __gmpfr_set_uj (mpfr_t, uintmax_t, mpfr_rnd_t);
int __gmpfr_set_uj_2exp (mpfr_t, uintmax_t, intmax_t, mpfr_rnd_t);
intmax_t __gmpfr_mpfr_get_sj (mpfr_srcptr, mpfr_rnd_t);
uintmax_t __gmpfr_mpfr_get_uj (mpfr_srcptr, mpfr_rnd_t);
}
# 1104 "/usr/include/mpfr.h" 3 4
extern "C" {
size_t __gmpfr_inp_str (mpfr_ptr, FILE*, int, mpfr_rnd_t);
size_t __gmpfr_out_str (FILE*, int, size_t, mpfr_srcptr,
mpfr_rnd_t);
int __gmpfr_fprintf (FILE*, const char*, ...);
int __gmpfr_fpif_export (FILE*, mpfr_ptr);
int __gmpfr_fpif_import (mpfr_ptr, FILE*);
}
# 1135 "/usr/include/mpfr.h" 3 4
extern "C" {
int __gmpfr_vprintf (const char*, va_list);
int __gmpfr_vasprintf (char**, const char*, va_list);
int __gmpfr_vsprintf (char*, const char*, va_list);
int __gmpfr_vsnprintf (char*, size_t, const char*, va_list);
}
# 1162 "/usr/include/mpfr.h" 3 4
extern "C" {
int __gmpfr_vfprintf (FILE*, const char*, va_list);
}
# 2189 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/gfortran.h" 2
# 1 "/usr/include/mpc.h" 1 3 4
# 25 "/usr/include/mpc.h" 3 4
# 1 "/usr/include/mpfr.h" 1 3 4
# 26 "/usr/include/mpc.h" 2 3 4
# 72 "/usr/include/mpc.h" 3 4
typedef int mpc_rnd_t;
# 101 "/usr/include/mpc.h" 3 4
typedef struct {
mpfr_t re;
mpfr_t im;
}
__mpc_struct;
typedef __mpc_struct mpc_t[1];
typedef __mpc_struct *mpc_ptr;
typedef const __mpc_struct *mpc_srcptr;
# 121 "/usr/include/mpc.h" 3 4
extern "C" {
int mpc_add (mpc_ptr, mpc_srcptr, mpc_srcptr, mpc_rnd_t);
int mpc_add_fr (mpc_ptr, mpc_srcptr, mpfr_srcptr, mpc_rnd_t);
int mpc_add_si (mpc_ptr, mpc_srcptr, long int, mpc_rnd_t);
int mpc_add_ui (mpc_ptr, mpc_srcptr, unsigned long int, mpc_rnd_t);
int mpc_sub (mpc_ptr, mpc_srcptr, mpc_srcptr, mpc_rnd_t);
int mpc_sub_fr (mpc_ptr, mpc_srcptr, mpfr_srcptr, mpc_rnd_t);
int mpc_fr_sub (mpc_ptr, mpfr_srcptr, mpc_srcptr, mpc_rnd_t);
int mpc_sub_ui (mpc_ptr, mpc_srcptr, unsigned long int, mpc_rnd_t);
int mpc_ui_ui_sub (mpc_ptr, unsigned long int, unsigned long int, mpc_srcptr, mpc_rnd_t);
int mpc_mul (mpc_ptr, mpc_srcptr, mpc_srcptr, mpc_rnd_t);
int mpc_mul_fr (mpc_ptr, mpc_srcptr, mpfr_srcptr, mpc_rnd_t);
int mpc_mul_ui (mpc_ptr, mpc_srcptr, unsigned long int, mpc_rnd_t);
int mpc_mul_si (mpc_ptr, mpc_srcptr, long int, mpc_rnd_t);
int mpc_mul_i (mpc_ptr, mpc_srcptr, int, mpc_rnd_t);
int mpc_sqr (mpc_ptr, mpc_srcptr, mpc_rnd_t);
int mpc_div (mpc_ptr, mpc_srcptr, mpc_srcptr, mpc_rnd_t);
int mpc_pow (mpc_ptr, mpc_srcptr, mpc_srcptr, mpc_rnd_t);
int mpc_pow_fr (mpc_ptr, mpc_srcptr, mpfr_srcptr, mpc_rnd_t);
int mpc_pow_ld (mpc_ptr, mpc_srcptr, long double, mpc_rnd_t);
int mpc_pow_d (mpc_ptr, mpc_srcptr, double, mpc_rnd_t);
int mpc_pow_si (mpc_ptr, mpc_srcptr, long, mpc_rnd_t);
int mpc_pow_ui (mpc_ptr, mpc_srcptr, unsigned long, mpc_rnd_t);
int mpc_pow_z (mpc_ptr, mpc_srcptr, mpz_srcptr, mpc_rnd_t);
int mpc_div_fr (mpc_ptr, mpc_srcptr, mpfr_srcptr, mpc_rnd_t);
int mpc_fr_div (mpc_ptr, mpfr_srcptr, mpc_srcptr, mpc_rnd_t);
int mpc_div_ui (mpc_ptr, mpc_srcptr, unsigned long int, mpc_rnd_t);
int mpc_ui_div (mpc_ptr, unsigned long int, mpc_srcptr, mpc_rnd_t);
int mpc_div_2ui (mpc_ptr, mpc_srcptr, unsigned long int, mpc_rnd_t);
int mpc_mul_2ui (mpc_ptr, mpc_srcptr, unsigned long int, mpc_rnd_t);
int mpc_div_2si (mpc_ptr, mpc_srcptr, long int, mpc_rnd_t);
int mpc_mul_2si (mpc_ptr, mpc_srcptr, long int, mpc_rnd_t);
int mpc_conj (mpc_ptr, mpc_srcptr, mpc_rnd_t);
int mpc_neg (mpc_ptr, mpc_srcptr, mpc_rnd_t);
int mpc_sum (mpc_ptr, const mpc_ptr *, unsigned long, mpc_rnd_t);
int mpc_dot (mpc_ptr, const mpc_ptr *, const mpc_ptr *, unsigned long, mpc_rnd_t);
int mpc_norm (mpfr_ptr, mpc_srcptr, mpfr_rnd_t);
int mpc_abs (mpfr_ptr, mpc_srcptr, mpfr_rnd_t);
int mpc_sqrt (mpc_ptr, mpc_srcptr, mpc_rnd_t);
int mpc_set (mpc_ptr, mpc_srcptr, mpc_rnd_t);
int mpc_set_d (mpc_ptr, double, mpc_rnd_t);
int mpc_set_d_d (mpc_ptr, double, double, mpc_rnd_t);
int mpc_set_ld (mpc_ptr, long double, mpc_rnd_t);
int mpc_set_ld_ld (mpc_ptr, long double, long double, mpc_rnd_t);
int mpc_set_f (mpc_ptr, mpf_srcptr, mpc_rnd_t);
int mpc_set_f_f (mpc_ptr, mpf_srcptr, mpf_srcptr, mpc_rnd_t);
int mpc_set_fr (mpc_ptr, mpfr_srcptr, mpc_rnd_t);
int mpc_set_fr_fr (mpc_ptr, mpfr_srcptr, mpfr_srcptr, mpc_rnd_t);
int mpc_set_q (mpc_ptr, mpq_srcptr, mpc_rnd_t);
int mpc_set_q_q (mpc_ptr, mpq_srcptr, mpq_srcptr, mpc_rnd_t);
int mpc_set_si (mpc_ptr, long int, mpc_rnd_t);
int mpc_set_si_si (mpc_ptr, long int, long int, mpc_rnd_t);
int mpc_set_ui (mpc_ptr, unsigned long int, mpc_rnd_t);
int mpc_set_ui_ui (mpc_ptr, unsigned long int, unsigned long int, mpc_rnd_t);
int mpc_set_z (mpc_ptr, mpz_srcptr, mpc_rnd_t);
int mpc_set_z_z (mpc_ptr, mpz_srcptr, mpz_srcptr, mpc_rnd_t);
void mpc_swap (mpc_ptr, mpc_ptr);
int mpc_fma (mpc_ptr, mpc_srcptr, mpc_srcptr, mpc_srcptr, mpc_rnd_t);
void mpc_set_nan (mpc_ptr);
int mpc_real (mpfr_ptr, mpc_srcptr, mpfr_rnd_t);
int mpc_imag (mpfr_ptr, mpc_srcptr, mpfr_rnd_t);
int mpc_arg (mpfr_ptr, mpc_srcptr, mpfr_rnd_t);
int mpc_proj (mpc_ptr, mpc_srcptr, mpc_rnd_t);
int mpc_cmp (mpc_srcptr, mpc_srcptr);
int mpc_cmp_si_si (mpc_srcptr, long int, long int);
int mpc_cmp_abs (mpc_srcptr, mpc_srcptr);
int mpc_exp (mpc_ptr, mpc_srcptr, mpc_rnd_t);
int mpc_log (mpc_ptr, mpc_srcptr, mpc_rnd_t);
int mpc_log10 (mpc_ptr, mpc_srcptr, mpc_rnd_t);
int mpc_sin (mpc_ptr, mpc_srcptr, mpc_rnd_t);
int mpc_cos (mpc_ptr, mpc_srcptr, mpc_rnd_t);
int mpc_sin_cos (mpc_ptr, mpc_ptr, mpc_srcptr, mpc_rnd_t, mpc_rnd_t);
int mpc_tan (mpc_ptr, mpc_srcptr, mpc_rnd_t);
int mpc_sinh (mpc_ptr, mpc_srcptr, mpc_rnd_t);
int mpc_cosh (mpc_ptr, mpc_srcptr, mpc_rnd_t);
int mpc_tanh (mpc_ptr, mpc_srcptr, mpc_rnd_t);
int mpc_asin (mpc_ptr, mpc_srcptr, mpc_rnd_t);
int mpc_acos (mpc_ptr, mpc_srcptr, mpc_rnd_t);
int mpc_atan (mpc_ptr, mpc_srcptr, mpc_rnd_t);
int mpc_asinh (mpc_ptr, mpc_srcptr, mpc_rnd_t);
int mpc_acosh (mpc_ptr, mpc_srcptr, mpc_rnd_t);
int mpc_atanh (mpc_ptr, mpc_srcptr, mpc_rnd_t);
int mpc_rootofunity (mpc_ptr, unsigned long int, unsigned long int, mpc_rnd_t);
void mpc_clear (mpc_ptr);
int mpc_urandom (mpc_ptr, gmp_randstate_t);
void mpc_init2 (mpc_ptr, mpfr_prec_t);
void mpc_init3 (mpc_ptr, mpfr_prec_t, mpfr_prec_t);
mpfr_prec_t mpc_get_prec (mpc_srcptr x);
void mpc_get_prec2 (mpfr_prec_t *pr, mpfr_prec_t *pi, mpc_srcptr x);
void mpc_set_prec (mpc_ptr, mpfr_prec_t);
const char * mpc_get_version (void);
int mpc_strtoc (mpc_ptr, const char *, char **, int, mpc_rnd_t);
int mpc_set_str (mpc_ptr, const char *, int, mpc_rnd_t);
char * mpc_get_str (int, size_t, mpc_srcptr, mpc_rnd_t);
void mpc_free_str (char *);
int mpc_set_sj (mpc_ptr, intmax_t, mpc_rnd_t);
int mpc_set_uj (mpc_ptr, uintmax_t, mpc_rnd_t);
int mpc_set_sj_sj (mpc_ptr, intmax_t, intmax_t, mpc_rnd_t);
int mpc_set_uj_uj (mpc_ptr, uintmax_t, uintmax_t, mpc_rnd_t);
# 238 "/usr/include/mpc.h" 3 4
int mpc_inp_str (mpc_ptr, FILE *, size_t *, int, mpc_rnd_t);
size_t mpc_out_str (FILE *, int, size_t, mpc_srcptr, mpc_rnd_t);
}
# 2190 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/gfortran.h" 2
# 2193 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/gfortran.h"
typedef splay_tree gfc_constructor_base;
typedef long gfc_charlen_t;
typedef struct gfc_expr
{
expr_t expr_type;
gfc_typespec ts;
int rank;
mpz_t *shape;
gfc_symtree *symtree;
gfc_ref *ref;
locus where;
struct gfc_expr *base_expr;
unsigned int is_snan : 1;
unsigned int error : 1;
unsigned int user_operator : 1;
unsigned int mold : 1;
unsigned int must_finalize : 1;
unsigned int no_bounds_check : 1;
unsigned int external_blas : 1;
unsigned int do_not_resolve_again : 1;
unsigned int do_not_warn : 1;
unsigned int from_constructor : 1;
struct
{
gfc_charlen_t length;
char *string;
}
representation;
struct
{
int len;
int rdx;
char *str;
}
boz;
union
{
int logical;
io_kind iokind;
mpz_t integer;
mpfr_t real;
mpc_t complex;
struct
{
gfc_intrinsic_op op;
gfc_user_op *uop;
struct gfc_expr *op1, *op2;
}
op;
struct
{
gfc_actual_arglist *actual;
const char *name;
gfc_intrinsic_sym *isym;
gfc_symbol *esym;
}
function;
struct
{
gfc_actual_arglist* actual;
const char* name;
struct gfc_expr* base_object;
gfc_typebound_proc* tbp;
unsigned ignore_pass:1;
unsigned assign:1;
}
compcall;
struct
{
gfc_charlen_t length;
gfc_char_t *string;
}
character;
gfc_constructor_base constructor;
}
value;
gfc_actual_arglist *param_list;
}
gfc_expr;
# 2355 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/gfortran.h"
typedef struct
{
mpz_t huge, pedantic_min_int, min_int;
int kind, radix, digits, bit_size, range;
unsigned int c_char : 1;
unsigned int c_short : 1;
unsigned int c_int : 1;
unsigned int c_long : 1;
unsigned int c_long_long : 1;
}
gfc_integer_info;
extern gfc_integer_info gfc_integer_kinds[];
typedef struct
{
int kind, bit_size;
unsigned int c_bool : 1;
}
gfc_logical_info;
extern gfc_logical_info gfc_logical_kinds[];
typedef struct
{
mpfr_t epsilon, huge, tiny, subnormal;
int kind, radix, digits, min_exponent, max_exponent;
int range, precision;
int mode_precision;
unsigned int c_float : 1;
unsigned int c_double : 1;
unsigned int c_long_double : 1;
unsigned int c_float128 : 1;
}
gfc_real_info;
extern gfc_real_info gfc_real_kinds[];
typedef struct
{
int kind, bit_size;
const char *name;
}
gfc_character_info;
extern gfc_character_info gfc_character_kinds[];
typedef struct gfc_equiv
{
struct gfc_equiv *next, *eq;
gfc_expr *expr;
const char *module;
int used;
}
gfc_equiv;
typedef struct gfc_equiv_info
{
gfc_symbol *sym;
long offset;
long length;
struct gfc_equiv_info *next;
} gfc_equiv_info;
typedef struct gfc_equiv_list
{
gfc_equiv_info *equiv;
struct gfc_equiv_list *next;
} gfc_equiv_list;
# 2458 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/gfortran.h"
typedef struct gfc_case
{
locus where;
int n;
gfc_expr *low, *high;
gfc_typespec ts;
struct gfc_case *next;
struct gfc_case *left, *right;
int unreachable;
}
gfc_case;
typedef struct
{
gfc_expr *var, *start, *end, *step;
unsigned short unroll;
bool ivdep;
bool vector;
bool novector;
}
gfc_iterator;
typedef struct gfc_alloc
{
gfc_expr *expr;
struct gfc_alloc *next;
}
gfc_alloc;
typedef struct
{
gfc_expr *unit, *file, *status, *access, *form, *recl,
*blank, *position, *action, *delim, *pad, *iostat, *iomsg, *convert,
*decimal, *encoding, *round, *sign, *asynchronous, *id, *newunit,
*share, *cc;
char readonly;
gfc_st_label *err;
}
gfc_open;
typedef struct
{
gfc_expr *unit, *status, *iostat, *iomsg;
gfc_st_label *err;
}
gfc_close;
typedef struct
{
gfc_expr *unit, *iostat, *iomsg;
gfc_st_label *err;
}
gfc_filepos;
typedef struct
{
gfc_expr *unit, *file, *iostat, *exist, *opened, *number, *named,
*name, *access, *sequential, *direct, *form, *formatted,
*unformatted, *recl, *nextrec, *blank, *position, *action, *read,
*write, *readwrite, *delim, *pad, *iolength, *iomsg, *convert, *strm_pos,
*asynchronous, *decimal, *encoding, *pending, *round, *sign, *size, *id,
*iqstream, *share, *cc;
gfc_st_label *err;
}
gfc_inquire;
typedef struct
{
gfc_expr *unit, *iostat, *iomsg, *id;
gfc_st_label *err, *end, *eor;
}
gfc_wait;
typedef struct
{
gfc_expr *io_unit, *format_expr, *rec, *advance, *iostat, *size, *iomsg,
*id, *pos, *asynchronous, *blank, *decimal, *delim, *pad, *round,
*sign, *extra_comma, *dt_io_kind, *udtio;
char dec_ext;
gfc_symbol *namelist;
gfc_st_label *format_label;
gfc_st_label *err, *end, *eor;
locus eor_where, end_where, err_where;
}
gfc_dt;
typedef struct gfc_forall_iterator
{
gfc_expr *var, *start, *end, *stride;
struct gfc_forall_iterator *next;
}
gfc_forall_iterator;
typedef struct gfc_association_list
{
struct gfc_association_list *next;
unsigned variable:1;
unsigned dangling:1;
unsigned rankguessed:1;
char name[63 + 1];
gfc_symtree *st;
locus where;
gfc_expr *target;
}
gfc_association_list;
enum gfc_exec_op
{
EXEC_NOP = 1, EXEC_END_NESTED_BLOCK, EXEC_END_BLOCK, EXEC_ASSIGN,
EXEC_LABEL_ASSIGN, EXEC_POINTER_ASSIGN, EXEC_CRITICAL, EXEC_ERROR_STOP,
EXEC_GOTO, EXEC_CALL, EXEC_COMPCALL, EXEC_ASSIGN_CALL, EXEC_RETURN,
EXEC_ENTRY, EXEC_PAUSE, EXEC_STOP, EXEC_CONTINUE, EXEC_INIT_ASSIGN,
EXEC_IF, EXEC_ARITHMETIC_IF, EXEC_DO, EXEC_DO_CONCURRENT, EXEC_DO_WHILE,
EXEC_SELECT, EXEC_BLOCK, EXEC_FORALL, EXEC_WHERE, EXEC_CYCLE, EXEC_EXIT,
EXEC_CALL_PPC, EXEC_ALLOCATE, EXEC_DEALLOCATE, EXEC_END_PROCEDURE,
EXEC_SELECT_TYPE, EXEC_SELECT_RANK, EXEC_SYNC_ALL, EXEC_SYNC_MEMORY,
EXEC_SYNC_IMAGES, EXEC_OPEN, EXEC_CLOSE, EXEC_WAIT,
EXEC_READ, EXEC_WRITE, EXEC_IOLENGTH, EXEC_TRANSFER, EXEC_DT_END,
EXEC_BACKSPACE, EXEC_ENDFILE, EXEC_INQUIRE, EXEC_REWIND, EXEC_FLUSH,
EXEC_FORM_TEAM, EXEC_CHANGE_TEAM, EXEC_END_TEAM, EXEC_SYNC_TEAM,
EXEC_LOCK, EXEC_UNLOCK, EXEC_EVENT_POST, EXEC_EVENT_WAIT, EXEC_FAIL_IMAGE,
EXEC_OACC_KERNELS_LOOP, EXEC_OACC_PARALLEL_LOOP, EXEC_OACC_SERIAL_LOOP,
EXEC_OACC_ROUTINE, EXEC_OACC_PARALLEL, EXEC_OACC_KERNELS, EXEC_OACC_SERIAL,
EXEC_OACC_DATA, EXEC_OACC_HOST_DATA, EXEC_OACC_LOOP, EXEC_OACC_UPDATE,
EXEC_OACC_WAIT, EXEC_OACC_CACHE, EXEC_OACC_ENTER_DATA, EXEC_OACC_EXIT_DATA,
EXEC_OACC_ATOMIC, EXEC_OACC_DECLARE,
EXEC_OMP_CRITICAL, EXEC_OMP_DO, EXEC_OMP_FLUSH, EXEC_OMP_MASTER,
EXEC_OMP_ORDERED, EXEC_OMP_PARALLEL, EXEC_OMP_PARALLEL_DO,
EXEC_OMP_PARALLEL_SECTIONS, EXEC_OMP_PARALLEL_WORKSHARE,
EXEC_OMP_SECTIONS, EXEC_OMP_SINGLE, EXEC_OMP_WORKSHARE,
EXEC_OMP_ATOMIC, EXEC_OMP_BARRIER, EXEC_OMP_END_NOWAIT,
EXEC_OMP_END_SINGLE, EXEC_OMP_TASK, EXEC_OMP_TASKWAIT,
EXEC_OMP_TASKYIELD, EXEC_OMP_CANCEL, EXEC_OMP_CANCELLATION_POINT,
EXEC_OMP_TASKGROUP, EXEC_OMP_SIMD, EXEC_OMP_DO_SIMD,
EXEC_OMP_PARALLEL_DO_SIMD, EXEC_OMP_TARGET, EXEC_OMP_TARGET_DATA,
EXEC_OMP_TEAMS, EXEC_OMP_DISTRIBUTE, EXEC_OMP_DISTRIBUTE_SIMD,
EXEC_OMP_DISTRIBUTE_PARALLEL_DO, EXEC_OMP_DISTRIBUTE_PARALLEL_DO_SIMD,
EXEC_OMP_TARGET_TEAMS, EXEC_OMP_TEAMS_DISTRIBUTE,
EXEC_OMP_TEAMS_DISTRIBUTE_SIMD, EXEC_OMP_TARGET_TEAMS_DISTRIBUTE,
EXEC_OMP_TARGET_TEAMS_DISTRIBUTE_SIMD,
EXEC_OMP_TEAMS_DISTRIBUTE_PARALLEL_DO,
EXEC_OMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_DO,
EXEC_OMP_TEAMS_DISTRIBUTE_PARALLEL_DO_SIMD,
EXEC_OMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_DO_SIMD,
EXEC_OMP_TARGET_UPDATE, EXEC_OMP_END_CRITICAL,
EXEC_OMP_TARGET_ENTER_DATA, EXEC_OMP_TARGET_EXIT_DATA,
EXEC_OMP_TARGET_PARALLEL, EXEC_OMP_TARGET_PARALLEL_DO,
EXEC_OMP_TARGET_PARALLEL_DO_SIMD, EXEC_OMP_TARGET_SIMD,
EXEC_OMP_TASKLOOP, EXEC_OMP_TASKLOOP_SIMD
};
enum gfc_omp_atomic_op
{
GFC_OMP_ATOMIC_UPDATE = 0,
GFC_OMP_ATOMIC_READ = 1,
GFC_OMP_ATOMIC_WRITE = 2,
GFC_OMP_ATOMIC_CAPTURE = 3,
GFC_OMP_ATOMIC_MASK = 3,
GFC_OMP_ATOMIC_SEQ_CST = 4,
GFC_OMP_ATOMIC_ACQ_REL = 8,
GFC_OMP_ATOMIC_SWAP = 16
};
typedef struct gfc_code
{
gfc_exec_op op;
struct gfc_code *block, *next;
locus loc;
gfc_st_label *here, *label1, *label2, *label3;
gfc_symtree *symtree;
gfc_expr *expr1, *expr2, *expr3, *expr4;
gfc_symbol *resolved_sym;
gfc_intrinsic_sym *resolved_isym;
union
{
gfc_actual_arglist *actual;
gfc_iterator *iterator;
struct
{
gfc_typespec ts;
gfc_alloc *list;
unsigned arr_spec_from_expr3:1;
}
alloc;
struct
{
gfc_namespace *ns;
gfc_association_list *assoc;
gfc_case *case_list;
}
block;
gfc_open *open;
gfc_close *close;
gfc_filepos *filepos;
gfc_inquire *inquire;
gfc_wait *wait;
gfc_dt *dt;
gfc_forall_iterator *forall_iterator;
struct gfc_code *which_construct;
int stop_code;
gfc_entry_list *entry;
gfc_oacc_declare *oacc_declare;
gfc_omp_clauses *omp_clauses;
const char *omp_name;
gfc_omp_namelist *omp_namelist;
bool omp_bool;
gfc_omp_atomic_op omp_atomic;
}
ext;
tree cycle_label;
tree exit_label;
}
gfc_code;
typedef struct gfc_data_variable
{
gfc_expr *expr;
gfc_iterator iter;
struct gfc_data_variable *list, *next;
}
gfc_data_variable;
typedef struct gfc_data_value
{
mpz_t repeat;
gfc_expr *expr;
struct gfc_data_value *next;
}
gfc_data_value;
typedef struct gfc_data
{
gfc_data_variable *var;
gfc_data_value *value;
locus where;
struct gfc_data *next;
}
gfc_data;
typedef struct
{
char *module_dir;
gfc_source_form source_form;
int max_continue_fixed;
int max_continue_free;
int max_identifier_length;
int max_errors;
int flag_preprocessed;
int flag_d_lines;
int flag_init_integer;
long flag_init_integer_value;
int flag_init_logical;
int flag_init_character;
char flag_init_character_value;
int fpe;
int fpe_summary;
int rtcheck;
int warn_std;
int allow_std;
}
gfc_option_t;
extern gfc_option_t gfc_option;
typedef struct gfc_constructor
{
gfc_constructor_base base;
mpz_t offset;
gfc_expr *expr;
gfc_iterator *iterator;
locus where;
union
{
gfc_component *component;
}
n;
mpz_t repeat;
}
gfc_constructor;
typedef struct iterator_stack
{
gfc_symtree *variable;
mpz_t value;
struct iterator_stack *prev;
}
iterator_stack;
extern iterator_stack *iter_stack;
typedef struct gfc_select_type_stack
{
gfc_symbol *selector;
gfc_symtree *tmp;
struct gfc_select_type_stack *prev;
}
gfc_select_type_stack;
extern gfc_select_type_stack *select_type_stack;
typedef struct gfc_finalizer
{
struct gfc_finalizer* next;
locus where;
gfc_symbol* proc_sym;
gfc_symtree* proc_tree;
}
gfc_finalizer;
bool gfc_in_match_data (void);
match gfc_match_char_spec (gfc_typespec *);
extern int directive_unroll;
extern bool directive_ivdep;
extern bool directive_vector;
extern bool directive_novector;
enum gfc_simd_clause
{
SIMD_NONE = (1 << 0),
SIMD_INBRANCH = (1 << 1),
SIMD_NOTINBRANCH = (1 << 2)
};
struct gfc_vect_builtin_tuple
{
gfc_vect_builtin_tuple (const char *n, gfc_simd_clause t)
: name (n), simd_type (t) {}
const char *name;
gfc_simd_clause simd_type;
};
extern hash_map<nofree_string_hash, int> *gfc_vectorized_builtins;
bool gfc_insert_kind_parameter_exprs (gfc_expr *);
bool gfc_insert_parameter_exprs (gfc_expr *, gfc_actual_arglist *);
match gfc_get_pdt_instance (gfc_actual_arglist *, gfc_symbol **,
gfc_actual_arglist **);
# 2909 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/gfortran.h"
void gfc_scanner_done_1 (void);
void gfc_scanner_init_1 (void);
void gfc_add_include_path (const char *, bool, bool, bool);
void gfc_add_intrinsic_modules_path (const char *);
void gfc_release_include_path (void);
FILE *gfc_open_included_file (const char *, bool, bool);
int gfc_at_end (void);
int gfc_at_eof (void);
int gfc_at_bol (void);
int gfc_at_eol (void);
void gfc_advance_line (void);
int gfc_check_include (void);
int gfc_define_undef_line (void);
int gfc_wide_is_printable (gfc_char_t);
int gfc_wide_is_digit (gfc_char_t);
int gfc_wide_fits_in_byte (gfc_char_t);
gfc_char_t gfc_wide_tolower (gfc_char_t);
gfc_char_t gfc_wide_toupper (gfc_char_t);
size_t gfc_wide_strlen (const gfc_char_t *);
int gfc_wide_strncasecmp (const gfc_char_t *, const char *, size_t);
gfc_char_t *gfc_wide_memset (gfc_char_t *, gfc_char_t, size_t);
char *gfc_widechar_to_char (const gfc_char_t *, int);
gfc_char_t *gfc_char_to_widechar (const char *);
void gfc_skip_comments (void);
gfc_char_t gfc_next_char_literal (gfc_instring);
gfc_char_t gfc_next_char (void);
char gfc_next_ascii_char (void);
gfc_char_t gfc_peek_char (void);
char gfc_peek_ascii_char (void);
void gfc_error_recovery (void);
void gfc_gobble_whitespace (void);
bool gfc_new_file (void);
const char * gfc_read_orig_filename (const char *, const char **);
extern gfc_source_form gfc_current_form;
extern const char *gfc_source_file;
extern locus gfc_current_locus;
void gfc_start_source_files (void);
void gfc_end_source_files (void);
void gfc_clear_ts (gfc_typespec *);
FILE *gfc_open_file (const char *);
const char *gfc_basic_typename (bt);
const char *gfc_dummy_typename (gfc_typespec *);
const char *gfc_typename (gfc_typespec *, bool for_hash = false);
const char *gfc_typename (gfc_expr *);
const char *gfc_op2string (gfc_intrinsic_op);
const char *gfc_code2string (const mstring *, int);
int gfc_string2code (const mstring *, const char *);
const char *gfc_intent_string (sym_intent);
void gfc_init_1 (void);
void gfc_init_2 (void);
void gfc_done_1 (void);
void gfc_done_2 (void);
int get_c_kind (const char *, CInteropKind_t *);
const char *gfc_closest_fuzzy_match (const char *, char **);
static inline void
vec_push (char **&optr, size_t &osz, const char *elt)
{
optr = ((char * *) xrealloc ((void *) (optr), sizeof (char *) * (osz + 2)));
optr[osz] = (const_cast<char *> ((elt)));
optr[++osz] =
# 2983 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/gfortran.h" 3 4
__null
# 2983 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/gfortran.h"
;
}
long gfc_mpz_get_hwi (mpz_t);
void gfc_mpz_set_hwi (mpz_t, const long);
unsigned int gfc_option_lang_mask (void);
void gfc_init_options_struct (struct gcc_options *);
void gfc_init_options (unsigned int,
struct cl_decoded_option *);
bool gfc_handle_option (size_t, const char *, long, int, location_t,
const struct cl_option_handlers *);
bool gfc_post_options (const char **);
char *gfc_get_option_string (void);
void gfc_maybe_initialize_eh (void);
const char * gfc_get_string (const char *, ...) __attribute__ ((__format__ (__printf__, 1, 2))) __attribute__ ((__nonnull__ (1)));
bool gfc_find_sym_in_expr (gfc_symbol *, gfc_expr *);
void gfc_error_init_1 (void);
void gfc_diagnostics_init (void);
void gfc_diagnostics_finish (void);
void gfc_buffer_error (bool);
const char *gfc_print_wide_char (gfc_char_t);
bool gfc_warning (int opt, const char *, ...) __attribute__ ((__format__ (__gcc_gfc__, 2, 3))) __attribute__ ((__nonnull__ (2)));
bool gfc_warning_now (int opt, const char *, ...) __attribute__ ((__format__ (__gcc_gfc__, 2, 3))) __attribute__ ((__nonnull__ (2)));
bool gfc_warning_internal (int opt, const char *, ...) __attribute__ ((__format__ (__gcc_gfc__, 2, 3))) __attribute__ ((__nonnull__ (2)));
bool gfc_warning_now_at (location_t loc, int opt, const char *gmsgid, ...)
__attribute__ ((__format__ (__gcc_gfc__, 3, 4))) __attribute__ ((__nonnull__ (3)));
void gfc_clear_warning (void);
void gfc_warning_check (void);
void gfc_error_opt (int opt, const char *, ...) __attribute__ ((__format__ (__gcc_gfc__, 2, 3))) __attribute__ ((__nonnull__ (2)));
void gfc_error (const char *, ...) __attribute__ ((__format__ (__gcc_gfc__, 1, 2))) __attribute__ ((__nonnull__ (1)));
void gfc_error_now (const char *, ...) __attribute__ ((__format__ (__gcc_gfc__, 1, 2))) __attribute__ ((__nonnull__ (1)));
void gfc_fatal_error (const char *, ...) __attribute__ ((__noreturn__)) __attribute__ ((__format__ (__gcc_gfc__, 1, 2))) __attribute__ ((__nonnull__ (1)));
void gfc_internal_error (const char *, ...) __attribute__ ((__noreturn__)) __attribute__ ((__format__ (__gcc_gfc__, 1, 2))) __attribute__ ((__nonnull__ (1)));
void gfc_clear_error (void);
bool gfc_error_check (void);
bool gfc_error_flag_test (void);
notification gfc_notification_std (int);
bool gfc_notify_std (int, const char *, ...) __attribute__ ((__format__ (__gcc_gfc__, 2, 3))) __attribute__ ((__nonnull__ (2)));
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/pretty-print.h" 1
# 24 "/home/giulianob/gcc_git_gnu/gcc/gcc/pretty-print.h"
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/../include/obstack.h" 1
# 111 "/home/giulianob/gcc_git_gnu/gcc/gcc/../include/obstack.h"
# 1 "/usr/lib/gcc/x86_64-linux-gnu/10/include/stddef.h" 1 3 4
# 112 "/home/giulianob/gcc_git_gnu/gcc/gcc/../include/obstack.h" 2
# 153 "/home/giulianob/gcc_git_gnu/gcc/gcc/../include/obstack.h"
extern "C" {
struct _obstack_chunk
{
char *limit;
struct _obstack_chunk *prev;
char contents[4];
};
struct obstack
{
size_t chunk_size;
struct _obstack_chunk *chunk;
char *object_base;
char *next_free;
char *chunk_limit;
union
{
size_t i;
void *p;
} temp;
size_t alignment_mask;
union
{
void *(*plain) (size_t);
void *(*extra) (void *, size_t);
} chunkfun;
union
{
void (*plain) (void *);
void (*extra) (void *, void *);
} freefun;
void *extra_arg;
unsigned use_extra_arg : 1;
unsigned maybe_empty_object : 1;
unsigned alloc_failed : 1;
};
extern void _obstack_newchunk (struct obstack *, size_t);
extern void _obstack_free (struct obstack *, void *);
extern int _obstack_begin (struct obstack *,
size_t, size_t,
void *(*) (size_t), void (*) (void *));
extern int _obstack_begin_1 (struct obstack *,
size_t, size_t,
void *(*) (void *, size_t),
void (*) (void *, void *), void *);
extern size_t _obstack_memory_used (struct obstack *)
# 212 "/home/giulianob/gcc_git_gnu/gcc/gcc/../include/obstack.h" 3 4
__attribute__ ((__pure__))
# 212 "/home/giulianob/gcc_git_gnu/gcc/gcc/../include/obstack.h"
;
extern void (*obstack_alloc_failed_handler) (void);
extern int obstack_exit_failure;
# 532 "/home/giulianob/gcc_git_gnu/gcc/gcc/../include/obstack.h"
}
# 25 "/home/giulianob/gcc_git_gnu/gcc/gcc/pretty-print.h" 2
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/diagnostic-url.h" 1
# 27 "/home/giulianob/gcc_git_gnu/gcc/gcc/diagnostic-url.h"
typedef enum
{
DIAGNOSTICS_URL_NO = 0,
DIAGNOSTICS_URL_YES = 1,
DIAGNOSTICS_URL_AUTO = 2
} diagnostic_url_rule_t;
enum diagnostic_url_format
{
URL_FORMAT_NONE,
URL_FORMAT_ST,
URL_FORMAT_BEL
};
const diagnostic_url_format URL_FORMAT_DEFAULT = URL_FORMAT_BEL;
extern diagnostic_url_format determine_url_format (diagnostic_url_rule_t);
# 26 "/home/giulianob/gcc_git_gnu/gcc/gcc/pretty-print.h" 2
struct text_info
{
const char *format_spec;
va_list *args_ptr;
int err_no;
void **x_data;
rich_location *m_richloc;
void set_location (unsigned int idx, location_t loc,
enum range_display_kind range_display_kind);
location_t get_location (unsigned int index_of_location) const;
};
enum diagnostic_prefixing_rule_t
{
DIAGNOSTICS_SHOW_PREFIX_ONCE = 0x0,
DIAGNOSTICS_SHOW_PREFIX_NEVER = 0x1,
DIAGNOSTICS_SHOW_PREFIX_EVERY_LINE = 0x2
};
struct chunk_info
{
struct chunk_info *prev;
const char *args[30 * 2];
};
class output_buffer
{
public:
output_buffer ();
~output_buffer ();
struct obstack formatted_obstack;
struct obstack chunk_obstack;
struct obstack *obstack;
struct chunk_info *cur_chunk_array;
FILE *stream;
int line_length;
char digit_buffer[128];
bool flush_p;
};
static inline const char *
output_buffer_formatted_text (output_buffer *buff)
{
__extension__ ({ struct obstack *__o = (buff->obstack); if (__extension__ ({ struct obstack const *__o1 = (__o); (size_t) (__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk (__o, 1); ((void) (*((__o)->next_free)++ = ('\0'))); });
return (const char *) ((void *) (buff->obstack)->object_base);
}
static inline void
output_buffer_append_r (output_buffer *buff, const char *start, int length)
{
((void)(!(start) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/pretty-print.h", 128, __FUNCTION__), 0 : 0));
__extension__ ({ struct obstack *__o = (buff->obstack); size_t __len = (length); if (__extension__ ({ struct obstack const *__o1 = (__o); (size_t) (__o1->chunk_limit - __o1->next_free); }) < __len) _obstack_newchunk (__o, __len); memcpy (__o->next_free, start, __len); __o->next_free += __len; (void) 0; });
for (int i = 0; i < length; i++)
if (start[i] == '\n')
buff->line_length = 0;
else
buff->line_length++;
}
static inline const char *
output_buffer_last_position_in_text (const output_buffer *buff)
{
const char *p =
# 142 "/home/giulianob/gcc_git_gnu/gcc/gcc/pretty-print.h" 3 4
__null
# 142 "/home/giulianob/gcc_git_gnu/gcc/gcc/pretty-print.h"
;
struct obstack *text = buff->obstack;
if (((void *) (text)->object_base) != ((void *) (text)->next_free))
p = ((const char *) ((void *) (text)->next_free)) - 1;
return p;
}
typedef unsigned int pp_flags;
enum pp_padding
{
pp_none, pp_before, pp_after
};
struct pp_wrapping_mode_t
{
diagnostic_prefixing_rule_t rule;
int line_cutoff;
};
# 184 "/home/giulianob/gcc_git_gnu/gcc/gcc/pretty-print.h"
typedef bool (*printer_fn) (pretty_printer *, text_info *, const char *,
int, bool, bool, bool, bool *, const char **);
class format_postprocessor
{
public:
virtual ~format_postprocessor () {}
virtual format_postprocessor *clone() const = 0;
virtual void handle (pretty_printer *) = 0;
};
# 220 "/home/giulianob/gcc_git_gnu/gcc/gcc/pretty-print.h"
class pretty_printer
{
public:
explicit pretty_printer (int = 0);
explicit pretty_printer (const pretty_printer &other);
virtual ~pretty_printer ();
virtual pretty_printer *clone () const;
output_buffer *buffer;
char *prefix;
pp_padding padding;
int maximum_length;
int indent_skip;
pp_wrapping_mode_t wrapping;
# 261 "/home/giulianob/gcc_git_gnu/gcc/gcc/pretty-print.h"
printer_fn format_decoder;
format_postprocessor *m_format_postprocessor;
bool emitted_prefix;
bool need_newline;
bool translate_identifiers;
bool show_color;
diagnostic_url_format url_format;
};
static inline const char *
pp_get_prefix (const pretty_printer *pp) { return pp->prefix; }
# 353 "/home/giulianob/gcc_git_gnu/gcc/gcc/pretty-print.h"
extern void pp_set_line_maximum_length (pretty_printer *, int);
extern void pp_set_prefix (pretty_printer *, char *);
extern char *pp_take_prefix (pretty_printer *);
extern void pp_destroy_prefix (pretty_printer *);
extern int pp_remaining_character_count_for_line (pretty_printer *);
extern void pp_clear_output_area (pretty_printer *);
extern const char *pp_formatted_text (pretty_printer *);
extern const char *pp_last_position_in_text (const pretty_printer *);
extern void pp_emit_prefix (pretty_printer *);
extern void pp_append_text (pretty_printer *, const char *, const char *);
extern void pp_newline_and_flush (pretty_printer *);
extern void pp_newline_and_indent (pretty_printer *, int);
extern void pp_separate_with (pretty_printer *, char);
# 382 "/home/giulianob/gcc_git_gnu/gcc/gcc/pretty-print.h"
extern void pp_printf (pretty_printer *, const char *, ...)
__attribute__ ((__format__ (__gcc_gfc__, 2 ,3))) __attribute__ ((__nonnull__ (2)));
extern void pp_verbatim (pretty_printer *, const char *, ...)
__attribute__ ((__format__ (__gcc_gfc__, 2 ,3))) __attribute__ ((__nonnull__ (2)));
extern void pp_flush (pretty_printer *);
extern void pp_really_flush (pretty_printer *);
extern void pp_format (pretty_printer *, text_info *);
extern void pp_output_formatted_text (pretty_printer *);
extern void pp_format_verbatim (pretty_printer *, text_info *);
extern void pp_indent (pretty_printer *);
extern void pp_newline (pretty_printer *);
extern void pp_character (pretty_printer *, int);
extern void pp_string (pretty_printer *, const char *);
extern void pp_write_text_to_stream (pretty_printer *);
extern void pp_write_text_as_dot_label_to_stream (pretty_printer *, bool);
extern void pp_write_text_as_html_like_dot_to_stream (pretty_printer *pp);
extern void pp_maybe_space (pretty_printer *);
extern void pp_begin_quote (pretty_printer *, bool);
extern void pp_end_quote (pretty_printer *, bool);
extern void pp_begin_url (pretty_printer *pp, const char *url);
extern void pp_end_url (pretty_printer *pp);
static inline pp_wrapping_mode_t
pp_set_verbatim_wrapping_ (pretty_printer *pp)
{
pp_wrapping_mode_t oldmode = (pp)->wrapping;
(pp)->wrapping.line_cutoff = 0;
(pp)->wrapping.rule = DIAGNOSTICS_SHOW_PREFIX_NEVER;
return oldmode;
}
extern const char *identifier_to_locale (const char *);
extern void *(*identifier_to_locale_alloc) (size_t);
extern void (*identifier_to_locale_free) (void *);
inline void
pp_wide_integer (pretty_printer *pp, long i)
{
do { sprintf ((pp)->buffer->digit_buffer, "%"
# 430 "/home/giulianob/gcc_git_gnu/gcc/gcc/pretty-print.h" 3 4
"l" "d"
# 430 "/home/giulianob/gcc_git_gnu/gcc/gcc/pretty-print.h"
, i); pp_string (pp, (pp)->buffer->digit_buffer); } while (0);
}
template<unsigned int N, typename T>
void pp_wide_integer (pretty_printer *pp, const poly_int_pod<N, T> &);
# 3040 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/gfortran.h" 2
struct gfc_error_buffer
{
bool flag;
output_buffer buffer;
gfc_error_buffer(void) : flag(false), buffer() {}
};
void gfc_push_error (gfc_error_buffer *);
void gfc_pop_error (gfc_error_buffer *);
void gfc_free_error (gfc_error_buffer *);
void gfc_get_errors (int *, int *);
void gfc_errors_to_warnings (bool);
void gfc_arith_init_1 (void);
void gfc_arith_done_1 (void);
arith gfc_check_integer_range (mpz_t p, int kind);
bool gfc_check_character_range (gfc_char_t, int);
extern bool gfc_seen_div0;
bool gfc_check_any_c_kind (gfc_typespec *);
int gfc_validate_kind (bt, int, bool);
int gfc_get_int_kind_from_width_isofortranenv (int size);
int gfc_get_real_kind_from_width_isofortranenv (int size);
tree gfc_get_union_type (gfc_symbol *);
tree gfc_get_derived_type (gfc_symbol * derived, int codimen = 0);
extern int gfc_index_integer_kind;
extern int gfc_default_integer_kind;
extern int gfc_max_integer_kind;
extern int gfc_default_real_kind;
extern int gfc_default_double_kind;
extern int gfc_default_character_kind;
extern int gfc_default_logical_kind;
extern int gfc_default_complex_kind;
extern int gfc_c_int_kind;
extern int gfc_atomic_int_kind;
extern int gfc_atomic_logical_kind;
extern int gfc_intio_kind;
extern int gfc_charlen_int_kind;
extern int gfc_size_kind;
extern int gfc_numeric_storage_size;
extern int gfc_character_storage_size;
void gfc_clear_new_implicit (void);
bool gfc_add_new_implicit_range (int, int);
bool gfc_merge_new_implicit (gfc_typespec *);
void gfc_set_implicit_none (bool, bool, locus *);
void gfc_check_function_type (gfc_namespace *);
bool gfc_is_intrinsic_typename (const char *);
bool gfc_check_conflict (symbol_attribute *, const char *, locus *);
gfc_typespec *gfc_get_default_type (const char *, gfc_namespace *);
bool gfc_set_default_type (gfc_symbol *, int, gfc_namespace *);
void gfc_set_sym_referenced (gfc_symbol *);
bool gfc_add_attribute (symbol_attribute *, locus *);
bool gfc_add_ext_attribute (symbol_attribute *, ext_attr_id_t, locus *);
bool gfc_add_allocatable (symbol_attribute *, locus *);
bool gfc_add_codimension (symbol_attribute *, const char *, locus *);
bool gfc_add_contiguous (symbol_attribute *, const char *, locus *);
bool gfc_add_dimension (symbol_attribute *, const char *, locus *);
bool gfc_add_external (symbol_attribute *, locus *);
bool gfc_add_intrinsic (symbol_attribute *, locus *);
bool gfc_add_optional (symbol_attribute *, locus *);
bool gfc_add_kind (symbol_attribute *, locus *);
bool gfc_add_len (symbol_attribute *, locus *);
bool gfc_add_pointer (symbol_attribute *, locus *);
bool gfc_add_cray_pointer (symbol_attribute *, locus *);
bool gfc_add_cray_pointee (symbol_attribute *, locus *);
match gfc_mod_pointee_as (gfc_array_spec *);
bool gfc_add_protected (symbol_attribute *, const char *, locus *);
bool gfc_add_result (symbol_attribute *, const char *, locus *);
bool gfc_add_automatic (symbol_attribute *, const char *, locus *);
bool gfc_add_save (symbol_attribute *, save_state, const char *, locus *);
bool gfc_add_threadprivate (symbol_attribute *, const char *, locus *);
bool gfc_add_omp_declare_target (symbol_attribute *, const char *, locus *);
bool gfc_add_omp_declare_target_link (symbol_attribute *, const char *,
locus *);
bool gfc_add_saved_common (symbol_attribute *, locus *);
bool gfc_add_target (symbol_attribute *, locus *);
bool gfc_add_dummy (symbol_attribute *, const char *, locus *);
bool gfc_add_generic (symbol_attribute *, const char *, locus *);
bool gfc_add_common (symbol_attribute *, locus *);
bool gfc_add_in_common (symbol_attribute *, const char *, locus *);
bool gfc_add_in_equivalence (symbol_attribute *, const char *, locus *);
bool gfc_add_data (symbol_attribute *, const char *, locus *);
bool gfc_add_in_namelist (symbol_attribute *, const char *, locus *);
bool gfc_add_sequence (symbol_attribute *, const char *, locus *);
bool gfc_add_elemental (symbol_attribute *, locus *);
bool gfc_add_pure (symbol_attribute *, locus *);
bool gfc_add_recursive (symbol_attribute *, locus *);
bool gfc_add_function (symbol_attribute *, const char *, locus *);
bool gfc_add_subroutine (symbol_attribute *, const char *, locus *);
bool gfc_add_volatile (symbol_attribute *, const char *, locus *);
bool gfc_add_asynchronous (symbol_attribute *, const char *, locus *);
bool gfc_add_proc (symbol_attribute *attr, const char *name, locus *where);
bool gfc_add_abstract (symbol_attribute* attr, locus* where);
bool gfc_add_access (symbol_attribute *, gfc_access, const char *, locus *);
bool gfc_add_is_bind_c (symbol_attribute *, const char *, locus *, int);
bool gfc_add_extension (symbol_attribute *, locus *);
bool gfc_add_value (symbol_attribute *, const char *, locus *);
bool gfc_add_flavor (symbol_attribute *, sym_flavor, const char *, locus *);
bool gfc_add_entry (symbol_attribute *, const char *, locus *);
bool gfc_add_procedure (symbol_attribute *, procedure_type,
const char *, locus *);
bool gfc_add_intent (symbol_attribute *, sym_intent, locus *);
bool gfc_add_explicit_interface (gfc_symbol *, ifsrc,
gfc_formal_arglist *, locus *);
bool gfc_add_type (gfc_symbol *, gfc_typespec *, locus *);
void gfc_clear_attr (symbol_attribute *);
bool gfc_missing_attr (symbol_attribute *, locus *);
bool gfc_copy_attr (symbol_attribute *, symbol_attribute *, locus *);
int gfc_copy_dummy_sym (gfc_symbol **, gfc_symbol *, int);
bool gfc_add_component (gfc_symbol *, const char *, gfc_component **);
gfc_symbol *gfc_use_derived (gfc_symbol *);
gfc_symtree *gfc_use_derived_tree (gfc_symtree *);
gfc_component *gfc_find_component (gfc_symbol *, const char *, bool, bool,
gfc_ref **);
gfc_st_label *gfc_get_st_label (int);
void gfc_free_st_label (gfc_st_label *);
void gfc_define_st_label (gfc_st_label *, gfc_sl_type, locus *);
bool gfc_reference_st_label (gfc_st_label *, gfc_sl_type);
gfc_namespace *gfc_get_namespace (gfc_namespace *, int);
gfc_symtree *gfc_new_symtree (gfc_symtree **, const char *);
gfc_symtree *gfc_find_symtree (gfc_symtree *, const char *);
void gfc_delete_symtree (gfc_symtree **, const char *);
gfc_symtree *gfc_get_unique_symtree (gfc_namespace *);
gfc_user_op *gfc_get_uop (const char *);
gfc_user_op *gfc_find_uop (const char *, gfc_namespace *);
void gfc_free_symbol (gfc_symbol *);
void gfc_release_symbol (gfc_symbol *);
gfc_symbol *gfc_new_symbol (const char *, gfc_namespace *);
gfc_symtree* gfc_find_symtree_in_proc (const char *, gfc_namespace *);
int gfc_find_symbol (const char *, gfc_namespace *, int, gfc_symbol **);
int gfc_find_sym_tree (const char *, gfc_namespace *, int, gfc_symtree **);
int gfc_get_symbol (const char *, gfc_namespace *, gfc_symbol **);
bool gfc_verify_c_interop (gfc_typespec *);
bool gfc_verify_c_interop_param (gfc_symbol *);
bool verify_bind_c_sym (gfc_symbol *, gfc_typespec *, int, gfc_common_head *);
bool verify_bind_c_derived_type (gfc_symbol *);
bool verify_com_block_vars_c_interop (gfc_common_head *);
gfc_symtree *generate_isocbinding_symbol (const char *, iso_c_binding_symbol,
const char *, gfc_symtree *, bool);
void gfc_save_symbol_data (gfc_symbol *);
int gfc_get_sym_tree (const char *, gfc_namespace *, gfc_symtree **, bool);
int gfc_get_ha_symbol (const char *, gfc_symbol **);
int gfc_get_ha_sym_tree (const char *, gfc_symtree **);
void gfc_drop_last_undo_checkpoint (void);
void gfc_restore_last_undo_checkpoint (void);
void gfc_undo_symbols (void);
void gfc_commit_symbols (void);
void gfc_commit_symbol (gfc_symbol *);
gfc_charlen *gfc_new_charlen (gfc_namespace *, gfc_charlen *);
void gfc_free_charlen (gfc_charlen *, gfc_charlen *);
void gfc_free_namespace (gfc_namespace *);
void gfc_symbol_init_2 (void);
void gfc_symbol_done_2 (void);
void gfc_traverse_symtree (gfc_symtree *, void (*)(gfc_symtree *));
void gfc_traverse_ns (gfc_namespace *, void (*)(gfc_symbol *));
void gfc_traverse_user_op (gfc_namespace *, void (*)(gfc_user_op *));
void gfc_save_all (gfc_namespace *);
void gfc_enforce_clean_symbol_state (void);
gfc_gsymbol *gfc_get_gsymbol (const char *, bool bind_c);
gfc_gsymbol *gfc_find_gsymbol (gfc_gsymbol *, const char *);
gfc_gsymbol *gfc_find_case_gsymbol (gfc_gsymbol *, const char *);
void gfc_traverse_gsymbol (gfc_gsymbol *, void (*)(gfc_gsymbol *, void *), void *);
gfc_typebound_proc* gfc_get_typebound_proc (gfc_typebound_proc*);
gfc_symbol* gfc_get_derived_super_type (gfc_symbol*);
gfc_symbol* gfc_get_ultimate_derived_super_type (gfc_symbol*);
bool gfc_type_is_extension_of (gfc_symbol *, gfc_symbol *);
bool gfc_type_compatible (gfc_typespec *, gfc_typespec *);
void gfc_copy_formal_args_intr (gfc_symbol *, gfc_intrinsic_sym *,
gfc_actual_arglist *);
void gfc_free_finalizer (gfc_finalizer *el);
bool gfc_check_symbol_typed (gfc_symbol*, gfc_namespace*, bool, locus);
gfc_namespace* gfc_find_proc_namespace (gfc_namespace*);
bool gfc_is_associate_pointer (gfc_symbol*);
gfc_symbol * gfc_find_dt_in_generic (gfc_symbol *);
gfc_formal_arglist *gfc_sym_get_dummy_args (gfc_symbol *);
extern bool gfc_init_expr_flag;
void gfc_intrinsic_init_1 (void);
void gfc_intrinsic_done_1 (void);
char gfc_type_letter (bt, bool logical_equals_int = false);
gfc_symbol * gfc_get_intrinsic_sub_symbol (const char *);
bool gfc_convert_type (gfc_expr *, gfc_typespec *, int);
bool gfc_convert_type_warn (gfc_expr *, gfc_typespec *, int, int,
bool array = false);
bool gfc_convert_chartype (gfc_expr *, gfc_typespec *);
int gfc_generic_intrinsic (const char *);
int gfc_specific_intrinsic (const char *);
bool gfc_is_intrinsic (gfc_symbol*, int, locus);
int gfc_intrinsic_actual_ok (const char *, const bool);
gfc_intrinsic_sym *gfc_find_function (const char *);
gfc_intrinsic_sym *gfc_find_subroutine (const char *);
gfc_intrinsic_sym *gfc_intrinsic_function_by_id (gfc_isym_id);
gfc_intrinsic_sym *gfc_intrinsic_subroutine_by_id (gfc_isym_id);
gfc_isym_id gfc_isym_id_by_intmod (intmod_id, int);
gfc_isym_id gfc_isym_id_by_intmod_sym (gfc_symbol *);
match gfc_intrinsic_func_interface (gfc_expr *, int);
match gfc_intrinsic_sub_interface (gfc_code *, int);
void gfc_warn_intrinsic_shadow (const gfc_symbol*, bool, bool);
bool gfc_check_intrinsic_standard (const gfc_intrinsic_sym*, const char**,
bool, locus);
void gfc_free_iterator (gfc_iterator *, int);
void gfc_free_forall_iterator (gfc_forall_iterator *);
void gfc_free_alloc_list (gfc_alloc *);
void gfc_free_namelist (gfc_namelist *);
void gfc_free_omp_namelist (gfc_omp_namelist *);
void gfc_free_equiv (gfc_equiv *);
void gfc_free_equiv_until (gfc_equiv *, gfc_equiv *);
void gfc_free_data (gfc_data *);
void gfc_reject_data (gfc_namespace *);
void gfc_free_case_list (gfc_case *);
gfc_expr *gfc_get_parentheses (gfc_expr *);
struct gfc_omp_saved_state { void *ptrs[2]; int ints[1]; };
bool gfc_omp_requires_add_clause (gfc_omp_requires_kind, const char *,
locus *, const char *);
void gfc_check_omp_requires (gfc_namespace *, int);
void gfc_free_omp_clauses (gfc_omp_clauses *);
void gfc_free_oacc_declare_clauses (struct gfc_oacc_declare *);
void gfc_free_omp_declare_simd (gfc_omp_declare_simd *);
void gfc_free_omp_declare_simd_list (gfc_omp_declare_simd *);
void gfc_free_omp_udr (gfc_omp_udr *);
gfc_omp_udr *gfc_omp_udr_find (gfc_symtree *, gfc_typespec *);
void gfc_resolve_omp_directive (gfc_code *, gfc_namespace *);
void gfc_resolve_do_iterator (gfc_code *, gfc_symbol *, bool);
void gfc_resolve_omp_local_vars (gfc_namespace *);
void gfc_resolve_omp_parallel_blocks (gfc_code *, gfc_namespace *);
void gfc_resolve_omp_do_blocks (gfc_code *, gfc_namespace *);
void gfc_resolve_omp_declare_simd (gfc_namespace *);
void gfc_resolve_omp_udrs (gfc_symtree *);
void gfc_omp_save_and_clear_state (struct gfc_omp_saved_state *);
void gfc_omp_restore_state (struct gfc_omp_saved_state *);
void gfc_free_expr_list (gfc_expr_list *);
void gfc_resolve_oacc_directive (gfc_code *, gfc_namespace *);
void gfc_resolve_oacc_declare (gfc_namespace *);
void gfc_resolve_oacc_parallel_loop_blocks (gfc_code *, gfc_namespace *);
void gfc_resolve_oacc_blocks (gfc_code *, gfc_namespace *);
void gfc_resolve_oacc_routines (gfc_namespace *);
void gfc_free_actual_arglist (gfc_actual_arglist *);
gfc_actual_arglist *gfc_copy_actual_arglist (gfc_actual_arglist *);
bool gfc_extract_int (gfc_expr *, int *, int = 0);
bool gfc_extract_hwi (gfc_expr *, long *, int = 0);
bool is_CFI_desc (gfc_symbol *, gfc_expr *);
bool is_subref_array (gfc_expr *);
bool gfc_is_simply_contiguous (gfc_expr *, bool, bool);
bool gfc_is_not_contiguous (gfc_expr *);
bool gfc_check_init_expr (gfc_expr *);
gfc_expr *gfc_build_conversion (gfc_expr *);
void gfc_free_ref_list (gfc_ref *);
void gfc_type_convert_binary (gfc_expr *, int);
bool gfc_is_constant_expr (gfc_expr *);
bool gfc_simplify_expr (gfc_expr *, int);
int gfc_has_vector_index (gfc_expr *);
gfc_expr *gfc_get_expr (void);
gfc_expr *gfc_get_array_expr (bt type, int kind, locus *);
gfc_expr *gfc_get_null_expr (locus *);
gfc_expr *gfc_get_operator_expr (locus *, gfc_intrinsic_op,gfc_expr *, gfc_expr *);
gfc_expr *gfc_get_structure_constructor_expr (bt, int, locus *);
gfc_expr *gfc_get_constant_expr (bt, int, locus *);
gfc_expr *gfc_get_character_expr (int, locus *, const char *, gfc_charlen_t len);
gfc_expr *gfc_get_int_expr (int, locus *, long);
gfc_expr *gfc_get_logical_expr (int, locus *, bool);
gfc_expr *gfc_get_iokind_expr (locus *, io_kind);
void gfc_clear_shape (mpz_t *shape, int rank);
void gfc_free_shape (mpz_t **shape, int rank);
void gfc_free_expr (gfc_expr *);
void gfc_replace_expr (gfc_expr *, gfc_expr *);
mpz_t *gfc_copy_shape (mpz_t *, int);
mpz_t *gfc_copy_shape_excluding (mpz_t *, int, gfc_expr *);
gfc_expr *gfc_copy_expr (gfc_expr *);
gfc_ref* gfc_copy_ref (gfc_ref*);
bool gfc_specification_expr (gfc_expr *);
int gfc_numeric_ts (gfc_typespec *);
int gfc_kind_max (gfc_expr *, gfc_expr *);
bool gfc_check_conformance (gfc_expr *, gfc_expr *, const char *, ...) __attribute__ ((__format__ (__printf__, 3, 4))) __attribute__ ((__nonnull__ (3)));
bool gfc_check_assign (gfc_expr *, gfc_expr *, int, bool c = true);
bool gfc_check_pointer_assign (gfc_expr *lvalue, gfc_expr *rvalue,
bool suppres_type_test = false,
bool is_init_expr = false);
bool gfc_check_assign_symbol (gfc_symbol *, gfc_component *, gfc_expr *);
gfc_expr *gfc_build_default_init_expr (gfc_typespec *, locus *);
gfc_expr *gfc_build_init_expr (gfc_typespec *, locus *, bool);
void gfc_apply_init (gfc_typespec *, symbol_attribute *, gfc_expr *);
bool gfc_has_default_initializer (gfc_symbol *);
gfc_expr *gfc_default_initializer (gfc_typespec *);
gfc_expr *gfc_generate_initializer (gfc_typespec *, bool);
gfc_expr *gfc_get_variable_expr (gfc_symtree *);
void gfc_add_full_array_ref (gfc_expr *, gfc_array_spec *);
gfc_expr * gfc_lval_expr_from_sym (gfc_symbol *);
gfc_array_spec *gfc_get_full_arrayspec_from_expr (gfc_expr *expr);
bool gfc_traverse_expr (gfc_expr *, gfc_symbol *,
bool (*)(gfc_expr *, gfc_symbol *, int*),
int);
void gfc_expr_set_symbols_referenced (gfc_expr *);
bool gfc_expr_check_typed (gfc_expr*, gfc_namespace*, bool);
bool gfc_derived_parameter_expr (gfc_expr *);
gfc_param_spec_type gfc_spec_list_type (gfc_actual_arglist *, gfc_symbol *);
gfc_component * gfc_get_proc_ptr_comp (gfc_expr *);
bool gfc_is_proc_ptr_comp (gfc_expr *);
bool gfc_is_alloc_class_scalar_function (gfc_expr *);
bool gfc_is_class_array_function (gfc_expr *);
bool gfc_ref_this_image (gfc_ref *ref);
bool gfc_is_coindexed (gfc_expr *);
bool gfc_is_coarray (gfc_expr *);
int gfc_get_corank (gfc_expr *);
bool gfc_has_ultimate_allocatable (gfc_expr *);
bool gfc_has_ultimate_pointer (gfc_expr *);
gfc_expr* gfc_find_team_co (gfc_expr *);
gfc_expr* gfc_find_stat_co (gfc_expr *);
gfc_expr* gfc_build_intrinsic_call (gfc_namespace *, gfc_isym_id, const char*,
locus, unsigned, ...);
bool gfc_check_vardef_context (gfc_expr*, bool, bool, bool, const char*);
extern gfc_code new_st;
void gfc_clear_new_st (void);
gfc_code *gfc_get_code (gfc_exec_op);
gfc_code *gfc_append_code (gfc_code *, gfc_code *);
void gfc_free_statement (gfc_code *);
void gfc_free_statements (gfc_code *);
void gfc_free_association_list (gfc_association_list *);
void gfc_expression_rank (gfc_expr *);
bool gfc_resolve_ref (gfc_expr *);
bool gfc_resolve_expr (gfc_expr *);
void gfc_resolve (gfc_namespace *);
void gfc_resolve_code (gfc_code *, gfc_namespace *);
void gfc_resolve_blocks (gfc_code *, gfc_namespace *);
void gfc_resolve_formal_arglist (gfc_symbol *);
int gfc_impure_variable (gfc_symbol *);
int gfc_pure (gfc_symbol *);
int gfc_implicit_pure (gfc_symbol *);
void gfc_unset_implicit_pure (gfc_symbol *);
int gfc_elemental (gfc_symbol *);
bool gfc_resolve_iterator (gfc_iterator *, bool, bool);
bool find_forall_index (gfc_expr *, gfc_symbol *, int);
bool gfc_resolve_index (gfc_expr *, int);
bool gfc_resolve_dim_arg (gfc_expr *);
bool gfc_is_formal_arg (void);
void gfc_resolve_substring_charlen (gfc_expr *);
match gfc_iso_c_sub_interface(gfc_code *, gfc_symbol *);
gfc_expr *gfc_expr_to_initialize (gfc_expr *);
bool gfc_type_is_extensible (gfc_symbol *);
bool gfc_resolve_intrinsic (gfc_symbol *, locus *);
bool gfc_explicit_interface_required (gfc_symbol *, char *, int);
extern int gfc_do_concurrent_flag;
const char* gfc_lookup_function_fuzzy (const char *, gfc_symtree *);
int gfc_pure_function (gfc_expr *e, const char **name);
int gfc_implicit_pure_function (gfc_expr *e);
gfc_iterator *gfc_copy_iterator (gfc_iterator *);
void gfc_free_array_spec (gfc_array_spec *);
gfc_array_ref *gfc_copy_array_ref (gfc_array_ref *);
bool gfc_set_array_spec (gfc_symbol *, gfc_array_spec *, locus *);
gfc_array_spec *gfc_copy_array_spec (gfc_array_spec *);
bool gfc_resolve_array_spec (gfc_array_spec *, int);
int gfc_compare_array_spec (gfc_array_spec *, gfc_array_spec *);
void gfc_simplify_iterator_var (gfc_expr *);
bool gfc_expand_constructor (gfc_expr *, bool);
int gfc_constant_ac (gfc_expr *);
int gfc_expanded_ac (gfc_expr *);
bool gfc_resolve_character_array_constructor (gfc_expr *);
bool gfc_resolve_array_constructor (gfc_expr *);
bool gfc_check_constructor_type (gfc_expr *);
bool gfc_check_iter_variable (gfc_expr *);
bool gfc_check_constructor (gfc_expr *, bool (*)(gfc_expr *));
bool gfc_array_size (gfc_expr *, mpz_t *);
bool gfc_array_dimen_size (gfc_expr *, int, mpz_t *);
bool gfc_array_ref_shape (gfc_array_ref *, mpz_t *);
gfc_array_ref *gfc_find_array_ref (gfc_expr *, bool a = false);
tree gfc_conv_array_initializer (tree type, gfc_expr *);
bool spec_size (gfc_array_spec *, mpz_t *);
bool spec_dimen_size (gfc_array_spec *, int, mpz_t *);
bool gfc_is_compile_time_shape (gfc_array_spec *);
bool gfc_ref_dimen_size (gfc_array_ref *, int dimen, mpz_t *, mpz_t *);
void gfc_free_interface (gfc_interface *);
bool gfc_compare_derived_types (gfc_symbol *, gfc_symbol *);
bool gfc_compare_types (gfc_typespec *, gfc_typespec *);
bool gfc_check_dummy_characteristics (gfc_symbol *, gfc_symbol *,
bool, char *, int);
bool gfc_check_result_characteristics (gfc_symbol *, gfc_symbol *,
char *, int);
bool gfc_compare_interfaces (gfc_symbol*, gfc_symbol*, const char *, int, int,
char *, int, const char *, const char *,
bool *bad_result_characteristics =
# 3497 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/gfortran.h" 3 4
__null
# 3497 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/gfortran.h"
);
void gfc_check_interfaces (gfc_namespace *);
bool gfc_procedure_use (gfc_symbol *, gfc_actual_arglist **, locus *);
void gfc_ppc_use (gfc_component *, gfc_actual_arglist **, locus *);
gfc_symbol *gfc_search_interface (gfc_interface *, int,
gfc_actual_arglist **);
match gfc_extend_expr (gfc_expr *);
void gfc_free_formal_arglist (gfc_formal_arglist *);
bool gfc_extend_assign (gfc_code *, gfc_namespace *);
bool gfc_check_new_interface (gfc_interface *, gfc_symbol *, locus);
bool gfc_add_interface (gfc_symbol *);
gfc_interface *gfc_current_interface_head (void);
void gfc_set_current_interface_head (gfc_interface *);
gfc_symtree* gfc_find_sym_in_symtree (gfc_symbol*);
bool gfc_arglist_matches_symbol (gfc_actual_arglist**, gfc_symbol*);
bool gfc_check_operator_interface (gfc_symbol*, gfc_intrinsic_op, locus);
bool gfc_has_vector_subscript (gfc_expr*);
gfc_intrinsic_op gfc_equivalent_op (gfc_intrinsic_op);
bool gfc_check_typebound_override (gfc_symtree*, gfc_symtree*);
void gfc_check_dtio_interfaces (gfc_symbol*);
gfc_symtree* gfc_find_typebound_dtio_proc (gfc_symbol *, bool, bool);
gfc_symbol* gfc_find_specific_dtio_proc (gfc_symbol*, bool, bool);
void gfc_get_formal_from_actual_arglist (gfc_symbol *, gfc_actual_arglist *);
bool gfc_compare_actual_formal (gfc_actual_arglist **, gfc_formal_arglist *,
int, int, bool, locus *);
extern gfc_st_label format_asterisk;
void gfc_free_open (gfc_open *);
bool gfc_resolve_open (gfc_open *, locus *);
void gfc_free_close (gfc_close *);
bool gfc_resolve_close (gfc_close *, locus *);
void gfc_free_filepos (gfc_filepos *);
bool gfc_resolve_filepos (gfc_filepos *, locus *);
void gfc_free_inquire (gfc_inquire *);
bool gfc_resolve_inquire (gfc_inquire *);
void gfc_free_dt (gfc_dt *);
bool gfc_resolve_dt (gfc_code *, gfc_dt *, locus *);
void gfc_free_wait (gfc_wait *);
bool gfc_resolve_wait (gfc_wait *);
void gfc_module_init_2 (void);
void gfc_module_done_2 (void);
void gfc_dump_module (const char *, int);
bool gfc_check_symbol_access (gfc_symbol *);
void gfc_free_use_stmts (gfc_use_list *);
const char *gfc_dt_lower_string (const char *);
const char *gfc_dt_upper_string (const char *);
symbol_attribute gfc_variable_attr (gfc_expr *, gfc_typespec *);
symbol_attribute gfc_expr_attr (gfc_expr *);
symbol_attribute gfc_caf_attr (gfc_expr *, bool i = false, bool *r =
# 3552 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/gfortran.h" 3 4
__null
# 3552 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/gfortran.h"
);
match gfc_match_rvalue (gfc_expr **);
match gfc_match_varspec (gfc_expr*, int, bool, bool);
int gfc_check_digit (char, int);
bool gfc_is_function_return_value (gfc_symbol *, gfc_namespace *);
bool gfc_convert_to_structure_constructor (gfc_expr *, gfc_symbol *,
gfc_expr **,
gfc_actual_arglist **, bool);
void gfc_generate_code (gfc_namespace *);
void gfc_generate_module_code (gfc_namespace *);
bool gfc_inline_intrinsic_function_p (gfc_expr *);
typedef int (*compare_fn) (void *, void *);
void gfc_insert_bbt (void *, void *, compare_fn);
void gfc_delete_bbt (void *, void *, compare_fn);
void gfc_dump_parse_tree (gfc_namespace *, FILE *);
void gfc_dump_c_prototypes (gfc_namespace *, FILE *);
void gfc_dump_external_c_prototypes (FILE *);
void gfc_dump_global_symbols (FILE *);
void debug (gfc_symbol *);
void debug (gfc_expr *);
bool gfc_parse_file (void);
void gfc_global_used (gfc_gsymbol *, locus *);
gfc_namespace* gfc_build_block_ns (gfc_namespace *);
int gfc_dep_compare_functions (gfc_expr *, gfc_expr *, bool);
int gfc_dep_compare_expr (gfc_expr *, gfc_expr *);
bool gfc_dep_difference (gfc_expr *, gfc_expr *, mpz_t *);
bool gfc_check_same_strlen (const gfc_expr*, const gfc_expr*, const char*);
bool gfc_calculate_transfer_sizes (gfc_expr*, gfc_expr*, gfc_expr*,
size_t*, size_t*, size_t*);
bool gfc_boz2int (gfc_expr *, int);
bool gfc_boz2real (gfc_expr *, int);
bool gfc_invalid_boz (const char *, locus *);
bool gfc_invalid_null_arg (gfc_expr *);
void gfc_fix_class_refs (gfc_expr *e);
void gfc_add_component_ref (gfc_expr *, const char *);
void gfc_add_class_array_ref (gfc_expr *);
bool gfc_is_class_array_ref (gfc_expr *, bool *);
bool gfc_is_class_scalar_expr (gfc_expr *);
bool gfc_is_class_container_ref (gfc_expr *e);
gfc_expr *gfc_class_initializer (gfc_typespec *, gfc_expr *);
unsigned int gfc_hash_value (gfc_symbol *);
gfc_expr *gfc_get_len_component (gfc_expr *e, int);
bool gfc_build_class_symbol (gfc_typespec *, symbol_attribute *,
gfc_array_spec **);
gfc_symbol *gfc_find_derived_vtab (gfc_symbol *);
gfc_symbol *gfc_find_vtab (gfc_typespec *);
gfc_symtree* gfc_find_typebound_proc (gfc_symbol*, bool*,
const char*, bool, locus*);
gfc_symtree* gfc_find_typebound_user_op (gfc_symbol*, bool*,
const char*, bool, locus*);
gfc_typebound_proc* gfc_find_typebound_intrinsic_op (gfc_symbol*, bool*,
gfc_intrinsic_op, bool,
locus*);
gfc_symtree* gfc_get_tbp_symtree (gfc_symtree**, const char*);
bool gfc_is_finalizable (gfc_symbol *, gfc_expr **);
# 3646 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/gfortran.h"
void gfc_run_passes (gfc_namespace *);
typedef int (*walk_code_fn_t) (gfc_code **, int *, void *);
typedef int (*walk_expr_fn_t) (gfc_expr **, int *, void *);
int gfc_dummy_code_callback (gfc_code **, int *, void *);
int gfc_expr_walker (gfc_expr **, walk_expr_fn_t, void *);
int gfc_code_walker (gfc_code **, walk_code_fn_t, walk_expr_fn_t, void *);
bool gfc_has_dimen_vector_ref (gfc_expr *e);
void gfc_check_externals (gfc_namespace *);
bool gfc_fix_implicit_pure (gfc_namespace *);
void gfc_convert_mpz_to_signed (mpz_t, int);
gfc_expr *gfc_simplify_ieee_functions (gfc_expr *);
bool gfc_is_size_zero_array (gfc_expr *);
bool gfc_is_reallocatable_lhs (gfc_expr *);
void finish_oacc_declare (gfc_namespace *, gfc_symbol *, bool);
void gfc_adjust_builtins (void);
# 31 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 2
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.h" 1
# 27 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.h"
void gfc_mpfr_to_mpz (mpz_t, mpfr_t, locus *);
void gfc_set_model_kind (int);
void gfc_set_model (mpfr_t);
arith gfc_range_check (gfc_expr *);
int gfc_compare_expr (gfc_expr *, gfc_expr *, gfc_intrinsic_op);
int gfc_compare_string (gfc_expr *, gfc_expr *);
int gfc_compare_with_Cstring (gfc_expr *, const char *, bool);
gfc_expr *gfc_parentheses (gfc_expr * op);
gfc_expr *gfc_uplus (gfc_expr * op);
gfc_expr *gfc_uminus (gfc_expr * op);
gfc_expr *gfc_add (gfc_expr *, gfc_expr *);
gfc_expr *gfc_subtract (gfc_expr *, gfc_expr *);
gfc_expr *gfc_multiply (gfc_expr *, gfc_expr *);
gfc_expr *gfc_divide (gfc_expr *, gfc_expr *);
gfc_expr *gfc_power (gfc_expr *, gfc_expr *);
gfc_expr *gfc_concat (gfc_expr *, gfc_expr *);
gfc_expr *gfc_and (gfc_expr *, gfc_expr *);
gfc_expr *gfc_or (gfc_expr *, gfc_expr *);
gfc_expr *gfc_not (gfc_expr *);
gfc_expr *gfc_eqv (gfc_expr *, gfc_expr *);
gfc_expr *gfc_neqv (gfc_expr *, gfc_expr *);
gfc_expr *gfc_eq (gfc_expr *, gfc_expr *, gfc_intrinsic_op);
gfc_expr *gfc_ne (gfc_expr *, gfc_expr *, gfc_intrinsic_op);
gfc_expr *gfc_gt (gfc_expr *, gfc_expr *, gfc_intrinsic_op);
gfc_expr *gfc_ge (gfc_expr *, gfc_expr *, gfc_intrinsic_op);
gfc_expr *gfc_lt (gfc_expr *, gfc_expr *, gfc_intrinsic_op);
gfc_expr *gfc_le (gfc_expr *, gfc_expr *, gfc_intrinsic_op);
gfc_expr *gfc_int2int (gfc_expr *, int);
gfc_expr *gfc_int2real (gfc_expr *, int);
gfc_expr *gfc_int2complex (gfc_expr *, int);
gfc_expr *gfc_real2int (gfc_expr *, int);
gfc_expr *gfc_real2real (gfc_expr *, int);
gfc_expr *gfc_real2complex (gfc_expr *, int);
gfc_expr *gfc_complex2int (gfc_expr *, int);
gfc_expr *gfc_complex2real (gfc_expr *, int);
gfc_expr *gfc_complex2complex (gfc_expr *, int);
gfc_expr *gfc_log2log (gfc_expr *, int);
gfc_expr *gfc_log2int (gfc_expr *, int);
gfc_expr *gfc_int2log (gfc_expr *, int);
gfc_expr *gfc_hollerith2int (gfc_expr *, int);
gfc_expr *gfc_hollerith2real (gfc_expr *, int);
gfc_expr *gfc_hollerith2complex (gfc_expr *, int);
gfc_expr *gfc_hollerith2character (gfc_expr *, int);
gfc_expr *gfc_hollerith2logical (gfc_expr *, int);
gfc_expr *gfc_character2int (gfc_expr *, int);
gfc_expr *gfc_character2real (gfc_expr *, int);
gfc_expr *gfc_character2complex (gfc_expr *, int);
gfc_expr *gfc_character2character (gfc_expr *, int);
gfc_expr *gfc_character2logical (gfc_expr *, int);
# 32 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 2
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/target-memory.h" 1
# 25 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/target-memory.h"
bool gfc_convert_boz (gfc_expr *, gfc_typespec *);
bool gfc_element_size (gfc_expr *, size_t *);
bool gfc_target_expr_size (gfc_expr *, size_t *);
size_t gfc_encode_character (int, size_t, const gfc_char_t *, unsigned char *,
size_t);
unsigned long gfc_target_encode_expr (gfc_expr *, unsigned char *,
size_t);
int gfc_interpret_integer (int, unsigned char *, size_t, mpz_t);
int gfc_interpret_float (int, unsigned char *, size_t, mpfr_t);
int gfc_interpret_complex (int, unsigned char *, size_t, mpc_t);
int gfc_interpret_logical (int, unsigned char *, size_t, int *);
size_t gfc_interpret_character (unsigned char *, size_t, gfc_expr *);
int gfc_interpret_derived (unsigned char *, size_t, gfc_expr *);
size_t gfc_target_interpret_expr (unsigned char *, size_t, gfc_expr *, bool);
size_t gfc_merge_initializers (gfc_typespec, gfc_expr *, locus *,
unsigned char *, unsigned char *,
size_t);
# 33 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 2
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/constructor.h" 1
# 24 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/constructor.h"
gfc_constructor *gfc_constructor_get (void);
gfc_constructor_base gfc_constructor_get_base (void);
gfc_constructor_base gfc_constructor_copy (gfc_constructor_base base);
void gfc_constructor_free (gfc_constructor_base base);
gfc_constructor *gfc_constructor_append (gfc_constructor_base *base,
gfc_constructor *c);
gfc_constructor *gfc_constructor_append_expr (gfc_constructor_base *base,
gfc_expr *e, locus *where);
gfc_constructor *gfc_constructor_insert (gfc_constructor_base *base,
gfc_constructor *c, int n);
gfc_constructor *gfc_constructor_insert_expr (gfc_constructor_base *base,
gfc_expr *e, locus *where,
int n);
gfc_constructor *gfc_constructor_lookup (gfc_constructor_base base, int n);
gfc_expr *gfc_constructor_lookup_expr (gfc_constructor_base base, int n);
int gfc_constructor_expr_foreach (gfc_constructor *ctor, int(*)(gfc_expr *));
void gfc_constructor_swap (gfc_constructor *ctor, int n, int m);
gfc_constructor *gfc_constructor_first (gfc_constructor_base base);
gfc_constructor *gfc_constructor_next (gfc_constructor *ctor);
void gfc_constructor_remove (gfc_constructor *);
gfc_constructor *gfc_constructor_lookup_next (gfc_constructor_base, int);
# 34 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 2
bool gfc_seen_div0;
void
gfc_mpfr_to_mpz (mpz_t z, mpfr_t x, locus *where)
{
mpfr_exp_t e;
if (
# 45 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
((
# 45 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
x
# 45 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
)->_mpfr_exp == (2 - ((mpfr_exp_t) (((mpfr_uexp_t) -1) >> 1))))
# 45 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
||
# 45 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
((
# 45 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
x
# 45 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
)->_mpfr_exp == (1 - ((mpfr_exp_t) (((mpfr_uexp_t) -1) >> 1))))
# 45 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
)
{
gfc_error ("Conversion of an Infinity or Not-a-Number at %L "
"to INTEGER", where);
# 49 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
__gmpz_set_ui
# 49 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
(z, 0);
return;
}
e =
# 53 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
mpfr_get_z_2exp
# 53 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
(z, x);
if (e > 0)
# 56 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
__gmpz_mul_2exp
# 56 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
(z, z, e);
else
# 58 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
__gmpz_tdiv_q_2exp
# 58 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
(z, z, -e);
}
void
gfc_set_model_kind (int kind)
{
int index = gfc_validate_kind (BT_REAL, kind, false);
int base2prec;
base2prec = gfc_real_kinds[index].digits;
if (gfc_real_kinds[index].radix != 2)
base2prec *= gfc_real_kinds[index].radix / 2;
mpfr_set_default_prec (base2prec);
}
void
gfc_set_model (mpfr_t x)
{
mpfr_set_default_prec (
# 82 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
(0 ? ((
# 82 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
x
# 82 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
)->_mpfr_prec) : ((
# 82 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
x
# 82 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
)->_mpfr_prec))
# 82 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
);
}
static const char *
gfc_arith_error (arith code)
{
const char *p;
switch (code)
{
case ARITH_OK:
p = "Arithmetic OK at %L";
break;
case ARITH_OVERFLOW:
p = "Arithmetic overflow at %L";
break;
case ARITH_UNDERFLOW:
p = "Arithmetic underflow at %L";
break;
case ARITH_NAN:
p = "Arithmetic NaN at %L";
break;
case ARITH_DIV0:
p = "Division by zero at %L";
break;
case ARITH_INCOMMENSURATE:
p = "Array operands are incommensurate at %L";
break;
case ARITH_ASYMMETRIC:
p = "Integer outside symmetric range implied by Standard Fortran" " at %L"
;
break;
case ARITH_WRONGCONCAT:
p = "Illegal type in character concatenation at %L";
break;
default:
gfc_internal_error ("gfc_arith_error(): Bad error code");
}
return p;
}
void
gfc_arith_init_1 (void)
{
gfc_integer_info *int_info;
gfc_real_info *real_info;
mpfr_t a, b;
int i;
mpfr_set_default_prec (128);
mpfr_init (a);
for (int_info = gfc_integer_kinds; int_info->kind != 0; int_info++)
{
# 148 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
__gmpz_init
# 148 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
(int_info->huge);
# 149 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
__gmpz_set_ui
# 149 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
(int_info->huge, int_info->radix);
# 150 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
__gmpz_pow_ui
# 150 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
(int_info->huge, int_info->huge, int_info->digits);
# 151 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
__gmpz_sub_ui
# 151 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
(int_info->huge, int_info->huge, 1);
if (int_info->radix != 2)
gfc_internal_error ("Fix min_int calculation");
# 165 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
# 165 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
__gmpz_init
# 165 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
(int_info->pedantic_min_int);
# 166 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
__gmpz_neg
# 166 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
(int_info->pedantic_min_int, int_info->huge);
# 168 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
__gmpz_init
# 168 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
(int_info->min_int);
# 169 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
__gmpz_sub_ui
# 169 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
(int_info->min_int, int_info->pedantic_min_int, 1);
mpfr_set_z (a, int_info->huge, MPFR_RNDN);
mpfr_log10 (a, a, MPFR_RNDN);
# 174 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
mpfr_rint((
# 174 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
a
# 174 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
), (
# 174 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
a
# 174 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
), MPFR_RNDZ)
# 174 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
;
int_info->range = (int) mpfr_get_si (a, MPFR_RNDN);
}
mpfr_clear (a);
for (real_info = gfc_real_kinds; real_info->kind != 0; real_info++)
{
gfc_set_model_kind (real_info->kind);
mpfr_init (a);
mpfr_init (b);
mpfr_init (real_info->huge);
mpfr_set_ui (real_info->huge, 1, MPFR_RNDN);
mpfr_set_ui (a, real_info->radix, MPFR_RNDN);
mpfr_pow_si (a, a, -real_info->digits, MPFR_RNDN);
mpfr_sub (real_info->huge, real_info->huge, a, MPFR_RNDN);
mpfr_set_ui (a, real_info->radix, MPFR_RNDN);
mpfr_pow_ui (a, a, real_info->max_exponent - 1, MPFR_RNDN);
mpfr_mul (real_info->huge, real_info->huge, a, MPFR_RNDN);
mpfr_mul_ui (real_info->huge, real_info->huge, real_info->radix,
MPFR_RNDN);
mpfr_init (real_info->tiny);
mpfr_set_ui (real_info->tiny, real_info->radix, MPFR_RNDN);
mpfr_pow_si (real_info->tiny, real_info->tiny,
real_info->min_exponent - 1, MPFR_RNDN);
mpfr_init (real_info->subnormal);
mpfr_set_ui (real_info->subnormal, real_info->radix, MPFR_RNDN);
mpfr_pow_si (real_info->subnormal, real_info->subnormal,
real_info->min_exponent - real_info->digits, MPFR_RNDN);
mpfr_init (real_info->epsilon);
mpfr_set_ui (real_info->epsilon, real_info->radix, MPFR_RNDN);
mpfr_pow_si (real_info->epsilon, real_info->epsilon,
1 - real_info->digits, MPFR_RNDN);
mpfr_log10 (a, real_info->huge, MPFR_RNDN);
mpfr_log10 (b, real_info->tiny, MPFR_RNDN);
mpfr_neg (b, b, MPFR_RNDN);
mpfr_min (a, a, b, MPFR_RNDN);
# 231 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
mpfr_rint((
# 231 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
a
# 231 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
), (
# 231 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
a
# 231 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
), MPFR_RNDZ)
# 231 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
;
real_info->range = (int) mpfr_get_si (a, MPFR_RNDN);
mpfr_set_ui (a, real_info->radix, MPFR_RNDN);
mpfr_log10 (a, a, MPFR_RNDN);
mpfr_mul_ui (a, a, real_info->digits - 1, MPFR_RNDN);
# 238 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
mpfr_rint((
# 238 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
a
# 238 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
), (
# 238 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
a
# 238 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
), MPFR_RNDZ)
# 238 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
;
real_info->precision = (int) mpfr_get_si (a, MPFR_RNDN);
for (i = 10; i <= real_info->radix; i *= 10)
if (i == real_info->radix)
real_info->precision++;
mpfr_clears (a, b,
# 246 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
__null
# 246 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
);
}
}
void
gfc_arith_done_1 (void)
{
gfc_integer_info *ip;
gfc_real_info *rp;
for (ip = gfc_integer_kinds; ip->kind; ip++)
{
# 261 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
__gmpz_clear
# 261 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
(ip->min_int);
# 262 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
__gmpz_clear
# 262 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
(ip->pedantic_min_int);
# 263 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
__gmpz_clear
# 263 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
(ip->huge);
}
for (rp = gfc_real_kinds; rp->kind; rp++)
mpfr_clears (rp->epsilon, rp->huge, rp->tiny, rp->subnormal,
# 267 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
__null
# 267 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
);
mpfr_free_cache ();
}
bool
gfc_check_character_range (gfc_char_t c, int kind)
{
if (kind == 4)
return true;
if (kind == 1)
return c <= 255 ? true : false;
(fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c", 286, __FUNCTION__));
}
arith
gfc_check_integer_range (mpz_t p, int kind)
{
arith result;
int i;
i = gfc_validate_kind (BT_INTEGER, kind, false);
result = ARITH_OK;
if (global_options.x_pedantic)
{
if (
# 305 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
__gmpz_cmp
# 305 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
(p, gfc_integer_kinds[i].pedantic_min_int) < 0)
result = ARITH_ASYMMETRIC;
}
if (global_options.x_flag_range_check == 0)
return result;
if (
# 313 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
__gmpz_cmp
# 313 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
(p, gfc_integer_kinds[i].min_int) < 0
||
# 314 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
__gmpz_cmp
# 314 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
(p, gfc_integer_kinds[i].huge) > 0)
result = ARITH_OVERFLOW;
return result;
}
static arith
gfc_check_real_range (mpfr_t p, int kind)
{
arith retval;
mpfr_t q;
int i;
i = gfc_validate_kind (BT_REAL, kind, false);
gfc_set_model (p);
mpfr_init (q);
# 336 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
mpfr_set4(
# 336 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
q
# 336 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
,
# 336 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
p
# 336 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
,
# 336 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
MPFR_RNDN
# 336 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
,1)
# 336 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
;
retval = ARITH_OK;
if (
# 340 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
((
# 340 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
p
# 340 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
)->_mpfr_exp == (2 - ((mpfr_exp_t) (((mpfr_uexp_t) -1) >> 1))))
# 340 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
)
{
if (global_options.x_flag_range_check != 0)
retval = ARITH_OVERFLOW;
}
else if (
# 345 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
((
# 345 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
p
# 345 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
)->_mpfr_exp == (1 - ((mpfr_exp_t) (((mpfr_uexp_t) -1) >> 1))))
# 345 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
)
{
if (global_options.x_flag_range_check != 0)
retval = ARITH_NAN;
}
else if (
# 350 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
((
# 350 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
q
# 350 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
)->_mpfr_exp < (2 - ((mpfr_exp_t) (((mpfr_uexp_t) -1) >> 1))) ? (((
# 350 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
q
# 350 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
)->_mpfr_exp == (1 - ((mpfr_exp_t) (((mpfr_uexp_t) -1) >> 1)))) ? mpfr_set_erangeflag () : (mpfr_void) 0), 0 : ((
# 350 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
q
# 350 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
)->_mpfr_sign))
# 350 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
== 0)
{
mpfr_clear (q);
return retval;
}
else if (
# 355 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
mpfr_cmp3(
# 355 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
q
# 355 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
,
# 355 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
gfc_real_kinds[i].huge
# 355 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
, 1)
# 355 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
> 0)
{
if (global_options.x_flag_range_check == 0)
mpfr_set_inf (p,
# 358 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
((
# 358 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
p
# 358 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
)->_mpfr_exp < (2 - ((mpfr_exp_t) (((mpfr_uexp_t) -1) >> 1))) ? (((
# 358 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
p
# 358 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
)->_mpfr_exp == (1 - ((mpfr_exp_t) (((mpfr_uexp_t) -1) >> 1)))) ? mpfr_set_erangeflag () : (mpfr_void) 0), 0 : ((
# 358 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
p
# 358 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
)->_mpfr_sign))
# 358 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
);
else
retval = ARITH_OVERFLOW;
}
else if (
# 362 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
mpfr_cmp3(
# 362 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
q
# 362 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
,
# 362 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
gfc_real_kinds[i].subnormal
# 362 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
, 1)
# 362 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
< 0)
{
if (global_options.x_flag_range_check == 0)
{
if (
# 366 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
((
# 366 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
p
# 366 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
)->_mpfr_exp < (2 - ((mpfr_exp_t) (((mpfr_uexp_t) -1) >> 1))) ? (((
# 366 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
p
# 366 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
)->_mpfr_exp == (1 - ((mpfr_exp_t) (((mpfr_uexp_t) -1) >> 1)))) ? mpfr_set_erangeflag () : (mpfr_void) 0), 0 : ((
# 366 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
p
# 366 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
)->_mpfr_sign))
# 366 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
< 0)
{
mpfr_set_ui (p, 0, MPFR_RNDN);
mpfr_set_si (q, -1, MPFR_RNDN);
# 370 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
mpfr_set4(
# 370 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
p
# 370 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
,
# 370 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
p
# 370 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
,
# 370 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
MPFR_RNDN
# 370 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
,((
# 370 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
q
# 370 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
)->_mpfr_sign))
# 370 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
;
}
else
mpfr_set_ui (p, 0, MPFR_RNDN);
}
else
retval = ARITH_UNDERFLOW;
}
else if (
# 378 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
mpfr_cmp3(
# 378 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
q
# 378 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
,
# 378 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
gfc_real_kinds[i].tiny
# 378 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
, 1)
# 378 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
< 0)
{
mpfr_exp_t emin, emax;
int en;
emin = mpfr_get_emin ();
emax = mpfr_get_emax ();
en = gfc_real_kinds[i].min_exponent - gfc_real_kinds[i].digits + 1;
mpfr_set_emin ((mpfr_exp_t) en);
mpfr_set_emax ((mpfr_exp_t) gfc_real_kinds[i].max_exponent);
mpfr_check_range (q, 0, MPFR_RNDN);
mpfr_subnormalize (q, 0, MPFR_RNDN);
mpfr_set_emin (emin);
mpfr_set_emax (emax);
if (
# 399 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
((
# 399 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
p
# 399 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
)->_mpfr_exp < (2 - ((mpfr_exp_t) (((mpfr_uexp_t) -1) >> 1))) ? (((
# 399 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
p
# 399 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
)->_mpfr_exp == (1 - ((mpfr_exp_t) (((mpfr_uexp_t) -1) >> 1)))) ? mpfr_set_erangeflag () : (mpfr_void) 0), 0 : ((
# 399 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
p
# 399 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
)->_mpfr_sign))
# 399 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
< 0)
mpfr_neg (p, q, MPFR_RNDN);
else
# 402 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
mpfr_set4(
# 402 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
p
# 402 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
,
# 402 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
q
# 402 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
,
# 402 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
MPFR_RNDN
# 402 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
,((
# 402 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
q
# 402 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
)->_mpfr_sign))
# 402 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
;
}
mpfr_clear (q);
return retval;
}
# 417 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
static arith
gfc_arith_not (gfc_expr *op1, gfc_expr **resultp)
{
gfc_expr *result;
result = gfc_get_constant_expr (BT_LOGICAL, op1->ts.kind, &op1->where);
result->value.logical = !op1->value.logical;
*resultp = result;
return ARITH_OK;
}
static arith
gfc_arith_and (gfc_expr *op1, gfc_expr *op2, gfc_expr **resultp)
{
gfc_expr *result;
result = gfc_get_constant_expr (BT_LOGICAL, gfc_kind_max (op1, op2),
&op1->where);
result->value.logical = op1->value.logical && op2->value.logical;
*resultp = result;
return ARITH_OK;
}
static arith
gfc_arith_or (gfc_expr *op1, gfc_expr *op2, gfc_expr **resultp)
{
gfc_expr *result;
result = gfc_get_constant_expr (BT_LOGICAL, gfc_kind_max (op1, op2),
&op1->where);
result->value.logical = op1->value.logical || op2->value.logical;
*resultp = result;
return ARITH_OK;
}
static arith
gfc_arith_eqv (gfc_expr *op1, gfc_expr *op2, gfc_expr **resultp)
{
gfc_expr *result;
result = gfc_get_constant_expr (BT_LOGICAL, gfc_kind_max (op1, op2),
&op1->where);
result->value.logical = op1->value.logical == op2->value.logical;
*resultp = result;
return ARITH_OK;
}
static arith
gfc_arith_neqv (gfc_expr *op1, gfc_expr *op2, gfc_expr **resultp)
{
gfc_expr *result;
result = gfc_get_constant_expr (BT_LOGICAL, gfc_kind_max (op1, op2),
&op1->where);
result->value.logical = op1->value.logical != op2->value.logical;
*resultp = result;
return ARITH_OK;
}
arith
gfc_range_check (gfc_expr *e)
{
arith rc;
arith rc2;
switch (e->ts.type)
{
case BT_INTEGER:
rc = gfc_check_integer_range (e->value.integer, e->ts.kind);
break;
case BT_REAL:
rc = gfc_check_real_range (e->value.real, e->ts.kind);
if (rc == ARITH_UNDERFLOW)
mpfr_set_ui (e->value.real, 0, MPFR_RNDN);
if (rc == ARITH_OVERFLOW)
mpfr_set_inf (e->value.real,
# 507 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
((
# 507 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
e->value.real
# 507 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
)->_mpfr_exp < (2 - ((mpfr_exp_t) (((mpfr_uexp_t) -1) >> 1))) ? (((
# 507 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
e->value.real
# 507 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
)->_mpfr_exp == (1 - ((mpfr_exp_t) (((mpfr_uexp_t) -1) >> 1)))) ? mpfr_set_erangeflag () : (mpfr_void) 0), 0 : ((
# 507 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
e->value.real
# 507 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
)->_mpfr_sign))
# 507 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
);
if (rc == ARITH_NAN)
mpfr_set_nan (e->value.real);
break;
case BT_COMPLEX:
rc = gfc_check_real_range (
# 513 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
((
# 513 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
e->value.complex
# 513 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
)->re)
# 513 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
, e->ts.kind);
if (rc == ARITH_UNDERFLOW)
mpfr_set_ui (
# 515 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
((
# 515 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
e->value.complex
# 515 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
)->re)
# 515 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
, 0, MPFR_RNDN);
if (rc == ARITH_OVERFLOW)
mpfr_set_inf (
# 517 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
((
# 517 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
e->value.complex
# 517 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
)->re)
# 517 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
,
# 518 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
((((
# 518 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
e->value.complex
# 518 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
)->re))->_mpfr_exp < (2 - ((mpfr_exp_t) (((mpfr_uexp_t) -1) >> 1))) ? (((((
# 518 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
e->value.complex
# 518 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
)->re))->_mpfr_exp == (1 - ((mpfr_exp_t) (((mpfr_uexp_t) -1) >> 1)))) ? mpfr_set_erangeflag () : (mpfr_void) 0), 0 : ((((
# 518 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
e->value.complex
# 518 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
)->re))->_mpfr_sign))
# 518 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
);
if (rc == ARITH_NAN)
mpfr_set_nan (
# 520 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
((
# 520 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
e->value.complex
# 520 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
)->re)
# 520 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
);
rc2 = gfc_check_real_range (
# 522 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
((
# 522 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
e->value.complex
# 522 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
)->im)
# 522 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
, e->ts.kind);
if (rc == ARITH_UNDERFLOW)
mpfr_set_ui (
# 524 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
((
# 524 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
e->value.complex
# 524 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
)->im)
# 524 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
, 0, MPFR_RNDN);
if (rc == ARITH_OVERFLOW)
mpfr_set_inf (
# 526 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
((
# 526 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
e->value.complex
# 526 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
)->im)
# 526 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
,
# 527 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
((((
# 527 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
e->value.complex
# 527 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
)->im))->_mpfr_exp < (2 - ((mpfr_exp_t) (((mpfr_uexp_t) -1) >> 1))) ? (((((
# 527 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
e->value.complex
# 527 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
)->im))->_mpfr_exp == (1 - ((mpfr_exp_t) (((mpfr_uexp_t) -1) >> 1)))) ? mpfr_set_erangeflag () : (mpfr_void) 0), 0 : ((((
# 527 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
e->value.complex
# 527 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
)->im))->_mpfr_sign))
# 527 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
);
if (rc == ARITH_NAN)
mpfr_set_nan (
# 529 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
((
# 529 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
e->value.complex
# 529 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
)->im)
# 529 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
);
if (rc == ARITH_OK)
rc = rc2;
break;
default:
gfc_internal_error ("gfc_range_check(): Bad type");
}
return rc;
}
static arith
check_result (arith rc, gfc_expr *x, gfc_expr *r, gfc_expr **rp)
{
arith val = rc;
if (val == ARITH_UNDERFLOW)
{
if (global_options.x_warn_underflow)
gfc_warning (OPT_Wunderflow, gfc_arith_error (val), &x->where);
val = ARITH_OK;
}
if (val == ARITH_ASYMMETRIC)
{
gfc_warning (0, gfc_arith_error (val), &x->where);
val = ARITH_OK;
}
if (val == ARITH_OK || val == ARITH_OVERFLOW)
*rp = r;
else
gfc_free_expr (r);
return val;
}
static arith
gfc_arith_identity (gfc_expr *op1, gfc_expr **resultp)
{
*resultp = gfc_copy_expr (op1);
return ARITH_OK;
}
static arith
gfc_arith_uminus (gfc_expr *op1, gfc_expr **resultp)
{
gfc_expr *result;
arith rc;
result = gfc_get_constant_expr (op1->ts.type, op1->ts.kind, &op1->where);
switch (op1->ts.type)
{
case BT_INTEGER:
# 597 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
__gmpz_neg
# 597 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
(result->value.integer, op1->value.integer);
break;
case BT_REAL:
mpfr_neg (result->value.real, op1->value.real, MPFR_RNDN);
break;
case BT_COMPLEX:
mpc_neg (result->value.complex, op1->value.complex,
# 605 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
(((int)(MPFR_RNDN)) + ((int)(MPFR_RNDN) << 4))
# 605 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
);
break;
default:
gfc_internal_error ("gfc_arith_uminus(): Bad basic type");
}
rc = gfc_range_check (result);
return check_result (rc, op1, result, resultp);
}
static arith
gfc_arith_plus (gfc_expr *op1, gfc_expr *op2, gfc_expr **resultp)
{
gfc_expr *result;
arith rc;
result = gfc_get_constant_expr (op1->ts.type, op1->ts.kind, &op1->where);
switch (op1->ts.type)
{
case BT_INTEGER:
# 629 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
__gmpz_add
# 629 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
(result->value.integer, op1->value.integer, op2->value.integer);
break;
case BT_REAL:
mpfr_add (result->value.real, op1->value.real, op2->value.real,
MPFR_RNDN);
break;
case BT_COMPLEX:
mpc_add (result->value.complex, op1->value.complex, op2->value.complex,
# 639 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
(((int)(MPFR_RNDN)) + ((int)(MPFR_RNDN) << 4))
# 639 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
);
break;
default:
gfc_internal_error ("gfc_arith_plus(): Bad basic type");
}
rc = gfc_range_check (result);
return check_result (rc, op1, result, resultp);
}
static arith
gfc_arith_minus (gfc_expr *op1, gfc_expr *op2, gfc_expr **resultp)
{
gfc_expr *result;
arith rc;
result = gfc_get_constant_expr (op1->ts.type, op1->ts.kind, &op1->where);
switch (op1->ts.type)
{
case BT_INTEGER:
# 663 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
__gmpz_sub
# 663 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
(result->value.integer, op1->value.integer, op2->value.integer);
break;
case BT_REAL:
mpfr_sub (result->value.real, op1->value.real, op2->value.real,
MPFR_RNDN);
break;
case BT_COMPLEX:
mpc_sub (result->value.complex, op1->value.complex,
op2->value.complex,
# 673 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
(((int)(MPFR_RNDN)) + ((int)(MPFR_RNDN) << 4))
# 673 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
);
break;
default:
gfc_internal_error ("gfc_arith_minus(): Bad basic type");
}
rc = gfc_range_check (result);
return check_result (rc, op1, result, resultp);
}
static arith
gfc_arith_times (gfc_expr *op1, gfc_expr *op2, gfc_expr **resultp)
{
gfc_expr *result;
arith rc;
result = gfc_get_constant_expr (op1->ts.type, op1->ts.kind, &op1->where);
switch (op1->ts.type)
{
case BT_INTEGER:
# 697 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
__gmpz_mul
# 697 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
(result->value.integer, op1->value.integer, op2->value.integer);
break;
case BT_REAL:
mpfr_mul (result->value.real, op1->value.real, op2->value.real,
MPFR_RNDN);
break;
case BT_COMPLEX:
gfc_set_model (
# 706 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
((
# 706 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
op1->value.complex
# 706 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
)->re)
# 706 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
);
mpc_mul (result->value.complex, op1->value.complex, op2->value.complex,
# 708 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
(((int)(MPFR_RNDN)) + ((int)(MPFR_RNDN) << 4))
# 708 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
);
break;
default:
gfc_internal_error ("gfc_arith_times(): Bad basic type");
}
rc = gfc_range_check (result);
return check_result (rc, op1, result, resultp);
}
static arith
gfc_arith_divide (gfc_expr *op1, gfc_expr *op2, gfc_expr **resultp)
{
gfc_expr *result;
arith rc;
rc = ARITH_OK;
result = gfc_get_constant_expr (op1->ts.type, op1->ts.kind, &op1->where);
switch (op1->ts.type)
{
case BT_INTEGER:
if (
# 734 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
((
# 734 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
op2->value.integer
# 734 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
)->_mp_size < 0 ? -1 : (
# 734 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
op2->value.integer
# 734 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
)->_mp_size > 0)
# 734 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
== 0)
{
rc = ARITH_DIV0;
break;
}
if (global_options.x_warn_integer_division)
{
mpz_t r;
# 743 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
__gmpz_init
# 743 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
(r);
# 744 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
__gmpz_tdiv_qr
# 744 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
(result->value.integer, r, op1->value.integer,
op2->value.integer);
if (
# 747 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
(__builtin_constant_p ((
# 747 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
0
# 747 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
) >= 0) && (
# 747 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
0
# 747 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
) >= 0 ? (__builtin_constant_p ((static_cast<unsigned long> (
# 747 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
0
# 747 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
))) && ((static_cast<unsigned long> (
# 747 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
0
# 747 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
))) == 0 ? ((
# 747 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
r
# 747 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
)->_mp_size < 0 ? -1 : (
# 747 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
r
# 747 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
)->_mp_size > 0) : __gmpz_cmp_ui (
# 747 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
r
# 747 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
,(static_cast<unsigned long> (
# 747 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
0
# 747 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
)))) : __gmpz_cmp_si (
# 747 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
r
# 747 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
,
# 747 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
0
# 747 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
))
# 747 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
!= 0)
{
char *p;
p =
# 750 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
__gmpz_get_str
# 750 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
(
# 750 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
__null
# 750 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
, 10, result->value.integer);
gfc_warning_now (OPT_Winteger_division, "Integer division "
"truncated to constant %qs at %L", p,
&op1->where);
free (p);
}
# 756 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
__gmpz_clear
# 756 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
(r);
}
else
# 759 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
__gmpz_tdiv_q
# 759 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
(result->value.integer, op1->value.integer,
op2->value.integer);
break;
case BT_REAL:
if (
# 765 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
((
# 765 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
op2->value.real
# 765 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
)->_mpfr_exp < (2 - ((mpfr_exp_t) (((mpfr_uexp_t) -1) >> 1))) ? (((
# 765 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
op2->value.real
# 765 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
)->_mpfr_exp == (1 - ((mpfr_exp_t) (((mpfr_uexp_t) -1) >> 1)))) ? mpfr_set_erangeflag () : (mpfr_void) 0), 0 : ((
# 765 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
op2->value.real
# 765 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
)->_mpfr_sign))
# 765 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
== 0 && global_options.x_flag_range_check == 1)
{
rc = ARITH_DIV0;
break;
}
mpfr_div (result->value.real, op1->value.real, op2->value.real,
MPFR_RNDN);
break;
case BT_COMPLEX:
if (mpc_cmp_si_si (op2->value.complex, 0, 0) == 0
&& global_options.x_flag_range_check == 1)
{
rc = ARITH_DIV0;
break;
}
gfc_set_model (
# 783 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
((
# 783 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
op1->value.complex
# 783 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
)->re)
# 783 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
);
if (mpc_cmp_si_si (op2->value.complex, 0, 0) == 0)
{
mpfr_set_nan (
# 788 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
((
# 788 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
result->value.complex
# 788 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
)->re)
# 788 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
);
mpfr_set_nan (
# 789 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
((
# 789 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
result->value.complex
# 789 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
)->im)
# 789 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
);
}
else
mpc_div (result->value.complex, op1->value.complex, op2->value.complex,
# 793 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
(((int)(MPFR_RNDN)) + ((int)(MPFR_RNDN) << 4))
# 793 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
);
break;
default:
gfc_internal_error ("gfc_arith_divide(): Bad basic type");
}
if (rc == ARITH_OK)
rc = gfc_range_check (result);
return check_result (rc, op1, result, resultp);
}
static arith
arith_power (gfc_expr *op1, gfc_expr *op2, gfc_expr **resultp)
{
int power_sign;
gfc_expr *result;
arith rc;
rc = ARITH_OK;
result = gfc_get_constant_expr (op1->ts.type, op1->ts.kind, &op1->where);
switch (op2->ts.type)
{
case BT_INTEGER:
power_sign =
# 821 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
((
# 821 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
op2->value.integer
# 821 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
)->_mp_size < 0 ? -1 : (
# 821 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
op2->value.integer
# 821 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
)->_mp_size > 0)
# 821 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
;
if (power_sign == 0)
{
switch (op1->ts.type)
{
case BT_INTEGER:
# 831 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
__gmpz_set_ui
# 831 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
(result->value.integer, 1);
break;
case BT_REAL:
mpfr_set_ui (result->value.real, 1, MPFR_RNDN);
break;
case BT_COMPLEX:
mpc_set_ui (result->value.complex, 1,
# 839 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
(((int)(MPFR_RNDN)) + ((int)(MPFR_RNDN) << 4))
# 839 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
);
break;
default:
gfc_internal_error ("arith_power(): Bad base");
}
}
else
{
switch (op1->ts.type)
{
case BT_INTEGER:
{
if (
# 853 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
(__builtin_constant_p ((
# 853 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
1
# 853 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
) >= 0) && (
# 853 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
1
# 853 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
) >= 0 ? (__builtin_constant_p ((static_cast<unsigned long> (
# 853 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
1
# 853 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
))) && ((static_cast<unsigned long> (
# 853 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
1
# 853 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
))) == 0 ? ((
# 853 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
op1->value.integer
# 853 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
)->_mp_size < 0 ? -1 : (
# 853 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
op1->value.integer
# 853 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
)->_mp_size > 0) : __gmpz_cmp_ui (
# 853 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
op1->value.integer
# 853 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
,(static_cast<unsigned long> (
# 853 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
1
# 853 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
)))) : __gmpz_cmp_si (
# 853 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
op1->value.integer
# 853 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
,
# 853 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
1
# 853 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
))
# 853 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
== 0)
{
# 856 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
__gmpz_set_si
# 856 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
(result->value.integer, 1);
}
else if (
# 858 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
(__builtin_constant_p ((
# 858 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
0
# 858 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
) >= 0) && (
# 858 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
0
# 858 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
) >= 0 ? (__builtin_constant_p ((static_cast<unsigned long> (
# 858 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
0
# 858 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
))) && ((static_cast<unsigned long> (
# 858 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
0
# 858 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
))) == 0 ? ((
# 858 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
op1->value.integer
# 858 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
)->_mp_size < 0 ? -1 : (
# 858 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
op1->value.integer
# 858 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
)->_mp_size > 0) : __gmpz_cmp_ui (
# 858 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
op1->value.integer
# 858 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
,(static_cast<unsigned long> (
# 858 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
0
# 858 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
)))) : __gmpz_cmp_si (
# 858 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
op1->value.integer
# 858 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
,
# 858 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
0
# 858 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
))
# 858 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
== 0)
{
# 863 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
__gmpz_set_si
# 863 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
(result->value.integer, 0);
if (
# 864 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
(__builtin_constant_p ((
# 864 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
0
# 864 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
) >= 0) && (
# 864 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
0
# 864 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
) >= 0 ? (__builtin_constant_p ((static_cast<unsigned long> (
# 864 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
0
# 864 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
))) && ((static_cast<unsigned long> (
# 864 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
0
# 864 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
))) == 0 ? ((
# 864 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
op2->value.integer
# 864 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
)->_mp_size < 0 ? -1 : (
# 864 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
op2->value.integer
# 864 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
)->_mp_size > 0) : __gmpz_cmp_ui (
# 864 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
op2->value.integer
# 864 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
,(static_cast<unsigned long> (
# 864 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
0
# 864 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
)))) : __gmpz_cmp_si (
# 864 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
op2->value.integer
# 864 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
,
# 864 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
0
# 864 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
))
# 864 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
< 0)
rc = ARITH_DIV0;
}
else if (
# 867 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
(__builtin_constant_p ((
# 867 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
-1
# 867 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
) >= 0) && (
# 867 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
-1
# 867 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
) >= 0 ? (__builtin_constant_p ((static_cast<unsigned long> (
# 867 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
-1
# 867 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
))) && ((static_cast<unsigned long> (
# 867 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
-1
# 867 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
))) == 0 ? ((
# 867 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
op1->value.integer
# 867 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
)->_mp_size < 0 ? -1 : (
# 867 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
op1->value.integer
# 867 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
)->_mp_size > 0) : __gmpz_cmp_ui (
# 867 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
op1->value.integer
# 867 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
,(static_cast<unsigned long> (
# 867 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
-1
# 867 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
)))) : __gmpz_cmp_si (
# 867 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
op1->value.integer
# 867 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
,
# 867 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
-1
# 867 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
))
# 867 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
== 0)
{
unsigned int odd =
# 870 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
__gmpz_fdiv_ui
# 870 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
(op2->value.integer, 2);
if (odd)
# 872 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
__gmpz_set_si
# 872 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
(result->value.integer, -1);
else
# 874 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
__gmpz_set_si
# 874 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
(result->value.integer, 1);
}
else if (
# 877 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
(__builtin_constant_p ((
# 877 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
0
# 877 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
) >= 0) && (
# 877 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
0
# 877 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
) >= 0 ? (__builtin_constant_p ((static_cast<unsigned long> (
# 877 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
0
# 877 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
))) && ((static_cast<unsigned long> (
# 877 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
0
# 877 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
))) == 0 ? ((
# 877 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
op2->value.integer
# 877 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
)->_mp_size < 0 ? -1 : (
# 877 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
op2->value.integer
# 877 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
)->_mp_size > 0) : __gmpz_cmp_ui (
# 877 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
op2->value.integer
# 877 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
,(static_cast<unsigned long> (
# 877 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
0
# 877 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
)))) : __gmpz_cmp_si (
# 877 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
op2->value.integer
# 877 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
,
# 877 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
0
# 877 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
))
# 877 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
< 0)
{
# 880 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
__gmpz_set_si
# 880 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
(result->value.integer, 0);
if (global_options.x_warn_integer_division)
gfc_warning_now (OPT_Winteger_division, "Negative "
"exponent of integer has zero "
"result at %L", &result->where);
}
else
{
int k, power;
k = gfc_validate_kind (BT_INTEGER, op1->ts.kind, false);
power = gfc_integer_kinds[k].bit_size;
if (
# 895 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
(__builtin_constant_p ((
# 895 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
power
# 895 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
) >= 0) && (
# 895 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
power
# 895 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
) >= 0 ? (__builtin_constant_p ((static_cast<unsigned long> (
# 895 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
power
# 895 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
))) && ((static_cast<unsigned long> (
# 895 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
power
# 895 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
))) == 0 ? ((
# 895 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
op2->value.integer
# 895 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
)->_mp_size < 0 ? -1 : (
# 895 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
op2->value.integer
# 895 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
)->_mp_size > 0) : __gmpz_cmp_ui (
# 895 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
op2->value.integer
# 895 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
,(static_cast<unsigned long> (
# 895 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
power
# 895 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
)))) : __gmpz_cmp_si (
# 895 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
op2->value.integer
# 895 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
,
# 895 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
power
# 895 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
))
# 895 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
< 0)
{
gfc_extract_int (op2, &power);
# 898 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
__gmpz_pow_ui
# 898 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
(result->value.integer, op1->value.integer,
power);
rc = gfc_range_check (result);
if (rc == ARITH_OVERFLOW)
gfc_error_now ("Result of exponentiation at %L "
"exceeds the range of %s", &op1->where,
gfc_typename (&(op1->ts)));
}
else
{
# 909 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
__gmpz_set
# 909 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
(result->value.integer,
gfc_integer_kinds[k].huge);
# 911 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
__gmpz_add_ui
# 911 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
(result->value.integer,
result->value.integer, 1);
rc = ARITH_OVERFLOW;
}
}
}
break;
case BT_REAL:
mpfr_pow_z (result->value.real, op1->value.real,
op2->value.integer, MPFR_RNDN);
break;
case BT_COMPLEX:
mpc_pow_z (result->value.complex, op1->value.complex,
op2->value.integer,
# 926 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
(((int)(MPFR_RNDN)) + ((int)(MPFR_RNDN) << 4))
# 926 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
);
break;
default:
break;
}
}
break;
case BT_REAL:
if (gfc_init_expr_flag)
{
if (!gfc_notify_std ((1<<4), "Noninteger "
"exponent in an initialization "
"expression at %L", &op2->where))
{
gfc_free_expr (result);
return ARITH_PROHIBIT;
}
}
if (
# 948 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
mpfr_cmp_si_2exp((
# 948 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
op1->value.real
# 948 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
),(
# 948 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
0
# 948 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
),0)
# 948 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
< 0)
{
gfc_error ("Raising a negative REAL at %L to "
"a REAL power is prohibited", &op1->where);
gfc_free_expr (result);
return ARITH_PROHIBIT;
}
mpfr_pow (result->value.real, op1->value.real, op2->value.real,
MPFR_RNDN);
break;
case BT_COMPLEX:
{
if (gfc_init_expr_flag)
{
if (!gfc_notify_std ((1<<4), "Noninteger "
"exponent in an initialization "
"expression at %L", &op2->where))
{
gfc_free_expr (result);
return ARITH_PROHIBIT;
}
}
mpc_pow (result->value.complex, op1->value.complex,
op2->value.complex,
# 974 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
(((int)(MPFR_RNDN)) + ((int)(MPFR_RNDN) << 4))
# 974 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
);
}
break;
default:
gfc_internal_error ("arith_power(): unknown type");
}
if (rc == ARITH_OK)
rc = gfc_range_check (result);
return check_result (rc, op1, result, resultp);
}
static arith
gfc_arith_concat (gfc_expr *op1, gfc_expr *op2, gfc_expr **resultp)
{
gfc_expr *result;
size_t len;
if (op1->ts.type != BT_CHARACTER || op2->ts.type != BT_CHARACTER
|| op1->ts.kind != op2->ts.kind)
return ARITH_WRONGCONCAT;
result = gfc_get_constant_expr (BT_CHARACTER, op1->ts.kind,
&op1->where);
len = op1->value.character.length + op2->value.character.length;
result->value.character.string = ((gfc_char_t *) xcalloc ((len + 1), sizeof (gfc_char_t)));
result->value.character.length = len;
memcpy (result->value.character.string, op1->value.character.string,
op1->value.character.length * sizeof (gfc_char_t));
memcpy (&result->value.character.string[op1->value.character.length],
op2->value.character.string,
op2->value.character.length * sizeof (gfc_char_t));
result->value.character.string[len] = '\0';
*resultp = result;
return ARITH_OK;
}
static int
compare_real (gfc_expr *op1, gfc_expr *op2, gfc_intrinsic_op op)
{
int rc;
switch (op)
{
case INTRINSIC_EQ:
rc = mpfr_equal_p (op1->value.real, op2->value.real) ? 0 : 1;
break;
case INTRINSIC_GT:
rc = mpfr_greater_p (op1->value.real, op2->value.real) ? 1 : -1;
break;
case INTRINSIC_GE:
rc = mpfr_greaterequal_p (op1->value.real, op2->value.real) ? 1 : -1;
break;
case INTRINSIC_LT:
rc = mpfr_less_p (op1->value.real, op2->value.real) ? -1 : 1;
break;
case INTRINSIC_LE:
rc = mpfr_lessequal_p (op1->value.real, op2->value.real) ? -1 : 1;
break;
default:
gfc_internal_error ("compare_real(): Bad operator");
}
return rc;
}
int
gfc_compare_expr (gfc_expr *op1, gfc_expr *op2, gfc_intrinsic_op op)
{
int rc;
switch (op1->ts.type)
{
case BT_INTEGER:
rc =
# 1067 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
__gmpz_cmp
# 1067 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
(op1->value.integer, op2->value.integer);
break;
case BT_REAL:
rc = compare_real (op1, op2, op);
break;
case BT_CHARACTER:
rc = gfc_compare_string (op1, op2);
break;
case BT_LOGICAL:
rc = ((!op1->value.logical && op2->value.logical)
|| (op1->value.logical && !op2->value.logical));
break;
default:
gfc_internal_error ("gfc_compare_expr(): Bad basic type");
}
return rc;
}
static int
compare_complex (gfc_expr *op1, gfc_expr *op2)
{
return mpc_cmp (op1->value.complex, op2->value.complex) == 0;
}
int
gfc_compare_string (gfc_expr *a, gfc_expr *b)
{
size_t len, alen, blen, i;
gfc_char_t ac, bc;
alen = a->value.character.length;
blen = b->value.character.length;
len = ((alen) > (blen) ? (alen) : (blen));
for (i = 0; i < len; i++)
{
ac = ((i < alen) ? a->value.character.string[i] : ' ');
bc = ((i < blen) ? b->value.character.string[i] : ' ');
if (ac < bc)
return -1;
if (ac > bc)
return 1;
}
return 0;
}
int
gfc_compare_with_Cstring (gfc_expr *a, const char *b, bool case_sensitive)
{
size_t len, alen, blen, i;
gfc_char_t ac, bc;
alen = a->value.character.length;
blen = strlen (b);
len = ((alen) > (blen) ? (alen) : (blen));
for (i = 0; i < len; i++)
{
ac = ((i < alen) ? a->value.character.string[i] : ' ');
bc = ((i < blen) ? b[i] : ' ');
if (!case_sensitive)
{
ac = _sch_tolower[(ac) & 0xff];
bc = _sch_tolower[(bc) & 0xff];
}
if (ac < bc)
return -1;
if (ac > bc)
return 1;
}
return 0;
}
static arith
gfc_arith_eq (gfc_expr *op1, gfc_expr *op2, gfc_expr **resultp)
{
gfc_expr *result;
result = gfc_get_constant_expr (BT_LOGICAL, gfc_default_logical_kind,
&op1->where);
result->value.logical = (op1->ts.type == BT_COMPLEX)
? compare_complex (op1, op2)
: (gfc_compare_expr (op1, op2, INTRINSIC_EQ) == 0);
*resultp = result;
return ARITH_OK;
}
static arith
gfc_arith_ne (gfc_expr *op1, gfc_expr *op2, gfc_expr **resultp)
{
gfc_expr *result;
result = gfc_get_constant_expr (BT_LOGICAL, gfc_default_logical_kind,
&op1->where);
result->value.logical = (op1->ts.type == BT_COMPLEX)
? !compare_complex (op1, op2)
: (gfc_compare_expr (op1, op2, INTRINSIC_EQ) != 0);
*resultp = result;
return ARITH_OK;
}
static arith
gfc_arith_gt (gfc_expr *op1, gfc_expr *op2, gfc_expr **resultp)
{
gfc_expr *result;
result = gfc_get_constant_expr (BT_LOGICAL, gfc_default_logical_kind,
&op1->where);
result->value.logical = (gfc_compare_expr (op1, op2, INTRINSIC_GT) > 0);
*resultp = result;
return ARITH_OK;
}
static arith
gfc_arith_ge (gfc_expr *op1, gfc_expr *op2, gfc_expr **resultp)
{
gfc_expr *result;
result = gfc_get_constant_expr (BT_LOGICAL, gfc_default_logical_kind,
&op1->where);
result->value.logical = (gfc_compare_expr (op1, op2, INTRINSIC_GE) >= 0);
*resultp = result;
return ARITH_OK;
}
static arith
gfc_arith_lt (gfc_expr *op1, gfc_expr *op2, gfc_expr **resultp)
{
gfc_expr *result;
result = gfc_get_constant_expr (BT_LOGICAL, gfc_default_logical_kind,
&op1->where);
result->value.logical = (gfc_compare_expr (op1, op2, INTRINSIC_LT) < 0);
*resultp = result;
return ARITH_OK;
}
static arith
gfc_arith_le (gfc_expr *op1, gfc_expr *op2, gfc_expr **resultp)
{
gfc_expr *result;
result = gfc_get_constant_expr (BT_LOGICAL, gfc_default_logical_kind,
&op1->where);
result->value.logical = (gfc_compare_expr (op1, op2, INTRINSIC_LE) <= 0);
*resultp = result;
return ARITH_OK;
}
static arith
reduce_unary (arith (*eval) (gfc_expr *, gfc_expr **), gfc_expr *op,
gfc_expr **result)
{
gfc_constructor_base head;
gfc_constructor *c;
gfc_expr *r;
arith rc;
if (op->expr_type == EXPR_CONSTANT)
return eval (op, result);
rc = ARITH_OK;
head = gfc_constructor_copy (op->value.constructor);
for (c = gfc_constructor_first (head); c; c = gfc_constructor_next (c))
{
rc = reduce_unary (eval, c->expr, &r);
if (rc != ARITH_OK)
break;
gfc_replace_expr (c->expr, r);
}
if (rc != ARITH_OK)
gfc_constructor_free (head);
else
{
gfc_constructor *c = gfc_constructor_first (head);
r = gfc_get_array_expr (c->expr->ts.type, c->expr->ts.kind,
&op->where);
r->shape = gfc_copy_shape (op->shape, op->rank);
r->rank = op->rank;
r->value.constructor = head;
*result = r;
}
return rc;
}
static arith
reduce_binary_ac (arith (*eval) (gfc_expr *, gfc_expr *, gfc_expr **),
gfc_expr *op1, gfc_expr *op2, gfc_expr **result)
{
gfc_constructor_base head;
gfc_constructor *c;
gfc_expr *r;
arith rc = ARITH_OK;
head = gfc_constructor_copy (op1->value.constructor);
for (c = gfc_constructor_first (head); c; c = gfc_constructor_next (c))
{
if (c->expr->expr_type == EXPR_CONSTANT)
rc = eval (c->expr, op2, &r);
else
rc = reduce_binary_ac (eval, c->expr, op2, &r);
if (rc != ARITH_OK)
break;
gfc_replace_expr (c->expr, r);
}
if (rc != ARITH_OK)
gfc_constructor_free (head);
else
{
gfc_constructor *c = gfc_constructor_first (head);
r = gfc_get_array_expr (c->expr->ts.type, c->expr->ts.kind,
&op1->where);
r->shape = gfc_copy_shape (op1->shape, op1->rank);
r->rank = op1->rank;
r->value.constructor = head;
*result = r;
}
return rc;
}
static arith
reduce_binary_ca (arith (*eval) (gfc_expr *, gfc_expr *, gfc_expr **),
gfc_expr *op1, gfc_expr *op2, gfc_expr **result)
{
gfc_constructor_base head;
gfc_constructor *c;
gfc_expr *r;
arith rc = ARITH_OK;
head = gfc_constructor_copy (op2->value.constructor);
for (c = gfc_constructor_first (head); c; c = gfc_constructor_next (c))
{
if (c->expr->expr_type == EXPR_CONSTANT)
rc = eval (op1, c->expr, &r);
else
rc = reduce_binary_ca (eval, op1, c->expr, &r);
if (rc != ARITH_OK)
break;
gfc_replace_expr (c->expr, r);
}
if (rc != ARITH_OK)
gfc_constructor_free (head);
else
{
gfc_constructor *c = gfc_constructor_first (head);
r = gfc_get_array_expr (c->expr->ts.type, c->expr->ts.kind,
&op2->where);
r->shape = gfc_copy_shape (op2->shape, op2->rank);
r->rank = op2->rank;
r->value.constructor = head;
*result = r;
}
return rc;
}
static arith reduce_binary (arith (*eval) (gfc_expr *, gfc_expr *, gfc_expr **),
gfc_expr *op1, gfc_expr *op2, gfc_expr **result);
static arith
reduce_binary_aa (arith (*eval) (gfc_expr *, gfc_expr *, gfc_expr **),
gfc_expr *op1, gfc_expr *op2, gfc_expr **result)
{
gfc_constructor_base head;
gfc_constructor *c, *d;
gfc_expr *r;
arith rc = ARITH_OK;
if (!gfc_check_conformance (op1, op2, gettext ("elemental binary operation")))
return ARITH_INCOMMENSURATE;
head = gfc_constructor_copy (op1->value.constructor);
for (c = gfc_constructor_first (head),
d = gfc_constructor_first (op2->value.constructor);
c && d;
c = gfc_constructor_next (c), d = gfc_constructor_next (d))
{
rc = reduce_binary (eval, c->expr, d->expr, &r);
if (rc != ARITH_OK)
break;
gfc_replace_expr (c->expr, r);
}
if (c || d)
rc = ARITH_INCOMMENSURATE;
if (rc != ARITH_OK)
gfc_constructor_free (head);
else
{
gfc_constructor *c = gfc_constructor_first (head);
r = gfc_get_array_expr (c->expr->ts.type, c->expr->ts.kind,
&op1->where);
r->shape = gfc_copy_shape (op1->shape, op1->rank);
r->rank = op1->rank;
r->value.constructor = head;
*result = r;
}
return rc;
}
static arith
reduce_binary (arith (*eval) (gfc_expr *, gfc_expr *, gfc_expr **),
gfc_expr *op1, gfc_expr *op2, gfc_expr **result)
{
if (op1->expr_type == EXPR_CONSTANT && op2->expr_type == EXPR_CONSTANT)
return eval (op1, op2, result);
if (op1->expr_type == EXPR_CONSTANT && op2->expr_type == EXPR_ARRAY)
return reduce_binary_ca (eval, op1, op2, result);
if (op1->expr_type == EXPR_ARRAY && op2->expr_type == EXPR_CONSTANT)
return reduce_binary_ac (eval, op1, op2, result);
return reduce_binary_aa (eval, op1, op2, result);
}
typedef union
{
arith (*f2)(gfc_expr *, gfc_expr **);
arith (*f3)(gfc_expr *, gfc_expr *, gfc_expr **);
}
eval_f;
# 1460 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
static gfc_expr *
eval_intrinsic (gfc_intrinsic_op op,
eval_f eval, gfc_expr *op1, gfc_expr *op2)
{
gfc_expr temp, *result;
int unary;
arith rc;
gfc_clear_ts (&temp.ts);
switch (op)
{
case INTRINSIC_NOT:
if (op1->ts.type != BT_LOGICAL)
goto runtime;
temp.ts.type = BT_LOGICAL;
temp.ts.kind = gfc_default_logical_kind;
unary = 1;
break;
case INTRINSIC_OR:
case INTRINSIC_AND:
case INTRINSIC_NEQV:
case INTRINSIC_EQV:
if (op1->ts.type != BT_LOGICAL || op2->ts.type != BT_LOGICAL)
goto runtime;
temp.ts.type = BT_LOGICAL;
temp.ts.kind = gfc_default_logical_kind;
unary = 0;
break;
case INTRINSIC_UPLUS:
case INTRINSIC_UMINUS:
if (!gfc_numeric_ts (&op1->ts))
goto runtime;
temp.ts = op1->ts;
unary = 1;
break;
case INTRINSIC_PARENTHESES:
temp.ts = op1->ts;
unary = 1;
break;
case INTRINSIC_GE:
case INTRINSIC_GE_OS:
case INTRINSIC_LT:
case INTRINSIC_LT_OS:
case INTRINSIC_LE:
case INTRINSIC_LE_OS:
case INTRINSIC_GT:
case INTRINSIC_GT_OS:
if (op1->ts.type == BT_COMPLEX || op2->ts.type == BT_COMPLEX)
{
temp.ts.type = BT_LOGICAL;
temp.ts.kind = gfc_default_logical_kind;
goto runtime;
}
case INTRINSIC_EQ:
case INTRINSIC_EQ_OS:
case INTRINSIC_NE:
case INTRINSIC_NE_OS:
if (op1->ts.type == BT_CHARACTER && op2->ts.type == BT_CHARACTER)
{
unary = 0;
temp.ts.type = BT_LOGICAL;
temp.ts.kind = gfc_default_logical_kind;
if (op1->ts.kind != op2->ts.kind)
goto runtime;
break;
}
__attribute__((fallthrough));
case INTRINSIC_PLUS:
case INTRINSIC_MINUS:
case INTRINSIC_TIMES:
case INTRINSIC_DIVIDE:
case INTRINSIC_POWER:
if (!gfc_numeric_ts (&op1->ts) || !gfc_numeric_ts (&op2->ts))
goto runtime;
temp.expr_type = EXPR_OP;
gfc_clear_ts (&temp.ts);
temp.value.op.op = op;
temp.value.op.op1 = op1;
temp.value.op.op2 = op2;
gfc_type_convert_binary (&temp, global_options.x_warn_conversion || global_options.x_warn_conversion_extra);
if (op == INTRINSIC_EQ || op == INTRINSIC_NE
|| op == INTRINSIC_GE || op == INTRINSIC_GT
|| op == INTRINSIC_LE || op == INTRINSIC_LT
|| op == INTRINSIC_EQ_OS || op == INTRINSIC_NE_OS
|| op == INTRINSIC_GE_OS || op == INTRINSIC_GT_OS
|| op == INTRINSIC_LE_OS || op == INTRINSIC_LT_OS)
{
temp.ts.type = BT_LOGICAL;
temp.ts.kind = gfc_default_logical_kind;
}
unary = 0;
break;
case INTRINSIC_CONCAT:
if (op1->ts.type != BT_CHARACTER || op2->ts.type != BT_CHARACTER
|| op1->ts.kind != op2->ts.kind)
goto runtime;
temp.ts.type = BT_CHARACTER;
temp.ts.kind = op1->ts.kind;
unary = 0;
break;
case INTRINSIC_USER:
goto runtime;
default:
gfc_internal_error ("eval_intrinsic(): Bad operator");
}
if (op1->expr_type != EXPR_CONSTANT
&& (op1->expr_type != EXPR_ARRAY
|| !gfc_is_constant_expr (op1) || !gfc_expanded_ac (op1)))
goto runtime;
if (op2 !=
# 1603 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
__null
# 1604 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
&& op2->expr_type != EXPR_CONSTANT
&& (op2->expr_type != EXPR_ARRAY
|| !gfc_is_constant_expr (op2) || !gfc_expanded_ac (op2)))
goto runtime;
if (unary)
rc = reduce_unary (eval.f2, op1, &result);
else
rc = reduce_binary (eval.f3, op1, op2, &result);
if (op == INTRINSIC_POWER && rc == ARITH_PROHIBIT)
return
# 1617 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
__null
# 1617 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
;
if (rc != ARITH_OK)
{
gfc_error (gfc_arith_error (rc), &op1->where);
if (rc == ARITH_OVERFLOW)
goto done;
if (rc == ARITH_DIV0 && op2->ts.type == BT_INTEGER)
gfc_seen_div0 = true;
return
# 1628 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
__null
# 1628 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
;
}
done:
gfc_free_expr (op1);
gfc_free_expr (op2);
return result;
runtime:
result = gfc_get_operator_expr (&op1->where, op, op1, op2);
result->ts = temp.ts;
return result;
}
static gfc_expr *
eval_type_intrinsic0 (gfc_intrinsic_op iop, gfc_expr *op)
{
if (op ==
# 1651 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
__null
# 1651 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
)
gfc_internal_error ("eval_type_intrinsic0(): op NULL");
switch (iop)
{
case INTRINSIC_GE:
case INTRINSIC_GE_OS:
case INTRINSIC_LT:
case INTRINSIC_LT_OS:
case INTRINSIC_LE:
case INTRINSIC_LE_OS:
case INTRINSIC_GT:
case INTRINSIC_GT_OS:
case INTRINSIC_EQ:
case INTRINSIC_EQ_OS:
case INTRINSIC_NE:
case INTRINSIC_NE_OS:
op->ts.type = BT_LOGICAL;
op->ts.kind = gfc_default_logical_kind;
break;
default:
break;
}
return op;
}
static int
gfc_zero_size_array (gfc_expr *e)
{
if (e->expr_type != EXPR_ARRAY)
return 0;
return e->value.constructor ==
# 1688 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
__null
# 1688 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
;
}
static gfc_expr *
reduce_binary0 (gfc_expr *op1, gfc_expr *op2)
{
if (gfc_zero_size_array (op1))
{
gfc_free_expr (op2);
return op1;
}
if (gfc_zero_size_array (op2))
{
gfc_free_expr (op1);
return op2;
}
return
# 1711 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
__null
# 1711 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
;
}
static gfc_expr *
eval_intrinsic_f2 (gfc_intrinsic_op op,
arith (*eval) (gfc_expr *, gfc_expr **),
gfc_expr *op1, gfc_expr *op2)
{
gfc_expr *result;
eval_f f;
if (op2 ==
# 1723 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
__null
# 1723 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
)
{
if (gfc_zero_size_array (op1))
return eval_type_intrinsic0 (op, op1);
}
else
{
result = reduce_binary0 (op1, op2);
if (result !=
# 1731 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
__null
# 1731 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
)
return eval_type_intrinsic0 (op, result);
}
f.f2 = eval;
return eval_intrinsic (op, f, op1, op2);
}
static gfc_expr *
eval_intrinsic_f3 (gfc_intrinsic_op op,
arith (*eval) (gfc_expr *, gfc_expr *, gfc_expr **),
gfc_expr *op1, gfc_expr *op2)
{
gfc_expr *result;
eval_f f;
if (!op1 && !op2)
return
# 1749 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
__null
# 1749 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
;
result = reduce_binary0 (op1, op2);
if (result !=
# 1752 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
__null
# 1752 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
)
return eval_type_intrinsic0(op, result);
f.f3 = eval;
return eval_intrinsic (op, f, op1, op2);
}
gfc_expr *
gfc_parentheses (gfc_expr *op)
{
if (gfc_is_constant_expr (op))
return op;
return eval_intrinsic_f2 (INTRINSIC_PARENTHESES, gfc_arith_identity,
op,
# 1767 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
__null
# 1767 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
);
}
gfc_expr *
gfc_uplus (gfc_expr *op)
{
return eval_intrinsic_f2 (INTRINSIC_UPLUS, gfc_arith_identity, op,
# 1773 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
__null
# 1773 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
);
}
gfc_expr *
gfc_uminus (gfc_expr *op)
{
return eval_intrinsic_f2 (INTRINSIC_UMINUS, gfc_arith_uminus, op,
# 1780 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
__null
# 1780 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
);
}
gfc_expr *
gfc_add (gfc_expr *op1, gfc_expr *op2)
{
return eval_intrinsic_f3 (INTRINSIC_PLUS, gfc_arith_plus, op1, op2);
}
gfc_expr *
gfc_subtract (gfc_expr *op1, gfc_expr *op2)
{
return eval_intrinsic_f3 (INTRINSIC_MINUS, gfc_arith_minus, op1, op2);
}
gfc_expr *
gfc_multiply (gfc_expr *op1, gfc_expr *op2)
{
return eval_intrinsic_f3 (INTRINSIC_TIMES, gfc_arith_times, op1, op2);
}
gfc_expr *
gfc_divide (gfc_expr *op1, gfc_expr *op2)
{
return eval_intrinsic_f3 (INTRINSIC_DIVIDE, gfc_arith_divide, op1, op2);
}
gfc_expr *
gfc_power (gfc_expr *op1, gfc_expr *op2)
{
return eval_intrinsic_f3 (INTRINSIC_POWER, arith_power, op1, op2);
}
gfc_expr *
gfc_concat (gfc_expr *op1, gfc_expr *op2)
{
return eval_intrinsic_f3 (INTRINSIC_CONCAT, gfc_arith_concat, op1, op2);
}
gfc_expr *
gfc_and (gfc_expr *op1, gfc_expr *op2)
{
return eval_intrinsic_f3 (INTRINSIC_AND, gfc_arith_and, op1, op2);
}
gfc_expr *
gfc_or (gfc_expr *op1, gfc_expr *op2)
{
return eval_intrinsic_f3 (INTRINSIC_OR, gfc_arith_or, op1, op2);
}
gfc_expr *
gfc_not (gfc_expr *op1)
{
return eval_intrinsic_f2 (INTRINSIC_NOT, gfc_arith_not, op1,
# 1843 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
__null
# 1843 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
);
}
gfc_expr *
gfc_eqv (gfc_expr *op1, gfc_expr *op2)
{
return eval_intrinsic_f3 (INTRINSIC_EQV, gfc_arith_eqv, op1, op2);
}
gfc_expr *
gfc_neqv (gfc_expr *op1, gfc_expr *op2)
{
return eval_intrinsic_f3 (INTRINSIC_NEQV, gfc_arith_neqv, op1, op2);
}
gfc_expr *
gfc_eq (gfc_expr *op1, gfc_expr *op2, gfc_intrinsic_op op)
{
return eval_intrinsic_f3 (op, gfc_arith_eq, op1, op2);
}
gfc_expr *
gfc_ne (gfc_expr *op1, gfc_expr *op2, gfc_intrinsic_op op)
{
return eval_intrinsic_f3 (op, gfc_arith_ne, op1, op2);
}
gfc_expr *
gfc_gt (gfc_expr *op1, gfc_expr *op2, gfc_intrinsic_op op)
{
return eval_intrinsic_f3 (op, gfc_arith_gt, op1, op2);
}
gfc_expr *
gfc_ge (gfc_expr *op1, gfc_expr *op2, gfc_intrinsic_op op)
{
return eval_intrinsic_f3 (op, gfc_arith_ge, op1, op2);
}
gfc_expr *
gfc_lt (gfc_expr *op1, gfc_expr *op2, gfc_intrinsic_op op)
{
return eval_intrinsic_f3 (op, gfc_arith_lt, op1, op2);
}
gfc_expr *
gfc_le (gfc_expr *op1, gfc_expr *op2, gfc_intrinsic_op op)
{
return eval_intrinsic_f3 (op, gfc_arith_le, op1, op2);
}
static void
arith_error (arith rc, gfc_typespec *from, gfc_typespec *to, locus *where)
{
switch (rc)
{
case ARITH_OK:
gfc_error ("Arithmetic OK converting %s to %s at %L",
gfc_typename (from), gfc_typename (to), where);
break;
case ARITH_OVERFLOW:
gfc_error ("Arithmetic overflow converting %s to %s at %L. This check "
"can be disabled with the option %<-fno-range-check%>",
gfc_typename (from), gfc_typename (to), where);
break;
case ARITH_UNDERFLOW:
gfc_error ("Arithmetic underflow converting %s to %s at %L. This check "
"can be disabled with the option %<-fno-range-check%>",
gfc_typename (from), gfc_typename (to), where);
break;
case ARITH_NAN:
gfc_error ("Arithmetic NaN converting %s to %s at %L. This check "
"can be disabled with the option %<-fno-range-check%>",
gfc_typename (from), gfc_typename (to), where);
break;
case ARITH_DIV0:
gfc_error ("Division by zero converting %s to %s at %L",
gfc_typename (from), gfc_typename (to), where);
break;
case ARITH_INCOMMENSURATE:
gfc_error ("Array operands are incommensurate converting %s to %s at %L",
gfc_typename (from), gfc_typename (to), where);
break;
case ARITH_ASYMMETRIC:
gfc_error ("Integer outside symmetric range implied by Standard Fortran"
" converting %s to %s at %L",
gfc_typename (from), gfc_typename (to), where);
break;
default:
gfc_internal_error ("gfc_arith_error(): Bad error code");
}
}
static bool
wprecision_real_real (mpfr_t r, int from_kind, int to_kind)
{
mpfr_t rv, diff;
bool ret;
gfc_set_model_kind (to_kind);
mpfr_init (rv);
gfc_set_model_kind (from_kind);
mpfr_init (diff);
# 1967 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
mpfr_set4(
# 1967 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
rv
# 1967 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
,
# 1967 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
r
# 1967 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
,
# 1967 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
MPFR_RNDN
# 1967 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
,((
# 1967 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
r
# 1967 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
)->_mpfr_sign))
# 1967 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
;
mpfr_sub (diff, rv, r, MPFR_RNDN);
ret = !
# 1970 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
((
# 1970 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
diff
# 1970 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
)->_mpfr_exp == (0 - ((mpfr_exp_t) (((mpfr_uexp_t) -1) >> 1))))
# 1970 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
;
mpfr_clear (rv);
mpfr_clear (diff);
return ret;
}
static bool
wprecision_int_real (mpz_t n, mpfr_t r)
{
bool ret;
mpz_t i;
# 1983 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
__gmpz_init
# 1983 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
(i);
mpfr_get_z (i, r, MPFR_RNDN);
# 1985 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
__gmpz_sub
# 1985 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
(i, i, n);
ret =
# 1986 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
(__builtin_constant_p ((
# 1986 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
0
# 1986 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
) >= 0) && (
# 1986 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
0
# 1986 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
) >= 0 ? (__builtin_constant_p ((static_cast<unsigned long> (
# 1986 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
0
# 1986 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
))) && ((static_cast<unsigned long> (
# 1986 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
0
# 1986 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
))) == 0 ? ((
# 1986 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
i
# 1986 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
)->_mp_size < 0 ? -1 : (
# 1986 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
i
# 1986 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
)->_mp_size > 0) : __gmpz_cmp_ui (
# 1986 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
i
# 1986 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
,(static_cast<unsigned long> (
# 1986 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
0
# 1986 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
)))) : __gmpz_cmp_si (
# 1986 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
i
# 1986 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
,
# 1986 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
0
# 1986 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
))
# 1986 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
!= 0;
# 1987 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
__gmpz_clear
# 1987 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
(i);
return ret;
}
gfc_expr *
gfc_int2int (gfc_expr *src, int kind)
{
gfc_expr *result;
arith rc;
result = gfc_get_constant_expr (BT_INTEGER, kind, &src->where);
# 2001 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
__gmpz_set
# 2001 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
(result->value.integer, src->value.integer);
if ((rc = gfc_check_integer_range (result->value.integer, kind)) != ARITH_OK)
{
if (rc == ARITH_ASYMMETRIC)
{
gfc_warning (0, gfc_arith_error (rc), &src->where);
}
else
{
arith_error (rc, &src->ts, &result->ts, &src->where);
gfc_free_expr (result);
return
# 2013 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
__null
# 2013 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
;
}
}
if (global_options.x_flag_range_check == 0)
{
int k;
k = gfc_validate_kind (BT_INTEGER, kind, false);
gfc_convert_mpz_to_signed (result->value.integer,
gfc_integer_kinds[k].bit_size);
if (global_options.x_warn_conversion && !src->do_not_warn && kind < src->ts.kind)
gfc_warning_now (OPT_Wconversion, "Conversion from %qs to %qs at %L",
gfc_typename (&src->ts), gfc_typename (&result->ts),
&src->where);
}
return result;
}
gfc_expr *
gfc_int2real (gfc_expr *src, int kind)
{
gfc_expr *result;
arith rc;
result = gfc_get_constant_expr (BT_REAL, kind, &src->where);
mpfr_set_z (result->value.real, src->value.integer, MPFR_RNDN);
if ((rc = gfc_check_real_range (result->value.real, kind)) != ARITH_OK)
{
arith_error (rc, &src->ts, &result->ts, &src->where);
gfc_free_expr (result);
return
# 2052 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
__null
# 2052 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
;
}
if (global_options.x_warn_conversion
&& wprecision_int_real (src->value.integer, result->value.real))
gfc_warning (OPT_Wconversion, "Change of value in conversion "
"from %qs to %qs at %L",
gfc_typename (&src->ts),
gfc_typename (&result->ts),
&src->where);
return result;
}
gfc_expr *
gfc_int2complex (gfc_expr *src, int kind)
{
gfc_expr *result;
arith rc;
result = gfc_get_constant_expr (BT_COMPLEX, kind, &src->where);
mpc_set_z (result->value.complex, src->value.integer,
# 2077 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
(((int)(MPFR_RNDN)) + ((int)(MPFR_RNDN) << 4))
# 2077 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
);
if ((rc = gfc_check_real_range (
# 2079 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
((
# 2079 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
result->value.complex
# 2079 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
)->re)
# 2079 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
, kind))
!= ARITH_OK)
{
arith_error (rc, &src->ts, &result->ts, &src->where);
gfc_free_expr (result);
return
# 2084 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
__null
# 2084 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
;
}
if (global_options.x_warn_conversion
&& wprecision_int_real (src->value.integer,
# 2089 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
((
# 2089 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
result->value.complex
# 2089 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
)->re)
# 2089 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
))
gfc_warning_now (OPT_Wconversion, "Change of value in conversion "
"from %qs to %qs at %L",
gfc_typename (&src->ts),
gfc_typename (&result->ts),
&src->where);
return result;
}
gfc_expr *
gfc_real2int (gfc_expr *src, int kind)
{
gfc_expr *result;
arith rc;
bool did_warn = false;
result = gfc_get_constant_expr (BT_INTEGER, kind, &src->where);
gfc_mpfr_to_mpz (result->value.integer, src->value.real, &src->where);
if ((rc = gfc_check_integer_range (result->value.integer, kind)) != ARITH_OK)
{
arith_error (rc, &src->ts, &result->ts, &src->where);
gfc_free_expr (result);
return
# 2117 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
__null
# 2117 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
;
}
if (global_options.x_warn_conversion)
{
mpfr_t f;
mpfr_init (f);
mpfr_frac (f, src->value.real, MPFR_RNDN);
if (
# 2127 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
mpfr_cmp_si_2exp((
# 2127 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
f
# 2127 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
),(
# 2127 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
0
# 2127 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
),0)
# 2127 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
!= 0)
{
gfc_warning_now (OPT_Wconversion, "Change of value in conversion "
"from %qs to %qs at %L", gfc_typename (&src->ts),
gfc_typename (&result->ts), &src->where);
did_warn = true;
}
}
if (!did_warn && global_options.x_warn_conversion_extra)
{
gfc_warning_now (OPT_Wconversion_extra, "Conversion from %qs to %qs "
"at %L", gfc_typename (&src->ts),
gfc_typename (&result->ts), &src->where);
}
return result;
}
gfc_expr *
gfc_real2real (gfc_expr *src, int kind)
{
gfc_expr *result;
arith rc;
bool did_warn = false;
result = gfc_get_constant_expr (BT_REAL, kind, &src->where);
# 2157 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
mpfr_set4(
# 2157 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
result->value.real
# 2157 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
,
# 2157 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
src->value.real
# 2157 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
,
# 2157 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
MPFR_RNDN
# 2157 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
,((
# 2157 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
src->value.real
# 2157 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
)->_mpfr_sign))
# 2157 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
;
rc = gfc_check_real_range (result->value.real, kind);
if (rc == ARITH_UNDERFLOW)
{
if (global_options.x_warn_underflow)
gfc_warning (OPT_Woverflow, gfc_arith_error (rc), &src->where);
mpfr_set_ui (result->value.real, 0, MPFR_RNDN);
}
else if (rc != ARITH_OK)
{
arith_error (rc, &src->ts, &result->ts, &src->where);
gfc_free_expr (result);
return
# 2171 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
__null
# 2171 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
;
}
if ((global_options.x_warn_conversion || global_options.x_warn_conversion_extra) && src->ts.kind > kind)
{
int w = global_options.x_warn_conversion ? OPT_Wconversion : OPT_Wconversion_extra;
if (wprecision_real_real (src->value.real, src->ts.kind, kind))
{
gfc_warning_now (w, "Change of value in conversion from "
"%qs to %qs at %L",
gfc_typename (&src->ts), gfc_typename (&result->ts),
&src->where);
did_warn = true;
}
}
if (!did_warn && global_options.x_warn_conversion_extra)
gfc_warning_now (OPT_Wconversion_extra, "Conversion from %qs to %qs "
"at %L", gfc_typename(&src->ts),
gfc_typename(&result->ts), &src->where);
return result;
}
gfc_expr *
gfc_real2complex (gfc_expr *src, int kind)
{
gfc_expr *result;
arith rc;
bool did_warn = false;
result = gfc_get_constant_expr (BT_COMPLEX, kind, &src->where);
mpc_set_fr (result->value.complex, src->value.real,
# 2216 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
(((int)(MPFR_RNDN)) + ((int)(MPFR_RNDN) << 4))
# 2216 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
);
rc = gfc_check_real_range (
# 2218 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
((
# 2218 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
result->value.complex
# 2218 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
)->re)
# 2218 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
, kind);
if (rc == ARITH_UNDERFLOW)
{
if (global_options.x_warn_underflow)
gfc_warning (OPT_Woverflow, gfc_arith_error (rc), &src->where);
mpfr_set_ui (
# 2224 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
((
# 2224 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
result->value.complex
# 2224 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
)->re)
# 2224 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
, 0, MPFR_RNDN);
}
else if (rc != ARITH_OK)
{
arith_error (rc, &src->ts, &result->ts, &src->where);
gfc_free_expr (result);
return
# 2230 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
__null
# 2230 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
;
}
if ((global_options.x_warn_conversion || global_options.x_warn_conversion_extra) && src->ts.kind > kind)
{
int w = global_options.x_warn_conversion ? OPT_Wconversion : OPT_Wconversion_extra;
if (wprecision_real_real (src->value.real, src->ts.kind, kind))
{
gfc_warning_now (w, "Change of value in conversion from "
"%qs to %qs at %L",
gfc_typename (&src->ts), gfc_typename (&result->ts),
&src->where);
did_warn = true;
}
}
if (!did_warn && global_options.x_warn_conversion_extra)
gfc_warning_now (OPT_Wconversion_extra, "Conversion from %qs to %qs "
"at %L", gfc_typename(&src->ts),
gfc_typename(&result->ts), &src->where);
return result;
}
gfc_expr *
gfc_complex2int (gfc_expr *src, int kind)
{
gfc_expr *result;
arith rc;
bool did_warn = false;
result = gfc_get_constant_expr (BT_INTEGER, kind, &src->where);
gfc_mpfr_to_mpz (result->value.integer,
# 2268 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
((
# 2268 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
src->value.complex
# 2268 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
)->re)
# 2268 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
,
&src->where);
if ((rc = gfc_check_integer_range (result->value.integer, kind)) != ARITH_OK)
{
arith_error (rc, &src->ts, &result->ts, &src->where);
gfc_free_expr (result);
return
# 2275 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
__null
# 2275 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
;
}
if (global_options.x_warn_conversion || global_options.x_warn_conversion_extra)
{
int w = global_options.x_warn_conversion ? OPT_Wconversion : OPT_Wconversion_extra;
if (
# 2283 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
mpfr_cmp_si_2exp((((
# 2283 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
src->value.complex
# 2283 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
)->im)),(
# 2283 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
0
# 2283 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
),0)
# 2283 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
!= 0)
{
gfc_warning_now (w, "Non-zero imaginary part discarded "
"in conversion from %qs to %qs at %L",
gfc_typename(&src->ts), gfc_typename (&result->ts),
&src->where);
did_warn = true;
}
else {
mpfr_t f;
mpfr_init (f);
mpfr_frac (f, src->value.real, MPFR_RNDN);
if (
# 2297 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
mpfr_cmp_si_2exp((
# 2297 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
f
# 2297 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
),(
# 2297 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
0
# 2297 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
),0)
# 2297 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
!= 0)
{
gfc_warning_now (w, "Change of value in conversion from "
"%qs to %qs at %L", gfc_typename (&src->ts),
gfc_typename (&result->ts), &src->where);
did_warn = true;
}
mpfr_clear (f);
}
if (!did_warn && global_options.x_warn_conversion_extra)
{
gfc_warning_now (OPT_Wconversion_extra, "Conversion from %qs to %qs "
"at %L", gfc_typename (&src->ts),
gfc_typename (&result->ts), &src->where);
}
}
return result;
}
gfc_expr *
gfc_complex2real (gfc_expr *src, int kind)
{
gfc_expr *result;
arith rc;
bool did_warn = false;
result = gfc_get_constant_expr (BT_REAL, kind, &src->where);
mpc_real (result->value.real, src->value.complex, MPFR_RNDN);
rc = gfc_check_real_range (result->value.real, kind);
if (rc == ARITH_UNDERFLOW)
{
if (global_options.x_warn_underflow)
gfc_warning (OPT_Woverflow, gfc_arith_error (rc), &src->where);
mpfr_set_ui (result->value.real, 0, MPFR_RNDN);
}
if (rc != ARITH_OK)
{
arith_error (rc, &src->ts, &result->ts, &src->where);
gfc_free_expr (result);
return
# 2344 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
__null
# 2344 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
;
}
if (global_options.x_warn_conversion || global_options.x_warn_conversion_extra)
{
int w = global_options.x_warn_conversion ? OPT_Wconversion : OPT_Wconversion_extra;
if (
# 2352 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
mpfr_cmp_si_2exp((((
# 2352 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
src->value.complex
# 2352 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
)->im)),(
# 2352 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
0
# 2352 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
),0)
# 2352 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
!= 0)
{
gfc_warning (w, "Non-zero imaginary part discarded "
"in conversion from %qs to %qs at %L",
gfc_typename(&src->ts), gfc_typename (&result->ts),
&src->where);
did_warn = true;
}
if (kind > src->ts.kind
&& wprecision_real_real (
# 2365 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
((
# 2365 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
src->value.complex
# 2365 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
)->re)
# 2365 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
,
src->ts.kind, kind))
{
gfc_warning_now (w, "Change of value in conversion from "
"%qs to %qs at %L",
gfc_typename (&src->ts), gfc_typename (&result->ts),
&src->where);
did_warn = true;
}
}
if (!did_warn && global_options.x_warn_conversion_extra)
gfc_warning_now (OPT_Wconversion, "Conversion from %qs to %qs at %L",
gfc_typename(&src->ts), gfc_typename (&result->ts),
&src->where);
return result;
}
gfc_expr *
gfc_complex2complex (gfc_expr *src, int kind)
{
gfc_expr *result;
arith rc;
bool did_warn = false;
result = gfc_get_constant_expr (BT_COMPLEX, kind, &src->where);
mpc_set (result->value.complex, src->value.complex,
# 2397 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
(((int)(MPFR_RNDN)) + ((int)(MPFR_RNDN) << 4))
# 2397 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
);
rc = gfc_check_real_range (
# 2399 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
((
# 2399 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
result->value.complex
# 2399 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
)->re)
# 2399 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
, kind);
if (rc == ARITH_UNDERFLOW)
{
if (global_options.x_warn_underflow)
gfc_warning (OPT_Woverflow, gfc_arith_error (rc), &src->where);
mpfr_set_ui (
# 2405 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
((
# 2405 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
result->value.complex
# 2405 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
)->re)
# 2405 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
, 0, MPFR_RNDN);
}
else if (rc != ARITH_OK)
{
arith_error (rc, &src->ts, &result->ts, &src->where);
gfc_free_expr (result);
return
# 2411 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
__null
# 2411 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
;
}
rc = gfc_check_real_range (
# 2414 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
((
# 2414 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
result->value.complex
# 2414 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
)->im)
# 2414 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
, kind);
if (rc == ARITH_UNDERFLOW)
{
if (global_options.x_warn_underflow)
gfc_warning (OPT_Woverflow, gfc_arith_error (rc), &src->where);
mpfr_set_ui (
# 2420 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
((
# 2420 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
result->value.complex
# 2420 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
)->im)
# 2420 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
, 0, MPFR_RNDN);
}
else if (rc != ARITH_OK)
{
arith_error (rc, &src->ts, &result->ts, &src->where);
gfc_free_expr (result);
return
# 2426 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
__null
# 2426 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
;
}
if ((global_options.x_warn_conversion || global_options.x_warn_conversion_extra) && src->ts.kind > kind
&& (wprecision_real_real (
# 2430 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
((
# 2430 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
src->value.complex
# 2430 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
)->re)
# 2430 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
,
src->ts.kind, kind)
|| wprecision_real_real (
# 2432 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
((
# 2432 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
src->value.complex
# 2432 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
)->im)
# 2432 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
,
src->ts.kind, kind)))
{
int w = global_options.x_warn_conversion ? OPT_Wconversion : OPT_Wconversion_extra;
gfc_warning_now (w, "Change of value in conversion from "
"%qs to %qs at %L",
gfc_typename (&src->ts), gfc_typename (&result->ts),
&src->where);
did_warn = true;
}
if (!did_warn && global_options.x_warn_conversion_extra && src->ts.kind != kind)
gfc_warning_now (OPT_Wconversion_extra, "Conversion from %qs to %qs "
"at %L", gfc_typename(&src->ts),
gfc_typename (&result->ts), &src->where);
return result;
}
gfc_expr *
gfc_log2log (gfc_expr *src, int kind)
{
gfc_expr *result;
result = gfc_get_constant_expr (BT_LOGICAL, kind, &src->where);
result->value.logical = src->value.logical;
return result;
}
gfc_expr *
gfc_log2int (gfc_expr *src, int kind)
{
gfc_expr *result;
result = gfc_get_constant_expr (BT_INTEGER, kind, &src->where);
# 2475 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
__gmpz_set_si
# 2475 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
(result->value.integer, src->value.logical);
return result;
}
gfc_expr *
gfc_int2log (gfc_expr *src, int kind)
{
gfc_expr *result;
result = gfc_get_constant_expr (BT_LOGICAL, kind, &src->where);
result->value.logical = (
# 2489 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
(__builtin_constant_p ((
# 2489 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
0
# 2489 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
) >= 0) && (
# 2489 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
0
# 2489 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
) >= 0 ? (__builtin_constant_p ((static_cast<unsigned long> (
# 2489 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
0
# 2489 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
))) && ((static_cast<unsigned long> (
# 2489 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
0
# 2489 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
))) == 0 ? ((
# 2489 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
src->value.integer
# 2489 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
)->_mp_size < 0 ? -1 : (
# 2489 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
src->value.integer
# 2489 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
)->_mp_size > 0) : __gmpz_cmp_ui (
# 2489 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
src->value.integer
# 2489 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
,(static_cast<unsigned long> (
# 2489 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
0
# 2489 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
)))) : __gmpz_cmp_si (
# 2489 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
src->value.integer
# 2489 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
,
# 2489 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
0
# 2489 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c" 3 4
))
# 2489 "/home/giulianob/gcc_git_gnu/gcc/gcc/fortran/arith.c"
!= 0);
return result;
}
gfc_expr *
gfc_character2character (gfc_expr *src, int kind)
{
gfc_expr *result;
result = gfc_copy_expr (src);
result->ts.kind = kind;
return result;
}
static void
hollerith2representation (gfc_expr *result, gfc_expr *src)
{
size_t src_len, result_len;
src_len = src->representation.length - src->ts.u.pad;
gfc_target_expr_size (result, &result_len);
if (src_len > result_len)
{
gfc_warning (OPT_Wcharacter_truncation, "The Hollerith constant at %L "
"is truncated in conversion to %qs", &src->where,
gfc_typename(&result->ts));
}
result->representation.string = ((char *) xcalloc ((result_len + 1), sizeof (char)));
memcpy (result->representation.string, src->representation.string,
((result_len) < (src_len) ? (result_len) : (src_len)));
if (src_len < result_len)
memset (&result->representation.string[src_len], ' ', result_len - src_len);
result->representation.string[result_len] = '\0';
result->representation.length = result_len;
}
static void
character2representation (gfc_expr *result, gfc_expr *src)
{
size_t src_len, result_len, i;
src_len = src->value.character.length;
gfc_target_expr_size (result, &result_len);
if (src_len > result_len)
gfc_warning (OPT_Wcharacter_truncation, "The character constant at %L is "
"truncated in conversion to %s", &src->where,
gfc_typename(&result->ts));
result->representation.string = ((char *) xcalloc ((result_len + 1), sizeof (char)));
for (i = 0; i < ((result_len) < (src_len) ? (result_len) : (src_len)); i++)
result->representation.string[i] = (char) src->value.character.string[i];
if (src_len < result_len)
memset (&result->representation.string[src_len], ' ',
result_len - src_len);
result->representation.string[result_len] = '\0';
result->representation.length = result_len;
}
gfc_expr *
gfc_hollerith2int (gfc_expr *src, int kind)
{
gfc_expr *result;
result = gfc_get_constant_expr (BT_INTEGER, kind, &src->where);
hollerith2representation (result, src);
gfc_interpret_integer (kind, (unsigned char *) result->representation.string,
result->representation.length, result->value.integer);
return result;
}
gfc_expr *
gfc_character2int (gfc_expr *src, int kind)
{
gfc_expr *result;
result = gfc_get_constant_expr (BT_INTEGER, kind, &src->where);
character2representation (result, src);
gfc_interpret_integer (kind, (unsigned char *) result->representation.string,
result->representation.length, result->value.integer);
return result;
}
gfc_expr *
gfc_hollerith2real (gfc_expr *src, int kind)
{
gfc_expr *result;
result = gfc_get_constant_expr (BT_REAL, kind, &src->where);
hollerith2representation (result, src);
gfc_interpret_float (kind, (unsigned char *) result->representation.string,
result->representation.length, result->value.real);
return result;
}
gfc_expr *
gfc_character2real (gfc_expr *src, int kind)
{
gfc_expr *result;
result = gfc_get_constant_expr (BT_REAL, kind, &src->where);
character2representation (result, src);
gfc_interpret_float (kind, (unsigned char *) result->representation.string,
result->representation.length, result->value.real);
return result;
}
gfc_expr *
gfc_hollerith2complex (gfc_expr *src, int kind)
{
gfc_expr *result;
result = gfc_get_constant_expr (BT_COMPLEX, kind, &src->where);
hollerith2representation (result, src);
gfc_interpret_complex (kind, (unsigned char *) result->representation.string,
result->representation.length, result->value.complex);
return result;
}
gfc_expr *
gfc_character2complex (gfc_expr *src, int kind)
{
gfc_expr *result;
result = gfc_get_constant_expr (BT_COMPLEX, kind, &src->where);
character2representation (result, src);
gfc_interpret_complex (kind, (unsigned char *) result->representation.string,
result->representation.length, result->value.complex);
return result;
}
gfc_expr *
gfc_hollerith2character (gfc_expr *src, int kind)
{
gfc_expr *result;
result = gfc_copy_expr (src);
result->ts.type = BT_CHARACTER;
result->ts.kind = kind;
result->ts.u.pad = 0;
result->value.character.length = result->representation.length;
result->value.character.string
= gfc_char_to_widechar (result->representation.string);
return result;
}
gfc_expr *
gfc_hollerith2logical (gfc_expr *src, int kind)
{
gfc_expr *result;
result = gfc_get_constant_expr (BT_LOGICAL, kind, &src->where);
hollerith2representation (result, src);
gfc_interpret_logical (kind, (unsigned char *) result->representation.string,
result->representation.length, &result->value.logical);
return result;
}
gfc_expr *
gfc_character2logical (gfc_expr *src, int kind)
{
gfc_expr *result;
result = gfc_get_constant_expr (BT_LOGICAL, kind, &src->where);
character2representation (result, src);
gfc_interpret_logical (kind, (unsigned char *) result->representation.string,
result->representation.length, &result->value.logical);
return result;
}
| [
"giuliano.belinassi@usp.br"
] | giuliano.belinassi@usp.br |
12c94c353092e952f78e3e7dc11c2ea95363b930 | df8e05a72536fa46213058ad1dea37975d81c139 | /CollisionEngine.cpp | 357b3a5c29a900513a1387bc269eaf10f708b5c2 | [] | no_license | MGuiGui/3DGameEngine | a43b5027f9538d507d3f15b5a4069c42f4258124 | 561b580923825b91ef09c6351aab39b589251c2b | refs/heads/master | 2020-04-05T23:27:40.049868 | 2015-03-26T23:27:20 | 2015-03-26T23:27:20 | 32,650,268 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,426 | cpp | #include "CollisionEngine.hpp"
#include <iostream>
bool CollisionEngine::checkIfColliding(Actor& actorOne, Actor& actorTwo)
{
//Calculate the sides of rect A
float leftA = actorOne._transform._position.x;
float rightA = actorOne._transform._position.x + actorOne._collision._width;
float topA = actorOne._transform._position.z;
float bottomA = actorOne._transform._position.z + actorOne._collision._length;
float depthTopA = actorOne._transform._position.y;
float depthBottomA = actorOne._transform._position.y + actorOne._collision._depth;
//Calculate the sides of rect B
float leftB = actorTwo._transform._position.x;
float rightB = actorTwo._transform._position.x + actorTwo._collision._width;
float topB = actorTwo._transform._position.z;
float bottomB = actorTwo._transform._position.z + actorTwo._collision._length;
float depthTopB = actorTwo._transform._position.y;
float depthBottomB = actorTwo._transform._position.y + actorTwo._collision._depth;
if(bottomA <= topB)
{
return false;
}
if(topA >= bottomB)
{
return false;
}
if(rightA <= leftB)
{
return false;
}
if(leftA >= rightB)
{
return false;
}
if(depthBottomA <= depthTopB)
{
return false;
}
if(depthTopA >= depthBottomB)
{
return false;
}
return true;
}
std::vector<Actor*>* CollisionEngine::getActorPlaceFree(Actor* testMe, float x, float y, float z)
{
float previousX = testMe->_transform._position.x;
float previousY = testMe->_transform._position.y;
float previousZ = testMe->_transform._position.z;
testMe->_transform.setPosition(glm::vec3(x,z,y));
for (int i = 0; i < _colliders.size(); i++)
{
if (_colliders.at(i)->_collision.isActive){
if (checkIfColliding(*testMe, *_colliders.at(i)))
{
if(testMe != _colliders.at(i))
{
testMe->_transform.setPosition(glm::vec3(previousX,previousY,previousZ));
_returnedCollider.push_back(_colliders.at(i));
}
}
}
}
if(_returnedCollider.size() > 0)
{
return &_returnedCollider;
}
testMe->_transform.setPosition(glm::vec3(previousX,previousY,previousZ));
return 0;
}
| [
"LGriggles@outlook.com"
] | LGriggles@outlook.com |
5b7318fec56cc8d8b70c096a3023502782e7755d | ec6bf7adab1b0f808fe4c51cdd18fad1420feced | /LCA2.cpp | 717509af6ef6c2a69a85c494395094765fb63096 | [
"MIT"
] | permissive | noopurrkalawatia/leetcode | b53b4e596d4ad7050bc09a63533a8de04daaef11 | 0129c0b5b39230419f540d66b2658335393eaf12 | refs/heads/master | 2020-03-27T22:51:30.782084 | 2020-03-23T03:09:35 | 2020-03-23T03:09:35 | 147,267,193 | 0 | 0 | null | 2019-09-26T14:14:32 | 2018-09-04T00:37:15 | C++ | UTF-8 | C++ | false | false | 736 | 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:
TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q)
{
if(root == NULL)
{
return root;
}
if(root == p || root == q)
{
return root;
}
TreeNode* left = lowestCommonAncestor(root->left,p,q);
TreeNode* right = lowestCommonAncestor(root->right,p,q);
if(left && right)
{
return root;
}
return(left ? left : right);
}
};
| [
"noreply@github.com"
] | noreply@github.com |
31647d4c6ee17e0475abb0571c7e4bca5284b2db | 2cca9b84658ebe4c16d833900781401be06f631f | /lab6/src/pract6.cpp | df751f8e835eb9be1462b79771469a4c3548f6c8 | [] | no_license | bbricmq/sailfish_labs | 3e4529d2535c74d0c91bfaf92d7a550208e722c0 | e4b402064b72bc4b1be83ebebb1eb933b441931b | refs/heads/main | 2023-08-17T17:17:58.716356 | 2021-09-27T18:04:03 | 2021-09-27T18:04:03 | 408,552,495 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 667 | cpp | #ifdef QT_QML_DEBUG
#include <QtQuick>
#endif
#include <sailfishapp.h>
int main(int argc, char *argv[])
{
// SailfishApp::main() will display "qml/pract6.qml", if you need more
// control over initialization, you can use:
//
// - SailfishApp::application(int, char *[]) to get the QGuiApplication *
// - SailfishApp::createView() to get a new QQuickView * instance
// - SailfishApp::pathTo(QString) to get a QUrl to a resource file
// - SailfishApp::pathToMainQml() to get a QUrl to the main QML file
//
// To display the view, call "show()" (will show fullscreen on device).
return SailfishApp::main(argc, argv);
}
| [
"73311720+bbricmq@users.noreply.github.com"
] | 73311720+bbricmq@users.noreply.github.com |
507aa9196b93a7f340623e9f0cb12e0e12470abe | 3615e904fb9dfa134d1db401bc0c3bb30e2afcaa | /C e C++/Substituição em Vetor I.cpp | 172497d52bbd4331ad401cda5c2e15396f975c28 | [] | no_license | DericsonPablo/URI | 215e4f31f1e671113cc2eb14af1318285b191e89 | b2a32349a1d5a3401f71a348987d2d9d140f1881 | refs/heads/master | 2020-07-31T05:06:13.210309 | 2019-09-24T02:39:06 | 2019-09-24T02:39:06 | 210,493,467 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 348 | cpp | #include <iostream>
using namespace std;
int main(){
int vetor[10];
int n = 0;
for(int i = 0; i < 10; i++){
cin >> vetor[i];
if(vetor[i] == 0 || vetor[i] < 0){
vetor[i] = 1;
}
}
while(n < 10){
cout << "X[" << n << "] = " << vetor[n] << endl;
n++;
}
return 0;
}
| [
"dericsoncalari@gmail.com"
] | dericsoncalari@gmail.com |
c29778950a9d624d6c02a2b20183052ac6468370 | 169bd4618ac6e2301296bdb82b1de06e7f84ef59 | /generated/include/mmx/Node_read_storage_return.hxx | 8a78c6b1e100aada258f2f58fcc2ebc93ca645d5 | [
"Apache-2.0"
] | permissive | madMAx43v3r/mmx-node | be9eeff35c9f6b11d45ebcc2b695b90c149550df | a0f4fdfede7cfdbd6c548a00c8a4905e6a76506c | refs/heads/master | 2023-08-23T06:32:15.434280 | 2023-08-18T08:17:15 | 2023-08-18T08:17:15 | 431,829,941 | 203 | 55 | Apache-2.0 | 2023-09-01T10:52:52 | 2021-11-25T12:02:35 | C++ | UTF-8 | C++ | false | false | 2,179 | hxx |
// AUTO GENERATED by vnxcppcodegen
#ifndef INCLUDE_mmx_Node_read_storage_return_HXX_
#define INCLUDE_mmx_Node_read_storage_return_HXX_
#include <mmx/package.hxx>
#include <mmx/vm/varptr_t.hpp>
#include <vnx/Value.h>
namespace mmx {
class MMX_EXPORT Node_read_storage_return : public ::vnx::Value {
public:
std::map<std::string, ::mmx::vm::varptr_t> _ret_0;
typedef ::vnx::Value Super;
static const vnx::Hash64 VNX_TYPE_HASH;
static const vnx::Hash64 VNX_CODE_HASH;
static constexpr uint64_t VNX_TYPE_ID = 0xab73866ba23ed19aull;
Node_read_storage_return() {}
vnx::Hash64 get_type_hash() const override;
std::string get_type_name() const override;
const vnx::TypeCode* get_type_code() const override;
static std::shared_ptr<Node_read_storage_return> create();
std::shared_ptr<vnx::Value> clone() const override;
void read(vnx::TypeInput& _in, const vnx::TypeCode* _type_code, const uint16_t* _code) override;
void write(vnx::TypeOutput& _out, const vnx::TypeCode* _type_code, const uint16_t* _code) const override;
void read(std::istream& _in) override;
void write(std::ostream& _out) const override;
template<typename T>
void accept_generic(T& _visitor) const;
void accept(vnx::Visitor& _visitor) const override;
vnx::Object to_object() const override;
void from_object(const vnx::Object& object) override;
vnx::Variant get_field(const std::string& name) const override;
void set_field(const std::string& name, const vnx::Variant& value) override;
friend std::ostream& operator<<(std::ostream& _out, const Node_read_storage_return& _value);
friend std::istream& operator>>(std::istream& _in, Node_read_storage_return& _value);
static const vnx::TypeCode* static_get_type_code();
static std::shared_ptr<vnx::TypeCode> static_create_type_code();
};
template<typename T>
void Node_read_storage_return::accept_generic(T& _visitor) const {
_visitor.template type_begin<Node_read_storage_return>(1);
_visitor.type_field("_ret_0", 0); _visitor.accept(_ret_0);
_visitor.template type_end<Node_read_storage_return>(1);
}
} // namespace mmx
namespace vnx {
} // vnx
#endif // INCLUDE_mmx_Node_read_storage_return_HXX_
| [
"max.wittal@mwittal.de"
] | max.wittal@mwittal.de |
981641d539632da5981b34cdb4ead66f55521dd7 | 0e6b011598f320581e00b0b2e1fe3a82c2245e48 | /code/01_language/book/effectiveSTL/list34/union/04set_symmetric_difference.cc | 2fdb41ba87ed193f57aab0fabfdc5c551a2fb734 | [] | no_license | eternally123/MyCode | 23f72eed6ce8e12ed1bfbaa538d29607aee554aa | 8d4ec14969606090d375780b708e93bc75d0e960 | refs/heads/master | 2023-07-01T16:52:07.257677 | 2021-08-04T10:03:22 | 2021-08-04T10:03:22 | 319,946,929 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 984 | cc | #include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
int main()
{
vector<int> v1{1, 2, 3, 4, 5, 6, 7, 8};
vector<int> v2{5, 7, 9, 10};
sort(v1.begin(), v1.end());
sort(v2.begin(), v2.end());
vector<int> v_symDifference;
set_symmetric_difference(
v1.begin(), v1.end(),
v2.begin(), v2.end(),
back_inserter(v_symDifference));
for (int n : v_symDifference)
cout << n << ' ';
}
/**
* 计算二个已排序范围的对称差：
* 复制在任一范围中，但不在两个范围中找到的元素，到始于 d_first 的范围。结果范围亦为已排序。
*
* 若某元素在 [first1, last1) 中找到 m 次而在 [first2, last2) 中找到 n 次，
* 则将准确复制它 std::abs(m-n) 次到 d_first 。
* 若 m>n ，则从 [first1,last1) 复制末尾的 m-n 个元素，
* 否则从 [first2,last2) 复制末尾的 n-m 个元素。结果范围不能与任一输入范围重叠。
**/
| [
"hbag666@163.com"
] | hbag666@163.com |
a96b5daa2e0d27b04046b5249edccbc90661885c | 4da7317e1e461e0ff5e17e6bf1e03e59a5289a07 | /pdmpk/csr.cc | 6341fda48ba7f71bdb78e27533ca9059c918b847 | [] | no_license | vatai/mpk | 81ccbcec4b2c6be1cd01cca865d3e112ce27e5f8 | 1687a77ccb9a7ecc154007f32d384a9acb2a8118 | refs/heads/master | 2022-09-07T18:09:51.431262 | 2022-08-29T05:00:35 | 2022-08-29T05:00:35 | 89,324,963 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,878 | cc | // Author: Emil VATAI <emil.vatai@gmail.com>
// Date: 2019-09-17
#include <sstream>
#include <string>
#include "csr.h"
Csr::Csr(const std::string &fname) {
std::ifstream file{fname};
MtxCheckBanner(file);
MtxFillSize(file);
MtxFillVectors(file);
}
std::vector<double> Csr::SpMV(const std::vector<double> &vec) const {
std::vector<double> result(vec.size());
auto const n = ptr.size() - 1;
for (size_t i = 0; i < n; i++) {
double tmp = 0.0;
for (int t = ptr[i]; t < ptr[i + 1]; t++) {
tmp += val[t] * vec[col[t]];
}
result[i] = tmp;
}
return result;
}
void Csr::MPK(const int &nlevels, std::vector<double> &vec) const {
for (int i = 0; i < nlevels; i++)
vec = SpMV(vec);
}
void Csr::MtxCheckBanner(std::ifstream &file) {
std::string banner;
std::getline(file, banner);
std::stringstream tmp;
std::string word;
tmp << banner;
tmp >> word;
if (word != "%%MatrixMarket")
throw std::logic_error("Incorrect mtx banner!");
tmp >> word;
if (word != "matrix")
throw std::logic_error("Incorrect mtx banner!");
tmp >> word;
if (word != "coordinate")
throw std::logic_error("Not coordinate (sparse) matrix!");
tmp >> word;
pattern = (word == std::string("pattern"));
if (not pattern and word != std::string("real"))
throw std::logic_error("Not real or pattern matrix!");
tmp >> word;
symmetric = (word == std::string("symmetric"));
if (not symmetric and word != std::string("general"))
throw std::logic_error("Not general or symmetric matrix!");
}
void Csr::MtxFillSize(std::ifstream &file) {
std::string line;
std::stringstream ss;
std::getline(file, line);
while (line[0] == '%')
std::getline(file, line);
ss << line;
idx_t m;
ss >> m >> n >> nnz;
if (m != n) {
throw std::logic_error("Matrix not square");
}
ptr.resize(n + 1);
col.reserve(nnz);
val.reserve(nnz);
}
void Csr::MtxFillVectors(std::ifstream &file) {
std::string line;
std::vector<std::vector<idx_t>> Js(this->n);
std::vector<std::vector<double>> vs(this->n);
while (std::getline(file, line)) {
if (line[0] != '%') {
std::stringstream ss(line);
double val;
int i, j;
ss >> i >> j;
if (not pattern)
ss >> val;
else
val = 1.0;
i--;
j--;
ptr[i + 1]++;
Js[i].push_back(j);
vs[i].push_back(val);
if (symmetric and i != j) {
Js[j].push_back(i);
vs[j].push_back(val);
}
}
}
for (int i = 0; i < n; i++) {
ptr[i + 1] += ptr[i];
col.insert(std::end(col), std::begin(Js[i]), std::end(Js[i]));
val.insert(std::end(val), std::begin(vs[i]), std::end(vs[i]));
}
if (pattern) {
for (int i = 0; i < n; i++) {
double v = 1. / (ptr[i + 1] - ptr[i]);
for (int t = ptr[i]; t < ptr[i + 1]; t++) {
val[t] = v;
}
}
}
}
| [
"emil.vatai@gmail.com"
] | emil.vatai@gmail.com |
8403ca7bfded03024b07434163953e4e4c6c235d | d64ad03f4af5588df57ca3c8fb3f117aa028920c | /fileManager.cpp | 597364badfdfefb3c80474237f4ddcc213667cc5 | [
"MIT"
] | permissive | ctSkennerton/fxtract | eee76e60dabcc7dbb9486cf533aa771a75cf18f7 | 958619a6b46f6f5886ea56a65eb7af060a53c347 | refs/heads/master | 2021-10-26T18:04:54.142418 | 2021-10-24T17:48:04 | 2021-10-24T17:48:04 | 11,765,226 | 7 | 6 | null | 2015-06-28T04:41:30 | 2013-07-30T13:05:33 | C++ | UTF-8 | C++ | false | false | 6,085 | cpp | /*
* fileManager.cpp
* Copyright (C) 2013 uqcskenn <uqcskenn@hawke>
*
* Distributed under terms of the MIT license.
*/
#include "fileManager.h"
#include "util.h"
#include <cassert>
#include <iostream>
FileWrapper::FileWrapper() {
file = NULL;
filename = "";
fileOpened = false;
closeAtEnd = false;
recordsWritten = 0;
}
FileWrapper::FileWrapper(std::string filename) {
file = NULL;
filename = filename;
fileOpened = false;
closeAtEnd = false;
recordsWritten = 0;
}
int FileWrapper::open() {
if(!fileOpened) {
if(recordsWritten) {
file = fopen(filename.c_str(), "a");
} else {
file = fopen(filename.c_str(), "w");
}
}
if (file == NULL) {
perror("problem opening file");
return 1;
}
fileOpened = true;
return 0;
}
void FileWrapper::close() {
if(fileOpened & closeAtEnd) {
fclose(file);
fileOpened = false;
}
}
FileWrapper::~FileWrapper() {
close();
}
FileManager::FileManager() {
openCount = 0;
}
FileManager::~FileManager() {
std::vector<FileWrapper *>::iterator iter2;
for(iter2 = files.begin(); iter2 != files.end(); ++iter2) {
if(*iter2 != NULL) {
delete *iter2;
*iter2 = NULL;
}
}
}
void FileManager::add(std::string pattern, std::string filename) {
int ret;
// check if the pattern has been seen before
std::map<std::string, int>::iterator pm_iter = patternMapping.find(pattern);
std::map<std::string, int>::iterator fp_iter;
if(pm_iter == patternMapping.end()) {
// add in the pattern key to the hash
patternMapping[pattern] = -1;
// now check to see if the filename has been seen before
fp_iter = filenameMapping.find(filename);
if (fp_iter == filenameMapping.end()) {
// it hasn't so make a new filewrapper and associate the
// pattern and the filename with it's index in the vector
FileWrapper * fw = new FileWrapper(filename);
// since the size value will always be one more than the index
// after we push on the filewrapper below the index will match
int n = files.size();
patternMapping[pattern] = n;
filenameMapping[filename] = n;
fw->filename = filename;
fw->closeAtEnd = true;
files.push_back(fw);
} else {
// the file has been seen before but the pattern hasn't
// so we need to associate the new pattern with the file
patternMapping[pattern] = fp_iter->second;
}
assert(patternMapping[pattern] != -1);
} else {
// the pattern is known
// check to see if the filename is also known
fp_iter = filenameMapping.find(filename);
if (fp_iter != filenameMapping.end() && filename != fp_iter->first) {
// same pattern different filename
// error in mapping file
std::cerr << "[WARNING]: The pattern "<<pattern<<" is associated with both "<<filename<<" and "<<fp_iter->first<<std::endl;
}
}
}
void FileManager::add(std::string pattern) {
std::map<std::string, int>::iterator fp_iter;
// check if the pattern has been seen before
std::map<std::string, int>::iterator pm_iter = patternMapping.find(pattern);
if(pm_iter == patternMapping.end()) {
// add in the pattern key to the hash
patternMapping[pattern] = -1;
fp_iter = filenameMapping.find("");
if (fp_iter == filenameMapping.end()) {
// it hasn't so make a new filewrapper and associate the
// pattern and the filename with it's index in the vector
FileWrapper * fw = new FileWrapper("");
// since the size value will always be one more than the index
// after we push on the filewrapper below the index will match
int n = files.size();
patternMapping[pattern] = n;
filenameMapping[""] = n;
fw->filename = "";
fw->closeAtEnd = false;
fw->file = stdout;
fw->fileOpened = true;
files.push_back(fw);
} else {
// the file has been seen before but the pattern hasn't
// so we need to associate the new pattern with the file
patternMapping[pattern] = filenameMapping[""];
}
assert(patternMapping[pattern] != -1);
} else {
// the pattern is known
// check to see if the filename is also known
fp_iter = filenameMapping.find("");
if (fp_iter == filenameMapping.end() || "" != fp_iter->first) {
// same pattern different filename
// error in mapping file
fprintf(stderr, "[WARNING]: The pattern \"%s\" is associated with both \"%s\" and \"%s\"\n",
pattern.c_str(),
"(stdout)",
fp_iter->first.c_str());
}
}
}
FILE * FileManager::find (std::string key) {
FileWrapper * fw;
std::map<std::string, int>::iterator iter = patternMapping.find(key);
if(iter == patternMapping.end()) {
//fprintf(stderr, "[ERROR]: The pattern \"%s\" is not found in the mapping\n", key.c_str());
return NULL;
}
fw = files[iter->second];
if(fw->fileOpened) {
++fw->recordsWritten;
return fw->file;
} else if (openCount >= OPEN_MAX) {
// we're above the max number of allowed open files
// pop the first one off the queue and close it
FileWrapper * fo = closingQueue.top();
fo->close();
--openCount;
closingQueue.pop();
}
int ret = fw->open();
if(ret) {
return NULL;
}
if(fw->file != stdout) {
// sdtout doesn't really count as it is implicitly opened for the process
// so we don't want to add it into our queue
closingQueue.push(fw);
++openCount;
}
++fw->recordsWritten;
return fw->file;
}
| [
"c.skennerton@gmail.com"
] | c.skennerton@gmail.com |
c3e39f663eeef79604b7bbf7925485676ccb5ddf | 351ccb6dec274a4d80a547bb1e50e7aeb70b8a75 | /tasks/Task121Solution/main.cpp | 56aa385c8fc1fc6a381de7eb54b1c61ec04ce082 | [] | no_license | UniversityOfPlymouth-Electronics/ELEC143 | ed18e9a4e009e03b8b369f8b036c0fcd3aa08d1a | eebe6717ca8eedbc7b23bc354da9f99b73b9ceae | refs/heads/master | 2022-11-18T05:43:52.396136 | 2020-07-16T13:54:10 | 2020-07-16T13:54:10 | 24,501,359 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 635 | cpp | #include "mbed.h"
//This is my solution, using C functions to avoid repetition.
DigitalOut myled(D7);
void flash(double t);
void dash();
void dot();
void symbGap() ;
int main() {
while(1) {
dot();
dot();
dot();
symbGap();
dash();
dash();
dash();
symbGap();
dot();
dot();
dot();
wait(5.0);
}
}
void dot() {
flash(0.15);
}
void symbGap() {
wait(0.15);
}
void dash() {
flash(0.45);
}
void flash(double t) {
myled = 1;
wait(t);
myled=0;
wait(0.15);
} | [
"nicholas.outram@plymouth.ac.uk"
] | nicholas.outram@plymouth.ac.uk |
e62f628510978548cf6aeff246aad6820b3a12a0 | c8fe786762f30c4f1f9cbebadba7f2b2cc50f1dd | /object-oriented-programming/function-overloading.cpp | 0975b2bc0e6e4ad95612795f8069a249f5d4bd51 | [] | no_license | kiranarsam/understanding-cpp-step-by-step | b39e11f5c52e894785b18b1585082722473f722d | 5d3781a25ad962c605c507da28cbd861992b46b5 | refs/heads/master | 2020-09-22T02:47:21.164857 | 2019-12-17T03:09:06 | 2019-12-17T03:09:06 | 225,022,544 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 513 | cpp | #include <iostream>
#include <bits/stdc++.h>
using namespace std;
class Test {
public:
void func(int x) {
cout << "Value of x = " << x << endl;
}
void func(double x) {
cout << "Value of x = " << x << endl;
}
void func(int x, int y) {
cout << "Value of x and y is " << x << ", " << y << endl;
}
};
int main() {
Test t;
t.func(30);
t.func(32.46);
t.func(32, 46);
return 0;
} | [
"kiran@noreply.com"
] | kiran@noreply.com |
dced2fcfd2687d88e30ea78345190db77360a2cd | 3988879e082b100c3ea2ba80fe03194f6ccc291a | /linearsearch.cpp | ae6638763e250cdb7cf3bb47b83121b9e0c4e385 | [] | no_license | Ujjwalupadhyay123/CPPcodes | 6f4c3514a741b8827d679dc526a6255255b26941 | 101cee09ccc1e85d61e5aad8868e9bc6aaa55099 | refs/heads/master | 2023-04-25T02:38:47.615461 | 2021-05-10T16:50:12 | 2021-05-10T16:50:12 | 345,062,565 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 316 | cpp | #include<iostream>
using namespace std;
int main(){
int a[]={1,2,3,4,5,6,7,8,9,10};
int x,n,c=0,i=0;
cin>>x;
n=sizeof(a)/sizeof(a[0]);
for(;i<n;++i){
if(a[i]==x){
c=1;
break;
}
}
if(c==1) cout<<"found at index ="<<i;
else cout<<"Not found";
return 0;
} | [
"ujjwalkumarupadhyay51@gmail.com"
] | ujjwalkumarupadhyay51@gmail.com |
cbd5490f8914ef4146a93fe35024192d3b653b3f | 0e5ea03c2455b34a2f416c6c94c1669d7fe26e37 | /_2017_05_09 Let's ★ IDOL!/BackGround.h | 1b07cc42f728b9713b8d5023b7b6eb19de070e6f | [] | no_license | Arroria/__old_project | 8682652fac9a95898b41eff5b4fdfab023cda699 | efb655b2356bd95744ba19093f25ab266a625722 | refs/heads/master | 2020-09-05T08:02:44.806509 | 2019-11-06T18:01:23 | 2019-11-06T18:01:23 | 220,033,980 | 1 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 273 | h | #pragma once
#include "GameObject.h"
class CBackGround :
public CGameObject
{
public:
virtual void Init() override;
virtual void Update() override;
virtual void Render() override;
virtual void Release() override;
public:
CBackGround();
virtual ~CBackGround();
};
| [
"mermerkwon@naver.com"
] | mermerkwon@naver.com |
74eb2ed759e5f0526b3f8693ecb87f43ca9a7f10 | ffe8ff1260218c62e4800d041db3ed4e3f7ca509 | /src/CO2Sensor.cpp | d11bae44cb485666b65b7a2c8d9a160b17fe1e3c | [] | no_license | WaFaTum/TC_Tummies_21 | 3664a0d81bceb5660064e613c56d691bd7af3c56 | bb4f398e86cb476426f2b219c751f4a23e2161fa | refs/heads/main | 2023-07-06T22:26:10.704678 | 2021-08-06T22:32:43 | 2021-08-06T22:32:43 | 384,901,051 | 1 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 1,462 | cpp | #include "CO2Sensor.h"
CO2Sensor::CO2Sensor(int devAddr): deviceAddr{devAddr} {}
bool CO2Sensor::init(){
}
bool CO2Sensor::init(){
// Initialize device
this->fd = wiringPiI2CSetup(this->deviceAddr);
if(this->fd == -1)
return false;
// Check status
if (wiringPiI2CReadReg8(this->fd, this->statusReg) == 0x88){
std::cout << "Sensor initialized correctly!" << std::endl;
return true;
}
else{
std::cout << "Something is wrong with the sensor. See the Status register and documentation for more info!" << std::endl;
return false;
}
}
int CO2Sensor::singleShotMeasurement(){
// Set the sensor to a single shot measurement
wiringPiI2CWriteReg8 (this->fd, this->OpModeReg, 0x02);
// Wait until new data is available
while(wiringPiI2CReadReg8(this->fd, this->NewValReg) != 0x10){}
// Read MSB and LSB registers and return the results
uint16_t msb, lsb;
lsb = wiringPiI2CReadReg8(this->fd, this->LSBReg);
msb = wiringPiI2CReadReg8(this->fd, this->MSBReg);
return (msb << 8)+lsb;
}
void CO2Sensor::SetContiniousMeasurement(){
wiringPiI2CWriteReg8 (this->fd, this->OpModeReg, 0x02);
}
int CO2Sensor::continousMeasuremnt(){
// If there's no new value don't read
if(wiringPiI2CReadReg8(this->fd, this->NewValReg) != 0x10)
return -1;
// Read MSB and LSB registers and return the results
uint16_t msb, lsb;
lsb = wiringPiI2CReadReg8(*fd, LSBRegister);
msb = wiringPiI2CReadReg8(*fd, MSBRegister);
return (msb << 8)+lsb;
} | [
"wafalaroussi@gmail.com"
] | wafalaroussi@gmail.com |
f0ecf5468a4ac22c84f86da777648275de0c8a07 | ec1528b64b838484649188462c1f1c9b2ebc6deb | /framework/src/minko/render/DrawCallPool.cpp | faba4312e5d6832ba6c0c7ab472558c403153012 | [] | no_license | atonamy/FbxImport | 019955d316c0cbd23e260a39a34edceec118129f | 23c05ed87991ae4a444d6455a322f23561102596 | refs/heads/master | 2021-01-10T14:01:14.083112 | 2016-03-10T06:56:55 | 2016-03-10T06:56:55 | 53,478,892 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 28,628 | cpp | /*
Copyright (c) 2014 Aerys
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 "minko/render/DrawCallPool.hpp"
#include "minko/data/ResolvedBinding.hpp"
#ifdef MINKO_USE_SPARSE_HASH_MAP
# include "sparsehash/sparse_hash_map"
#endif
using namespace minko;
using namespace minko::render;
const std::vector<DrawCallPool::PropertyName> DrawCallPool::_zSortUsefulPropertyNames = {
"modelToWorldMatrix",
"material[${materialUuid}].priority",
"material[${materialUuid}].zSorted",
"geometry[${geometryUuid}].position"
};
const std::vector<DrawCallPool::PropertyName> DrawCallPool::_sortUsefulPropertyNames = {
"material[${materialUuid}].priority",
"material[${materialUuid}].zSorted",
"material[${materialUuid}].target"
};
bool
DrawCallPool::SortPropertyKeyComparator::operator()(const SortPropertyTuple& left,
const SortPropertyTuple& right) const
{
const auto leftPriority = std::get<0>(left);
const auto rightPriority = std::get<0>(right);
const bool samePriority = fabsf(leftPriority - rightPriority) < 1e-3f;
if (samePriority)
{
const auto leftTargetId = std::get<1>(left);
const auto rightTargetId = std::get<1>(right);
return leftTargetId < rightTargetId;
}
return leftPriority > rightPriority;
}
DrawCallPool::DrawCallPool() :
_batchId(0),
_drawCalls(),
_macroToDrawCalls(new MacroToDrawCallsMap()),
_invalidDrawCalls(),
_macroChangedSlot(new MacroToChangedSlotMap()),
_propChangedSlot(new PropertyChangedSlotMap()),
_drawCallToPropRebindFuncs(new PropertyRebindFuncMap()),
_sortUsefulPropertyChangedSlot(new PropertyChangedSlotMap()),
_zSortUsefulPropertyChangedSlot(new PropertyChangedSlotMap()),
_mustZSort(false)
{
#ifdef MINKO_USE_SPARSE_HASH_MAP
_macroToDrawCalls->set_deleted_key(MacroBindingKey("", nullptr, nullptr));
_macroChangedSlot->set_deleted_key(MacroBindingKey("", nullptr, nullptr));
_propChangedSlot->set_deleted_key(DrawCallKey(nullptr, nullptr));
_sortUsefulPropertyChangedSlot->set_deleted_key(DrawCallKey(nullptr, nullptr));
_zSortUsefulPropertyChangedSlot->set_deleted_key(DrawCallKey(nullptr, nullptr));
_drawCallToPropRebindFuncs->set_deleted_key(nullptr);
#endif
}
DrawCallPool::~DrawCallPool()
{
delete _macroToDrawCalls;
delete _macroChangedSlot;
delete _propChangedSlot;
delete _drawCallToPropRebindFuncs;
}
uint
DrawCallPool::addDrawCalls(Effect::Ptr effect,
const std::string& techniqueName,
const EffectVariables& variables,
data::Store& rootData,
data::Store& rendererData,
data::Store& targetData)
{
const auto& technique = effect->technique(techniqueName);
_batchId++;
for (const auto& pass : technique)
{
DrawCall* drawCall = new DrawCall(_batchId, pass, variables, rootData, rendererData, targetData);
initializeDrawCall(*drawCall);
// if the draw call is meant only for post-processing, then it should only exist once
if (!pass->isForward())
{
auto seekedDrawCall = findDrawCall(
[&](const DrawCall* d)
{
return d->program() == drawCall->program();
}
);
// FIXME: cumbersome and wasteful to completely init. a DrawCall just to discard it
if (seekedDrawCall != nullptr)
{
seekedDrawCall->batchIDs().push_back(_batchId);
delete drawCall;
continue;
}
}
addDrawCallToSortedBucket(drawCall);
}
return _batchId;
}
void
DrawCallPool::removeDrawCalls(uint batchId)
{
for (auto& priorityAndTargetIdToDrawCalls : _drawCalls)
{
for (auto& drawCalls : priorityAndTargetIdToDrawCalls.second)
{
drawCalls.erase(std::remove_if(
drawCalls.begin(),
drawCalls.end(),
[&](DrawCall* drawCall)
{
auto& batchIDs = drawCall->batchIDs();
auto it = std::find(batchIDs.begin(), batchIDs.end(), batchId);
if (it != batchIDs.end())
{
batchIDs.erase(it);
if (batchIDs.size() != 0)
return false;
unwatchProgramSignature(
*drawCall,
drawCall->pass()->macroBindings(),
drawCall->rootData(),
drawCall->rendererData(),
drawCall->targetData()
);
unbindDrawCall(*drawCall);
_invalidDrawCalls.erase(drawCall);
_drawCallsToBeSorted.erase(drawCall);
delete drawCall;
assert(_drawCallToPropRebindFuncs->count(drawCall) == 0);
for (auto it = _propChangedSlot->begin(); it != _propChangedSlot->end(); ++it)
assert(it->first.second != drawCall);
return true;
}
return false;
}
), drawCalls.end());
}
}
}
void
DrawCallPool::watchProgramSignature(DrawCall& drawCall,
const data::MacroBindingMap& macroBindings,
data::Store& rootData,
data::Store& rendererData,
data::Store& targetData)
{
for (const auto& macroNameAndBinding : macroBindings.bindings)
{
const auto& macroName = macroNameAndBinding.first;
const auto& macroBinding = macroNameAndBinding.second;
auto& store = macroBinding.source == data::Binding::Source::ROOT ? rootData
: macroBinding.source == data::Binding::Source::RENDERER ? rendererData
: targetData;
auto propertyName = Store::getActualPropertyName(drawCall.variables(), macroBinding.propertyName);
auto bindingKey = MacroBindingKey(propertyName, ¯oBinding, &store);
DrawCallList* drawCalls = _macroToDrawCalls->count(bindingKey) != 0
? (*_macroToDrawCalls)[bindingKey]
: (*_macroToDrawCalls)[bindingKey] = new DrawCallList();
assert(std::find(drawCalls->begin(), drawCalls->end(), &drawCall) == drawCalls->end());
drawCalls->push_back(&drawCall);
if (macroBindings.types.at(macroName) != data::MacroBindingMap::MacroType::UNSET)
{
addMacroCallback(
bindingKey,
store.propertyChanged(propertyName),
[&, drawCalls, this](data::Store&, data::Provider::Ptr, const data::Provider::PropertyName&)
{
macroPropertyChangedHandler(macroBinding, drawCalls);
}
);
}
else
{
auto hasProperty = store.hasProperty(propertyName);
addMacroCallback(
bindingKey,
hasProperty ? store.propertyRemoved(propertyName) : store.propertyAdded(propertyName),
[&, hasProperty, propertyName, drawCalls, this](data::Store& s, data::Provider::Ptr, const data::Provider::PropertyName& p)
{
if (hasProperty)
macroPropertyRemovedHandler(macroBinding, propertyName, s, drawCalls);
else
macroPropertyAddedHandler(macroBinding, propertyName, s, drawCalls);
}
);
}
}
}
void
DrawCallPool::addMacroCallback(const MacroBindingKey& key,
PropertyChanged& signal,
const PropertyCallback& callback)
{
//if (_macroChangedSlot->count(key) == 0)
(*_macroChangedSlot)[key] = ChangedSlot(signal.connect(callback), 1);
/*else
(*_macroChangedSlot)[key].second++;*/
}
void
DrawCallPool::removeMacroCallback(const MacroBindingKey& key)
{
if (!_macroChangedSlot->count(key))
return;
assert((*_macroChangedSlot)[key].second != 0);
(*_macroChangedSlot)[key].second--;
if ((*_macroChangedSlot)[key].second == 0)
_macroChangedSlot->erase(key);
}
bool
DrawCallPool::hasMacroCallback(const MacroBindingKey& key)
{
return _macroChangedSlot->count(key) != 0;
}
void
DrawCallPool::macroPropertyChangedHandler(const data::MacroBinding& macroBinding, const DrawCallList* drawCalls)
{
for (auto* drawCall : *drawCalls)
{
_invalidDrawCalls.emplace(drawCall, std::make_pair(false, EffectVariables()));
}
}
void
DrawCallPool::macroPropertyAddedHandler(const data::MacroBinding& macroBinding,
const PropertyName& propertyName,
data::Store& store,
const DrawCallList* drawCalls)
{
MacroBindingKey key(propertyName, ¯oBinding, &store);
removeMacroCallback(key);
addMacroCallback(
key,
store.propertyRemoved(propertyName),
[&, propertyName, drawCalls, this](data::Store& s, data::Provider::Ptr, const data::Provider::PropertyName& p)
{
macroPropertyRemovedHandler(macroBinding, propertyName, s, drawCalls);
}
);
macroPropertyChangedHandler(macroBinding, drawCalls);
}
void
DrawCallPool::macroPropertyRemovedHandler(const data::MacroBinding& macroBinding,
const PropertyName& propertyName,
data::Store& store,
const DrawCallList* drawCalls)
{
// If the store still has the property, it means that it was not really removed
// but that one of the copies of the properties was removed (ie same material added multiple
// times to the same store). Thus the macro state should not be affected.
if (store.hasProperty(propertyName))
return;
MacroBindingKey key(propertyName, ¯oBinding, &store);
removeMacroCallback(key);
addMacroCallback(
key,
store.propertyAdded(propertyName),
[&, propertyName, drawCalls, this](data::Store& s, data::Provider::Ptr, const data::Provider::PropertyName& p)
{
macroPropertyAddedHandler(macroBinding, propertyName, s, drawCalls);
}
);
macroPropertyChangedHandler(macroBinding, drawCalls);
}
void
DrawCallPool::unwatchProgramSignature(DrawCall& drawCall,
const data::MacroBindingMap& macroBindings,
data::Store& rootData,
data::Store& rendererData,
data::Store& targetData)
{
for (const auto& macroNameAndBinding : macroBindings.bindings)
{
const auto& macroBinding = macroNameAndBinding.second;
auto& store = macroBinding.source == data::Binding::Source::ROOT ? rootData
: macroBinding.source == data::Binding::Source::RENDERER ? rendererData
: targetData;
auto propertyName = Store::getActualPropertyName(drawCall.variables(), macroBinding.propertyName);
auto bindingKey = MacroBindingKey(propertyName, ¯oBinding, &store);
auto* drawCalls = (*_macroToDrawCalls)[bindingKey];
drawCalls->erase(std::remove(drawCalls->begin(), drawCalls->end(), &drawCall), drawCalls->end());
if (drawCalls->size() == 0)
{
delete drawCalls;
_macroToDrawCalls->erase(bindingKey);
}
removeMacroCallback(bindingKey);
}
}
void
DrawCallPool::initializeDrawCall(DrawCall& drawCall, bool forceRebind)
{
auto invalidDrawCallIt = _invalidDrawCalls.find(&drawCall);
const auto variablesChanged = invalidDrawCallIt != _invalidDrawCalls.end() &&
invalidDrawCallIt->second.first;
auto newVariables = EffectVariables();
if (variablesChanged)
newVariables = invalidDrawCallIt->second.second;
const auto& variables = variablesChanged
? newVariables
: drawCall.variables();
auto pass = drawCall.pass();
auto programAndSignature = pass->selectProgram(
variables, drawCall.targetData(), drawCall.rendererData(), drawCall.rootData()
);
auto program = programAndSignature.first;
if (program == drawCall.program())
{
if (variablesChanged)
drawCall.variables().assign(variables.begin(), variables.end());
return;
}
if (drawCall.program())
{
unwatchProgramSignature(
drawCall,
drawCall.pass()->macroBindings(),
drawCall.rootData(),
drawCall.rendererData(),
drawCall.targetData()
);
unbindDrawCall(drawCall);
}
if (variablesChanged)
drawCall.variables().assign(variables.begin(), variables.end());
bindDrawCall(drawCall, pass, program, forceRebind);
if (programAndSignature.second != nullptr)
{
watchProgramSignature(
drawCall,
drawCall.pass()->macroBindings(),
drawCall.rootData(),
drawCall.rendererData(),
drawCall.targetData()
);
}
}
void
DrawCallPool::uniformBindingPropertyAddedHandler(DrawCall& drawCall,
const ProgramInputs::UniformInput& input,
const data::BindingMap& uniformBindingMap,
bool forceRebind)
{
if (!forceRebind && _invalidDrawCalls.find(&drawCall) != _invalidDrawCalls.end())
return;
data::ResolvedBinding* resolvedBinding = drawCall.bindUniform(
input, uniformBindingMap.bindings, uniformBindingMap.defaultValues
);
if (resolvedBinding != nullptr)
{
auto& propertyName = resolvedBinding->propertyName;
auto bindingPtr = &resolvedBinding->binding;
auto propertyExist = resolvedBinding->store.hasProperty(propertyName);
auto& signal = propertyExist
? resolvedBinding->store.propertyRemoved(propertyName)
: resolvedBinding->store.propertyAdded(propertyName);
_propChangedSlot->insert(std::make_pair(
std::make_pair(bindingPtr, &drawCall),
signal.connect(
[&, bindingPtr](data::Store&, data::Provider::Ptr, const data::Provider::PropertyName&)
{
_propChangedSlot->erase({ bindingPtr, &drawCall });
(*_drawCallToPropRebindFuncs)[&drawCall].push_back(
[&, forceRebind, this]()
{
uniformBindingPropertyAddedHandler(drawCall, input, uniformBindingMap, forceRebind);
}
);
}
)
));
// If this draw call needs to be sorted
// => we listen to the useful properties
if (propertyExist && drawCall.zSorted())
{
auto propertyRelatedToZSortIt = std::find_if(
_zSortUsefulPropertyNames.begin(),
_zSortUsefulPropertyNames.end(),
[&](const PropertyName& zSortUsefulPropertyName) -> bool
{
return
data::Store::getActualPropertyName(drawCall.variables(), zSortUsefulPropertyName) ==
propertyName;
}
);
if (propertyRelatedToZSortIt != _zSortUsefulPropertyNames.end())
{
// Bind the signal to request a Z-sorting if one of these properties changed
_zSortUsefulPropertyChangedSlot->insert(
std::make_pair(
std::make_pair(bindingPtr, &drawCall),
resolvedBinding->store.propertyChanged(propertyName).connect(
[&](data::Store&, data::Provider::Ptr, const data::Provider::PropertyName&)
{
_mustZSort = true;
}
)
)
);
}
}
delete resolvedBinding;
}
if (input.type == ProgramInputs::Type::sampler2d || input.type == ProgramInputs::Type::samplerCube)
samplerStatesBindingPropertyAddedHandler(drawCall, input, uniformBindingMap);
}
void
DrawCallPool::samplerStatesBindingPropertyAddedHandler(DrawCall& drawCall,
const ProgramInputs::UniformInput& input,
const data::BindingMap& uniformBindingMap)
{
auto resolvedBindings = drawCall.bindSamplerStates(
input, uniformBindingMap.bindings, uniformBindingMap.defaultValues
);
for (auto resolvedBinding : resolvedBindings)
{
if (resolvedBinding != nullptr)
{
auto& propertyName = resolvedBinding->propertyName;
auto& signal = resolvedBinding->store.hasProperty(propertyName)
? resolvedBinding->store.propertyRemoved(propertyName)
: resolvedBinding->store.propertyAdded(propertyName);
_propChangedSlot->insert(std::make_pair(
std::make_pair(&resolvedBinding->binding, &drawCall),
signal.connect(
[&](data::Store&, data::Provider::Ptr, const data::Provider::PropertyName&)
{
(*_drawCallToPropRebindFuncs)[&drawCall].push_back(
[&, this]()
{
samplerStatesBindingPropertyAddedHandler(drawCall, input, uniformBindingMap);
}
);
}
)
));
delete resolvedBinding;
}
}
}
void
DrawCallPool::stateBindingPropertyAddedHandler(const std::string& stateName,
DrawCall& drawCall,
const data::BindingMap& stateBindingMap,
bool forceRebind)
{
if (!forceRebind && _invalidDrawCalls.find(&drawCall) != _invalidDrawCalls.end())
return;
auto resolvedBinding = drawCall.bindState(stateName, stateBindingMap.bindings, stateBindingMap.defaultValues);
if (resolvedBinding != nullptr)
{
auto bindingPtr = &resolvedBinding->binding;
auto& propertyName = resolvedBinding->propertyName;
auto& signal = resolvedBinding->store.hasProperty(propertyName)
? resolvedBinding->store.propertyRemoved(propertyName)
: resolvedBinding->store.propertyAdded(propertyName);
_propChangedSlot->insert(
std::make_pair(
std::make_pair(&resolvedBinding->binding, &drawCall),
signal.connect(
[&, bindingPtr](data::Store&, data::Provider::Ptr, const data::Provider::PropertyName&)
{
_propChangedSlot->erase({ bindingPtr, &drawCall });
(*_drawCallToPropRebindFuncs)[&drawCall].push_back(
[&, forceRebind, this]()
{
stateBindingPropertyAddedHandler(stateName, drawCall, stateBindingMap, forceRebind);
});
})
)
);
auto propertyRelatedToSortIt = std::find_if(
_sortUsefulPropertyNames.begin(),
_sortUsefulPropertyNames.end(),
[&](const PropertyName& sortUsefulPropertyName) -> bool
{
return
data::Store::getActualPropertyName(drawCall.variables(), sortUsefulPropertyName) ==
propertyName;
}
);
if (propertyRelatedToSortIt != _sortUsefulPropertyNames.end())
{
_sortUsefulPropertyChangedSlot->insert(
std::make_pair(
std::make_pair(bindingPtr, &drawCall),
resolvedBinding->store.propertyChanged(propertyName).connect(
[&](data::Store&, data::Provider::Ptr, const data::Provider::PropertyName&)
{
_drawCallsToBeSorted.insert(&drawCall);
}
)
)
);
}
delete resolvedBinding;
}
}
void
DrawCallPool::update(bool forceSort, bool mustZSort)
{
for (auto& invalidDrawCall : _invalidDrawCalls)
{
auto* drawCallPtr = invalidDrawCall.first;
initializeDrawCall(*drawCallPtr, true);
}
_invalidDrawCalls.clear();
for (auto drawCallPtrAndFuncList : *_drawCallToPropRebindFuncs)
{
for (auto& func : drawCallPtrAndFuncList.second)
func();
}
_drawCallToPropRebindFuncs->clear();
#ifdef MINKO_USE_SPARSE_HASH_MAP
_drawCallToPropRebindFuncs->resize(0);
#endif
for (auto drawCall : _drawCallsToBeSorted)
{
removeDrawCallFromSortedBucket(drawCall);
addDrawCallToSortedBucket(drawCall);
}
_drawCallsToBeSorted.clear();
const auto finalMustZSort = forceSort || _mustZSort || mustZSort;
if (finalMustZSort)
{
_mustZSort = false;
zSortDrawCalls();
}
}
void
DrawCallPool::invalidateDrawCalls(uint batchId, const EffectVariables& variables)
{
foreachDrawCall(
[&](DrawCall* drawCall)
{
auto& batchIDs = drawCall->batchIDs();
auto it = std::find(batchIDs.begin(), batchIDs.end(), batchId);
if (it != batchIDs.end())
{
_invalidDrawCalls[drawCall] = std::make_pair(true, variables);
}
}
);
}
void
DrawCallPool::clear()
{
_drawCalls.clear();
_macroToDrawCalls->clear();
#ifdef MINKO_USE_SPARSE_HASH_MAP
_macroToDrawCalls->resize(0);
#endif
_invalidDrawCalls.clear();
_macroChangedSlot->clear();
#ifdef MINKO_USE_SPARSE_HASH_MAP
_macroChangedSlot->resize(0);
#endif
_propChangedSlot->clear();
#ifdef MINKO_USE_SPARSE_HASH_MAP
_propChangedSlot->resize(0);
#endif
_sortUsefulPropertyChangedSlot->clear();
#ifdef MINKO_USE_SPARSE_HASH_MAP
_sortUsefulPropertyChangedSlot->resize(0);
#endif
_zSortUsefulPropertyChangedSlot->clear();
#ifdef MINKO_USE_SPARSE_HASH_MAP
_zSortUsefulPropertyChangedSlot->resize(0);
#endif
_drawCallToPropRebindFuncs->clear();
#ifdef MINKO_USE_SPARSE_HASH_MAP
_drawCallToPropRebindFuncs->resize(0);
#endif
_drawCallsToBeSorted.clear();
}
void
DrawCallPool::addDrawCallToSortedBucket(DrawCall* drawCall)
{
const auto priority = drawCall->priority();
const auto targetId = drawCall->target().id;
const auto zSortedIndex = drawCall->zSorted() ? 1u : 0u;
_drawCalls[SortPropertyTuple(priority, targetId)][zSortedIndex].push_back(drawCall);
}
void
DrawCallPool::removeDrawCallFromSortedBucket(DrawCall* drawCall)
{
for (auto& sortPropertiesToDrawCalls : _drawCalls)
{
for (auto& drawCalls : sortPropertiesToDrawCalls.second)
{
drawCalls.erase(
std::remove(drawCalls.begin(), drawCalls.end(), drawCall),
drawCalls.end()
);
}
}
}
DrawCall*
DrawCallPool::findDrawCall(const std::function<bool(DrawCall*)>& predicate)
{
for (const auto& sortPropertiesToDrawCalls : _drawCalls)
{
for (const auto& drawCalls : sortPropertiesToDrawCalls.second)
{
for (auto drawCall : drawCalls)
{
if (predicate(drawCall))
return drawCall;
}
}
}
return nullptr;
}
void
DrawCallPool::foreachDrawCall(const std::function<void(DrawCall*)>& function)
{
for (const auto& sortPropertiesToDrawCalls : _drawCalls)
{
for (const auto& drawCalls : sortPropertiesToDrawCalls.second)
{
for (auto drawCall : drawCalls)
{
function(drawCall);
}
}
}
}
unsigned int
DrawCallPool::numDrawCalls() const
{
auto numDrawCalls = 0u;
for (const auto& sortPropertiesToDrawCalls : _drawCalls)
{
for (const auto& drawCalls : sortPropertiesToDrawCalls.second)
{
numDrawCalls += drawCalls.size();
}
}
return numDrawCalls;
}
void
DrawCallPool::bindDrawCall(DrawCall& drawCall, Pass::Ptr pass, Program::Ptr program, bool forceRebind)
{
drawCall.bind(program);
// bind attributes
// FIXME: like for uniforms, watch and swap default values / binding value
for (const auto& input : program->inputs().attributes())
drawCall.bindAttribute(input, pass->attributeBindings().bindings, pass->attributeBindings().defaultValues);
// bind states
for (const auto& stateName : States::PROPERTY_NAMES)
stateBindingPropertyAddedHandler(stateName, drawCall, pass->stateBindings(), forceRebind);
// bind uniforms
for (const auto& input : program->inputs().uniforms())
uniformBindingPropertyAddedHandler(drawCall, input, pass->uniformBindings(), forceRebind);
// bind index buffer
if (!!pass->isForward())
drawCall.bindIndexBuffer();
}
void
DrawCallPool::unbindDrawCall(DrawCall& drawCall)
{
for (auto it = _propChangedSlot->begin(); it != _propChangedSlot->end();)
{
if (it->first.second == &drawCall)
_propChangedSlot->erase(it++);
else
++it;
}
//_propChangedSlot->clear();
for (auto it = _sortUsefulPropertyChangedSlot->begin(); it != _sortUsefulPropertyChangedSlot->end();)
{
if (it->first.second == &drawCall)
_sortUsefulPropertyChangedSlot->erase(it++);
else
++it;
}
for (auto it = _zSortUsefulPropertyChangedSlot->begin(); it != _zSortUsefulPropertyChangedSlot->end();)
{
if (it->first.second == &drawCall)
_zSortUsefulPropertyChangedSlot->erase(it++);
else
++it;
}
_drawCallToPropRebindFuncs->erase(&drawCall);
//_drawCallToPropRebindFuncs->clear();
}
bool
DrawCallPool::compareZSortedDrawCalls(DrawCall* a, DrawCall* b)
{
const auto aPosition = a->getEyeSpacePosition();
const auto bPosition = b->getEyeSpacePosition();
return aPosition.z > bPosition.z;
}
void
DrawCallPool::zSortDrawCalls()
{
for (auto& sortPropertiesToDrawCalls : _drawCalls)
{
auto& drawCalls = sortPropertiesToDrawCalls.second.at(1u);
std::sort(
drawCalls.begin(),
drawCalls.end(),
compareZSortedDrawCalls
);
}
}
| [
"archie@coinpip.com"
] | archie@coinpip.com |
d88145cc32bd3d749e81cf468ff6e98929fb73d0 | f1bbe8d82a104f945973fa7299813d8892f7cc32 | /src/qt/aezora/receivedialog.h | 1dd7c26615ef7d014d037c1effb1f30dcb9342fd | [
"MIT"
] | permissive | wukki16/Aezora | a9cd76ca9c11ca7f92ec541a34e4f3c3ed4ff855 | a4204bbe1370933eab7de5313573dafc193db3ed | refs/heads/master | 2022-12-31T19:02:55.062154 | 2020-10-12T18:47:42 | 2020-10-12T18:47:42 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 702 | h | // Copyright (c) 2019 The AEZORA developers
// Distributed under the MIT software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
#ifndef RECEIVEDIALOG_H
#define RECEIVEDIALOG_H
#include "qt/aezora/focuseddialog.h"
#include <QPixmap>
class SendCoinsRecipient;
namespace Ui {
class ReceiveDialog;
}
class ReceiveDialog : public FocusedDialog
{
Q_OBJECT
public:
explicit ReceiveDialog(QWidget *parent = nullptr);
~ReceiveDialog();
void updateQr(QString address);
private Q_SLOTS:
void onCopy();
private:
Ui::ReceiveDialog *ui;
QPixmap *qrImage;
SendCoinsRecipient *info = nullptr;
};
#endif // RECEIVEDIALOG_H
| [
"59030118+Aezora@users.noreply.github.com"
] | 59030118+Aezora@users.noreply.github.com |
7bf737599c73fae4b185a4ac82835901efd34f7b | 942ea59a9bcbeacceb6b8d63b65da64d2d716810 | /StreamCopyFile.cpp | f4345d4467340444fa4f33b3ddd36b95866f4c23 | [] | no_license | PiangGG/CppStandardText | 192854f5c64ec4401e929c4d7a084cad3bc23a1c | e2f79bab3248077475059fb384354e26d43f5dc3 | refs/heads/master | 2023-02-06T02:15:19.735766 | 2020-12-30T03:30:50 | 2020-12-30T03:30:50 | 323,780,734 | 0 | 0 | null | null | null | null | GB18030 | C++ | false | false | 173 | cpp | #include <iostream>
/*
@author piang
透过"C++I/O Stream 来复制文件"
*/
using namespace std;
int _main_5()
{
std::cout << std::cin.rdbuf() << std::endl;
return 0;
} | [
"piangpiangpiang@outlook.com"
] | piangpiangpiang@outlook.com |
635091e2c1b2c0b3754ccdaaf2a8ec48f26b59f0 | 2465d5aac8230436d3a08383a722d6437e97ac40 | /SDK/PUBG_Foliage_classes.hpp | 260fffda9290b2a3ec3c0613ae7ca8a967fd6ca6 | [] | no_license | xuhao1/PUBG-SDK | 9684baf0471678eaf366de3b3ca5f933ace357ab | 5f0041ef5ad7f16111361316fa8dff1ad4647993 | refs/heads/master | 2021-08-14T13:32:37.783490 | 2017-11-15T20:56:12 | 2017-11-15T20:56:12 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 26,611 | hpp | #pragma once
// PlayerUnknown's Battlegrounds SDK
#ifdef _MSC_VER
#pragma pack(push, 0x8)
#endif
namespace Classes
{
//---------------------------------------------------------------------------
//Classes
//---------------------------------------------------------------------------
// Class Foliage.FoliageInstancedStaticMeshComponent
// 0x0020 (0x0A00 - 0x09E0)
class UFoliageInstancedStaticMeshComponent : public UHierarchicalInstancedStaticMeshComponent
{
public:
unsigned char UnknownData00[0x8]; // 0x09E0(0x0008) MISSED OFFSET
struct FScriptMulticastDelegate OnInstanceTakeRadialDamage; // 0x09E8(0x0010) (CPF_ZeroConstructor, CPF_InstancedReference, CPF_BlueprintAssignable)
unsigned char UnknownData01[0x8]; // 0x09F8(0x0008) MISSED OFFSET
static UClass* StaticClass()
{
static UClass* ptr = nullptr;
if (!ptr) ptr = UObject::FindClass(0xb057c160);
return ptr;
}
};
// Class Foliage.FoliageStatistics
// 0x0000 (0x0028 - 0x0028)
class UFoliageStatistics : public UBlueprintFunctionLibrary
{
public:
static UClass* StaticClass()
{
static UClass* ptr = nullptr;
if (!ptr) ptr = UObject::FindClass(0x9c9a4e);
return ptr;
}
int STATIC_FoliageOverlappingSphereCount(class UObject* WorldContextObject, class UStaticMesh* StaticMesh, const struct FVector& CenterPosition, float Radius);
int STATIC_FoliageOverlappingBoxCount(class UObject* WorldContextObject, class UStaticMesh* StaticMesh, const struct FBox& Box);
};
// Class Foliage.FoliageType
// 0x03A8 (0x03D0 - 0x0028)
class UFoliageType : public UObject
{
public:
struct FGuid UpdateGuid; // 0x0028(0x0010) (CPF_ZeroConstructor, CPF_IsPlainOldData)
float Density; // 0x0038(0x0004) (CPF_Edit, CPF_ZeroConstructor, CPF_IsPlainOldData)
float DensityAdjustmentFactor; // 0x003C(0x0004) (CPF_Edit, CPF_ZeroConstructor, CPF_IsPlainOldData)
float Radius; // 0x0040(0x0004) (CPF_Edit, CPF_ZeroConstructor, CPF_IsPlainOldData)
TEnumAsByte<EFoliageScaling> Scaling; // 0x0044(0x0001) (CPF_Edit, CPF_ZeroConstructor, CPF_IsPlainOldData)
unsigned char UnknownData00[0x3]; // 0x0045(0x0003) MISSED OFFSET
struct FFloatInterval ScaleX; // 0x0048(0x0008) (CPF_Edit, CPF_ZeroConstructor, CPF_IsPlainOldData)
struct FFloatInterval ScaleY; // 0x0050(0x0008) (CPF_Edit, CPF_ZeroConstructor, CPF_IsPlainOldData)
struct FFloatInterval ScaleZ; // 0x0058(0x0008) (CPF_Edit, CPF_ZeroConstructor, CPF_IsPlainOldData)
struct FFoliageVertexColorChannelMask VertexColorMaskByChannel[0x4]; // 0x0060(0x000C) (CPF_Edit)
TEnumAsByte<EFoliageVertexColorMask> VertexColorMask; // 0x0090(0x0001) (CPF_ZeroConstructor, CPF_Deprecated, CPF_IsPlainOldData)
unsigned char UnknownData01[0x3]; // 0x0091(0x0003) MISSED OFFSET
float VertexColorMaskThreshold; // 0x0094(0x0004) (CPF_ZeroConstructor, CPF_Deprecated, CPF_IsPlainOldData)
unsigned char VertexColorMaskInvert : 1; // 0x0098(0x0001) (CPF_Deprecated)
unsigned char UnknownData02[0x3]; // 0x0099(0x0003) MISSED OFFSET
struct FFloatInterval ZOffset; // 0x009C(0x0008) (CPF_Edit, CPF_ZeroConstructor, CPF_IsPlainOldData)
unsigned char AlignToNormal : 1; // 0x00A4(0x0001) (CPF_Edit)
unsigned char UnknownData03[0x3]; // 0x00A5(0x0003) MISSED OFFSET
float AlignMaxAngle; // 0x00A8(0x0004) (CPF_Edit, CPF_ZeroConstructor, CPF_IsPlainOldData)
unsigned char RandomYaw : 1; // 0x00AC(0x0001) (CPF_Edit)
unsigned char UnknownData04[0x3]; // 0x00AD(0x0003) MISSED OFFSET
float RandomPitchAngle; // 0x00B0(0x0004) (CPF_Edit, CPF_ZeroConstructor, CPF_IsPlainOldData)
struct FFloatInterval GroundSlopeAngle; // 0x00B4(0x0008) (CPF_Edit, CPF_ZeroConstructor, CPF_IsPlainOldData)
struct FFloatInterval Height; // 0x00BC(0x0008) (CPF_Edit, CPF_ZeroConstructor, CPF_IsPlainOldData)
unsigned char UnknownData05[0x4]; // 0x00C4(0x0004) MISSED OFFSET
TArray<struct FName> LandscapeLayers; // 0x00C8(0x0010) (CPF_Edit, CPF_ZeroConstructor)
struct FName LandscapeLayer; // 0x00D8(0x0008) (CPF_ZeroConstructor, CPF_Deprecated, CPF_IsPlainOldData)
unsigned char CollisionWithWorld : 1; // 0x00E0(0x0001) (CPF_Edit)
unsigned char UnknownData06[0x3]; // 0x00E1(0x0003) MISSED OFFSET
struct FVector CollisionScale; // 0x00E4(0x000C) (CPF_Edit, CPF_ZeroConstructor, CPF_IsPlainOldData)
float MinimumLayerWeight; // 0x00F0(0x0004) (CPF_Edit, CPF_ZeroConstructor, CPF_IsPlainOldData)
struct FBoxSphereBounds MeshBounds; // 0x00F4(0x001C) (CPF_ZeroConstructor, CPF_IsPlainOldData)
struct FVector LowBoundOriginRadius; // 0x0110(0x000C) (CPF_ZeroConstructor, CPF_IsPlainOldData)
TEnumAsByte<EComponentMobility> Mobility; // 0x011C(0x0001) (CPF_Edit, CPF_BlueprintVisible, CPF_BlueprintReadOnly, CPF_ZeroConstructor, CPF_IsPlainOldData)
unsigned char UnknownData07[0x3]; // 0x011D(0x0003) MISSED OFFSET
struct FInt32Interval CullDistance; // 0x0120(0x0008) (CPF_Edit, CPF_ZeroConstructor, CPF_IsPlainOldData)
unsigned char bEnableStaticLighting : 1; // 0x0128(0x0001) (CPF_Deprecated)
unsigned char CastShadow : 1; // 0x0128(0x0001) (CPF_Edit, CPF_BlueprintVisible, CPF_BlueprintReadOnly)
unsigned char bAffectDynamicIndirectLighting : 1; // 0x0128(0x0001) (CPF_Edit, CPF_BlueprintVisible, CPF_BlueprintReadOnly)
unsigned char bAffectDistanceFieldLighting : 1; // 0x0128(0x0001) (CPF_Edit, CPF_BlueprintVisible, CPF_BlueprintReadOnly)
unsigned char bCastDynamicShadow : 1; // 0x0128(0x0001) (CPF_Edit, CPF_BlueprintVisible, CPF_BlueprintReadOnly)
unsigned char bCastStaticShadow : 1; // 0x0128(0x0001) (CPF_Edit, CPF_BlueprintVisible, CPF_BlueprintReadOnly)
unsigned char bCastShadowAsTwoSided : 1; // 0x0128(0x0001) (CPF_Edit, CPF_BlueprintVisible, CPF_BlueprintReadOnly)
unsigned char bReceivesDecals : 1; // 0x0128(0x0001) (CPF_Edit, CPF_BlueprintVisible, CPF_BlueprintReadOnly)
unsigned char bOverrideLightMapRes : 1; // 0x0129(0x0001) (CPF_Edit, CPF_BlueprintVisible, CPF_BlueprintReadOnly)
unsigned char UnknownData08[0x2]; // 0x012A(0x0002) MISSED OFFSET
int OverriddenLightMapRes; // 0x012C(0x0004) (CPF_Edit, CPF_BlueprintVisible, CPF_BlueprintReadOnly, CPF_ZeroConstructor, CPF_IsPlainOldData)
unsigned char bUseAsOccluder : 1; // 0x0130(0x0001) (CPF_Edit, CPF_BlueprintVisible, CPF_BlueprintReadOnly)
unsigned char UnknownData09[0xF]; // 0x0131(0x000F) MISSED OFFSET
struct FBodyInstance BodyInstance; // 0x0140(0x01C0) (CPF_Edit)
TEnumAsByte<EHasCustomNavigableGeometry> CustomNavigableGeometry; // 0x0300(0x0001) (CPF_Edit, CPF_ZeroConstructor, CPF_IsPlainOldData)
struct FLightingChannels LightingChannels; // 0x0301(0x0003) (CPF_Edit, CPF_BlueprintVisible, CPF_BlueprintReadOnly)
float CollisionRadius; // 0x0304(0x0004) (CPF_Edit, CPF_ZeroConstructor, CPF_IsPlainOldData)
float ShadeRadius; // 0x0308(0x0004) (CPF_Edit, CPF_ZeroConstructor, CPF_IsPlainOldData)
int NumSteps; // 0x030C(0x0004) (CPF_Edit, CPF_ZeroConstructor, CPF_IsPlainOldData)
float InitialSeedDensity; // 0x0310(0x0004) (CPF_Edit, CPF_ZeroConstructor, CPF_IsPlainOldData)
float AverageSpreadDistance; // 0x0314(0x0004) (CPF_Edit, CPF_ZeroConstructor, CPF_IsPlainOldData)
float SpreadVariance; // 0x0318(0x0004) (CPF_Edit, CPF_ZeroConstructor, CPF_IsPlainOldData)
int SeedsPerStep; // 0x031C(0x0004) (CPF_Edit, CPF_ZeroConstructor, CPF_IsPlainOldData)
int DistributionSeed; // 0x0320(0x0004) (CPF_Edit, CPF_ZeroConstructor, CPF_IsPlainOldData)
float MaxInitialSeedOffset; // 0x0324(0x0004) (CPF_Edit, CPF_ZeroConstructor, CPF_IsPlainOldData)
bool bCanGrowInShade; // 0x0328(0x0001) (CPF_Edit, CPF_ZeroConstructor, CPF_IsPlainOldData)
bool bSpawnsInShade; // 0x0329(0x0001) (CPF_Edit, CPF_ZeroConstructor, CPF_IsPlainOldData)
unsigned char UnknownData10[0x2]; // 0x032A(0x0002) MISSED OFFSET
float MaxInitialAge; // 0x032C(0x0004) (CPF_Edit, CPF_ZeroConstructor, CPF_IsPlainOldData)
float MaxAge; // 0x0330(0x0004) (CPF_Edit, CPF_ZeroConstructor, CPF_IsPlainOldData)
float OverlapPriority; // 0x0334(0x0004) (CPF_Edit, CPF_ZeroConstructor, CPF_IsPlainOldData)
struct FFloatInterval ProceduralScale; // 0x0338(0x0008) (CPF_Edit, CPF_ZeroConstructor, CPF_IsPlainOldData)
struct FRuntimeFloatCurve ScaleCurve; // 0x0340(0x0080) (CPF_Edit)
int ChangeCount; // 0x03C0(0x0004) (CPF_ZeroConstructor, CPF_IsPlainOldData)
unsigned char ReapplyDensity : 1; // 0x03C4(0x0001) (CPF_Edit, CPF_DisableEditOnInstance)
unsigned char ReapplyRadius : 1; // 0x03C4(0x0001) (CPF_Edit, CPF_DisableEditOnInstance)
unsigned char ReapplyAlignToNormal : 1; // 0x03C4(0x0001) (CPF_Edit, CPF_DisableEditOnInstance)
unsigned char ReapplyRandomYaw : 1; // 0x03C4(0x0001) (CPF_Edit, CPF_DisableEditOnInstance)
unsigned char ReapplyScaling : 1; // 0x03C4(0x0001) (CPF_Edit, CPF_DisableEditOnInstance)
unsigned char ReapplyScaleX : 1; // 0x03C4(0x0001) (CPF_Edit, CPF_DisableEditOnInstance)
unsigned char ReapplyScaleY : 1; // 0x03C4(0x0001) (CPF_Edit, CPF_DisableEditOnInstance)
unsigned char ReapplyScaleZ : 1; // 0x03C4(0x0001) (CPF_Edit, CPF_DisableEditOnInstance)
unsigned char ReapplyRandomPitchAngle : 1; // 0x03C5(0x0001) (CPF_Edit, CPF_DisableEditOnInstance)
unsigned char ReapplyGroundSlope : 1; // 0x03C5(0x0001) (CPF_Edit, CPF_DisableEditOnInstance)
unsigned char ReapplyHeight : 1; // 0x03C5(0x0001) (CPF_Edit, CPF_DisableEditOnInstance)
unsigned char ReapplyLandscapeLayers : 1; // 0x03C5(0x0001) (CPF_Edit, CPF_DisableEditOnInstance)
unsigned char ReapplyZOffset : 1; // 0x03C5(0x0001) (CPF_Edit, CPF_DisableEditOnInstance)
unsigned char ReapplyCollisionWithWorld : 1; // 0x03C5(0x0001) (CPF_Edit, CPF_DisableEditOnInstance)
unsigned char ReapplyVertexColorMask : 1; // 0x03C5(0x0001) (CPF_Edit, CPF_DisableEditOnInstance)
unsigned char bEnableDensityScaling : 1; // 0x03C5(0x0001) (CPF_Edit)
unsigned char UnknownData11[0xA]; // 0x03C6(0x000A) MISSED OFFSET
static UClass* StaticClass()
{
static UClass* ptr = nullptr;
if (!ptr) ptr = UObject::FindClass(0x61fe5667);
return ptr;
}
};
// Class Foliage.FoliageType_InstancedStaticMesh
// 0x0020 (0x03F0 - 0x03D0)
class UFoliageType_InstancedStaticMesh : public UFoliageType
{
public:
TArray<class UMaterialInterface*> OverrideMaterials; // 0x03D0(0x0010) (CPF_Edit, CPF_ZeroConstructor)
class UClass* ComponentClass; // 0x03E0(0x0008) (CPF_Edit, CPF_ZeroConstructor, CPF_IsPlainOldData)
unsigned char UnknownData00[0x8]; // 0x03E8(0x0008) MISSED OFFSET
static UClass* StaticClass()
{
static UClass* ptr = nullptr;
if (!ptr) ptr = UObject::FindClass(0x27dd4984);
return ptr;
}
};
// Class Foliage.InstancedFoliageActor
// 0x0050 (0x03F0 - 0x03A0)
class AInstancedFoliageActor : public AActor
{
public:
unsigned char UnknownData00[0x50]; // 0x03A0(0x0050) MISSED OFFSET
static UClass* StaticClass()
{
static UClass* ptr = nullptr;
if (!ptr) ptr = UObject::FindClass(0x19f5);
return ptr;
}
};
// Class Foliage.InteractiveFoliageActor
// 0x0060 (0x0410 - 0x03B0)
class AInteractiveFoliageActor : public AStaticMeshActor
{
public:
class UCapsuleComponent* CapsuleComponent; // 0x03B0(0x0008) (CPF_ExportObject, CPF_ZeroConstructor, CPF_InstancedReference, CPF_IsPlainOldData)
struct FVector TouchingActorEntryPosition; // 0x03B8(0x000C) (CPF_ZeroConstructor, CPF_Transient, CPF_IsPlainOldData)
struct FVector FoliageVelocity; // 0x03C4(0x000C) (CPF_ZeroConstructor, CPF_Transient, CPF_IsPlainOldData)
struct FVector FoliageForce; // 0x03D0(0x000C) (CPF_ZeroConstructor, CPF_Transient, CPF_IsPlainOldData)
struct FVector FoliagePosition; // 0x03DC(0x000C) (CPF_ZeroConstructor, CPF_Transient, CPF_IsPlainOldData)
float FoliageDamageImpulseScale; // 0x03E8(0x0004) (CPF_Edit, CPF_BlueprintVisible, CPF_ZeroConstructor, CPF_IsPlainOldData)
float FoliageTouchImpulseScale; // 0x03EC(0x0004) (CPF_Edit, CPF_BlueprintVisible, CPF_ZeroConstructor, CPF_IsPlainOldData)
float FoliageStiffness; // 0x03F0(0x0004) (CPF_Edit, CPF_BlueprintVisible, CPF_ZeroConstructor, CPF_IsPlainOldData)
float FoliageStiffnessQuadratic; // 0x03F4(0x0004) (CPF_Edit, CPF_BlueprintVisible, CPF_ZeroConstructor, CPF_IsPlainOldData)
float FoliageDamping; // 0x03F8(0x0004) (CPF_Edit, CPF_BlueprintVisible, CPF_ZeroConstructor, CPF_IsPlainOldData)
float MaxDamageImpulse; // 0x03FC(0x0004) (CPF_Edit, CPF_BlueprintVisible, CPF_ZeroConstructor, CPF_IsPlainOldData)
float MaxTouchImpulse; // 0x0400(0x0004) (CPF_Edit, CPF_BlueprintVisible, CPF_ZeroConstructor, CPF_IsPlainOldData)
float MaxForce; // 0x0404(0x0004) (CPF_Edit, CPF_BlueprintVisible, CPF_ZeroConstructor, CPF_IsPlainOldData)
float Mass; // 0x0408(0x0004) (CPF_ZeroConstructor, CPF_IsPlainOldData)
unsigned char UnknownData00[0x4]; // 0x040C(0x0004) MISSED OFFSET
static UClass* StaticClass()
{
static UClass* ptr = nullptr;
if (!ptr) ptr = UObject::FindClass(0x7593ce4e);
return ptr;
}
void CapsuleTouched(class UPrimitiveComponent* OverlappedComp, class AActor* Other, class UPrimitiveComponent* OtherComp, int OtherBodyIndex, bool bFromSweep, const struct FHitResult& OverlapInfo);
};
// Class Foliage.InteractiveFoliageComponent
// 0x0000 (0x0810 - 0x0810)
class UInteractiveFoliageComponent : public UStaticMeshComponent
{
public:
static UClass* StaticClass()
{
static UClass* ptr = nullptr;
if (!ptr) ptr = UObject::FindClass(0xb1808720);
return ptr;
}
};
// Class Foliage.ProceduralFoliageBlockingVolume
// 0x0008 (0x03E0 - 0x03D8)
class AProceduralFoliageBlockingVolume : public AVolume
{
public:
class AProceduralFoliageVolume* ProceduralFoliageVolume; // 0x03D8(0x0008) (CPF_Edit, CPF_ZeroConstructor, CPF_IsPlainOldData)
static UClass* StaticClass()
{
static UClass* ptr = nullptr;
if (!ptr) ptr = UObject::FindClass(0x30eb4227);
return ptr;
}
};
// Class Foliage.ProceduralFoliageComponent
// 0x0028 (0x0120 - 0x00F8)
class UProceduralFoliageComponent : public UActorComponent
{
public:
class UProceduralFoliageSpawner* FoliageSpawner; // 0x00F8(0x0008) (CPF_Edit, CPF_BlueprintVisible, CPF_ZeroConstructor, CPF_IsPlainOldData)
float TileOverlap; // 0x0100(0x0004) (CPF_Edit, CPF_BlueprintVisible, CPF_ZeroConstructor, CPF_IsPlainOldData)
unsigned char UnknownData00[0x4]; // 0x0104(0x0004) MISSED OFFSET
class AVolume* SpawningVolume; // 0x0108(0x0008) (CPF_ZeroConstructor, CPF_IsPlainOldData)
struct FGuid ProceduralGuid; // 0x0110(0x0010) (CPF_ZeroConstructor, CPF_IsPlainOldData)
static UClass* StaticClass()
{
static UClass* ptr = nullptr;
if (!ptr) ptr = UObject::FindClass(0x9b0299d9);
return ptr;
}
};
// Class Foliage.ProceduralFoliageSpawner
// 0x0048 (0x0070 - 0x0028)
class UProceduralFoliageSpawner : public UObject
{
public:
int RandomSeed; // 0x0028(0x0004) (CPF_Edit, CPF_BlueprintVisible, CPF_BlueprintReadOnly, CPF_ZeroConstructor, CPF_IsPlainOldData)
float TileSize; // 0x002C(0x0004) (CPF_Edit, CPF_BlueprintVisible, CPF_BlueprintReadOnly, CPF_ZeroConstructor, CPF_IsPlainOldData)
int NumUniqueTiles; // 0x0030(0x0004) (CPF_Edit, CPF_BlueprintVisible, CPF_BlueprintReadOnly, CPF_ZeroConstructor, CPF_IsPlainOldData)
float MinimumQuadTreeSize; // 0x0034(0x0004) (CPF_Edit, CPF_BlueprintVisible, CPF_BlueprintReadOnly, CPF_ZeroConstructor, CPF_IsPlainOldData)
unsigned char UnknownData00[0x8]; // 0x0038(0x0008) MISSED OFFSET
TArray<struct FFoliageTypeObject> FoliageTypes; // 0x0040(0x0010) (CPF_Edit, CPF_ZeroConstructor)
bool bNeedsSimulation; // 0x0050(0x0001) (CPF_ZeroConstructor, CPF_IsPlainOldData)
unsigned char UnknownData01[0x1F]; // 0x0051(0x001F) MISSED OFFSET
static UClass* StaticClass()
{
static UClass* ptr = nullptr;
if (!ptr) ptr = UObject::FindClass(0x24ec0be8);
return ptr;
}
void Simulate(int NumSteps);
};
// Class Foliage.ProceduralFoliageTile
// 0x0130 (0x0158 - 0x0028)
class UProceduralFoliageTile : public UObject
{
public:
class UProceduralFoliageSpawner* FoliageSpawner; // 0x0028(0x0008) (CPF_ZeroConstructor, CPF_IsPlainOldData)
unsigned char UnknownData00[0xA0]; // 0x0030(0x00A0) MISSED OFFSET
TArray<struct FProceduralFoliageInstance> InstancesArray; // 0x00D0(0x0010) (CPF_ZeroConstructor)
unsigned char UnknownData01[0x78]; // 0x00E0(0x0078) MISSED OFFSET
static UClass* StaticClass()
{
static UClass* ptr = nullptr;
if (!ptr) ptr = UObject::FindClass(0xb94ae6d0);
return ptr;
}
};
// Class Foliage.ProceduralFoliageVolume
// 0x0008 (0x03E0 - 0x03D8)
class AProceduralFoliageVolume : public AVolume
{
public:
class UProceduralFoliageComponent* ProceduralComponent; // 0x03D8(0x0008) (CPF_Edit, CPF_BlueprintVisible, CPF_ExportObject, CPF_BlueprintReadOnly, CPF_ZeroConstructor, CPF_EditConst, CPF_InstancedReference, CPF_IsPlainOldData)
static UClass* StaticClass()
{
static UClass* ptr = nullptr;
if (!ptr) ptr = UObject::FindClass(0x545c6762);
return ptr;
}
};
}
#ifdef _MSC_VER
#pragma pack(pop)
#endif
| [
"pubgsdk@gmail.com"
] | pubgsdk@gmail.com |
bfe06a3f96aeab36eb72502cd3fc33cc73c6889b | a82facec4d7111825c59c67a859825074823e6f7 | /IGC/VectorCompiler/include/vc/Utils/General/InstRebuilder.h | bf547518075502207ba4a3318067cfa3e0d762e6 | [
"MIT"
] | permissive | mfkiwl/intel-graphics-compiler-dp4a | f6f85313f1f62ffc86786fc7d3239d5366a015d1 | 9d3ddd2a85278b225930dac964427a0395c39c58 | refs/heads/master | 2023-04-02T17:24:52.035704 | 2021-05-21T02:17:42 | 2021-05-21T04:03:30 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 11,809 | h | /*========================== begin_copyright_notice ============================
Copyright (C) 2021 Intel Corporation
SPDX-License-Identifier: MIT
============================= end_copyright_notice ===========================*/
#ifndef VC_UTILS_GENERAL_INST_REBUILDER_H
#define VC_UTILS_GENERAL_INST_REBUILDER_H
#include "Probe/Assertion.h"
#include <llvm/ADT/ArrayRef.h>
#include <llvm/IR/Instructions.h>
#include <llvm/IR/Use.h>
#include <llvm/Support/Casting.h>
#include <numeric>
#include <unordered_set>
#include <vector>
namespace vc {
// Creates new instruction with all the properties taken from the \p OrigInst
// except for operands that are taken from \p NewOps.
// nullptr is returned when clonning is imposible or yet unsupported.
llvm::Instruction *cloneInstWithNewOps(llvm::Instruction &OrigInst,
llvm::ArrayRef<llvm::Value *> NewOps);
// This structure defines a use with \p User instruction and \p OperandNo of its
// operand. And there's new value \p NewOperand for this operand.
struct UseToRebuild {
llvm::Instruction *User = nullptr;
int OperandNo;
llvm::Value *NewOperand;
bool IsTerminal = false;
};
// This structure defines which \p OperandNos of \p User instruction should be
// rebuilt. Corresponding new values are provided in \p NewOperands.
// (OperandNos.size() == NewOperands.size())
struct InstToRebuild {
llvm::Instruction *User = nullptr;
std::vector<int> OperandNos;
std::vector<llvm::Value *> NewOperands;
bool IsTerminal = false;
};
// The info required to rebuild the instructions.
// If element's NewOperand is equal to nullptr, it means that this operand/use
// should be replaced with previously build instruction.
using RebuildInfo = std::vector<UseToRebuild>;
// A helper class to generate RebuildInfo.
// Abstract:
// One does not simply change an operand of an instruction with a value with a
// different type. In this case instruction changes its type and must be
// rebuild. That causes a chain reaction as instruction's users now has to be
// rebuild to.
//
// Usage:
// A user should provide instructions into this builder in reverse post-order.
// An instruction must be defined as entry (the one that causes chain reaction)
// or as a potential node inside the chain(user can pass all instructions that
// are not entries - that's fine, if user knows for sure that this instruction
// isn't in the chain, user is able to not pass this instruction).
// A user must provide a functor (const Instruction &)-> bool that will define
// whether an instruction is a terminal - the last instruction in the chain
// reaction. For all other instructions it is considered that they are
// continuing the reaction.
template <typename IsTerminalFunc> class RebuildInfoBuilder {
IsTerminalFunc IsTerminal;
RebuildInfo Info;
std::unordered_set<llvm::Value *> ChangedOperands;
public:
RebuildInfoBuilder(IsTerminalFunc IsTerminalIn) : IsTerminal{IsTerminalIn} {}
void addEntry(llvm::Instruction &Inst, int OperandNo,
llvm::Value &NewOperand) {
addNode(Inst, OperandNo, &NewOperand);
}
void addNodeIfRequired(llvm::Instruction &Inst, int OperandNo) {
if (ChangedOperands.count(Inst.getOperand(OperandNo)))
addNode(Inst, OperandNo, nullptr);
}
// Emit the gathered data.
RebuildInfo emit() && { return std::move(Info); }
private:
void addNode(llvm::Instruction &Inst, int OperandNo,
llvm::Value *NewOperand) {
// Users are covered here too as phi use can be back edge, so RPO won't help
// and it won't be covered.
IGC_ASSERT_MESSAGE(!llvm::isa<llvm::PHINode>(Inst),
"phi-nodes aren't yet supported");
IGC_ASSERT_MESSAGE(IsTerminal(Inst) ||
std::all_of(Inst.user_begin(), Inst.user_end(),
[](const llvm::User *U) {
return !llvm::isa<llvm::PHINode>(U);
}),
"phi-nodes aren't yet supported");
auto InstIsTerminal = IsTerminal(Inst);
Info.push_back({&Inst, OperandNo, NewOperand, InstIsTerminal});
if (!InstIsTerminal)
ChangedOperands.insert(&Inst);
}
};
template <typename IsTerminalFunc>
RebuildInfoBuilder<IsTerminalFunc>
MakeRebuildInfoBuilder(IsTerminalFunc IsTerminator) {
return RebuildInfoBuilder{IsTerminator};
}
// Rebuilds instructions according to info provided in RebuildInfo.
// New instructions inherit all properties of original ones, only
// operands change. User can customize this behaviour with two functors:
// IsSpecialInst: (const InstToRebuild&) -> bool - returns whether inst
// should be processed with a custom handler
// CreateSpecialInst: (const InstToRebuild&) -> Instruction* - custom handler
// to rebuild provided instruction.
template <typename IsSpecialInstFunc, typename CreateSpecialInstFunc>
class InstructionRebuilder {
// Pop should be called only in getNextInstToRebuild.
std::vector<UseToRebuild> ToRebuild;
IsSpecialInstFunc IsSpecialInst;
CreateSpecialInstFunc CreateSpecialInst;
// Map between original inst and its replacement.
std::unordered_map<llvm::Instruction *, llvm::Value *> Replacement;
std::vector<llvm::Instruction *> ToErase;
public:
InstructionRebuilder(RebuildInfo ToRebuildIn,
IsSpecialInstFunc IsSpecialInstIn,
CreateSpecialInstFunc CreateSpecialInstIn)
: ToRebuild{ToRebuildIn}, IsSpecialInst{IsSpecialInstIn},
CreateSpecialInst{CreateSpecialInstIn} {}
void rebuild() && {
std::vector<llvm::Instruction *> Terminals;
for (auto First = ToRebuild.begin(), Last = ToRebuild.end();
First != Last;) {
InstToRebuild InstInfo;
std::tie(InstInfo, First) = getNextInstToRebuild(First, Last);
IGC_ASSERT_MESSAGE(!llvm::isa<llvm::PHINode>(InstInfo.User),
"phi-nodes aren't yet supported");
rebuildNonPhiInst(InstInfo);
if (InstInfo.IsTerminal)
Terminals.push_back(InstInfo.User);
}
for (auto *Terminal : Terminals)
Terminal->replaceAllUsesWith(Replacement[Terminal]);
// Instructions must be deleted in post-order - uses first, than defs.
// As ToErase is in RPO, reverse is required.
for (auto *Inst : reverse(ToErase))
Inst->eraseFromParent();
}
private:
// Takes a range of UseToRebuild - [\p First, \p Last).
// Aggregates first uses with the same user from the range and adds collected
// Replacement info to produce info for the next inst to rebuild. Returns
// collected inst info and the first use with a different to returned user
// (next user) or \p Last when there's no more users.
template <typename InputIter>
std::pair<InstToRebuild, InputIter> getNextInstToRebuild(InputIter First,
InputIter Last) {
IGC_ASSERT_MESSAGE(First != Last,
"this method shouldn't be called when list of uses to "
"rebuild is already empty");
InstToRebuild CurInst;
CurInst.User = First->User;
CurInst.IsTerminal = First->IsTerminal;
auto LastUse = std::adjacent_find(
First, Last, [](const UseToRebuild &LHS, const UseToRebuild &RHS) {
return LHS.User != RHS.User;
});
if (LastUse != Last)
++LastUse;
// Filling operand related fields.
CurInst =
std::accumulate(First, LastUse, std::move(CurInst),
[this](InstToRebuild Inst, const UseToRebuild &Use) {
return appendOperand(Inst, Use);
});
return {CurInst, LastUse};
}
// Appends operand/use from \p CurUse to \p InstInfo.
// Returns updated \p InstInfo.
InstToRebuild appendOperand(InstToRebuild InstInfo,
const UseToRebuild &CurUse) {
IGC_ASSERT_MESSAGE(InstInfo.User == CurUse.User,
"trying to append a wrong use with wrong user");
IGC_ASSERT_MESSAGE(
InstInfo.IsTerminal == CurUse.IsTerminal,
"two uses don't agree on the instruction being terminal");
InstInfo.OperandNos.push_back(CurUse.OperandNo);
auto *NewOperand = CurUse.NewOperand;
if (!NewOperand) {
NewOperand = Replacement.at(llvm::cast<llvm::Instruction>(
CurUse.User->getOperand(CurUse.OperandNo)));
}
InstInfo.NewOperands.push_back(NewOperand);
return std::move(InstInfo);
}
void rebuildNonPhiInst(InstToRebuild &OrigInst) {
auto *Replace = createNonPhiInst(OrigInst);
Replacement[OrigInst.User] = Replace;
ToErase.push_back(OrigInst.User);
}
// Unlike rebuildNonPhiInst method just creates instruction, doesn't
// update the class state.
llvm::Value *createNonPhiInst(InstToRebuild &OrigInst) const {
llvm::Instruction *Replace;
if (IsSpecialInst(OrigInst))
Replace = CreateSpecialInst(OrigInst);
else
Replace =
vc::cloneInstWithNewOps(*OrigInst.User, createNewOperands(OrigInst));
if (!Replace)
return coverNonCloneCase(*OrigInst.User, createNewOperands(OrigInst));
Replace->takeName(OrigInst.User);
Replace->insertBefore(OrigInst.User);
Replace->setDebugLoc(OrigInst.User->getDebugLoc());
return Replace;
}
// Takes arguments of the original instruction (OrigInst.User) and rewrites
// the required ones with new values according to info in \p OrigInst
static std::vector<llvm::Value *>
createNewOperands(const InstToRebuild &OrigInst) {
std::vector<llvm::Value *> NewOperands{OrigInst.User->value_op_begin(),
OrigInst.User->value_op_end()};
for (auto &&OpReplacement :
zip(OrigInst.OperandNos, OrigInst.NewOperands)) {
int OperandNo = std::get<0>(OpReplacement);
llvm::Value *NewOperand = std::get<1>(OpReplacement);
IGC_ASSERT_MESSAGE(OperandNo >= 0, "no such operand");
IGC_ASSERT_MESSAGE(OperandNo < static_cast<int>(NewOperands.size()),
"no such operand");
NewOperands[OperandNo] = NewOperand;
}
return std::move(NewOperands);
}
// covers cases when \p OrigInst cannot be cloned by cloneInstWithNewOps
// with the provided \p NewOps.
// Peplacement for the \p OrigInst is returned.
static llvm::Value *coverNonCloneCase(llvm::Instruction &OrigInst,
llvm::ArrayRef<llvm::Value *> NewOps) {
IGC_ASSERT_MESSAGE(llvm::isa<llvm::AddrSpaceCastInst>(OrigInst),
"only addr space cast case is yet considered");
IGC_ASSERT_MESSAGE(NewOps.size() == 1, "cast has only one operand");
llvm::Value *NewOp = NewOps.front();
auto *NewOpTy = llvm::cast<llvm::PointerType>(NewOp->getType());
auto *CastTy = llvm::cast<llvm::PointerType>(OrigInst.getType());
IGC_ASSERT_MESSAGE(
NewOpTy->getAddressSpace() == CastTy->getAddressSpace(),
"when addrspaces different clonnig helps and it should've "
"been covered before");
return NewOp;
}
};
template <typename IsSpecialInstFunc, typename CreateSpecialInstFunc>
InstructionRebuilder<IsSpecialInstFunc, CreateSpecialInstFunc>
MakeInstructionRebuilder(RebuildInfo Info, IsSpecialInstFunc IsSpecialInst,
CreateSpecialInstFunc CreateSpecialInst) {
return {std::move(Info), std::move(IsSpecialInst),
std::move(CreateSpecialInst)};
}
inline auto MakeInstructionRebuilder(RebuildInfo Info) {
return MakeInstructionRebuilder(
std::move(Info), [](const InstToRebuild &Inst) { return false; },
[](const InstToRebuild &Inst) { return nullptr; });
}
} // namespace vc
#endif // VC_UTILS_GENERAL_INST_REBUILDER_H
| [
"sys_igcbot@intel.com"
] | sys_igcbot@intel.com |
040795185e0e9acb80b58ee6712e892224e1f173 | 994e37af734c5ac0b05f78040bcdf605ffb69129 | /C++ - MiniCodes/T1.cpp | dd2917a7a94eb7310379186ad2618c615dad5a04 | [] | no_license | kevP00/Mini-Codes | 85dc0dfb769c0ce07ee28656b2b25ee13969cf34 | dc3672c84c648ab30069817b2273b490c137b232 | refs/heads/main | 2023-02-02T18:41:54.091523 | 2020-12-01T04:52:41 | 2020-12-01T04:52:41 | 317,424,217 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 270 | cpp | #include <iostream>
using namespace std;
int main()
{
int check;
cout << "Input the Number: ";
cin >> check;
if ( check % 2 == 0)
cout<< "The given num is even:";
else
cout<< "The given num is odd:";
return 0;
}
| [
"noreply@github.com"
] | noreply@github.com |
8bc3ab5fc5bad52a7184515df56c92d00c4f394f | decf0e1f4aea433976ed5597c0b92090d5e09018 | /Blynk/Blynk.ino | a357943c912c111e333934996d26312755c3d942 | [] | no_license | danielpollak/Bapabackup | 5b7b8e6afb9dcaae2cc838b0c5302f5dcb5ee2ec | 1850ce32d19da259bc92132be10d4418a822e8f4 | refs/heads/master | 2022-05-01T01:13:41.088855 | 2017-11-05T16:43:03 | 2017-11-05T16:43:03 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 743 | ino | #define BLYNK_PRINT Serial
#include <BlynkSimpleEsp8266.h>
#include <ESP8266WiFi.h>
#include <WiFiClient.h>
WiFiClient client;
char auth[] = "9b1b5f1de728419487c4dca8ef396462"; char ssid[] = "CS390IOT"; char pass[] = "12345678";
volatile byte ONOFF = HIGH;
int row_idx = 0, v0 = 0, v2 = 0;
void setup() {
Serial.begin(9600);
Blynk.begin(auth, ssid, pass);
Blynk.virtualWrite(V0, HIGH);
Blynk.virtualWrite(V1, "clr");
}
BLYNK_WRITE(V0){
v0 = param.asInt();
ONOFF = v0;
if(!ONOFF){
Blynk.virtualWrite(V1, "clr");
row_idx = 0;
}
}
BLYNK_WRITE(V2){
v2 = param.asInt();
if(v2 && ONOFF){
Blynk.virtualWrite(V1, "add", row_idx, "Name", "Value");
row_idx = row_idx + 1;
}
}
void loop() {
Blynk.run();
}
| [
"reiffev@gmail.com"
] | reiffev@gmail.com |
bfd0e4fd6fd21188e95527835f3c91a2071f6179 | 34833b729aeaa693083bae47af4d5198c570aa6b | /cvpyr.hpp | 3769a69f6a28e3df94394908922e1e43c4bdaa3f | [] | no_license | hesitationer/miscvision | 8f5b1ca58b87a2b36fdbc6089e6ae449f5d6b3cc | 6365d3ca00301fd14e88e8f845817c2ce8a2f92d | refs/heads/master | 2020-04-14T15:36:32.045612 | 2017-01-21T05:36:21 | 2017-01-21T05:38:33 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,108 | hpp | #ifndef __CV_IMAGE_PYRAMID_HH
#define __CV_IMAGE_PYRAMID_HH
struct CvImagePyr {
IplImage ** images;
int size;
};
CvImagePyr * cvCreateImagePyr( int nimages, CvSize size, int depth, int nch, int minSize=16, int maxLevels=0 ){
if(maxLevels=0){
// calculate number of scales to consider
int logMinSize = log2(minSize);
int w = (int) log2(size.width);
int h = (int) log2(size.height);
if(w>h) maxLevels = h - logMinSize + 1;
else maxLevels = w - logMinSize + 1;
}
CvImagePyr * pyr = cvAlloc( sizeof( CvImagePyr ) );
pyr->images = cvAlloc (sizeof((IplImage *) * maxLevels));
pyr->size = maxLevels;
for(int i=0; i<maxLevels; i++){
pyr->images[i] = cvCreateImage(size, depth, nch);
size.width /= 2;
size.height /= 2;
}
return pyr;
}
void cvPyrDownAll( CvImagePyr * pyr ) {
for(int i=1; i<pyr->size; i++){
cvPyrDown(pyr->images[i-1], pyr->images[i], CV_GAUSSIAN_5x5 );
}
}
void cvPyrUpAll( CvImagePyr * pyr ) {
for(int i=pyr->size-1; i>0; i++){
cvPyrUp(pyr->images[i], pyr->images[i-1], CV_GAUSSIAN_5x5 );
}
}
#endif //__CV_IMAGE_PYRAMID_HH
| [
"rstanchak@semaconnect.com"
] | rstanchak@semaconnect.com |
71cc3977928a576c3fdb292c6e8e9b1f3d758de2 | b4d5e8e2e9f5754ad77544f1408169ec316a290f | /triangleiterator.cpp | fd67abf658a505210b695ec5dd9d6963a26dbfde | [] | no_license | Piapiou/mesh | b88b07c8f91fd7c377eb0f54f33a87d2abf93db7 | 2d1ec42163df11a65b7f4bb1040b1a9f23a0c25d | refs/heads/master | 2020-12-25T14:14:19.305777 | 2016-11-07T15:42:43 | 2016-11-07T15:42:43 | 67,804,276 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 612 | cpp | #include "triangleiterator.h"
TriangleIterator::TriangleIterator(Mesh &m)
{
v = m.getTriangles();
i = 0;
}
void TriangleIterator::reinit() {
i = 0;
}
bool TriangleIterator::hasNext() {
return (i < v->length());
}
Triangle TriangleIterator::next() {
if (i >= v->length())
throw "ERROR : NO MORE TRIANGLE";
return (v->at(i++));
}
void TriangleIterator::goTo(int n) {
if (n >= v->length())
throw "ERROR : OUT OF BOUND";
i = n;
}
Triangle TriangleIterator::first() {
return v->at(0);
}
Triangle TriangleIterator::last() {
return v->at(v->length()-1);
}
| [
"Pierre Sénéclauze"
] | Pierre Sénéclauze |
60653021dfed6e3194211f2bdc6df2ef8db3c714 | 8e8cdf669786b4d280272868ae3cfb3feac19c59 | /src/CameraTransitions/SdkModel/ExitCurrentInteriorStage.h | 9b9d13e3c2edf600705779076cdca9216a1ab978 | [
"BSD-2-Clause"
] | permissive | wrld3d/wrld-example-app | e1ad99814d80a11ce13d6941543119c989d26704 | c7622c3ee359b2d06d881d234c780b07a2d0ee58 | refs/heads/master | 2022-11-07T23:31:54.091568 | 2022-11-02T15:18:12 | 2022-11-02T15:18:12 | 22,911,969 | 79 | 37 | BSD-2-Clause | 2022-11-02T15:18:14 | 2014-08-13T10:33:12 | C++ | UTF-8 | C++ | false | false | 1,060 | h | // Copyright eeGeo Ltd (2012-2015), All Rights Reserved
#pragma once
#include "ICameraTransitionStage.h"
#include "InteriorsExplorer.h"
#include "AppModes.h"
namespace ExampleApp
{
namespace CameraTransitions
{
namespace SdkModel
{
class ExitCurrentInteriorStage : public ICameraTransitionStage
{
public:
ExitCurrentInteriorStage(InteriorsExplorer::SdkModel::InteriorsExplorerModel& interiorsExplorerModel,
AppModes::SdkModel::IAppModeModel& appModeModel);
void Start();
void Update(float dt);
void End();
const bool StageIsComplete() const;
const bool StageHasFailed() const;
private:
InteriorsExplorer::SdkModel::InteriorsExplorerModel& m_interiorsExplorerModel;
AppModes::SdkModel::IAppModeModel& m_appModeModel;
};
}
}
} | [
"DragonXVIFB&GMail.com"
] | DragonXVIFB&GMail.com |
8ee2b39edb5648fe30beae31e562dec80d502254 | 0a398c797c6258cc8b25a6a5261af2a963fce2b6 | /learningTools/eval - コピー.cpp | 5af1f795e9719a0c7fda841d7808517c1799f0d9 | [] | no_license | kazura-utb/KZRevesi_Learn | d25ddc5e163b8bdc8fa5042465b2cade7eb231d8 | 874ad4484c74c27998fe18245235e6286b2bb1b6 | refs/heads/master | 2021-01-20T18:29:11.250475 | 2020-03-05T02:39:09 | 2020-03-05T02:39:09 | 60,455,270 | 0 | 0 | null | null | null | null | SHIFT_JIS | C++ | false | false | 27,498 | cpp | /***************************************************************************
* Name : eval.cpp
* Brief : 評価値関連の処理を行う
* Date : 2016/02/01
****************************************************************************/
#include "stdafx.h"
#include <stdlib.h>
#include "bit64.h"
#include "book.h"
#include "move.h"
#include "eval.h"
#include "board.h"
#include "fio.h"
#include "cpu.h"
/* 各座標 */
#define A1 0 /* A1 */
#define A2 1 /* A2 */
#define A3 2 /* A3 */
#define A4 3 /* A4 */
#define A5 4 /* A5 */
#define A6 5 /* A6 */
#define A7 6 /* A7 */
#define A8 7 /* A8 */
#define B1 8 /* B1 */
#define B2 9 /* B2 */
#define B3 10 /* B3 */
#define B4 11 /* B4 */
#define B5 12 /* B5 */
#define B6 13 /* B6 */
#define B7 14 /* B7 */
#define B8 15 /* B8 */
#define C1 16 /* C1 */
#define C2 17 /* C2 */
#define C3 18 /* C3 */
#define C4 19 /* C4 */
#define C5 20 /* C5 */
#define C6 21 /* C6 */
#define C7 22 /* C7 */
#define C8 23 /* C8 */
#define D1 24 /* D1 */
#define D2 25 /* D2 */
#define D3 26 /* D3 */
#define D4 27 /* D4 */
#define D5 28 /* D5 */
#define D6 29 /* D6 */
#define D7 30 /* D7 */
#define D8 31 /* D8 */
#define E1 32 /* E1 */
#define E2 33 /* E2 */
#define E3 34 /* E3 */
#define E4 35 /* E4 */
#define E5 36 /* E5 */
#define E6 37 /* E6 */
#define E7 38 /* E7 */
#define E8 39 /* E8 */
#define F1 40 /* F1 */
#define F2 41 /* F2 */
#define F3 42 /* F3 */
#define F4 43 /* F4 */
#define F5 44 /* F5 */
#define F6 45 /* F6 */
#define F7 46 /* F7 */
#define F8 47 /* F8 */
#define G1 48 /* G1 */
#define G2 49 /* G2 */
#define G3 50 /* G3 */
#define G4 51 /* G4 */
#define G5 52 /* G5 */
#define G6 53 /* G6 */
#define G7 54 /* G7 */
#define G8 55 /* G8 */
#define H1 56 /* H1 */
#define H2 57 /* H2 */
#define H3 58 /* H3 */
#define H4 59 /* H4 */
#define H5 60 /* H5 */
#define H6 61 /* H6 */
#define H7 62 /* H7 */
#define H8 63 /* H8 */
/* 評価パターンテーブル(現在のステージにより内容が変わるポインタ) */
double *hori_ver1;
double *hori_ver2;
double *hori_ver3;
double *dia_ver1;
double *dia_ver2;
double *dia_ver3;
double *dia_ver4;
double *edge;
double *corner5_2;
double *corner3_3;
double *triangle;
double *mobility;
double *parity;
/* 評価パターンテーブル(おおもと) */
double hori_ver1_data[2][60][INDEX_NUM];
double hori_ver2_data[2][60][INDEX_NUM];
double hori_ver3_data[2][60][INDEX_NUM];
double dia_ver1_data[2][60][INDEX_NUM];
double dia_ver2_data[2][60][INDEX_NUM / 3];
double dia_ver3_data[2][60][INDEX_NUM / 9];
double dia_ver4_data[2][60][INDEX_NUM / 27];
double edge_data[2][60][INDEX_NUM * 9];
double corner5_2_data[2][60][INDEX_NUM * 9];
double corner3_3_data[2][60][INDEX_NUM * 3];
double triangle_data[2][60][INDEX_NUM * 9];
double mobility_data[2][60][MOBILITY_NUM];
double parity_data[2][60][PARITY_NUM];
double constant_data[2][60];
int pow_table[10] = { 1, 3, 9, 27, 81, 243, 729, 2187, 6561, 19683 };
double key_hori_ver1[4];
double key_hori_ver2[4];
double key_hori_ver3[4];
double key_dia_ver1[2];
double key_dia_ver2[4];
double key_dia_ver3[4];
double key_dia_ver4[4];
double key_edge[4];
double key_corner5_2[8];
double key_corner3_3[4];
double key_triangle[4];
double key_mobility;
double key_parity;
double key_constant;
double eval_sum;
INT32 GetExactScore(UINT64 bk, UINT64 wh, INT32 empty);
INT32 GetWinLossScore(UINT64 bk, UINT64 wh, INT32 empty);
UINT64 a1 = 1ULL; /* a1 */
UINT64 a2 = (1ULL << 1); /* a2 */
UINT64 a3 = (1ULL << 2); /* a3 */
UINT64 a4 = (1ULL << 3); /* a4 */
UINT64 a5 = (1ULL << 4); /* a5 */
UINT64 a6 = (1ULL << 5); /* a6 */
UINT64 a7 = (1ULL << 6); /* a7 */
UINT64 a8 = (1ULL << 7); /* a8 */
UINT64 b1 = (1ULL << 8); /* b1 */
UINT64 b2 = (1ULL << 9); /* b2 */
UINT64 b3 = (1ULL << 10); /* b3 */
UINT64 b4 = (1ULL << 11); /* b4 */
UINT64 b5 = (1ULL << 12); /* b5 */
UINT64 b6 = (1ULL << 13); /* b6 */
UINT64 b7 = (1ULL << 14); /* b7 */
UINT64 b8 = (1ULL << 15); /* b8 */
UINT64 c1 = (1ULL << 16); /* c1 */
UINT64 c2 = (1ULL << 17); /* c2 */
UINT64 c3 = (1ULL << 18); /* c3 */
UINT64 c4 = (1ULL << 19); /* c4 */
UINT64 c5 = (1ULL << 20); /* c5 */
UINT64 c6 = (1ULL << 21); /* c6 */
UINT64 c7 = (1ULL << 22); /* c7 */
UINT64 c8 = (1ULL << 23); /* c8 */
UINT64 d1 = (1ULL << 24); /* d1 */
UINT64 d2 = (1ULL << 25); /* d2 */
UINT64 d3 = (1ULL << 26); /* d3 */
UINT64 d4 = (1ULL << 27); /* d4 */
UINT64 d5 = (1ULL << 28); /* d5 */
UINT64 d6 = (1ULL << 29); /* d6 */
UINT64 d7 = (1ULL << 30); /* d7 */
UINT64 d8 = (1ULL << 31); /* d8 */
UINT64 e1 = (1ULL << 32); /* e1 */
UINT64 e2 = (1ULL << 33); /* e2 */
UINT64 e3 = (1ULL << 34); /* e3 */
UINT64 e4 = (1ULL << 35); /* e4 */
UINT64 e5 = (1ULL << 36); /* e5 */
UINT64 e6 = (1ULL << 37); /* e6 */
UINT64 e7 = (1ULL << 38); /* e7 */
UINT64 e8 = (1ULL << 39); /* e8 */
UINT64 f1 = (1ULL << 40); /* f1 */
UINT64 f2 = (1ULL << 41); /* f2 */
UINT64 f3 = (1ULL << 42); /* f3 */
UINT64 f4 = (1ULL << 43); /* f4 */
UINT64 f5 = (1ULL << 44); /* f5 */
UINT64 f6 = (1ULL << 45); /* f6 */
UINT64 f7 = (1ULL << 46); /* f7 */
UINT64 f8 = (1ULL << 47); /* f8 */
UINT64 g1 = (1ULL << 48); /* g1 */
UINT64 g2 = (1ULL << 49); /* g2 */
UINT64 g3 = (1ULL << 50); /* g3 */
UINT64 g4 = (1ULL << 51); /* g4 */
UINT64 g5 = (1ULL << 52); /* g5 */
UINT64 g6 = (1ULL << 53); /* g6 */
UINT64 g7 = (1ULL << 54); /* g7 */
UINT64 g8 = (1ULL << 55); /* g8 */
UINT64 h1 = (1ULL << 56); /* h1 */
UINT64 h2 = (1ULL << 57); /* h2 */
UINT64 h3 = (1ULL << 58); /* h3 */
UINT64 h4 = (1ULL << 59); /* h4 */
UINT64 h5 = (1ULL << 60); /* h5 */
UINT64 h6 = (1ULL << 61); /* h6 */
UINT64 h7 = (1ULL << 62); /* h7 */
UINT64 h8 = (1ULL << 63); /* h8 */
UINT8 posEval[64] =
{
8, 1, 5, 6, 6, 5, 1, 8,
1, 0, 2, 3, 3, 2, 0, 1,
5, 2, 7, 4, 4, 7, 2, 5,
6, 3, 4, 0, 0, 4, 3, 6,
6, 3, 4, 0, 0, 4, 3, 6,
5, 2, 7, 4, 4, 7, 2, 5,
1, 0, 2, 3, 3, 2, 0, 1,
8, 1, 5, 6, 6, 5, 1, 8
};
INT32 g_evaluation;
/* function empty 0 or end leave empty */
INT32(*GetEndScore[])(UINT64 bk, UINT64 wh, INT32 empty) = {
GetWinLossScore,
GetExactScore
};
float check_h_ver1(UINT8 *board)
{
int key;
double eval;
/* a2 b2 c2 d2 e2 f2 g2 h2 */
/* a7 b7 c7 d7 e7 f7 g7 h7 */
/* b1 b2 b3 b4 b5 b6 b7 b8 */
/* g1 g2 g3 g4 g5 g6 g7 g8 */
key = board[A2];
key += 3 * board[B2];
key += 9 * board[C2];
key += 27 * board[D2];
key += 81 * board[E2];
key += 243 * board[F2];
key += 729 * board[G2];
key += 2187 * board[H2];
eval = hori_ver1[key];
key_hori_ver1[0] = hori_ver1[key];
key = board[A7];
key += 3 * board[B7];
key += 9 * board[C7];
key += 27 * board[D7];
key += 81 * board[E7];
key += 243 * board[F7];
key += 729 * board[G7];
key += 2187 * board[H7];
eval += hori_ver1[key];
key_hori_ver1[1] = hori_ver1[key];
key = board[B1];
key += 3 * board[B2];
key += 9 * board[B3];
key += 27 * board[B4];
key += 81 * board[B5];
key += 243 * board[B6];
key += 729 * board[B7];
key += 2187 * board[B8];
eval += hori_ver1[key];
key_hori_ver1[2] = hori_ver1[key];
key = board[G1];
key += 3 * board[G2];
key += 9 * board[G3];
key += 27 * board[G4];
key += 81 * board[G5];
key += 243 * board[G6];
key += 729 * board[G7];
key += 2187 * board[G8];
eval += hori_ver1[key];
key_hori_ver1[3] = hori_ver1[key];
return (float)eval;
}
float check_h_ver2(UINT8 *board)
{
int key;
double eval;
/* a3 b3 c3 d3 e3 f3 g3 h3 */
/* a6 b6 c6 d6 e6 f6 g6 h6 */
/* c1 c2 c3 c4 c5 c6 c7 c8 */
/* f1 f2 f3 f4 f5 f6 f7 f8 */
key = board[A3];
key += 3 * board[B3];
key += 9 * board[C3];
key += 27 * board[D3];
key += 81 * board[E3];
key += 243 * board[F3];
key += 729 * board[G3];
key += 2187 * board[H3];
eval = hori_ver2[key];
key_hori_ver2[0] = hori_ver2[key];
key = board[A6];
key += 3 * board[B6];
key += 9 * board[C6];
key += 27 * board[D6];
key += 81 * board[E6];
key += 243 * board[F6];
key += 729 * board[G6];
key += 2187 * board[H6];
eval += hori_ver2[key];
key_hori_ver2[1] = hori_ver2[key];
key = board[C1];
key += 3 * board[C2];
key += 9 * board[C3];
key += 27 * board[C4];
key += 81 * board[C5];
key += 243 * board[C6];
key += 729 * board[C7];
key += 2187 * board[C8];
eval += hori_ver2[key];
key_hori_ver2[2] = hori_ver2[key];
key = board[F1];
key += 3 * board[F2];
key += 9 * board[F3];
key += 27 * board[F4];
key += 81 * board[F5];
key += 243 * board[F6];
key += 729 * board[F7];
key += 2187 * board[F8];
eval += hori_ver2[key];
key_hori_ver2[3] = hori_ver2[key];
return (float)eval;
}
float check_h_ver3(UINT8 *board)
{
int key;
double eval;
/* a4 b4 c4 d4 e4 f4 g4 h4 */
/* a5 b5 c5 d5 e5 f5 g5 h5 */
/* d1 d2 d3 d4 d5 d6 d7 d8 */
/* e1 e2 e3 e4 e5 e6 e7 e8 */
key = board[A4];
key += 3 * board[B4];
key += 9 * board[C4];
key += 27 * board[D4];
key += 81 * board[E4];
key += 243 * board[F4];
key += 729 * board[G4];
key += 2187 * board[H4];
eval = hori_ver3[key];
key_hori_ver3[0] = hori_ver3[key];
key = board[A5];
key += 3 * board[B5];
key += 9 * board[C5];
key += 27 * board[D5];
key += 81 * board[E5];
key += 243 * board[F5];
key += 729 * board[G5];
key += 2187 * board[H5];
eval += hori_ver3[key];
key_hori_ver3[1] = hori_ver3[key];
key = board[D1];
key += 3 * board[D2];
key += 9 * board[D3];
key += 27 * board[D4];
key += 81 * board[D5];
key += 243 * board[D6];
key += 729 * board[D7];
key += 2187 * board[D8];
eval += hori_ver3[key];
key_hori_ver3[2] = hori_ver3[key];
key = board[E1];
key += 3 * board[E2];
key += 9 * board[E3];
key += 27 * board[E4];
key += 81 * board[E5];
key += 243 * board[E6];
key += 729 * board[E7];
key += 2187 * board[E8];
eval += hori_ver3[key];
key_hori_ver3[3] = hori_ver3[key];
return (float)eval;
}
float check_dia_ver1(UINT8 *board)
{
int key;
double eval;
/* a1 b2 c3 d4 e5 f6 g7 h8 */
/* h1 g2 f3 e4 d5 c6 b7 a8 */
key = board[A1];
key += 3 * board[B2];
key += 9 * board[C3];
key += 27 * board[D4];
key += 81 * board[E5];
key += 243 * board[F6];
key += 729 * board[G7];
key += 2187 * board[H8];
eval = dia_ver1[key];
key_dia_ver1[0] = dia_ver1[key];
key = board[A8];
key += 3 * board[B7];
key += 9 * board[C6];
key += 27 * board[D5];
key += 81 * board[E4];
key += 243 * board[F3];
key += 729 * board[G2];
key += 2187 * board[H1];
eval += dia_ver1[key];
key_dia_ver1[1] = dia_ver1[key];
return (float)eval;
}
float check_dia_ver2(UINT8 *board)
{
int key;
double eval;
/* a2 b3 c4 d5 e6 f7 g8 */
/* b1 c2 d3 e4 f5 g6 h7 */
/* h2 g3 f4 e5 d6 c7 b8 */
/* g1 f2 e3 d4 c5 b6 a7 */
key = board[A2];
key += 3 * board[B3];
key += 9 * board[C4];
key += 27 * board[D5];
key += 81 * board[E6];
key += 243 * board[F7];
key += 729 * board[G8];
eval = dia_ver2[key];
key_dia_ver2[0] = dia_ver2[key];
key = board[B1];
key += 3 * board[C2];
key += 9 * board[D3];
key += 27 * board[E4];
key += 81 * board[F5];
key += 243 * board[G6];
key += 729 * board[H7];
eval += dia_ver2[key];
key_dia_ver2[1] = dia_ver2[key];
key = board[B8];
key += 3 * board[C7];
key += 9 * board[D6];
key += 27 * board[E5];
key += 81 * board[F4];
key += 243 * board[G3];
key += 729 * board[H2];
eval += dia_ver2[key];
key_dia_ver2[2] = dia_ver2[key];
key = board[A7];
key += 3 * board[B6];
key += 9 * board[C5];
key += 27 * board[D4];
key += 81 * board[E3];
key += 243 * board[F2];
key += 729 * board[G1];
eval += dia_ver2[key];
key_dia_ver2[3] = dia_ver2[key];
return (float)eval;
}
float check_dia_ver3(UINT8 *board)
{
int key;
double eval;
key = board[A3];
key += 3 * board[B4];
key += 9 * board[C5];
key += 27 * board[D6];
key += 81 * board[E7];
key += 243 * board[F8];
eval = dia_ver3[key];
key_dia_ver3[0] = dia_ver3[key];
key = board[C1];
key += 3 * board[D2];
key += 9 * board[E3];
key += 27 * board[F4];
key += 81 * board[G5];
key += 243 * board[H6];
eval += dia_ver3[key];
key_dia_ver3[1] = dia_ver3[key];
key = board[C8];
key += 3 * board[D7];
key += 9 * board[E6];
key += 27 * board[F5];
key += 81 * board[G4];
key += 243 * board[H3];
eval += dia_ver3[key];
key_dia_ver3[2] = dia_ver3[key];
key = board[A6];
key += 3 * board[B5];
key += 9 * board[C4];
key += 27 * board[D3];
key += 81 * board[E2];
key += 243 * board[F1];
eval += dia_ver3[key];
key_dia_ver3[3] = dia_ver3[key];
return (float)eval;
}
float check_dia_ver4(UINT8 *board)
{
int key;
double eval;
key = board[A4];
key += 3 * board[B5];
key += 9 * board[C6];
key += 27 * board[D7];
key += 81 * board[E8];
eval = dia_ver4[key];
key_dia_ver4[0] = dia_ver4[key];
key = board[D1];
key += 3 * board[E2];
key += 9 * board[F3];
key += 27 * board[G4];
key += 81 * board[H5];
eval += dia_ver4[key];
key_dia_ver4[1] = dia_ver4[key];
key = board[D8];
key += 3 * board[E7];
key += 9 * board[F6];
key += 27 * board[G5];
key += 81 * board[H4];
eval += dia_ver4[key];
key_dia_ver4[2] = dia_ver4[key];
key = board[A5];
key += 3 * board[B4];
key += 9 * board[C3];
key += 27 * board[D2];
key += 81 * board[E1];
eval += dia_ver4[key];
key_dia_ver4[3] = dia_ver4[key];
return (float)eval;
}
float check_edge(UINT8 *board)
{
int key;
double eval;
key = board[A1];
key += 3 * board[A2];
key += 9 * board[A3];
key += 27 * board[A4];
key += 81 * board[A5];
key += 243 * board[A6];
key += 729 * board[A7];
key += 2187 * board[A8];
key += 6561 * board[B2];
key += 19683 * board[B7];
eval = edge[key];
key_edge[0] = edge[key];
key = board[H1];
key += 3 * board[H2];
key += 9 * board[H3];
key += 27 * board[H4];
key += 81 * board[H5];
key += 243 * board[H6];
key += 729 * board[H7];
key += 2187 * board[H8];
key += 6561 * board[G2];
key += 19683 * board[G7];
eval += edge[key];
key_edge[1] = edge[key];
key = board[A1];
key += 3 * board[B1];
key += 9 * board[C1];
key += 27 * board[D1];
key += 81 * board[E1];
key += 243 * board[F1];
key += 729 * board[G1];
key += 2187 * board[H1];
key += 6561 * board[B2];
key += 19683 * board[G2];
eval += edge[key];
key_edge[2] = edge[key];
key = board[A8];
key += 3 * board[B8];
key += 9 * board[C8];
key += 27 * board[D8];
key += 81 * board[E8];
key += 243 * board[F8];
key += 729 * board[G8];
key += 2187 * board[H8];
key += 6561 * board[B7];
key += 19683 * board[G7];
eval += edge[key];
key_edge[3] = edge[key];
return (float)eval;
}
float check_corner3_3(UINT8 *board)
{
int key;
double eval;
key = board[A1];
key += 3 * board[A2];
key += 9 * board[A3];
key += 27 * board[B1];
key += 81 * board[B2];
key += 243 * board[B3];
key += 729 * board[C1];
key += 2187 * board[C2];
key += 6561 * board[C3];
eval = corner3_3[key];
key_corner3_3[0] = corner3_3[key];
key = board[H1];
key += 3 * board[H2];
key += 9 * board[H3];
key += 27 * board[G1];
key += 81 * board[G2];
key += 243 * board[G3];
key += 729 * board[F1];
key += 2187 * board[F2];
key += 6561 * board[F3];
eval += corner3_3[key];
key_corner3_3[1] = corner3_3[key];
key = board[A8];
key += 3 * board[A7];
key += 9 * board[A6];
key += 27 * board[B8];
key += 81 * board[B7];
key += 243 * board[B6];
key += 729 * board[C8];
key += 2187 * board[C7];
key += 6561 * board[C6];
eval += corner3_3[key];
key_corner3_3[2] = corner3_3[key];
key = board[H8];
key += 3 * board[H7];
key += 9 * board[H6];
key += 27 * board[G8];
key += 81 * board[G7];
key += 243 * board[G6];
key += 729 * board[F8];
key += 2187 * board[F7];
key += 6561 * board[F6];
eval += corner3_3[key];
key_corner3_3[3] = corner3_3[key];
return (float)eval;
}
float check_corner5_2(UINT8 *board)
{
int key;
double eval;
key = board[A1];
key += 3 * board[B1];
key += 9 * board[C1];
key += 27 * board[D1];
key += 81 * board[E1];
key += 243 * board[A2];
key += 729 * board[B2];
key += 2187 * board[C2];
key += 6561 * board[D2];
key += 19683 * board[E2];
eval = corner5_2[key];
key_corner5_2[0] = corner5_2[key];
key = board[A8];
key += 3 * board[B8];
key += 9 * board[C8];
key += 27 * board[D8];
key += 81 * board[E8];
key += 243 * board[A7];
key += 729 * board[B7];
key += 2187 * board[C7];
key += 6561 * board[D7];
key += 19683 * board[E7];
eval += corner5_2[key];
key_corner5_2[1] = corner5_2[key];
key = board[H1];
key += 3 * board[G1];
key += 9 * board[F1];
key += 27 * board[E1];
key += 81 * board[D1];
key += 243 * board[H2];
key += 729 * board[G2];
key += 2187 * board[F2];
key += 6561 * board[E2];
key += 19683 * board[D2];
eval += corner5_2[key];
key_corner5_2[2] = corner5_2[key];
key = board[H8];
key += 3 * board[G8];
key += 9 * board[F8];
key += 27 * board[E8];
key += 81 * board[D8];
key += 243 * board[H7];
key += 729 * board[G7];
key += 2187 * board[F7];
key += 6561 * board[E7];
key += 19683 * board[D7];
eval += corner5_2[key];
key_corner5_2[3] = corner5_2[key];
key = board[A1];
key += 3 * board[A2];
key += 9 * board[A3];
key += 27 * board[A4];
key += 81 * board[A5];
key += 243 * board[B1];
key += 729 * board[B2];
key += 2187 * board[B3];
key += 6561 * board[B4];
key += 19683 * board[B5];
eval += corner5_2[key];
key_corner5_2[4] = corner5_2[key];
key = board[H1];
key += 3 * board[H2];
key += 9 * board[H3];
key += 27 * board[H4];
key += 81 * board[H5];
key += 243 * board[G1];
key += 729 * board[G2];
key += 2187 * board[G3];
key += 6561 * board[G4];
key += 19683 * board[G5];
eval += corner5_2[key];
key_corner5_2[5] = corner5_2[key];
key = board[A8];
key += 3 * board[A7];
key += 9 * board[A6];
key += 27 * board[A5];
key += 81 * board[A4];
key += 243 * board[B8];
key += 729 * board[B7];
key += 2187 * board[B6];
key += 6561 * board[B5];
key += 19683 * board[B4];
eval += corner5_2[key];
key_corner5_2[6] = corner5_2[key];
key = board[H8];
key += 3 * board[H7];
key += 9 * board[H6];
key += 27 * board[H5];
key += 81 * board[H4];
key += 243 * board[G8];
key += 729 * board[G7];
key += 2187 * board[G6];
key += 6561 * board[G5];
key += 19683 * board[G4];
eval += corner5_2[key];
key_corner5_2[7] = corner5_2[key];
return (float)eval;
}
float check_triangle(UINT8 *board)
{
int key;
double eval;
key = board[A1];
key += 3 * board[A2];
key += 9 * board[A3];
key += 27 * board[A4];
key += 81 * board[B1];
key += 243 * board[B2];
key += 729 * board[B3];
key += 2187 * board[C1];
key += 6561 * board[C2];
key += 19683 * board[D1];
eval = triangle[key];
key_triangle[0] = triangle[key];
key = board[H1];
key += 3 * board[H2];
key += 9 * board[H3];
key += 27 * board[H4];
key += 81 * board[G1];
key += 243 * board[G2];
key += 729 * board[G3];
key += 2187 * board[F1];
key += 6561 * board[F2];
key += 19683 * board[E1];
eval += triangle[key];
key_triangle[1] = triangle[key];
key = board[A8];
key += 3 * board[A7];
key += 9 * board[A6];
key += 27 * board[A5];
key += 81 * board[B8];
key += 243 * board[B7];
key += 729 * board[B6];
key += 2187 * board[C8];
key += 6561 * board[C7];
key += 19683 * board[D8];
eval += triangle[key];
key_triangle[2] = triangle[key];
key = board[H8];
key += 3 * board[H7];
key += 9 * board[H6];
key += 27 * board[H5];
key += 81 * board[G8];
key += 243 * board[G7];
key += 729 * board[G6];
key += 2187 * board[F8];
key += 6561 * board[F7];
key += 19683 * board[E8];
eval += triangle[key];
key_triangle[3] = triangle[key];
return (float)eval;
}
float check_parity(UINT64 blank, UINT32 color)
{
int p;
p = CountBit(blank & 0x0f0f0f0f) % 2;
p |= (CountBit(blank & 0xf0f0f0f0) % 2) << 1;
p |= (CountBit(blank & 0x0f0f0f0f00000000) % 2) << 2;
p |= (CountBit(blank & 0xf0f0f0f000000000) % 2) << 3;
return (float)parity[p];
}
double check_mobility(UINT64 b_board, UINT64 w_board)
{
UINT32 mob1;
CreateMoves(b_board, w_board, &mob1);
//CreateMoves(w_board, b_board, &mob2);
//key_mobility = mob1 * mobility[0];
key_mobility = mobility[mob1];
return key_mobility;
}
/**
* @brief Get the final score.
*
* Get the final score, when no move can be made.
*
* @param board Board.
* @param n_empties Number of empty squares remaining on the board.
* @return The final score, as a disc difference.
*/
INT32 GetExactScore(UINT64 bk, UINT64 wh, INT32 empty)
{
const int n_discs_p = CountBit(bk);
const int n_discs_o = 64 - empty - n_discs_p;
int score = n_discs_p - n_discs_o;
if (score > 0) score += empty;
else if (score < 0) score -= empty;
#ifdef LOSSGAME
return -score;
#else
return score;
#endif
}
/**
* @brief Get the final score.
*
* Get the final score, when no move can be made.
*
* @param board Board.
* @param n_empties Number of empty squares remaining on the board.
* @return The final score, as a disc difference.
*/
INT32 GetWinLossScore(UINT64 bk, UINT64 wh, INT32 empty)
{
const int n_discs_p = CountBit(bk);
const int n_discs_o = 64 - empty - n_discs_p;
int score = n_discs_p - n_discs_o;
if (score > 0) score += empty;
else if (score < 0) score -= empty;
#ifdef LOSSGAME
if (n_discs_p < n_discs_o)
{
score = WIN;
}
else if (n_discs_p > n_discs_o)
{
score = LOSS;
}
else
{
score = DRAW;
}
#else
if (score > 0)
{
score = WIN;
}
else if (score < 0)
{
score = LOSS;
}
else
{
score = DRAW;
}
#endif
return score;
}
INT32 Evaluation(UINT8 *board, UINT64 bk, UINT64 wh, UINT32 color, UINT32 stage)
{
double eval;
/* 現在の色とステージでポインタを指定 */
hori_ver1 = hori_ver1_data[color][stage];
hori_ver2 = hori_ver2_data[color][stage];
hori_ver3 = hori_ver3_data[color][stage];
dia_ver1 = dia_ver1_data[color][stage];
dia_ver2 = dia_ver2_data[color][stage];
dia_ver3 = dia_ver3_data[color][stage];
dia_ver4 = dia_ver4_data[color][stage];
edge = edge_data[color][stage];
corner5_2 = corner5_2_data[color][stage];
corner3_3 = corner3_3_data[color][stage];
triangle = triangle_data[color][stage];
mobility = mobility_data[color][stage];
parity = parity_data[color][stage];
eval = check_h_ver1(board);
eval += check_h_ver2(board);
eval += check_h_ver3(board);
eval += check_dia_ver1(board);
eval += check_dia_ver2(board);
eval += check_dia_ver3(board);
eval += check_dia_ver4(board);
eval += check_edge(board);
eval += check_corner5_2(board);
eval += check_corner3_3(board);
eval += check_triangle(board);
eval += check_mobility(bk, wh);
//eval += check_parity(~(bk | wh), color);
eval_sum = eval;
//eval *= EVAL_ONE_STONE;
return (INT32)eval;
}
int opponent_feature(int l, int d)
{
const int o[] = { 0, 2, 1 };
int f = o[l % 3];
if (d > 1) f += opponent_feature(l / 3, d - 1) * 3;
return f;
}
#if 1
BOOL OpenEvalData(char *filename)
{
int stage = 0;
int i;
UCHAR *buf;
char *line, *ctr = NULL;
double *p_table, *p_table_op;
size_t evalSize;
buf = DecodeEvalData(&evalSize, filename);
if (buf == NULL)
{
return FALSE;
}
line = strtok_s((char *)buf, "\n", &ctr);
while (stage < 60)
{
/* horizon_ver1 */
p_table = hori_ver1_data[0][stage];
p_table_op = hori_ver1_data[1][stage];
for (i = 0; i < 6561; i++)
{
#ifdef LOSSGAME
p_table[i] = -atof(line);
#else
p_table[i] = atof(line);
#endif
/* opponent */
p_table_op[opponent_feature(i, 8)] = -p_table[i];
line = strtok_s(NULL, "\n", &ctr);
}
/* horizon_ver2 */
p_table = hori_ver2_data[0][stage];
p_table_op = hori_ver2_data[1][stage];
for (i = 0; i < 6561; i++)
{
#ifdef LOSSGAME
p_table[i] = -atof(line);
#else
p_table[i] = atof(line);
#endif
p_table_op[opponent_feature(i, 8)] = -p_table[i];
line = strtok_s(NULL, "\n", &ctr);
}
/* horizon_ver3 */
p_table = hori_ver3_data[0][stage];
p_table_op = hori_ver3_data[1][stage];
for (i = 0; i < 6561; i++)
{
#ifdef LOSSGAME
p_table[i] = -atof(line);
#else
p_table[i] = atof(line);
#endif
p_table_op[opponent_feature(i, 8)] = -p_table[i];
line = strtok_s(NULL, "\n", &ctr);
}
/* diagram_ver1 */
p_table = dia_ver1_data[0][stage];
p_table_op = dia_ver1_data[1][stage];
for (i = 0; i < 6561; i++)
{
#ifdef LOSSGAME
p_table[i] = -atof(line);
#else
p_table[i] = atof(line);
#endif
p_table_op[opponent_feature(i, 8)] = -p_table[i];
line = strtok_s(NULL, "\n", &ctr);
}
/* diagram_ver2 */
p_table = dia_ver2_data[0][stage];
p_table_op = dia_ver2_data[1][stage];
for (i = 0; i < 2187; i++)
{
#ifdef LOSSGAME
p_table[i] = -atof(line);
#else
p_table[i] = atof(line);
#endif
p_table_op[opponent_feature(i, 7)] = -p_table[i];
line = strtok_s(NULL, "\n", &ctr);
}
/* diagram_ver3 */
p_table = dia_ver3_data[0][stage];
p_table_op = dia_ver3_data[1][stage];
for (i = 0; i < 729; i++)
{
#ifdef LOSSGAME
p_table[i] = -atof(line);
#else
p_table[i] = atof(line);
#endif
p_table_op[opponent_feature(i, 6)] = -p_table[i];
line = strtok_s(NULL, "\n", &ctr);
}
/* diagram_ver4 */
p_table = dia_ver4_data[0][stage];
p_table_op = dia_ver4_data[1][stage];
for (i = 0; i < 243; i++)
{
#ifdef LOSSGAME
p_table[i] = -atof(line);
#else
p_table[i] = atof(line);
#endif
p_table_op[opponent_feature(i, 5)] = -p_table[i];
line = strtok_s(NULL, "\n", &ctr);
}
/* edge */
p_table = edge_data[0][stage];
p_table_op = edge_data[1][stage];
for (i = 0; i < 59049; i++)
{
#ifdef LOSSGAME
p_table[i] = -atof(line);
#else
p_table[i] = atof(line);
#endif
p_table_op[opponent_feature(i, 10)] = -p_table[i];
line = strtok_s(NULL, "\n", &ctr);
}
/* corner5 + 2X */
p_table = corner5_2_data[0][stage];
p_table_op = corner5_2_data[1][stage];
for (i = 0; i < 59049; i++)
{
#ifdef LOSSGAME
p_table[i] = -atof(line);
#else
p_table[i] = atof(line);
#endif
p_table_op[opponent_feature(i, 10)] = -p_table[i];
line = strtok_s(NULL, "\n", &ctr);
}
/* corner3_3 */
p_table = corner3_3_data[0][stage];
p_table_op = corner3_3_data[1][stage];
for (i = 0; i < 19683; i++)
{
#ifdef LOSSGAME
p_table[i] = -atof(line);
#else
p_table[i] = atof(line);
#endif
p_table_op[opponent_feature(i, 9)] = -p_table[i];
line = strtok_s(NULL, "\n", &ctr);
}
/* triangle */
p_table = triangle_data[0][stage];
p_table_op = triangle_data[1][stage];
for (i = 0; i < 59049; i++)
{
#ifdef LOSSGAME
p_table[i] = -atof(line);
#else
p_table[i] = atof(line);
#endif
p_table_op[opponent_feature(i, 10)] = -p_table[i];
line = strtok_s(NULL, "\n", &ctr);
}
/* mobility */
p_table = mobility_data[0][stage];
p_table_op = mobility_data[1][stage];
for (i = 0; i < MOBILITY_NUM; i++)
{
p_table[i] = atof(line);
p_table_op[i] = p_table[i];
line = strtok_s(NULL, "\n", &ctr);
}
#if 0
/* parity */
p_table = parity_data[0][stage];
p_table_op = parity_data[1][stage];
for (i = 0; i < PARITY_NUM; i++)
{
p_table[i] = atof(line);
p_table_op[i] = p_table[i];
line = strtok_s(NULL, "\n", &ctr);
}
#endif
/* constant */
//constant_data[0][stage] = (float)atof(line);
//line = strtok_s(NULL, "\n", &ctr);
stage++;
}
free(buf);
return TRUE;
}
#endif
BOOL LoadData()
{
BOOL result;
/* 定石データの読み込み */
#if 0
result = OpenBook("src\\books.bin");
if (result == FALSE)
{
return result;
}
#endif
/* 評価テーブルの読み込み */
result = OpenEvalData("src\\eval.bin");
if (result == FALSE)
{
return result;
}
///* MPCテーブルの読み込み */
//result = OpenMpcInfoData("src\\mpc.dat");
return result;
} | [
"kazura2008@gmail.com"
] | kazura2008@gmail.com |
39670092e2a75bd35b17b54a36291b6d96253ff3 | dbf5688128cf8fd27d559788b427563cfd9c39a6 | /NavigationSystem3/myCode/CJsonPersistence.cpp | 5f4feab20ddf04e7e6f7fa1774ee22e646c7796a | [] | no_license | MinarAshiqTishan/NavigationSystem | 438eb63ed5d8804c5ca08171bf76f06908ce8150 | ef0d3076cff3679be88186bb9dd94a182b3bc7a5 | refs/heads/master | 2023-01-11T21:23:55.873199 | 2020-11-09T02:39:07 | 2020-11-09T02:39:07 | 302,281,926 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 12,786 | cpp | /*
* CJsonPersistence.cpp
*
* Created on: Dec 23, 2017
* Author: Tishan
*/
#include <ios>
#include <cstdlib>
#include <algorithm>
#include "CGPSSensor.h"
#include "CRoute.h"
#include "CNavigationSystem.h"
#include "CWaypoint.h"
#include "CPOI.h"
#include "CJsonPersistence.h"
#include "CWpDatabase.h"
#include "CPoiDatabase.h"
#include "CJsonStructure.h"
#include "CJsonScanner.h"
#include "CJsonToken.h"
using namespace std;
CJsonPersistence::CJsonPersistence(){}
void CJsonPersistence::setMediaName(string name){
m_name = name + ".json";
}
bool CJsonPersistence::writeData(const CWpDatabase& waypointDb,
const CPoiDatabase& poiDb){
string name;
double latitude;
double longitude;
t_poi type;
string description;
CJsonStructure jstruct,jarray;
CJsonStructure jpoi,jpoiArray;
this->m_storage.open(m_name.c_str(),m_storage.out);
if((m_storage.rdstate() & ofstream::failbit)!=0){
printError(WRITE,m_name,0);
return true;
}
jstruct.setEncloser("{\n ","},\n");
jarray.setEncloser("[ \n","],\n");
map<string,CWaypoint> wp = waypointDb.getDB();
map<string,CWaypoint>::iterator itrcopy;
for(map<string,CWaypoint>::iterator itr = wp.begin(); itr!=wp.end(); ++itr){
(*itr).second.getAllDataByReference(name,latitude,longitude);
map<string,CWaypoint>::iterator itrcopy=itr;
addStructToJson<string>(jstruct,3,"name",name," ",",\n");
addStructToJson<double>(jstruct,6,"latitude",latitude," ",",\n");
addStructToJson<double>(jstruct,6,"longitude",longitude," ","\n");
if(++itrcopy == wp.end()){
jstruct.setEncloser("{ \n","} \n");
}else
jstruct.setEncloser("{ \n" ,"},\n");
jstruct.setLevel(6);
jstruct.enclose();
jarray.structAdd(jstruct);
jstruct.clear();
}
jarray.setLevel(4);
jarray.enclose();
jstruct.setLevel(3);
jstruct.setEncloser("{\n","}\n");
jstruct.structAdd("waypoint",jarray);
string typeStr;
map<string,CPOI> poi = poiDb.getDB();
jpoi.setEncloser("{ \n","},\n");
jpoiArray.setEncloser("[ \n","] \n");
for(map<string,CPOI>::iterator itr = poi.begin(); itr!=poi.end(); ++itr){
(*itr).second.getAllDataByReference(name,latitude,longitude,type,description);
switch(type){
case RESTAURANT:
typeStr = "RESTAURANT;";
break;
case TOURISTIC:
typeStr = "TOURISTIC;";
break;
case GASSTATION:
typeStr = "GASSTAION;";
break;
case UNIVERSITY:
typeStr = "UNIVERSITY;";
break;
};
map<string,CPOI>::iterator itrcopy=itr;
addStructToJson<string>(jpoi,1,"name",name,"",",\n");
addStructToJson<double>(jpoi,6,"latitude",latitude," ",",\n");
addStructToJson<double>(jpoi,6,"longitude",longitude," ",",\n");
addStructToJson<string>(jpoi,6,"type",typeStr," ",",\n");
addStructToJson<string>(jpoi,6,"description",description," ","\n");
if(++itrcopy == poi.end()){
jpoi.setEncloser("{ \n","} \n");
}else
jpoi.setEncloser("{ \n" ,"},\n");
jpoi.setLevel(6);
jpoi.enclose();
jpoiArray.structAdd(jpoi);
jpoi.clear();
}
jpoiArray.setLevel(4);
jpoiArray.enclose();
jpoi.setLevel(3);
jpoi.setEncloser("{","}");
jpoi.structAdd("pois",jpoiArray);
jstruct.structAdd(jpoi);
jstruct.setLevel(1);
jstruct.enclose();
m_storage<<jstruct.getStream().str();
this->m_storage.close();
return false;
}
void CJsonPersistence::printError(int errorNo, string objName, int lineNo){
cout << "ERROR: ";
switch(errorNo){
case 1:
cout << "can't open file " << objName <<" for writing" << endl;
return;
break;
case 2:
cout << "can't open file "<< objName <<" for reading" << endl;
return;
break;
case 3:
cout << "FIELD DELIMITER error";
break;
case 4:
cout << "TYPE error";
break;
case 5:
cout << "NAME MISSING";
break;
case 6:
cout << "DESCRIPTION MISSING";
break;
case 7:
cout << "NOT A DIGIT";
break;
case 8:
cout << "LATITUDE MISSING";
break;
case 9:
cout << "LONGITUDE MISSING";
break;
case 10:
cout << "LATITUDE OUT of Range";
break;
case 11:
cout << "LONGITUDE OUT of Range";
break;
};
cout <<" in line " << lineNo <<": '" << objName <<"'"<<endl;
}
void CJsonPersistence::trim(string& obj){
obj = obj.substr(obj.find_first_not_of(" \t"),obj.npos);
obj = obj.substr(0,obj.find_last_not_of(" \t")+1);
}
bool CJsonPersistence::readData(CWpDatabase& waypointDb, CPoiDatabase& poiDb,
MergeMode mode){
string name,attribName,typeStr;
double latitude;
double longitude;
t_poi type;
string description;
waypointDb.clearDatabase();
poiDb.clearDatabase();
this->m_storage.open(m_name.c_str(),m_storage.in);
if((m_storage.rdstate() & ifstream::failbit)!=0){
printError(READ,m_name,0);
return true;
}
APT::CJsonScanner scnObj(m_storage);
APT::CJsonToken *token;
APT::CJsonNumberToken *nToken;
APT::CJsonStringToken *sToken;
APT::CJsonToken::TokenType event;
CJsonPersistence::States state = IDLE;
string db;
CJsonPersistence::States action = IDLE;
try{
token = scnObj.nextToken();
}
catch(const std::invalid_argument& e){
cout << "At line " <<scnObj.scannedLine() << ": " <<e.what() << endl;
this->m_storage.close();
return true;
}
// cout << "------IDLE--------------------"<<endl;
while(token){
nToken = dynamic_cast<APT::CJsonNumberToken*>(token);
sToken = dynamic_cast<APT::CJsonStringToken*>(token);
// cout<<token->str()<<endl;
event = token->getType();
// APT::CJsonToken::BEGIN_OBJECT
// APT::CJsonToken::BEGIN_ARRAY
// APT::CJsonToken::NAME_SEPARATOR
// APT::CJsonToken::VALUE_SEPARATOR
// APT::CJsonToken::STRING
// APT::CJsonToken::NUMBER
// APT::CJsonToken::END_ARRAY
// APT::CJsonToken::END_OBJECT
//
switch(state){
case IDLE:
if(event == APT::CJsonToken::BEGIN_OBJECT){
state = WAITING_FOR_DB_NAME;
// cout << "------IDLE to WAITING_FOR_DB_NAME--------------------"<<endl;
}
if(event == APT::CJsonToken::VALUE_SEPARATOR){
state = WAITING_FOR_DB_NAME;
// cout << "------IDLE to WAITING_FOR_DB_NAME--------------------"<<endl;
}
break;
case WAITING_FOR_DB_NAME:
if(event == APT::CJsonToken::STRING){
action = STORE_ATTRIBUTE_NAME;
state = WAITING_FOR_NAME_SEPARATOR;
// cout << "------WAITING_FOR_DB_NAME to WAITING_FOR_NAME_SEPARATOR--------------------"<<endl;
}
break;
case WAITING_FOR_DB_BEGIN:
if(event == APT::CJsonToken::BEGIN_ARRAY){
state = WAITING_FOR_BEGIN_OBJECT;
// cout << "------WAITING_FOR_DB_BEGIN to WAITING_FOR_BEGIN_OBJECT--------------------"<<endl;
}
else if(event == APT::CJsonToken::STRING){
action = ASSIGN_VALUE_ACCORDING_TO_STORED_ATTRIBUTE_NAME;
state = WAITING_FOR_VALUE_SEPARATOR;
}
else if (event == APT::CJsonToken::BEGIN_OBJECT){
state = WAITING_FOR_ATTRIBUTE_NAME;
// cout << "------WAITING_FOR_DB_BEGIN to WAITING_FOR_ATTRIBUTE_NAME--------------------"<<endl;
}
break;
case WAITING_FOR_ATTRIBUTE_NAME:
if(event == APT::CJsonToken::STRING){
action = STORE_ATTRIBUTE_NAME;
state = WAITING_FOR_NAME_SEPARATOR;
// cout << "------WAITING_FOR_ATTRIBUTE_NAME to WAITING_FOR_NAME_SEPARATOR--------------------"<<endl;
}else if (event == APT::CJsonToken::BEGIN_OBJECT){
state = WAITING_FOR_ATTRIBUTE_NAME;
// cout << "------WAITING_FOR_ATTRIBUTE_NAME to WAITING_FOR_ATTRIBUTE_NAME--------------------"<<endl;
}
break;
case WAITING_FOR_NAME_SEPARATOR:
if(event == APT::CJsonToken::NAME_SEPARATOR){
state = WAITING_FOR_VALUE;
// cout << "------WAITING_FOR_NAME_SEPARATOR to WAITING_FOR_VALUE--------------------"<<endl;
}
break;
case WAITING_FOR_VALUE_SEPARATOR:
if(event == APT::CJsonToken::VALUE_SEPARATOR){
state = WAITING_FOR_ATTRIBUTE_NAME;
// cout << "------WAITING_FOR_VALUE_SEPARATOR to WAITING_FOR_ATTRIBUTE_NAME--------------------"<<endl;
}
else if(event == APT::CJsonToken::END_OBJECT){
action = STORE_THE_OBJECT_IN_DB;
state = WAITING_FOR_END_ARRAY;
// cout << "------action : STORE_THE_OBJECT_IN_DB if action != SET_TO_IDLE-------"<<endl;
// cout << "------WAITING_FOR_VALUE_SEPARATOR to WAITING_FOR_END_ARRAY--------------------"<<endl;
//
}
else if(event == APT::CJsonToken::END_ARRAY){
state = IDLE;
// cout << "------WAITING_FOR_VALUE_SEPARATOR to IDLE--------------------"<<endl;
}
break;
case WAITING_FOR_VALUE:
if(event == APT::CJsonToken::BEGIN_ARRAY){
state = WAITING_FOR_DB_BEGIN;
// cout << "------WAITING_FOR_VALUE to WAITING_FOR_DB_BEGIN--------------------"<<endl;
}else if(event == APT::CJsonToken::STRING){
action = ASSIGN_VALUE_ACCORDING_TO_STORED_ATTRIBUTE_NAME;
state = WAITING_FOR_VALUE_SEPARATOR;
// cout << "------WAITING_FOR_VALUE to WAITING_FOR_VALUE_SEPARATOR--------------------"<<endl;
}else if(event == APT::CJsonToken::NUMBER){
action = ASSIGN_VALUE_ACCORDING_TO_STORED_ATTRIBUTE_NAME;
state = WAITING_FOR_VALUE_SEPARATOR;
// cout << "------WAITING_FOR_VALUE to WAITING_FOR_VALUE_SEPARATOR--------------------"<<endl;
}
break;
case WAITING_FOR_BEGIN_OBJECT:
if(event == APT::CJsonToken::STRING){
action = STORE_ATTRIBUTE_NAME;
state = WAITING_FOR_NAME_SEPARATOR;
// cout << "------WAITING_FOR_BEGIN_OBJECT to WAITING_FOR_NAME_SEPARATOR--------------------"<<endl;
} else if (event == APT::CJsonToken::BEGIN_OBJECT){
state = WAITING_FOR_ATTRIBUTE_NAME;
// cout << "------WAITING_FOR_BEGIN_OBJECT to WAITING_FOR_ATTRIBUTE_NAME--------------------"<<endl;
}
break;
case WAITING_FOR_END_OBJECT:
if(event == APT::CJsonToken::VALUE_SEPARATOR){
state = WAITING_FOR_DB_NAME;
// cout << "------WAITING_FOR_END_OBJECT to WAITING_FOR_DB_NAME--------------------"<<endl;
}
if(event == APT::CJsonToken::END_OBJECT){
state = IDLE;
// cout << "------WAITING_FOR_END_OBJECT to IDLE--------------------"<<endl;
}
break;
case WAITING_FOR_END_ARRAY:
if(event == APT::CJsonToken::VALUE_SEPARATOR){
state = WAITING_FOR_BEGIN_OBJECT;
// cout << "------WAITING_FOR_END_ARRAY to WAITING_FOR_BEGIN_OBJECT--------------------"<<endl;
}
else if (event == APT::CJsonToken::END_ARRAY){
state = WAITING_FOR_END_OBJECT;
// cout << "------WAITING_FOR_END_ARRAY to WAITING_FOR_END_OBJECT--------------------"<<endl;
}
break;
default:
break;
}
switch(action){
case IDLE:
break;
case STORE_ATTRIBUTE_NAME:
if(sToken != NULL){
attribName = sToken->getValue();
}
if(attribName == "waypoint" || attribName == "pois"){
db = attribName;
// cout << "------db: " << db << "--------------------"<<endl;
}else
// cout << "------attribName: " << attribName << "--------------------"<<endl;
action = IDLE;
break;
case ASSIGN_VALUE_ACCORDING_TO_STORED_ATTRIBUTE_NAME:
if(attribName == "name"){
if(sToken != NULL){
name = sToken->getValue();
// cout << "------name: " << name << "--------------------"<<endl;
}
}
else if (attribName == "latitude"){
if(nToken != NULL){
latitude = nToken->getValue();
// cout << "------latitude: " << latitude << "--------------------"<<endl;
}
}
else if (attribName == "longitude"){
if(nToken != NULL){
longitude = nToken->getValue();
// cout << "------longitude: " << longitude << "--------------------"<<endl;
}
}
else if(attribName == "description"){
if(sToken != NULL){
description = sToken->getValue();
// cout << "------description: " << description << "--------------------"<<endl;
}
}
else if(attribName == "type"){
if(sToken != NULL){
typeStr = sToken->getValue();
// cout << "------type: " << type << "--------------------"<<endl;
}
if(typeStr == "RESTAURANT"){
type = RESTAURANT;
}
else if(typeStr == "TOURISTIC"){
type = TOURISTIC;
}
else if(typeStr == "GASSTAION"){
type = GASSTATION;
}
else if(typeStr == "UNIVERSITY"){
type = UNIVERSITY;
}
}
action = IDLE;
break;
case STORE_THE_OBJECT_IN_DB:
if(db == "waypoint"){
waypointDb.addWaypoint( CWaypoint(name,latitude,longitude));
// cout<<"------stored in waypoint "<< name << latitude<< longitude <<"---------------" <<endl;
}
else if(db == "pois"){
poiDb.addPoi(CPOI(type,name,description,latitude,longitude));
// cout<<"------stored in pois "<< typeStr << name << description << latitude<< longitude <<"---------------"<< endl;
}
action = IDLE;
break;
default:
action = IDLE;
break;
}
try{
token = scnObj.nextToken();
}
catch(const std::invalid_argument& e){
cout << "Invalid Character(s) At line " <<scnObj.scannedLine() << ": " <<e.what() << endl;
break;
}
// cout<< endl;
}
// waypointDb.print();
// poiDb.print();
this->m_storage.close();
return false;
}
| [
"tishan150@gmail.com"
] | tishan150@gmail.com |
4d2ecd7630b17e7fa843bafcc9f15da54ead6658 | 2e44b55fcd62eaf8ce92207488280a0241a869cf | /360Degree_GyroHand_using_MPU/360Degree_GyroHand_using_MPU.ino | f34112b560ea1389de8860420b46e53488b67618 | [] | no_license | AtharavRH/360Degree_Gyro-Controlled-Hand-using-MPU6050 | eb37af88d66b31ea70acdfc18195c4c41401a39a | b386f479544fc8f329ff2d74c0bc448fe862a35b | refs/heads/main | 2023-01-06T17:26:54.293019 | 2020-11-09T18:58:05 | 2020-11-09T18:58:05 | 311,432,871 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 939 | ino | #include <Wire.h>
#include <MPU6050.h>
#include <Servo.h>
Servo servo1;
Servo servo2; //initlizeing servo instance
int servo_pin1 = 2;
int servo_pin2 = 3;
MPU6050 sensor ;
int16_t ax, ay, az ; //16 byte variable
int16_t gx, gy, gz ; //16 byte variable
void setup()
{
servo1.attach ( servo_pin1 );
servo1.attach ( servo_pin2 );
Wire.begin ( );
Serial.begin (9600);
Serial.println ( "Initializing the sensor" );
sensor.initialize ( );
Serial.println (sensor.testConnection ( ) ? "Successfully Connected" : "Connection failed");
delay (1000);
Serial.println ( "Taking Values from the sensor" );
delay (1000);
}
void loop ( )
{
sensor.getMotion6 (&ax, &ay, &az, &gx, &gy, &gz);
ax = map (ax, -17000, 17000, 0, 180) ;
ay = map (ay, -17000, 17000, 0, 180) ;
Serial.println (ax);
servo1.write (ax);
servo2.write (ay);
delay (200);
}
| [
"noreply@github.com"
] | noreply@github.com |
f999c60bf2b07b10f27b54ae2431a3240bab5f0b | 1f2031871dd34da895c00a103a3ff395930e8370 | /Algo/Contest4/mda.cpp | 567c4d920988b028c6250593f25a57df95d3c1e8 | [] | no_license | irodionzaytsev/Yandex-School-of-Data-Analysis | 5144799f52e166634d28432d37e78750f0408738 | f9ffa955a9963ea400bfb6c95787b0ecd6246a6f | refs/heads/master | 2022-07-07T22:32:20.569998 | 2017-09-02T13:41:13 | 2017-09-02T13:41:13 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,668 | cpp | #include <iostream>
#include <stack>
#include <string>
#include <vector>
#include <utility>
#include <math.h>
#include <algorithm>
#include <list>
#include <ctime>
const long long MOD = 123456789;
template <typename T>
void printPointers(const std::vector<T*>& some_vector) {
for (T* element : some_vector) {
std::cerr << *element << "\n";
}
}
template <typename T>
void printVector(const std::vector<T>& some_vector) {
for (T element : some_vector) {
std::cerr << element << "\n";
}
std::cerr << "\n";
}
template <typename T>
void printVector(const std::vector<std::vector<T>>& some_vector) {
std::cerr << "vector vector:\n";
for (auto sub_vector : some_vector) {
std::cerr << ": ";
for (T& element : sub_vector) {
std::cerr << element << " ";
}
std::cerr << "\n";
}
std::cerr << "\n";
}
void readInput(std::vector<long long>* numbers,
std::istream &in_stream = std::cin) {
int count_numbers;
in_stream >> count_numbers;
numbers->resize(count_numbers);
for (int i = 0; i < count_numbers; ++i) {
in_stream >> (*numbers)[i];
}
}
void writeOutput(long long result,
std::ostream &out_stream = std::cout) {
out_stream << result << "\n";
}
long long solve(const std::vector<long long>& numbers) {
std::vector<long long> sorted_numbers = numbers;
int count = sorted_numbers.size();
std::sort(sorted_numbers.begin(), sorted_numbers.end());
std::vector<std::vector<long long>> dynamics(count, std::vector<long long>(count, 1));
for (int len = 1; len < count; ++len) {
for (int left = 0; left + len < count; ++left) {
int right = left + len;
dynamics[left][right] = dynamics[left + 1][right];
if (sorted_numbers[right] != sorted_numbers[right - 1]) {
dynamics[left][right] = (dynamics[left][right] + dynamics[left][right - 1]) % MOD;
}
for (int inner = left + 1; inner < right; ++inner) {
if (inner > left && sorted_numbers[inner] == sorted_numbers[inner - 1]) {
continue;
}
dynamics[left][right] +=
(dynamics[left][inner - 1] * dynamics[inner + 1][right]) % MOD;
dynamics[left][right] %= MOD;
}
}
}
// printVector(dynamics);
return dynamics[0][count - 1];
}
int main() {
std::ios_base::sync_with_stdio(false);
std::cin.tie(0);
std::vector<long long> numbers;
readInput(&numbers);
long long result = solve(numbers);
writeOutput(result);
}
| [
"leshaxim@mail.ru"
] | leshaxim@mail.ru |
3c009781e6bd46723afb88ed221f48af7c82d069 | 8cb01266f06178a148c215d1e16abda2d9738f39 | /constexpr.cpp | 118fb1936be1ac3441b50a5c2635a0b6901a3b61 | [
"MIT"
] | permissive | kennethpat/CPP-Keywords-Testing | 593d5c3270fdfd16366e7ce19b0eda6dba607351 | 8108c65c723ea139de165862c6911d8b2165b571 | refs/heads/main | 2023-03-26T08:15:11.783054 | 2021-03-29T00:06:23 | 2021-03-29T00:06:23 | 352,184,657 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 222 | cpp | int main()
{
int a = 0;
const int b = a + 1; // allowed
const int c = 0;
//constexpr int d = a + 1; // not allowed because a is not const
constexpr int d = c + 1; // allowed
return 0;
}
| [
"noreply@github.com"
] | noreply@github.com |
7a0a81acdf013dcaabdfdf2bbad563647c0a3c01 | ac9edde30546067bbfe8e3be9b1addfce2891143 | /courselib/src/array_set.hpp | ca6460fd8092fcdf245188744fcc06ec95a47a68 | [] | no_license | bigtreeIan/Programming-in-Cpp | 93e2a2ab00307d8ffa051079bd171f045310daf3 | d71f756e28ac70a769a98bbcf07805575ab0403e | refs/heads/master | 2020-05-15T08:44:30.668935 | 2019-04-18T22:26:40 | 2019-04-18T22:26:40 | 182,030,534 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 13,915 | hpp | #ifndef ARRAY_SET_HPP_
#define ARRAY_SET_HPP_
#include <string>
#include <iostream>
#include <sstream>
#include <initializer_list>
#include "ics_exceptions.hpp"
namespace ics {
template<class T> class ArraySet {
public:
//Destructor/Constructors
~ArraySet();
ArraySet ();
explicit ArraySet (int initial_length);
ArraySet (const ArraySet<T>& to_copy);
explicit ArraySet (const std::initializer_list<T>& il);
//Iterable class must support "for-each" loop: .begin()/.end()/.size() and prefix ++ on returned result
template <class Iterable>
explicit ArraySet (const Iterable& i);
//Queries
bool empty () const;
int size () const;
bool contains (const T& element) const;
std::string str () const; //supplies useful debugging information; contrast to operator <<
//Iterable class must support "for-each" loop: .begin()/.end() and prefix ++ on returned result
template <class Iterable>
bool contains_all (const Iterable& i) const;
//Commands
int insert (const T& element);
int erase (const T& element);
void clear ();
//Iterable class must support "for" loop: .begin()/.end() and prefix ++ on returned result
template <class Iterable>
int insert_all(const Iterable& i);
template <class Iterable>
int erase_all(const Iterable& i);
template<class Iterable>
int retain_all(const Iterable& i);
//Operators
ArraySet<T>& operator = (const ArraySet<T>& rhs);
bool operator == (const ArraySet<T>& rhs) const;
bool operator != (const ArraySet<T>& rhs) const;
bool operator <= (const ArraySet<T>& rhs) const;
bool operator < (const ArraySet<T>& rhs) const;
bool operator >= (const ArraySet<T>& rhs) const;
bool operator > (const ArraySet<T>& rhs) const;
template<class T2>
friend std::ostream& operator << (std::ostream& outs, const ArraySet<T2>& s);
class Iterator {
public:
//Private constructor called in begin/end, which are friends of ArraySet<T>
~Iterator();
T erase();
std::string str () const;
ArraySet<T>::Iterator& operator ++ ();
ArraySet<T>::Iterator operator ++ (int);
bool operator == (const ArraySet<T>::Iterator& rhs) const;
bool operator != (const ArraySet<T>::Iterator& rhs) const;
T& operator * () const;
T* operator -> () const;
friend std::ostream& operator << (std::ostream& outs, const ArraySet<T>::Iterator& i) {
outs << i.str(); //Use the same meaning as the debugging .str() method
return outs;
}
friend Iterator ArraySet<T>::begin () const;
friend Iterator ArraySet<T>::end () const;
private:
//If can_erase is false, current indexes the "next" value (must ++ to reach it)
int current;
ArraySet<T>* ref_set;
int expected_mod_count;
bool can_erase = true;
//Called in friends begin/end
Iterator(ArraySet<T>* iterate_over, int initial);
};
Iterator begin () const;
Iterator end () const;
private:
T* set; //Unordered contiguous array
int length = 0; //Physical length of array: must be >= .size()
int used = 0; //Amount of array used: invariant: 0 <= used <= length
int mod_count = 0; //For sensing concurrent modification
//Helper methods
int erase_at (int i);
void ensure_length(int new_length);
};
////////////////////////////////////////////////////////////////////////////////
//
//ArraySet class and related definitions
//Destructor/Constructors
template<class T>
ArraySet<T>::~ArraySet() {
delete[] set;
}
template<class T>
ArraySet<T>::ArraySet() {
set = new T[length];
}
template<class T>
ArraySet<T>::ArraySet(int initial_length)
: length(initial_length) {
if (length < 0)
length = 0;
set = new T[length];
}
template<class T>
ArraySet<T>::ArraySet(const ArraySet<T>& to_copy)
: length(to_copy.length), used(to_copy.used) {
set = new T[length];
for (int i=0; i<to_copy.used; ++i)
set[i] = to_copy.set[i];
}
template<class T>
ArraySet<T>::ArraySet(const std::initializer_list<T>& il)
: length(il.size()) {
set = new T[length];
for (const T& s_elem : il)
insert(s_elem);
}
template<class T>
template<class Iterable>
ArraySet<T>::ArraySet(const Iterable& i)
: length(i.size()) {
set = new T[length];
for (const T& v : i)
insert(v);
}
////////////////////////////////////////////////////////////////////////////////
//
//Queries
template<class T>
bool ArraySet<T>::empty() const {
return used == 0;
}
template<class T>
int ArraySet<T>::size() const {
return used;
}
template<class T>
bool ArraySet<T>::contains (const T& element) const {
for (int i=0; i<used; ++i)
if (set[i] == element)
return true;
return false;
}
template<class T>
std::string ArraySet<T>::str() const {
std::ostringstream answer;
answer << "ArraySet[";
if (length != 0) {
answer << "0:" << set[0];
for (int i = 1; i < length; ++i)
answer << "," << i << ":" << set[i];
}
answer << "](length=" << length << ",used=" << used << ",mod_count=" << mod_count << ")";
return answer.str();
}
template<class T>
template<class Iterable>
bool ArraySet<T>::contains_all (const Iterable& i) const {
for (const T& v : i)
if (!contains(v))
return false;
return true;
}
////////////////////////////////////////////////////////////////////////////////
//
//Commands
template<class T>
int ArraySet<T>::insert(const T& element) {
for (int i=0; i<used; ++i)
if (set[i] == element)
return 0;
this->ensure_length(used+1);
set[used++] = element;
++mod_count;
return 1;
}
template<class T>
int ArraySet<T>::erase(const T& element) {
for (int i=0; i<used; ++i)
if (set[i] == element)
return erase_at(i);
return 0;
}
template<class T>
void ArraySet<T>::clear() {
used = 0;
++mod_count;
}
template<class T>
template<class Iterable>
int ArraySet<T>::insert_all(const Iterable& i) {
int count = 0;
for (const T& v : i)
count += insert(v);
return count;
}
template<class T>
template<class Iterable>
int ArraySet<T>::erase_all(const Iterable& i) {
int count = 0;
for (const T& v : i)
count += erase(v);
return count;
}
template<class T>
template<class Iterable>
int ArraySet<T>::retain_all(const Iterable& i) {
ArraySet s(i);
int count = 0;
for (int i=0; i<used; i++)
if (!s.contains(set[i])) {
erase_at(i);
--i;
++count;
}
return count;
}
////////////////////////////////////////////////////////////////////////////////
//
//Operators
template<class T>
ArraySet<T>& ArraySet<T>::operator = (const ArraySet<T>& rhs) {
if (this == &rhs)
return *this;
this->ensure_length(rhs.used);
used = rhs.used;
for (int i=0; i<used; ++i)
set[i] = rhs.set[i];
++mod_count;
return *this;
}
template<class T>
bool ArraySet<T>::operator == (const ArraySet<T>& rhs) const {
if (this == &rhs)
return true;
if (used != rhs.size())
return false;
for (int i=0; i<used; ++i)
if (!rhs.contains(set[i]))
return false;
return true;
}
template<class T>
bool ArraySet<T>::operator != (const ArraySet<T>& rhs) const {
return !(*this == rhs);
}
template<class T>
bool ArraySet<T>::operator <= (const ArraySet<T>& rhs) const {
if (this == &rhs)
return true;
if (used > rhs.size())
return false;
for (int i=0; i<used; ++i)
if (!rhs.contains(set[i]))
return false;
return true;
}
template<class T>
bool ArraySet<T>::operator < (const ArraySet<T>& rhs) const {
if (this == &rhs)
return false;
if (used >= rhs.size())
return false;
for (int i=0; i<used; ++i)
if (!rhs.contains(set[i]))
return false;
return true;
}
template<class T>
bool ArraySet<T>::operator >= (const ArraySet<T>& rhs) const {
return rhs <= *this;
}
template<class T>
bool ArraySet<T>::operator > (const ArraySet<T>& rhs) const {
return rhs < *this;
}
template<class T>
std::ostream& operator << (std::ostream& outs, const ArraySet<T>& s) {
outs << "set[";
if (!s.empty()) {
outs << s.set[0];
for (int i = 1; i < s.used; ++i)
outs << ","<< s.set[i];
}
outs << "]";
return outs;
}
////////////////////////////////////////////////////////////////////////////////
//
//Iterator constructors
template<class T>
auto ArraySet<T>::begin () const -> ArraySet<T>::Iterator {
return Iterator(const_cast<ArraySet<T>*>(this),0);
}
template<class T>
auto ArraySet<T>::end () const -> ArraySet<T>::Iterator {
return Iterator(const_cast<ArraySet<T>*>(this),used);
}
////////////////////////////////////////////////////////////////////////////////
//
//Private helper methods
template<class T>
int ArraySet<T>::erase_at(int i) {
set[i] = set[--used];
++mod_count;
return 1;
}
template<class T>
void ArraySet<T>::ensure_length(int new_length) {
if (length >= new_length)
return;
T* old_set = set;
length = std::max(new_length,2*length);
set = new T[length];
for (int i=0; i<used; ++i)
set[i] = old_set[i];
delete [] old_set;
}
////////////////////////////////////////////////////////////////////////////////
//
//Iterator class definitions
template<class T>
ArraySet<T>::Iterator::Iterator(ArraySet<T>* iterate_over, int initial)
: current(initial), ref_set(iterate_over), expected_mod_count(ref_set->mod_count) {
}
template<class T>
ArraySet<T>::Iterator::~Iterator() {}
template<class T>
T ArraySet<T>::Iterator::erase() {
if (expected_mod_count != ref_set->mod_count)
throw ConcurrentModificationError("ArraySet::Iterator::erase");
if (!can_erase)
throw CannotEraseError("ArraySet::Iterator::erase Iterator cursor already erased");
if (current < 0 || current >= ref_set->used)
throw CannotEraseError("ArraySet::Iterator::erase Iterator cursor beyond data structure");
can_erase = false;
T to_return = ref_set->set[current];
ref_set->erase_at(current);
expected_mod_count = ref_set->mod_count;
return to_return;
}
template<class T>
std::string ArraySet<T>::Iterator::str() const {
std::ostringstream answer;
answer << ref_set->str() << "(current=" << current << ",expected_mod_count=" << expected_mod_count << ",can_erase=" << can_erase << ")";
return answer.str();
}
template<class T>
auto ArraySet<T>::Iterator::operator ++ () -> ArraySet<T>::Iterator& {
if (expected_mod_count != ref_set->mod_count)
throw ConcurrentModificationError("ArraySet::Iterator::operator ++");
if (current >= ref_set->used)
return *this;
if (can_erase)
++current;
else
can_erase = true; //current already indexes "one beyond" deleted value
return *this;
}
template<class T>
auto ArraySet<T>::Iterator::operator ++ (int) -> ArraySet<T>::Iterator {
if (expected_mod_count != ref_set->mod_count)
throw ConcurrentModificationError("ArraySet::Iterator::operator ++(int)");
if (current >= ref_set->used)
return *this;
Iterator to_return(*this);
if (can_erase)
++current;
else
can_erase = true; //current already indexes "one beyond" deleted value
return to_return;
}
template<class T>
bool ArraySet<T>::Iterator::operator == (const ArraySet<T>::Iterator& rhs) const {
const Iterator* rhsASI = dynamic_cast<const Iterator*>(&rhs);
if (rhsASI == 0)
throw IteratorTypeError("ArraySet::Iterator::operator ==");
if (expected_mod_count != ref_set->mod_count)
throw ConcurrentModificationError("ArraySet::Iterator::operator ==");
if (ref_set != rhsASI->ref_set)
throw ComparingDifferentIteratorsError("ArraySet::Iterator::operator ==");
return current == rhsASI->current;
}
template<class T>
bool ArraySet<T>::Iterator::operator != (const ArraySet<T>::Iterator& rhs) const {
const Iterator* rhsASI = dynamic_cast<const Iterator*>(&rhs);
if (rhsASI == 0)
throw IteratorTypeError("ArraySet::Iterator::operator !=");
if (expected_mod_count != ref_set->mod_count)
throw ConcurrentModificationError("ArraySet::Iterator::operator !=");
if (ref_set != rhsASI->ref_set)
throw ComparingDifferentIteratorsError("ArraySet::Iterator::operator !=");
return current != rhsASI->current;
}
template<class T>
T& ArraySet<T>::Iterator::operator *() const {
if (expected_mod_count != ref_set->mod_count)
throw ConcurrentModificationError("ArraySet::Iterator::operator *");
if (!can_erase || current < 0 || current >= ref_set->used) {
std::ostringstream where;
where << current << " when size = " << ref_set->size();
throw IteratorPositionIllegal("ArraySet::Iterator::operator * Iterator illegal: "+where.str());
}
return ref_set->set[current];
}
template<class T>
T* ArraySet<T>::Iterator::operator ->() const {
if (expected_mod_count != ref_set->mod_count)
throw ConcurrentModificationError("ArraySet::Iterator::operator ->");
if (!can_erase || current < 0 || current >= ref_set->used) {
std::ostringstream where;
where << current << " when size = " << ref_set->size();
throw IteratorPositionIllegal("ArraySet::Iterator::operator -> Iterator illegal: "+where.str());
}
return &ref_set->set[current];
}
}
#endif /* ARRAY_SET_HPP_ */
| [
"noreply@github.com"
] | noreply@github.com |
e5aae89ba11ae3f6ed0e1c457ca91b048f95368b | 9b0f009b79f9072f362ab480d6584a957fed7af0 | /VoxelEngine/VEChunkData.h | d9a785e375efcc28f533d415e487224446ac8f54 | [] | no_license | Orangeatang/BattleBlocks | c5b29ab995fe40a9395bc2f75f790f1e1ac3f21e | ea43d307db30f20d9c15093408cc2f369dbf4495 | refs/heads/master | 2020-12-02T16:22:39.935184 | 2017-07-07T13:59:57 | 2017-07-07T13:59:57 | 96,543,622 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,760 | h | #ifndef VE_CHUNK_DATA_H
#define VE_CHUNK_DATA_H
// ----------------------- Includes -----------------------
#include "VETypes.h"
// ------------------ Forward Declarations ----------------
class VEChunk;
// ----------------------- Classes ------------------------
// The chunk data class maintains the vertex and index buffer data for a single chunk
class VEChunkData
{
public :
// ------- Public Functions -------
// Construction
VEChunkData( VEChunk* aChunk );
// Initialises the required bits and pieces used for threading
bool Initialise();
// Cleans up the memory used by the
void Uninitialise();
// Clears the vertex and index buffers
void Reset();
// Adds voxel vertices and indices based on the visible faces
void AddFaces( DirectX::XMFLOAT3& aPosition, DWORD aVisability, DirectX::XMFLOAT4& aColour );
// Creates a thread that builds the vertex and index buffers
bool BuildBuffers();
// ---------- Accessors ----------
ID3D11Buffer* GetVertexBuffer() { return myVertexBuffer; }
void SetVertexBuffer( ID3D11Buffer* aVertexBuffer );
ID3D11Buffer* GetIndexBuffer() { return myIndexBuffer; }
void SetIndexBuffer( ID3D11Buffer* anIndexBuffer );
std::vector<VoxelVertices>& GetVertices() { return myVertices; }
std::vector<unsigned long>& GetIndices() { return myIndices; }
int GetIndexCount() { return myIndices.size(); }
private :
// ------- Private Functions ------
// ------- Private Variables ------
ID3D11Buffer* myVertexBuffer;
std::vector<VoxelVertices> myVertices;
ID3D11Buffer* myIndexBuffer;
std::vector<unsigned long> myIndices;
VEChunk* myChunk;
};
#endif // !VE_CHUNK_DATA_H | [
"capoeiraolly@gmail.com"
] | capoeiraolly@gmail.com |
72fd2e1265628531af236bc8462a61c922b7f579 | d128a90d7e8814764ebd67d8169f782367fe65cc | /Cpp/865_Smallest_Subtree_with_all_the_Deepest_Nodes.cpp | d72307092e672d25aed160d8829020894759204c | [] | no_license | silverthreadk/leetcode | 5419a286972fe5646c89804669c591109db9ff04 | 524ba65472f685a4bfff89c61411a35bfdf949c9 | refs/heads/master | 2023-08-31T01:36:06.784134 | 2023-08-29T14:29:50 | 2023-08-29T14:29:50 | 187,839,797 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 899 | 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:
TreeNode* subtreeWithAllDeepest(TreeNode* root) {
auto result = recursive(root);
return result.second;
}
pair<int, TreeNode*> recursive(TreeNode* node){
if(!node) return std::make_pair(0, nullptr);
auto left_result = recursive(node->left);
auto right_result = recursive(node->right);
if (left_result.first == right_result.first) return std::make_pair(left_result.first+1, node);
else if (left_result.first > right_result.first) return std::make_pair(left_result.first+1, left_result.second);
else return std::make_pair(right_result.first+1, right_result.second);
}
}; | [
"eunsill91@gmail.com"
] | eunsill91@gmail.com |
392b8ead7a9d8b36ce358379c8e61bc170154d8a | 88c81e0a7ca42bfa97abdefbb212099006d427de | /ThreeUpMoon.h | a4ad4032d608513f1c4aec916dcbbe9c31fa3673 | [] | no_license | Zombie10/SuperMarioWorld | 4558351547ac978c35d8ee092451ae1b07b520b1 | 180cd5d10ac14ce7973217b000c1fa066036c80a | refs/heads/master | 2023-03-19T02:10:53.422622 | 2016-06-17T09:50:14 | 2016-06-17T09:50:14 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 270 | h | #pragma once
#include "Item.h"
class ThreeUpMoon : public Item
{
public:
ThreeUpMoon(DOUBLE2 topLeft, Level* levelPtr);
ThreeUpMoon(const ThreeUpMoon&) = delete;
ThreeUpMoon& operator=(const ThreeUpMoon&) = delete;
void Tick(double deltaTime);
void Paint();
};
| [
"ajweeks@shaw.ca"
] | ajweeks@shaw.ca |
659bcb776510cd68e5120321936183406a865310 | 11d000973ca6432689eb88684f20c5874e92aebe | /Year2Intro/Year2Intro/src/Loaders/TinyObjLoader/TinyObjSideProject.cpp | fba2fe6a3033fc34c35c0ad8e9e30e3a9c9a24cc | [] | no_license | Boopy321/OpenGlEngineTutorial | c60cdcb1febd6c741e49f75e3a527dd6a293931e | 755db11b4f1f92d6c15c81ee4c015ce712297c51 | refs/heads/master | 2016-09-06T17:18:48.522827 | 2015-07-31T01:12:47 | 2015-07-31T01:12:47 | 32,112,421 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,964 | cpp | //#include "gl_core_4_4.h"
//#include "GLFW\glfw3.h"
//#include "TinyObjSideProject.h"
//#include <glm/ext.hpp>
//#include <glm/glm.hpp>
//#include <stb_image.h>
//#include "FlyCamera.h"
//#include "Gizmos.h"
//#include "Application.h"
//#include <iostream>
//#include <cstdlib>
//#include <stdlib.h>
//#include <time.h>
//#include "ObjectLoader.h"
//#include <AntTweakBar.h>
//#include "tiny_obj_loader.h"
//
//using namespace std;
//
//
//
//
//TinyObjSideProject::TinyObjSideProject()
//{
//}
//
//TinyObjSideProject::~TinyObjSideProject()
//{
//}
//
//void TinyObjSideProject::CreateOpenGlBuffers(std::vector<tinyobj::shape_t>& shapes)
//{
//
// m_gl_info.resize(shapes.size());
//
// for (unsigned int mesh_index = 0; mesh_index < shapes.size(); ++mesh_index)
// {
// glGenVertexArrays(1, &m_gl_info[mesh_index].m_VAO);
// glGenBuffers(1, &m_gl_info[mesh_index].m_VBO);
//
// glGenBuffers(1, &m_gl_info[mesh_index].m_IBO);
// glBindVertexArray(m_gl_info[mesh_index].m_VAO);
//
// unsigned int float_count = shapes[mesh_index].mesh.positions.size();
// float_count += shapes[mesh_index].mesh.normals.size();
// float_count += shapes[mesh_index].mesh.texcoords.size();
//
// std::vector<float> vertex_data;
// vertex_data.reserve(float_count);
//
// vertex_data.insert(vertex_data.end(),
// shapes[mesh_index].mesh.positions.begin(),
// shapes[mesh_index].mesh.positions.end());
//
// vertex_data.insert(vertex_data.end(),
// shapes[mesh_index].mesh.normals.begin(),
// shapes[mesh_index].mesh.normals.end());
//
// m_gl_info[mesh_index].m_index_count =
// shapes[mesh_index].mesh.indices.size();
//
// glBindBuffer(GL_ARRAY_BUFFER, m_gl_info[mesh_index].m_VBO);
// glBufferData(GL_ARRAY_BUFFER,
// vertex_data.size() * sizeof(float),
// vertex_data.data(), GL_STATIC_DRAW);
//
// glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_gl_info[mesh_index].m_IBO);
//
// glBufferData(GL_ELEMENT_ARRAY_BUFFER,
// shapes[mesh_index].mesh.indices.size() * sizeof(unsigned int),
// shapes[mesh_index].mesh.indices.data(), GL_STATIC_DRAW);
//
// glEnableVertexAttribArray(0); //position
// glEnableVertexAttribArray(1); //normal data
//
// glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, 0);
// glVertexAttribPointer(1, 3, GL_FLOAT, GL_TRUE, 0,
// (void*)(sizeof(float)*shapes[mesh_index].mesh.positions.size()));
// glBindVertexArray(0);
// glBindBuffer(GL_ARRAY_BUFFER, 0);
// glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
// }
//
//}
//
//void TinyObjSideProject::ImageLoad()
//{
//
//}
//
//void TinyObjSideProject::Draw(FlyCamera &_gameCamera, float a_deltatime)
//{
// Gizmos::addTransform(glm::mat4(1), 5.0f);
//
// glUseProgram(m_program);
//
// int view_proj_uniform = glGetUniformLocation(m_program, "projection_view");
//
// glUniformMatrix4fv(view_proj_uniform, 1, GL_FALSE, (float*)&_gameCamera.getProjectionView());
//
// for (unsigned int i = 0; i < m_gl_info.size(); ++i)
// {
// glBindVertexArray(m_gl_info[i].m_VAO);
// glDrawElements(GL_TRIANGLES, m_gl_info[i].m_index_count, GL_UNSIGNED_INT, 0);
// }
//}
//
//void TinyObjSideProject::Update()
//{
//}
//
//void TinyObjSideProject::GameLoop()
//{
//}
//
//void TinyObjSideProject::AddVarToTwBar(TwBar* a_bar)
//{
// //Add the variables for Tweak bar
// TwAddVarRW(a_bar, "Light Colour",
// TW_TYPE_COLOR3F, &m_lightColour[0], "");
//
// TwAddVarRW(a_bar, "Light Direction",
// TW_TYPE_DIR3F, &m_lightDir[0], "");
//
// TwAddVarRW(a_bar, "Specular Power",
// TW_TYPE_FLOAT, &m_spec, "");
//}
//
//void TinyObjSideProject::GetShaderProgram(GLuint a_program)
//{
// m_program = a_program;
//}
//
//void TinyObjSideProject::LoadObj()
//{
// std::vector<tinyobj::shape_t> shapes;
// std::vector<tinyobj::material_t> materials;
//
// std::string err = tinyobj::LoadObj(shapes, materials,
// "./models/stanford/bunny.obj");
//
//} | [
"butters_jnr@hotmail.com"
] | butters_jnr@hotmail.com |
2ea0f672518761a3f8078f52328b831446d3a88f | 0fed32c108c680ab4a80b8c4267014f4a8b19c57 | /tst/rankz_ut.cpp | 224ca3c37dd54c3bdefe16c9009a572913cfdc7e | [] | no_license | lingjf/Headz | ede445c42b1e49e5972df0c9b4e0fd4b03f73b09 | 03a47a544c5cef0cdee5c0060671267e7fd6ffcd | refs/heads/master | 2020-04-15T02:13:58.025214 | 2014-07-01T11:54:15 | 2014-07-01T11:54:15 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,187 | cpp | #include "h2unit.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <time.h>
#include "jeffz.h"
#include "rankz.h"
extern "C" {
}
H2SUITE(rankz)
{
void setup()
{
}
void teardown()
{
}
} ;
H2CASE(rankz, Pnm)
{
H2EQUAL_INTEGER(1, Pnm(0,0));
H2EQUAL_INTEGER(1, Pnm(3,0));
H2EQUAL_INTEGER(3, Pnm(3,1));
H2EQUAL_INTEGER(6, Pnm(3,2));
H2EQUAL_INTEGER(6, Pnm(3,3));
H2EQUAL_INTEGER(0, Pnm(3,4));
}
H2CASE(rankz, Ann)
{
H2EQUAL_INTEGER(1, Ann(0));
H2EQUAL_INTEGER(1, Ann(1));
H2EQUAL_INTEGER(2, Ann(2));
H2EQUAL_INTEGER(6, Ann(3));
}
H2CASE(rankz, Cnm)
{
H2EQUAL_INTEGER(1, Cnm(0,0));
H2EQUAL_INTEGER(1, Cnm(3,0));
H2EQUAL_INTEGER(3, Cnm(3,1));
H2EQUAL_INTEGER(3, Cnm(3,2));
H2EQUAL_INTEGER(1, Cnm(3,3));
H2EQUAL_INTEGER(0, Cnm(3,4));
}
void __callback(int a[], int n, int idx)
{
int b[12];
idx_2_seq(b, n, idx);
H2EQUAL_INTEGER(0, memcmp(a,b,n));
}
H2CASE(rankz, seq_idx_gen)
{
int i, a[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12 };
for (i=3; i<10; i++) {
seq_gen(a, i, 0, __callback);
}
}
| [
"lingjf@gmail.com"
] | lingjf@gmail.com |
8b73a4a791b7c90bc3d4cf0638c43b2d9d5bce8c | 0e56ee6fdfe0dd3dad736e608c2e823e8bbed521 | /egen/TestHarness/Reference/src/Random.cpp | 1734588a9b52574c65b7152382546315e360b04d | [
"Artistic-1.0"
] | permissive | dotweiba/dbt5 | d510ab80e979704db71b6d25a9cd7a1a754640b4 | 39e23b0a0bfd4dfcb80cb2231270324f6bbf4b42 | refs/heads/master | 2021-03-09T23:10:31.789560 | 2020-04-27T00:07:33 | 2020-04-27T00:38:06 | 246,391,034 | 0 | 0 | NOASSERTION | 2020-03-10T19:36:36 | 2020-03-10T19:36:36 | null | UTF-8 | C++ | false | false | 7,920 | cpp | /*
* Legal Notice
*
* This document and associated source code (the "Work") is a preliminary
* version of a benchmark specification being developed by the TPC. The
* Work is being made available to the public for review and comment only.
* The TPC reserves all right, title, and interest to the Work as provided
* under U.S. and international laws, including without limitation all patent
* and trademark rights therein.
*
* No Warranty
*
* 1.1 TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THE INFORMATION
* CONTAINED HEREIN IS PROVIDED "AS IS" AND WITH ALL FAULTS, AND THE
* AUTHORS AND DEVELOPERS OF THE WORK HEREBY DISCLAIM ALL OTHER
* WARRANTIES AND CONDITIONS, EITHER EXPRESS, IMPLIED OR STATUTORY,
* INCLUDING, BUT NOT LIMITED TO, ANY (IF ANY) IMPLIED WARRANTIES,
* DUTIES OR CONDITIONS OF MERCHANTABILITY, OF FITNESS FOR A PARTICULAR
* PURPOSE, OF ACCURACY OR COMPLETENESS OF RESPONSES, OF RESULTS, OF
* WORKMANLIKE EFFORT, OF LACK OF VIRUSES, AND OF LACK OF NEGLIGENCE.
* ALSO, THERE IS NO WARRANTY OR CONDITION OF TITLE, QUIET ENJOYMENT,
* QUIET POSSESSION, CORRESPONDENCE TO DESCRIPTION OR NON-INFRINGEMENT
* WITH REGARD TO THE WORK.
* 1.2 IN NO EVENT WILL ANY AUTHOR OR DEVELOPER OF THE WORK BE LIABLE TO
* ANY OTHER PARTY FOR ANY DAMAGES, INCLUDING BUT NOT LIMITED TO THE
* COST OF PROCURING SUBSTITUTE GOODS OR SERVICES, LOST PROFITS, LOSS
* OF USE, LOSS OF DATA, OR ANY INCIDENTAL, CONSEQUENTIAL, DIRECT,
* INDIRECT, OR SPECIAL DAMAGES WHETHER UNDER CONTRACT, TORT, WARRANTY,
* OR OTHERWISE, ARISING IN ANY WAY OUT OF THIS OR ANY OTHER AGREEMENT
* RELATING TO THE WORK, WHETHER OR NOT SUCH AUTHOR OR DEVELOPER HAD
* ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES.
*
* Contributors
* - Charles Levine, Philip Durr, Doug Johnson
*/
#include "../inc/EGenUtilities_stdafx.h"
using namespace TPCE;
inline RNGSEED CRandom::UInt64Rand(void){
UINT64 a = (UINT64) UInt64Rand_A_MULTIPLIER;
UINT64 c = (UINT64) UInt64Rand_C_INCREMENT;
m_seed = (m_seed * a + c); // implicitly truncated to 64bits
return (m_seed);
}
RNGSEED CRandom::RndNthElement( RNGSEED nSeed, RNGSEED nCount) {
UINT64 a = UInt64Rand_A_MULTIPLIER;
UINT64 c = UInt64Rand_C_INCREMENT;
int nBit;
UINT64 Apow = a;
UINT64 Dsum = UInt64Rand_ONE;
// if nothing to do, do nothing !
if( nCount == 0 ) {
return nSeed;
}
// Recursively compute X(n) = A * X(n-1) + C
//
// explicitly:
// X(n) = A^n * X(0) + { A^(n-1) + A^(n-2) + ... A + 1 } * C
//
// we write this as:
// X(n) = Apow(n) * X(0) + Dsum(n) * C
//
// we use the following relations:
// Apow(n) = A^(n%2)*Apow(n/2)*Apow(n/2)
// Dsum(n) = (n%2)*Apow(n/2)*Apow(n/2) + (Apow(n/2) + 1) * Dsum(n/2)
//
// first get the highest non-zero bit
for( nBit = 0; (nCount >> nBit) != UInt64Rand_ONE ; nBit ++){}
// go 1 bit at the time
while( --nBit >= 0 ) {
Dsum *= (Apow + 1);
Apow = Apow * Apow;
if( ((nCount >> nBit) % 2) == 1 ) { // odd value
Dsum += Apow;
Apow *= a;
}
}
nSeed = nSeed * Apow + Dsum * c;
return nSeed;
}
CRandom::CRandom(void)
{
do {
//use portable way to get the seed
m_seed = (RNGSEED) time(NULL);
} while (m_seed == 0);
}
CRandom::CRandom(RNGSEED seed)
{
SetSeed(seed);
}
void CRandom::SetSeed(RNGSEED seed)
{
m_seed = seed;
}
// returns a random value in the range [0 .. 0.99999999999999999994578989137572]
// care should be taken in casting the result as a float because of the
// potential loss of precision.
double CRandom::RndDouble(void)
{
return ((double)UInt64Rand()) * (double) UInt64Rand_RECIPROCAL_2_POWER_64;
}
//return Nth element in the sequence converted to double
double CRandom::RndNthDouble(RNGSEED Seed, RNGSEED N)
{
return ((double)RndNthElement(Seed, N)) * (double) UInt64Rand_RECIPROCAL_2_POWER_64;
}
int CRandom::RndIntRange(int min, int max)
{
if ( min == max ) {
return min;
}
// Check on system symbol for MAXINT
// assert( max < MAXINT );
// This assert would detect when the next line would
// cause an overflow.
max++;
if ( max <= min ) {
return max;
}
return min + (int)(RndDouble() * (double)(max - min));
}
INT64 CRandom::RndInt64Range( INT64 min, INT64 max)
{
if ( min == max )
return min;
// Check on system symbol for 64-bit MAXINT
//assert( max < MAXINT );
// This assert would detect when the next line would
// cause an overflow.
max++;
if ( max <= min )
return max;
return min + (INT64)(RndDouble() * (double)(max - min));
}
//return Nth element in the sequence over the integer range
int CRandom::RndNthIntRange(RNGSEED Seed, RNGSEED N, int min, int max)
{
if ( min == max )
return min;
max++;
if ( max <= min )
return max;
return min + (int)(RndNthDouble(Seed, N) * (double)(max - min));
}
//return Nth element in the sequence over the integer range
INT64 CRandom::RndNthInt64Range(RNGSEED Seed, RNGSEED N, INT64 min, INT64 max)
{
if ( min == max )
return min;
max++;
if ( max <= min )
return max;
return min + (INT64)(RndNthDouble(Seed, N) * (double)(max - min));
}
int CRandom::RndIntRangeExclude(int low, int high, int exclude)
{
int temp;
temp = RndIntRange( low, high-1 );
if (temp >= exclude)
temp += 1;
return temp;
}
INT64 CRandom::RndInt64RangeExclude(INT64 low, INT64 high, INT64 exclude)
{
INT64 temp;
temp = RndInt64Range( low, high-1 );
if (temp >= exclude)
temp += 1;
return temp;
}
float CRandom::RndFloatRange(float min, float max)
{
return min + (float) RndDouble() * (max - min);
}
double CRandom::RndDoubleRange(double min, double max)
{
return min + RndDouble() * (max - min);
}
double CRandom::RndDoubleIncrRange(double min, double max, double incr)
{
INT64 width = (INT64)((max - min) / incr); // need [0..width], so no +1
return min + ((double)RndInt64Range(0, width) * incr);
}
/* Returns a non-uniform random 64-bit integer in range of [P .. Q].
*
* NURnd is used to create a skewed data access pattern. The function is
* similar to NURand in TPC-C. (The two functions are identical when C=0
* and s=0.)
*
* The parameter A must be of the form 2^k - 1, so that Rnd[0..A] will
* produce a k-bit field with all bits having 50/50 probability of being 0
* or 1.
*
* With a k-bit A value, the weights range from 3^k down to 1 with the
* number of equal probability values given by C(k,i) = k! /(i!(k-i)!) for
* 0 <= i <= k. So a bigger A value from a larger k has much more skew.
*
* Left shifting of Rnd[0..A] by "s" bits gets a larger interval without
* getting huge amounts of skew. For example, when applied to elapsed time
* in milliseconds, s=10 effectively ignores the milliseconds, while s=16
* effectively ignores seconds and milliseconds, giving a granularity of
* just over 1 minute (65.536 seconds). A smaller A value can then give
* the desired amount of skew at effectively one-minute resolution.
*/
INT64 CRandom::NURnd( INT64 P, INT64 Q, INT32 A, INT32 s )
{
return ((( RndInt64Range( P, Q ) | (RndInt64Range( 0, A ) << s )) % (Q - P + 1) ) + P );
}
/*
* Returns an alphanumeric string in a specified format;
*/
void CRandom::RndAlphaNumFormatted(char *szReturnString, const char *szFormat)
{
while (szFormat && *szFormat)
{
switch (*szFormat)
{
case 'a': *szReturnString = UpperCaseLetters[ RndIntRange( 0, 25 ) ]; //only uppercase
break;
case 'n': *szReturnString = Numerals[ RndIntRange( 0, 9 ) ];
break;
default:
*szReturnString = *szFormat;
}
++szFormat;
++szReturnString;
}
*szReturnString = '\0';
}
| [
"devnull@localhost"
] | devnull@localhost |
361f338d0b509d050a168b9449a085053d4782e0 | 10b85163837c1c1976d4de6e179d53cf6e371478 | /third_party/common/include/RE/hkStepInfo.h | 5b3ba3908d8540b36d8f93c95392531139cfabb3 | [
"MIT",
"ISC",
"LicenseRef-scancode-mit-taylor-variant",
"LicenseRef-scancode-unknown-license-reference"
] | permissive | rethesda/alchemy | 8e02352240bfb295e1fe7c6682acabe93fc11aa6 | fe6897fa8c065eccc49b61c8c82eda223d865d51 | refs/heads/master | 2023-03-15T19:10:10.132829 | 2020-05-12T05:02:33 | 2020-05-12T05:02:33 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 271 | h | #pragma once
#include "RE/hkBaseTypes.h"
namespace RE
{
class hkStepInfo
{
public:
alignas(0x10) hkTime startTime; // 00
hkTime endTime; // 04
float deltaTime; // 08
float invDeltaTime; // 0C
};
static_assert(sizeof(hkStepInfo) == 0x10);
}
| [
"alexej.h@xiphos.de"
] | alexej.h@xiphos.de |
37685aa2cee15109175320f38b813a768ccb8527 | 45fae7af1a169bd52de9b09082e8ec37e5d42c0a | /sample_code/代码/项目/p2将 Python 翻译成 C++/p2pytoc++/simulate.h | bf6d0bf50c49dacac34d1a87a10b89ae1c7d9e5f | [] | no_license | emp3or/IntroToSelf-control | 05d3bd7f40fa46303b1bc9cd757d7a4ef0ce7bb6 | 4525feb69eedb31c5d2db0877d9bf8c5c43fc6dc | refs/heads/master | 2023-08-22T15:38:39.116984 | 2021-09-26T06:12:12 | 2021-09-26T06:12:12 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 178 | h | //#pragma once
#ifndef SIMULATE_H
#define SIMULATE_H
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
class Simulation;
#endif /* SIMULATE_H */
| [
"15356203871@163.com"
] | 15356203871@163.com |
b65c7e746419901e36ba320649885b242fa6c8b9 | 77da06161391c56143739871992f99c73a470094 | /2014_CodeChallenge/MSP_Code_Challenge_Problem11/Coin.h | 5cf4a4b54634d3d5ec7f59275af34948dda3115e | [] | no_license | KimBoWoon/MSP_Code_Challenge | 99f30790f045b457fa41b7dd99a11d49af6ac7de | 702b2b3d56ea53a7429e55ee3c450dc27d6e7d59 | refs/heads/master | 2016-08-12T19:12:27.157389 | 2016-01-28T07:37:40 | 2016-01-28T07:37:40 | 49,620,984 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 171 | h | #ifndef __COIN__
#define __COIN__
#include <iostream>
#include <cmath>
using namespace std;
class Coin
{
private:
int coin;
public:
Coin();
void compute();
};
#endif | [
"haioer@naver.com"
] | haioer@naver.com |
f7872bb55cb81530e3128d0130ba9184a027b539 | 86bdd374a17c6bf974adc608ef670f6c7b3dfac2 | /src/main.h | 2a4be11218856295e186de9115220d65ca549985 | [
"MIT"
] | permissive | jeronimek/WWFcoin2 | e1bc285a6d4a97b60b5d3188c51c8e913b8e7699 | 9ae9edeaf8701da627c9babb8c32fdd2d1114725 | refs/heads/master | 2021-01-23T20:12:44.170123 | 2014-06-09T12:02:40 | 2014-06-09T12:02:40 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 72,521 | h | // Copyright (c) 2009-2010 Satoshi Nakamoto
// Copyright (c) 2009-2014 The Bitcoin developers
// Distributed under the MIT/X11 software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
#ifndef BITCOIN_MAIN_H
#define BITCOIN_MAIN_H
#include "bignum.h"
#include "sync.h"
#include "net.h"
#include "script.h"
#include "scrypt.h"
#include <list>
class CWallet;
class CBlock;
class CBlockIndex;
class CKeyItem;
class CReserveKey;
class CAddress;
class CInv;
class CNode;
struct CBlockIndexWorkComparator;
/** The maximum allowed size for a serialized block, in bytes (network rule) */
static const unsigned int MAX_BLOCK_SIZE = 1000000; // 1000KB block hard limit
/** Obsolete: maximum size for mined blocks */
static const unsigned int MAX_BLOCK_SIZE_GEN = MAX_BLOCK_SIZE/4; // 250KB block soft limit
/** Default for -blockmaxsize, maximum size for mined blocks **/
static const unsigned int DEFAULT_BLOCK_MAX_SIZE = 250000;
/** Default for -blockprioritysize, maximum space for zero/low-fee transactions **/
static const unsigned int DEFAULT_BLOCK_PRIORITY_SIZE = 17000;
/** The maximum size for transactions we're willing to relay/mine */
static const unsigned int MAX_STANDARD_TX_SIZE = 100000;
/** The maximum allowed number of signature check operations in a block (network rule) */
static const unsigned int MAX_BLOCK_SIGOPS = MAX_BLOCK_SIZE/50;
/** The maximum number of orphan transactions kept in memory */
static const unsigned int MAX_ORPHAN_TRANSACTIONS = MAX_BLOCK_SIZE/100;
/** The maximum number of entries in an 'inv' protocol message */
static const unsigned int MAX_INV_SZ = 50000;
/** The maximum size of a blk?????.dat file (since 0.8) */
static const unsigned int MAX_BLOCKFILE_SIZE = 0x8000000; // 128 MiB
/** The pre-allocation chunk size for blk?????.dat files (since 0.8) */
static const unsigned int BLOCKFILE_CHUNK_SIZE = 0x1000000; // 16 MiB
/** The pre-allocation chunk size for rev?????.dat files (since 0.8) */
static const unsigned int UNDOFILE_CHUNK_SIZE = 0x100000; // 1 MiB
/** Fake height value used in CCoins to signify they are only in the memory pool (since 0.8) */
static const unsigned int MEMPOOL_HEIGHT = 0x7FFFFFFF;
/** Dust Soft Limit, allowed with additional fee per output */
static const int64 DUST_SOFT_LIMIT = 100000; // 0.001 WWFC
/** Dust Hard Limit, ignored as wallet inputs (mininput default) */
static const int64 DUST_HARD_LIMIT = 1000; // 0.00001 WWFC mininput
/** No amount larger than this (in satoshi) is valid */
static const int64 MAX_MONEY = 26910720 * COIN;
inline bool MoneyRange(int64 nValue) { return (nValue >= 0 && nValue <= MAX_MONEY); }
/** Coinbase transaction outputs can only be spent after this number of new blocks (network rule) */
static const int COINBASE_MATURITY = 100;
/** Threshold for nLockTime: below this value it is interpreted as block number, otherwise as UNIX timestamp. */
static const unsigned int LOCKTIME_THRESHOLD = 500000000; // Tue Nov 5 00:53:20 1985 UTC
/** Maximum number of script-checking threads allowed */
static const int MAX_SCRIPTCHECK_THREADS = 16;
#ifdef USE_UPNP
static const int fHaveUPnP = true;
#else
static const int fHaveUPnP = false;
#endif
extern CScript COINBASE_FLAGS;
extern CCriticalSection cs_main;
extern std::map<uint256, CBlockIndex*> mapBlockIndex;
extern std::set<CBlockIndex*, CBlockIndexWorkComparator> setBlockIndexValid;
extern uint256 hashGenesisBlock;
extern CBlockIndex* pindexGenesisBlock;
extern int nBestHeight;
extern uint256 nBestChainWork;
extern uint256 nBestInvalidWork;
extern uint256 hashBestChain;
extern CBlockIndex* pindexBest;
extern unsigned int nTransactionsUpdated;
extern uint64 nLastBlockTx;
extern uint64 nLastBlockSize;
extern const std::string strMessageMagic;
extern double dHashesPerSec;
extern int64 nHPSTimerStart;
extern int64 nTimeBestReceived;
extern CCriticalSection cs_setpwalletRegistered;
extern std::set<CWallet*> setpwalletRegistered;
extern unsigned char pchMessageStart[4];
extern bool fImporting;
extern bool fReindex;
extern bool fBenchmark;
extern int nScriptCheckThreads;
extern bool fTxIndex;
extern unsigned int nCoinCacheSize;
// Settings
extern int64 nTransactionFee;
extern int64 nMinimumInputValue;
// Minimum disk space required - used in CheckDiskSpace()
static const uint64 nMinDiskSpace = 52428800;
class CReserveKey;
class CCoinsDB;
class CBlockTreeDB;
struct CDiskBlockPos;
class CCoins;
class CTxUndo;
class CCoinsView;
class CCoinsViewCache;
class CScriptCheck;
class CValidationState;
struct CBlockTemplate;
/** Register a wallet to receive updates from core */
void RegisterWallet(CWallet* pwalletIn);
/** Unregister a wallet from core */
void UnregisterWallet(CWallet* pwalletIn);
/** Push an updated transaction to all registered wallets */
void SyncWithWallets(const uint256 &hash, const CTransaction& tx, const CBlock* pblock = NULL, bool fUpdate = false);
/** Process an incoming block */
bool ProcessBlock(CValidationState &state, CNode* pfrom, CBlock* pblock, CDiskBlockPos *dbp = NULL);
/** Check whether enough disk space is available for an incoming block */
bool CheckDiskSpace(uint64 nAdditionalBytes = 0);
/** Open a block file (blk?????.dat) */
FILE* OpenBlockFile(const CDiskBlockPos &pos, bool fReadOnly = false);
/** Open an undo file (rev?????.dat) */
FILE* OpenUndoFile(const CDiskBlockPos &pos, bool fReadOnly = false);
/** Import blocks from an external file */
bool LoadExternalBlockFile(FILE* fileIn, CDiskBlockPos *dbp = NULL);
/** Initialize a new block tree database + block data on disk */
bool InitBlockIndex();
/** Load the block tree and coins database from disk */
bool LoadBlockIndex();
/** Unload database information */
void UnloadBlockIndex();
/** Verify consistency of the block and coin databases */
bool VerifyDB(int nCheckLevel, int nCheckDepth);
/** Print the loaded block tree */
void PrintBlockTree();
/** Find a block by height in the currently-connected chain */
CBlockIndex* FindBlockByHeight(int nHeight);
/** Process protocol messages received from a given node */
bool ProcessMessages(CNode* pfrom);
/** Send queued protocol messages to be sent to a give node */
bool SendMessages(CNode* pto, bool fSendTrickle);
/** Run an instance of the script checking thread */
void ThreadScriptCheck();
/** Run the miner threads */
void GenerateBitcoins(bool fGenerate, CWallet* pwallet);
/** Generate a new block, without valid proof-of-work */
CBlockTemplate* CreateNewBlock(const CScript& scriptPubKeyIn);
CBlockTemplate* CreateNewBlockWithKey(CReserveKey& reservekey);
/** Modify the extranonce in a block */
void IncrementExtraNonce(CBlock* pblock, CBlockIndex* pindexPrev, unsigned int& nExtraNonce);
/** Do mining precalculation */
void FormatHashBuffers(CBlock* pblock, char* pmidstate, char* pdata, char* phash1);
/** Check mined block */
bool CheckWork(CBlock* pblock, CWallet& wallet, CReserveKey& reservekey);
/** Check whether a block hash satisfies the proof-of-work requirement specified by nBits */
bool CheckProofOfWork(uint256 hash, unsigned int nBits);
/** Calculate the minimum amount of work a received block needs, without knowing its direct parent */
unsigned int ComputeMinWork(unsigned int nBase, int64 nTime);
/** Get the number of active peers */
int GetNumBlocksOfPeers();
/** Check whether we are doing an initial block download (synchronizing from disk or network) */
bool IsInitialBlockDownload();
/** Format a string that describes several potential problems detected by the core */
std::string GetWarnings(std::string strFor);
/** Retrieve a transaction (from memory pool, or from disk, if possible) */
bool GetTransaction(const uint256 &hash, CTransaction &tx, uint256 &hashBlock, bool fAllowSlow = false);
/** Connect/disconnect blocks until pindexNew is the new tip of the active block chain */
bool SetBestChain(CValidationState &state, CBlockIndex* pindexNew);
/** Find the best known block, and make it the tip of the block chain */
bool ConnectBestBlock(CValidationState &state);
/** Create a new block index entry for a given block hash */
CBlockIndex * InsertBlockIndex(uint256 hash);
/** Verify a signature */
bool VerifySignature(const CCoins& txFrom, const CTransaction& txTo, unsigned int nIn, unsigned int flags, int nHashType);
/** Abort with a message */
bool AbortNode(const std::string &msg);
bool GetWalletFile(CWallet* pwallet, std::string &strWalletFileOut);
struct CDiskBlockPos
{
int nFile;
unsigned int nPos;
IMPLEMENT_SERIALIZE(
READWRITE(VARINT(nFile));
READWRITE(VARINT(nPos));
)
CDiskBlockPos() {
SetNull();
}
CDiskBlockPos(int nFileIn, unsigned int nPosIn) {
nFile = nFileIn;
nPos = nPosIn;
}
friend bool operator==(const CDiskBlockPos &a, const CDiskBlockPos &b) {
return (a.nFile == b.nFile && a.nPos == b.nPos);
}
friend bool operator!=(const CDiskBlockPos &a, const CDiskBlockPos &b) {
return !(a == b);
}
void SetNull() { nFile = -1; nPos = 0; }
bool IsNull() const { return (nFile == -1); }
};
struct CDiskTxPos : public CDiskBlockPos
{
unsigned int nTxOffset; // after header
IMPLEMENT_SERIALIZE(
READWRITE(*(CDiskBlockPos*)this);
READWRITE(VARINT(nTxOffset));
)
CDiskTxPos(const CDiskBlockPos &blockIn, unsigned int nTxOffsetIn) : CDiskBlockPos(blockIn.nFile, blockIn.nPos), nTxOffset(nTxOffsetIn) {
}
CDiskTxPos() {
SetNull();
}
void SetNull() {
CDiskBlockPos::SetNull();
nTxOffset = 0;
}
};
/** An inpoint - a combination of a transaction and an index n into its vin */
class CInPoint
{
public:
CTransaction* ptx;
unsigned int n;
CInPoint() { SetNull(); }
CInPoint(CTransaction* ptxIn, unsigned int nIn) { ptx = ptxIn; n = nIn; }
void SetNull() { ptx = NULL; n = (unsigned int) -1; }
bool IsNull() const { return (ptx == NULL && n == (unsigned int) -1); }
};
/** An outpoint - a combination of a transaction hash and an index n into its vout */
class COutPoint
{
public:
uint256 hash;
unsigned int n;
COutPoint() { SetNull(); }
COutPoint(uint256 hashIn, unsigned int nIn) { hash = hashIn; n = nIn; }
IMPLEMENT_SERIALIZE( READWRITE(FLATDATA(*this)); )
void SetNull() { hash = 0; n = (unsigned int) -1; }
bool IsNull() const { return (hash == 0 && n == (unsigned int) -1); }
friend bool operator<(const COutPoint& a, const COutPoint& b)
{
return (a.hash < b.hash || (a.hash == b.hash && a.n < b.n));
}
friend bool operator==(const COutPoint& a, const COutPoint& b)
{
return (a.hash == b.hash && a.n == b.n);
}
friend bool operator!=(const COutPoint& a, const COutPoint& b)
{
return !(a == b);
}
std::string ToString() const
{
return strprintf("COutPoint(%s, %u)", hash.ToString().c_str(), n);
}
void print() const
{
printf("%s\n", ToString().c_str());
}
};
/** An input of a transaction. It contains the location of the previous
* transaction's output that it claims and a signature that matches the
* output's public key.
*/
class CTxIn
{
public:
COutPoint prevout;
CScript scriptSig;
unsigned int nSequence;
CTxIn()
{
nSequence = std::numeric_limits<unsigned int>::max();
}
explicit CTxIn(COutPoint prevoutIn, CScript scriptSigIn=CScript(), unsigned int nSequenceIn=std::numeric_limits<unsigned int>::max())
{
prevout = prevoutIn;
scriptSig = scriptSigIn;
nSequence = nSequenceIn;
}
CTxIn(uint256 hashPrevTx, unsigned int nOut, CScript scriptSigIn=CScript(), unsigned int nSequenceIn=std::numeric_limits<unsigned int>::max())
{
prevout = COutPoint(hashPrevTx, nOut);
scriptSig = scriptSigIn;
nSequence = nSequenceIn;
}
IMPLEMENT_SERIALIZE
(
READWRITE(prevout);
READWRITE(scriptSig);
READWRITE(nSequence);
)
bool IsFinal() const
{
return (nSequence == std::numeric_limits<unsigned int>::max());
}
friend bool operator==(const CTxIn& a, const CTxIn& b)
{
return (a.prevout == b.prevout &&
a.scriptSig == b.scriptSig &&
a.nSequence == b.nSequence);
}
friend bool operator!=(const CTxIn& a, const CTxIn& b)
{
return !(a == b);
}
std::string ToString() const
{
std::string str;
str += "CTxIn(";
str += prevout.ToString();
if (prevout.IsNull())
str += strprintf(", coinbase %s", HexStr(scriptSig).c_str());
else
str += strprintf(", scriptSig=%s", scriptSig.ToString().substr(0,24).c_str());
if (nSequence != std::numeric_limits<unsigned int>::max())
str += strprintf(", nSequence=%u", nSequence);
str += ")";
return str;
}
void print() const
{
printf("%s\n", ToString().c_str());
}
};
/** An output of a transaction. It contains the public key that the next input
* must be able to sign with to claim it.
*/
class CTxOut
{
public:
int64 nValue;
CScript scriptPubKey;
CTxOut()
{
SetNull();
}
CTxOut(int64 nValueIn, CScript scriptPubKeyIn)
{
nValue = nValueIn;
scriptPubKey = scriptPubKeyIn;
}
IMPLEMENT_SERIALIZE
(
READWRITE(nValue);
READWRITE(scriptPubKey);
)
void SetNull()
{
nValue = -1;
scriptPubKey.clear();
}
bool IsNull() const
{
return (nValue == -1);
}
uint256 GetHash() const
{
return SerializeHash(*this);
}
friend bool operator==(const CTxOut& a, const CTxOut& b)
{
return (a.nValue == b.nValue &&
a.scriptPubKey == b.scriptPubKey);
}
friend bool operator!=(const CTxOut& a, const CTxOut& b)
{
return !(a == b);
}
bool IsDust() const;
std::string ToString() const
{
return strprintf("CTxOut(nValue=%"PRI64d".%08"PRI64d", scriptPubKey=%s)", nValue / COIN, nValue % COIN, scriptPubKey.ToString().substr(0,30).c_str());
}
void print() const
{
printf("%s\n", ToString().c_str());
}
};
enum GetMinFee_mode
{
GMF_BLOCK,
GMF_RELAY,
GMF_SEND,
};
/** The basic transaction that is broadcasted on the network and contained in
* blocks. A transaction can contain multiple inputs and outputs.
*/
class CTransaction
{
public:
static int64 nMinTxFee;
static int64 nMinRelayTxFee;
static const int CURRENT_VERSION=1;
int nVersion;
std::vector<CTxIn> vin;
std::vector<CTxOut> vout;
unsigned int nLockTime;
CTransaction()
{
SetNull();
}
IMPLEMENT_SERIALIZE
(
READWRITE(this->nVersion);
nVersion = this->nVersion;
READWRITE(vin);
READWRITE(vout);
READWRITE(nLockTime);
)
void SetNull()
{
nVersion = CTransaction::CURRENT_VERSION;
vin.clear();
vout.clear();
nLockTime = 0;
}
bool IsNull() const
{
return (vin.empty() && vout.empty());
}
uint256 GetHash() const
{
return SerializeHash(*this);
}
uint256 GetNormalizedHash() const
{
return SignatureHash(CScript(), *this, 0, SIGHASH_ALL);
}
bool IsFinal(int nBlockHeight=0, int64 nBlockTime=0) const
{
// Time based nLockTime implemented in 0.1.6
if (nLockTime == 0)
return true;
if (nBlockHeight == 0)
nBlockHeight = nBestHeight;
if (nBlockTime == 0)
nBlockTime = GetAdjustedTime();
if ((int64)nLockTime < ((int64)nLockTime < LOCKTIME_THRESHOLD ? (int64)nBlockHeight : nBlockTime))
return true;
BOOST_FOREACH(const CTxIn& txin, vin)
if (!txin.IsFinal())
return false;
return true;
}
bool IsNewerThan(const CTransaction& old) const
{
if (vin.size() != old.vin.size())
return false;
for (unsigned int i = 0; i < vin.size(); i++)
if (vin[i].prevout != old.vin[i].prevout)
return false;
bool fNewer = false;
unsigned int nLowest = std::numeric_limits<unsigned int>::max();
for (unsigned int i = 0; i < vin.size(); i++)
{
if (vin[i].nSequence != old.vin[i].nSequence)
{
if (vin[i].nSequence <= nLowest)
{
fNewer = false;
nLowest = vin[i].nSequence;
}
if (old.vin[i].nSequence < nLowest)
{
fNewer = true;
nLowest = old.vin[i].nSequence;
}
}
}
return fNewer;
}
bool IsCoinBase() const
{
return (vin.size() == 1 && vin[0].prevout.IsNull());
}
/** Check for standard transaction types
@return True if all outputs (scriptPubKeys) use only standard transaction forms
*/
bool IsStandard(std::string& strReason) const;
bool IsStandard() const
{
std::string strReason;
return IsStandard(strReason);
}
/** Check for standard transaction types
@param[in] mapInputs Map of previous transactions that have outputs we're spending
@return True if all inputs (scriptSigs) use only standard transaction forms
*/
bool AreInputsStandard(CCoinsViewCache& mapInputs) const;
/** Count ECDSA signature operations the old-fashioned (pre-0.6) way
@return number of sigops this transaction's outputs will produce when spent
*/
unsigned int GetLegacySigOpCount() const;
/** Count ECDSA signature operations in pay-to-script-hash inputs.
@param[in] mapInputs Map of previous transactions that have outputs we're spending
@return maximum number of sigops required to validate this transaction's inputs
*/
unsigned int GetP2SHSigOpCount(CCoinsViewCache& mapInputs) const;
/** Amount of bitcoins spent by this transaction.
@return sum of all outputs (note: does not include fees)
*/
int64 GetValueOut() const
{
int64 nValueOut = 0;
BOOST_FOREACH(const CTxOut& txout, vout)
{
nValueOut += txout.nValue;
if (!MoneyRange(txout.nValue) || !MoneyRange(nValueOut))
throw std::runtime_error("CTransaction::GetValueOut() : value out of range");
}
return nValueOut;
}
/** Amount of bitcoins coming in to this transaction
Note that lightweight clients may not know anything besides the hash of previous transactions,
so may not be able to calculate this.
@param[in] mapInputs Map of previous transactions that have outputs we're spending
@return Sum of value of all inputs (scriptSigs)
*/
int64 GetValueIn(CCoinsViewCache& mapInputs) const;
static bool AllowFree(double dPriority)
{
// Large (in bytes) low-priority (new, small-coin) transactions
// need a fee.
return dPriority > COIN * 288 / 250;
}
// Apply the effects of this transaction on the UTXO set represented by view
void UpdateCoins(const CTransaction& tx, CValidationState &state, CCoinsViewCache &inputs, CTxUndo &txundo, int nHeight, const uint256 &txhash);
int64 GetMinFee(unsigned int nBlockSize=1, bool fAllowFree=true, enum GetMinFee_mode mode=GMF_BLOCK) const;
friend bool operator==(const CTransaction& a, const CTransaction& b)
{
return (a.nVersion == b.nVersion &&
a.vin == b.vin &&
a.vout == b.vout &&
a.nLockTime == b.nLockTime);
}
friend bool operator!=(const CTransaction& a, const CTransaction& b)
{
return !(a == b);
}
std::string ToString() const
{
std::string str;
str += strprintf("CTransaction(hash=%s, ver=%d, vin.size=%"PRIszu", vout.size=%"PRIszu", nLockTime=%u)\n",
GetHash().ToString().c_str(),
nVersion,
vin.size(),
vout.size(),
nLockTime);
for (unsigned int i = 0; i < vin.size(); i++)
str += " " + vin[i].ToString() + "\n";
for (unsigned int i = 0; i < vout.size(); i++)
str += " " + vout[i].ToString() + "\n";
return str;
}
void print() const
{
printf("%s", ToString().c_str());
}
// Check whether all prevouts of this transaction are present in the UTXO set represented by view
bool HaveInputs(CCoinsViewCache &view) const;
// Check whether all inputs of this transaction are valid (no double spends, scripts & sigs, amounts)
// This does not modify the UTXO set. If pvChecks is not NULL, script checks are pushed onto it
// instead of being performed inline.
bool CheckInputs(CValidationState &state, CCoinsViewCache &view, bool fScriptChecks = true,
unsigned int flags = SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_STRICTENC,
std::vector<CScriptCheck> *pvChecks = NULL) const;
// Apply the effects of this transaction on the UTXO set represented by view
void UpdateCoins(CValidationState &state, CCoinsViewCache &view, CTxUndo &txundo, int nHeight, const uint256 &txhash) const;
// Context-independent validity checks
bool CheckTransaction(CValidationState &state) const;
// Try to accept this transaction into the memory pool
bool AcceptToMemoryPool(CValidationState &state, bool fCheckInputs=true, bool fLimitFree = true, bool* pfMissingInputs=NULL, bool fRejectInsaneFee = false);
protected:
static const CTxOut &GetOutputFor(const CTxIn& input, CCoinsViewCache& mapInputs);
};
/** wrapper for CTxOut that provides a more compact serialization */
class CTxOutCompressor
{
private:
CTxOut &txout;
public:
static uint64 CompressAmount(uint64 nAmount);
static uint64 DecompressAmount(uint64 nAmount);
CTxOutCompressor(CTxOut &txoutIn) : txout(txoutIn) { }
IMPLEMENT_SERIALIZE(({
if (!fRead) {
uint64 nVal = CompressAmount(txout.nValue);
READWRITE(VARINT(nVal));
} else {
uint64 nVal = 0;
READWRITE(VARINT(nVal));
txout.nValue = DecompressAmount(nVal);
}
CScriptCompressor cscript(REF(txout.scriptPubKey));
READWRITE(cscript);
});)
};
/** Undo information for a CTxIn
*
* Contains the prevout's CTxOut being spent, and if this was the
* last output of the affected transaction, its metadata as well
* (coinbase or not, height, transaction version)
*/
class CTxInUndo
{
public:
CTxOut txout; // the txout data before being spent
bool fCoinBase; // if the outpoint was the last unspent: whether it belonged to a coinbase
unsigned int nHeight; // if the outpoint was the last unspent: its height
int nVersion; // if the outpoint was the last unspent: its version
CTxInUndo() : txout(), fCoinBase(false), nHeight(0), nVersion(0) {}
CTxInUndo(const CTxOut &txoutIn, bool fCoinBaseIn = false, unsigned int nHeightIn = 0, int nVersionIn = 0) : txout(txoutIn), fCoinBase(fCoinBaseIn), nHeight(nHeightIn), nVersion(nVersionIn) { }
unsigned int GetSerializeSize(int nType, int nVersion) const {
return ::GetSerializeSize(VARINT(nHeight*2+(fCoinBase ? 1 : 0)), nType, nVersion) +
(nHeight > 0 ? ::GetSerializeSize(VARINT(this->nVersion), nType, nVersion) : 0) +
::GetSerializeSize(CTxOutCompressor(REF(txout)), nType, nVersion);
}
template<typename Stream>
void Serialize(Stream &s, int nType, int nVersion) const {
::Serialize(s, VARINT(nHeight*2+(fCoinBase ? 1 : 0)), nType, nVersion);
if (nHeight > 0)
::Serialize(s, VARINT(this->nVersion), nType, nVersion);
::Serialize(s, CTxOutCompressor(REF(txout)), nType, nVersion);
}
template<typename Stream>
void Unserialize(Stream &s, int nType, int nVersion) {
unsigned int nCode = 0;
::Unserialize(s, VARINT(nCode), nType, nVersion);
nHeight = nCode / 2;
fCoinBase = nCode & 1;
if (nHeight > 0)
::Unserialize(s, VARINT(this->nVersion), nType, nVersion);
::Unserialize(s, REF(CTxOutCompressor(REF(txout))), nType, nVersion);
}
};
/** Undo information for a CTransaction */
class CTxUndo
{
public:
// undo information for all txins
std::vector<CTxInUndo> vprevout;
IMPLEMENT_SERIALIZE(
READWRITE(vprevout);
)
};
/** Undo information for a CBlock */
class CBlockUndo
{
public:
std::vector<CTxUndo> vtxundo; // for all but the coinbase
IMPLEMENT_SERIALIZE(
READWRITE(vtxundo);
)
bool WriteToDisk(CDiskBlockPos &pos, const uint256 &hashBlock)
{
// Open history file to append
CAutoFile fileout = CAutoFile(OpenUndoFile(pos), SER_DISK, CLIENT_VERSION);
if (!fileout)
return error("CBlockUndo::WriteToDisk() : OpenUndoFile failed");
// Write index header
unsigned int nSize = fileout.GetSerializeSize(*this);
fileout << FLATDATA(pchMessageStart) << nSize;
// Write undo data
long fileOutPos = ftell(fileout);
if (fileOutPos < 0)
return error("CBlockUndo::WriteToDisk() : ftell failed");
pos.nPos = (unsigned int)fileOutPos;
fileout << *this;
// calculate & write checksum
CHashWriter hasher(SER_GETHASH, PROTOCOL_VERSION);
hasher << hashBlock;
hasher << *this;
fileout << hasher.GetHash();
// Flush stdio buffers and commit to disk before returning
fflush(fileout);
if (!IsInitialBlockDownload())
FileCommit(fileout);
return true;
}
bool ReadFromDisk(const CDiskBlockPos &pos, const uint256 &hashBlock)
{
// Open history file to read
CAutoFile filein = CAutoFile(OpenUndoFile(pos, true), SER_DISK, CLIENT_VERSION);
if (!filein)
return error("CBlockUndo::ReadFromDisk() : OpenBlockFile failed");
// Read block
uint256 hashChecksum;
try {
filein >> *this;
filein >> hashChecksum;
}
catch (std::exception &e) {
return error("%s() : deserialize or I/O error", __PRETTY_FUNCTION__);
}
// Verify checksum
CHashWriter hasher(SER_GETHASH, PROTOCOL_VERSION);
hasher << hashBlock;
hasher << *this;
if (hashChecksum != hasher.GetHash())
return error("CBlockUndo::ReadFromDisk() : checksum mismatch");
return true;
}
};
/** pruned version of CTransaction: only retains metadata and unspent transaction outputs
*
* Serialized format:
* - VARINT(nVersion)
* - VARINT(nCode)
* - unspentness bitvector, for vout[2] and further; least significant byte first
* - the non-spent CTxOuts (via CTxOutCompressor)
* - VARINT(nHeight)
*
* The nCode value consists of:
* - bit 1: IsCoinBase()
* - bit 2: vout[0] is not spent
* - bit 4: vout[1] is not spent
* - The higher bits encode N, the number of non-zero bytes in the following bitvector.
* - In case both bit 2 and bit 4 are unset, they encode N-1, as there must be at
* least one non-spent output).
*
* Example: 0104835800816115944e077fe7c803cfa57f29b36bf87c1d358bb85e
* <><><--------------------------------------------><---->
* | \ | /
* version code vout[1] height
*
* - version = 1
* - code = 4 (vout[1] is not spent, and 0 non-zero bytes of bitvector follow)
* - unspentness bitvector: as 0 non-zero bytes follow, it has length 0
* - vout[1]: 835800816115944e077fe7c803cfa57f29b36bf87c1d35
* * 8358: compact amount representation for 60000000000 (600 BTC)
* * 00: special txout type pay-to-pubkey-hash
* * 816115944e077fe7c803cfa57f29b36bf87c1d35: address uint160
* - height = 203998
*
*
* Example: 0109044086ef97d5790061b01caab50f1b8e9c50a5057eb43c2d9563a4eebbd123008c988f1a4a4de2161e0f50aac7f17e7f9555caa486af3b
* <><><--><--------------------------------------------------><----------------------------------------------><---->
* / \ \ | | /
* version code unspentness vout[4] vout[16] height
*
* - version = 1
* - code = 9 (coinbase, neither vout[0] or vout[1] are unspent,
* 2 (1, +1 because both bit 2 and bit 4 are unset) non-zero bitvector bytes follow)
* - unspentness bitvector: bits 2 (0x04) and 14 (0x4000) are set, so vout[2+2] and vout[14+2] are unspent
* - vout[4]: 86ef97d5790061b01caab50f1b8e9c50a5057eb43c2d9563a4ee
* * 86ef97d579: compact amount representation for 234925952 (2.35 BTC)
* * 00: special txout type pay-to-pubkey-hash
* * 61b01caab50f1b8e9c50a5057eb43c2d9563a4ee: address uint160
* - vout[16]: bbd123008c988f1a4a4de2161e0f50aac7f17e7f9555caa4
* * bbd123: compact amount representation for 110397 (0.001 BTC)
* * 00: special txout type pay-to-pubkey-hash
* * 8c988f1a4a4de2161e0f50aac7f17e7f9555caa4: address uint160
* - height = 120891
*/
class CCoins
{
public:
// whether transaction is a coinbase
bool fCoinBase;
// unspent transaction outputs; spent outputs are .IsNull(); spent outputs at the end of the array are dropped
std::vector<CTxOut> vout;
// at which height this transaction was included in the active block chain
int nHeight;
// version of the CTransaction; accesses to this value should probably check for nHeight as well,
// as new tx version will probably only be introduced at certain heights
int nVersion;
// construct a CCoins from a CTransaction, at a given height
CCoins(const CTransaction &tx, int nHeightIn) : fCoinBase(tx.IsCoinBase()), vout(tx.vout), nHeight(nHeightIn), nVersion(tx.nVersion) { }
// empty constructor
CCoins() : fCoinBase(false), vout(0), nHeight(0), nVersion(0) { }
// remove spent outputs at the end of vout
void Cleanup() {
while (vout.size() > 0 && vout.back().IsNull())
vout.pop_back();
if (vout.empty())
std::vector<CTxOut>().swap(vout);
}
void swap(CCoins &to) {
std::swap(to.fCoinBase, fCoinBase);
to.vout.swap(vout);
std::swap(to.nHeight, nHeight);
std::swap(to.nVersion, nVersion);
}
// equality test
friend bool operator==(const CCoins &a, const CCoins &b) {
return a.fCoinBase == b.fCoinBase &&
a.nHeight == b.nHeight &&
a.nVersion == b.nVersion &&
a.vout == b.vout;
}
friend bool operator!=(const CCoins &a, const CCoins &b) {
return !(a == b);
}
// calculate number of bytes for the bitmask, and its number of non-zero bytes
// each bit in the bitmask represents the availability of one output, but the
// availabilities of the first two outputs are encoded separately
void CalcMaskSize(unsigned int &nBytes, unsigned int &nNonzeroBytes) const {
unsigned int nLastUsedByte = 0;
for (unsigned int b = 0; 2+b*8 < vout.size(); b++) {
bool fZero = true;
for (unsigned int i = 0; i < 8 && 2+b*8+i < vout.size(); i++) {
if (!vout[2+b*8+i].IsNull()) {
fZero = false;
continue;
}
}
if (!fZero) {
nLastUsedByte = b + 1;
nNonzeroBytes++;
}
}
nBytes += nLastUsedByte;
}
bool IsCoinBase() const {
return fCoinBase;
}
unsigned int GetSerializeSize(int nType, int nVersion) const {
unsigned int nSize = 0;
unsigned int nMaskSize = 0, nMaskCode = 0;
CalcMaskSize(nMaskSize, nMaskCode);
bool fFirst = vout.size() > 0 && !vout[0].IsNull();
bool fSecond = vout.size() > 1 && !vout[1].IsNull();
assert(fFirst || fSecond || nMaskCode);
unsigned int nCode = 8*(nMaskCode - (fFirst || fSecond ? 0 : 1)) + (fCoinBase ? 1 : 0) + (fFirst ? 2 : 0) + (fSecond ? 4 : 0);
// version
nSize += ::GetSerializeSize(VARINT(this->nVersion), nType, nVersion);
// size of header code
nSize += ::GetSerializeSize(VARINT(nCode), nType, nVersion);
// spentness bitmask
nSize += nMaskSize;
// txouts themself
for (unsigned int i = 0; i < vout.size(); i++)
if (!vout[i].IsNull())
nSize += ::GetSerializeSize(CTxOutCompressor(REF(vout[i])), nType, nVersion);
// height
nSize += ::GetSerializeSize(VARINT(nHeight), nType, nVersion);
return nSize;
}
template<typename Stream>
void Serialize(Stream &s, int nType, int nVersion) const {
unsigned int nMaskSize = 0, nMaskCode = 0;
CalcMaskSize(nMaskSize, nMaskCode);
bool fFirst = vout.size() > 0 && !vout[0].IsNull();
bool fSecond = vout.size() > 1 && !vout[1].IsNull();
assert(fFirst || fSecond || nMaskCode);
unsigned int nCode = 8*(nMaskCode - (fFirst || fSecond ? 0 : 1)) + (fCoinBase ? 1 : 0) + (fFirst ? 2 : 0) + (fSecond ? 4 : 0);
// version
::Serialize(s, VARINT(this->nVersion), nType, nVersion);
// header code
::Serialize(s, VARINT(nCode), nType, nVersion);
// spentness bitmask
for (unsigned int b = 0; b<nMaskSize; b++) {
unsigned char chAvail = 0;
for (unsigned int i = 0; i < 8 && 2+b*8+i < vout.size(); i++)
if (!vout[2+b*8+i].IsNull())
chAvail |= (1 << i);
::Serialize(s, chAvail, nType, nVersion);
}
// txouts themself
for (unsigned int i = 0; i < vout.size(); i++) {
if (!vout[i].IsNull())
::Serialize(s, CTxOutCompressor(REF(vout[i])), nType, nVersion);
}
// coinbase height
::Serialize(s, VARINT(nHeight), nType, nVersion);
}
template<typename Stream>
void Unserialize(Stream &s, int nType, int nVersion) {
unsigned int nCode = 0;
// version
::Unserialize(s, VARINT(this->nVersion), nType, nVersion);
// header code
::Unserialize(s, VARINT(nCode), nType, nVersion);
fCoinBase = nCode & 1;
std::vector<bool> vAvail(2, false);
vAvail[0] = nCode & 2;
vAvail[1] = nCode & 4;
unsigned int nMaskCode = (nCode / 8) + ((nCode & 6) != 0 ? 0 : 1);
// spentness bitmask
while (nMaskCode > 0) {
unsigned char chAvail = 0;
::Unserialize(s, chAvail, nType, nVersion);
for (unsigned int p = 0; p < 8; p++) {
bool f = (chAvail & (1 << p)) != 0;
vAvail.push_back(f);
}
if (chAvail != 0)
nMaskCode--;
}
// txouts themself
vout.assign(vAvail.size(), CTxOut());
for (unsigned int i = 0; i < vAvail.size(); i++) {
if (vAvail[i])
::Unserialize(s, REF(CTxOutCompressor(vout[i])), nType, nVersion);
}
// coinbase height
::Unserialize(s, VARINT(nHeight), nType, nVersion);
Cleanup();
}
// mark an outpoint spent, and construct undo information
bool Spend(const COutPoint &out, CTxInUndo &undo) {
if (out.n >= vout.size())
return false;
if (vout[out.n].IsNull())
return false;
undo = CTxInUndo(vout[out.n]);
vout[out.n].SetNull();
Cleanup();
if (vout.size() == 0) {
undo.nHeight = nHeight;
undo.fCoinBase = fCoinBase;
undo.nVersion = this->nVersion;
}
return true;
}
// mark a vout spent
bool Spend(int nPos) {
CTxInUndo undo;
COutPoint out(0, nPos);
return Spend(out, undo);
}
// check whether a particular output is still available
bool IsAvailable(unsigned int nPos) const {
return (nPos < vout.size() && !vout[nPos].IsNull());
}
// check whether the entire CCoins is spent
// note that only !IsPruned() CCoins can be serialized
bool IsPruned() const {
BOOST_FOREACH(const CTxOut &out, vout)
if (!out.IsNull())
return false;
return true;
}
};
/** Closure representing one script verification
* Note that this stores references to the spending transaction */
class CScriptCheck
{
private:
CScript scriptPubKey;
const CTransaction *ptxTo;
unsigned int nIn;
unsigned int nFlags;
int nHashType;
public:
CScriptCheck() {}
CScriptCheck(const CCoins& txFromIn, const CTransaction& txToIn, unsigned int nInIn, unsigned int nFlagsIn, int nHashTypeIn) :
scriptPubKey(txFromIn.vout[txToIn.vin[nInIn].prevout.n].scriptPubKey),
ptxTo(&txToIn), nIn(nInIn), nFlags(nFlagsIn), nHashType(nHashTypeIn) { }
bool operator()() const;
void swap(CScriptCheck &check) {
scriptPubKey.swap(check.scriptPubKey);
std::swap(ptxTo, check.ptxTo);
std::swap(nIn, check.nIn);
std::swap(nFlags, check.nFlags);
std::swap(nHashType, check.nHashType);
}
};
/** A transaction with a merkle branch linking it to the block chain. */
class CMerkleTx : public CTransaction
{
private:
int GetDepthInMainChainINTERNAL(CBlockIndex* &pindexRet) const;
public:
uint256 hashBlock;
std::vector<uint256> vMerkleBranch;
int nIndex;
// memory only
mutable bool fMerkleVerified;
CMerkleTx()
{
Init();
}
CMerkleTx(const CTransaction& txIn) : CTransaction(txIn)
{
Init();
}
void Init()
{
hashBlock = 0;
nIndex = -1;
fMerkleVerified = false;
}
IMPLEMENT_SERIALIZE
(
nSerSize += SerReadWrite(s, *(CTransaction*)this, nType, nVersion, ser_action);
nVersion = this->nVersion;
READWRITE(hashBlock);
READWRITE(vMerkleBranch);
READWRITE(nIndex);
)
int SetMerkleBranch(const CBlock* pblock=NULL);
// Return depth of transaction in blockchain:
// -1 : not in blockchain, and not in memory pool (conflicted transaction)
// 0 : in memory pool, waiting to be included in a block
// >=1 : this many blocks deep in the main chain
int GetDepthInMainChain(CBlockIndex* &pindexRet) const;
int GetDepthInMainChain() const { CBlockIndex *pindexRet; return GetDepthInMainChain(pindexRet); }
bool IsInMainChain() const { CBlockIndex *pindexRet; return GetDepthInMainChainINTERNAL(pindexRet) > 0; }
int GetBlocksToMaturity() const;
bool AcceptToMemoryPool(bool fCheckInputs=true, bool fLimitFree=true);
};
/** Data structure that represents a partial merkle tree.
*
* It respresents a subset of the txid's of a known block, in a way that
* allows recovery of the list of txid's and the merkle root, in an
* authenticated way.
*
* The encoding works as follows: we traverse the tree in depth-first order,
* storing a bit for each traversed node, signifying whether the node is the
* parent of at least one matched leaf txid (or a matched txid itself). In
* case we are at the leaf level, or this bit is 0, its merkle node hash is
* stored, and its children are not explorer further. Otherwise, no hash is
* stored, but we recurse into both (or the only) child branch. During
* decoding, the same depth-first traversal is performed, consuming bits and
* hashes as they written during encoding.
*
* The serialization is fixed and provides a hard guarantee about the
* encoded size:
*
* SIZE <= 10 + ceil(32.25*N)
*
* Where N represents the number of leaf nodes of the partial tree. N itself
* is bounded by:
*
* N <= total_transactions
* N <= 1 + matched_transactions*tree_height
*
* The serialization format:
* - uint32 total_transactions (4 bytes)
* - varint number of hashes (1-3 bytes)
* - uint256[] hashes in depth-first order (<= 32*N bytes)
* - varint number of bytes of flag bits (1-3 bytes)
* - byte[] flag bits, packed per 8 in a byte, least significant bit first (<= 2*N-1 bits)
* The size constraints follow from this.
*/
class CPartialMerkleTree
{
protected:
// the total number of transactions in the block
unsigned int nTransactions;
// node-is-parent-of-matched-txid bits
std::vector<bool> vBits;
// txids and internal hashes
std::vector<uint256> vHash;
// flag set when encountering invalid data
bool fBad;
// helper function to efficiently calculate the number of nodes at given height in the merkle tree
unsigned int CalcTreeWidth(int height) {
return (nTransactions+(1 << height)-1) >> height;
}
// calculate the hash of a node in the merkle tree (at leaf level: the txid's themself)
uint256 CalcHash(int height, unsigned int pos, const std::vector<uint256> &vTxid);
// recursive function that traverses tree nodes, storing the data as bits and hashes
void TraverseAndBuild(int height, unsigned int pos, const std::vector<uint256> &vTxid, const std::vector<bool> &vMatch);
// recursive function that traverses tree nodes, consuming the bits and hashes produced by TraverseAndBuild.
// it returns the hash of the respective node.
uint256 TraverseAndExtract(int height, unsigned int pos, unsigned int &nBitsUsed, unsigned int &nHashUsed, std::vector<uint256> &vMatch);
public:
// serialization implementation
IMPLEMENT_SERIALIZE(
READWRITE(nTransactions);
READWRITE(vHash);
std::vector<unsigned char> vBytes;
if (fRead) {
READWRITE(vBytes);
CPartialMerkleTree &us = *(const_cast<CPartialMerkleTree*>(this));
us.vBits.resize(vBytes.size() * 8);
for (unsigned int p = 0; p < us.vBits.size(); p++)
us.vBits[p] = (vBytes[p / 8] & (1 << (p % 8))) != 0;
us.fBad = false;
} else {
vBytes.resize((vBits.size()+7)/8);
for (unsigned int p = 0; p < vBits.size(); p++)
vBytes[p / 8] |= vBits[p] << (p % 8);
READWRITE(vBytes);
}
)
// Construct a partial merkle tree from a list of transaction id's, and a mask that selects a subset of them
CPartialMerkleTree(const std::vector<uint256> &vTxid, const std::vector<bool> &vMatch);
CPartialMerkleTree();
// extract the matching txid's represented by this partial merkle tree.
// returns the merkle root, or 0 in case of failure
uint256 ExtractMatches(std::vector<uint256> &vMatch);
};
/** Nodes collect new transactions into a block, hash them into a hash tree,
* and scan through nonce values to make the block's hash satisfy proof-of-work
* requirements. When they solve the proof-of-work, they broadcast the block
* to everyone and the block is added to the block chain. The first transaction
* in the block is a special one that creates a new coin owned by the creator
* of the block.
*/
class CBlockHeader
{
public:
// header
static const int CURRENT_VERSION=2;
int nVersion;
uint256 hashPrevBlock;
uint256 hashMerkleRoot;
unsigned int nTime;
unsigned int nBits;
unsigned int nNonce;
CBlockHeader()
{
SetNull();
}
IMPLEMENT_SERIALIZE
(
READWRITE(this->nVersion);
nVersion = this->nVersion;
READWRITE(hashPrevBlock);
READWRITE(hashMerkleRoot);
READWRITE(nTime);
READWRITE(nBits);
READWRITE(nNonce);
)
void SetNull()
{
nVersion = CBlockHeader::CURRENT_VERSION;
hashPrevBlock = 0;
hashMerkleRoot = 0;
nTime = 0;
nBits = 0;
nNonce = 0;
}
bool IsNull() const
{
return (nBits == 0);
}
uint256 GetHash() const
{
return Hash(BEGIN(nVersion), END(nNonce));
}
int64 GetBlockTime() const
{
return (int64)nTime;
}
void UpdateTime(const CBlockIndex* pindexPrev);
};
class CBlock : public CBlockHeader
{
public:
// network and disk
std::vector<CTransaction> vtx;
// memory only
mutable std::vector<uint256> vMerkleTree;
CBlock()
{
SetNull();
}
CBlock(const CBlockHeader &header)
{
SetNull();
*((CBlockHeader*)this) = header;
}
IMPLEMENT_SERIALIZE
(
READWRITE(*(CBlockHeader*)this);
READWRITE(vtx);
)
void SetNull()
{
CBlockHeader::SetNull();
vtx.clear();
vMerkleTree.clear();
}
uint256 GetPoWHash() const
{
uint256 thash;
scrypt_1024_1_1_256(BEGIN(nVersion), BEGIN(thash));
return thash;
}
CBlockHeader GetBlockHeader() const
{
CBlockHeader block;
block.nVersion = nVersion;
block.hashPrevBlock = hashPrevBlock;
block.hashMerkleRoot = hashMerkleRoot;
block.nTime = nTime;
block.nBits = nBits;
block.nNonce = nNonce;
return block;
}
uint256 BuildMerkleTree() const
{
vMerkleTree.clear();
BOOST_FOREACH(const CTransaction& tx, vtx)
vMerkleTree.push_back(tx.GetHash());
int j = 0;
for (int nSize = vtx.size(); nSize > 1; nSize = (nSize + 1) / 2)
{
for (int i = 0; i < nSize; i += 2)
{
int i2 = std::min(i+1, nSize-1);
vMerkleTree.push_back(Hash(BEGIN(vMerkleTree[j+i]), END(vMerkleTree[j+i]),
BEGIN(vMerkleTree[j+i2]), END(vMerkleTree[j+i2])));
}
j += nSize;
}
return (vMerkleTree.empty() ? 0 : vMerkleTree.back());
}
const uint256 &GetTxHash(unsigned int nIndex) const {
assert(vMerkleTree.size() > 0); // BuildMerkleTree must have been called first
assert(nIndex < vtx.size());
return vMerkleTree[nIndex];
}
std::vector<uint256> GetMerkleBranch(int nIndex) const
{
if (vMerkleTree.empty())
BuildMerkleTree();
std::vector<uint256> vMerkleBranch;
int j = 0;
for (int nSize = vtx.size(); nSize > 1; nSize = (nSize + 1) / 2)
{
int i = std::min(nIndex^1, nSize-1);
vMerkleBranch.push_back(vMerkleTree[j+i]);
nIndex >>= 1;
j += nSize;
}
return vMerkleBranch;
}
static uint256 CheckMerkleBranch(uint256 hash, const std::vector<uint256>& vMerkleBranch, int nIndex)
{
if (nIndex == -1)
return 0;
BOOST_FOREACH(const uint256& otherside, vMerkleBranch)
{
if (nIndex & 1)
hash = Hash(BEGIN(otherside), END(otherside), BEGIN(hash), END(hash));
else
hash = Hash(BEGIN(hash), END(hash), BEGIN(otherside), END(otherside));
nIndex >>= 1;
}
return hash;
}
bool WriteToDisk(CDiskBlockPos &pos)
{
// Open history file to append
CAutoFile fileout = CAutoFile(OpenBlockFile(pos), SER_DISK, CLIENT_VERSION);
if (!fileout)
return error("CBlock::WriteToDisk() : OpenBlockFile failed");
// Write index header
unsigned int nSize = fileout.GetSerializeSize(*this);
fileout << FLATDATA(pchMessageStart) << nSize;
// Write block
long fileOutPos = ftell(fileout);
if (fileOutPos < 0)
return error("CBlock::WriteToDisk() : ftell failed");
pos.nPos = (unsigned int)fileOutPos;
fileout << *this;
// Flush stdio buffers and commit to disk before returning
fflush(fileout);
if (!IsInitialBlockDownload())
FileCommit(fileout);
return true;
}
bool ReadFromDisk(const CDiskBlockPos &pos)
{
SetNull();
// Open history file to read
CAutoFile filein = CAutoFile(OpenBlockFile(pos, true), SER_DISK, CLIENT_VERSION);
if (!filein)
return error("CBlock::ReadFromDisk() : OpenBlockFile failed");
// Read block
try {
filein >> *this;
}
catch (std::exception &e) {
return error("%s() : deserialize or I/O error", __PRETTY_FUNCTION__);
}
// Check the header
if (!CheckProofOfWork(GetPoWHash(), nBits))
return error("CBlock::ReadFromDisk() : errors in block header");
return true;
}
void print() const
{
printf("CBlock(hash=%s, input=%s, PoW=%s, ver=%d, hashPrevBlock=%s, hashMerkleRoot=%s, nTime=%u, nBits=%08x, nNonce=%u, vtx=%"PRIszu")\n",
GetHash().ToString().c_str(),
HexStr(BEGIN(nVersion),BEGIN(nVersion)+80,false).c_str(),
GetPoWHash().ToString().c_str(),
nVersion,
hashPrevBlock.ToString().c_str(),
hashMerkleRoot.ToString().c_str(),
nTime, nBits, nNonce,
vtx.size());
for (unsigned int i = 0; i < vtx.size(); i++)
{
printf(" ");
vtx[i].print();
}
printf(" vMerkleTree: ");
for (unsigned int i = 0; i < vMerkleTree.size(); i++)
printf("%s ", vMerkleTree[i].ToString().c_str());
printf("\n");
}
/** Undo the effects of this block (with given index) on the UTXO set represented by coins.
* In case pfClean is provided, operation will try to be tolerant about errors, and *pfClean
* will be true if no problems were found. Otherwise, the return value will be false in case
* of problems. Note that in any case, coins may be modified. */
bool DisconnectBlock(CValidationState &state, CBlockIndex *pindex, CCoinsViewCache &coins, bool *pfClean = NULL);
// Apply the effects of this block (with given index) on the UTXO set represented by coins
bool ConnectBlock(CValidationState &state, CBlockIndex *pindex, CCoinsViewCache &coins, bool fJustCheck=false);
// Read a block from disk
bool ReadFromDisk(const CBlockIndex* pindex);
// Add this block to the block index, and if necessary, switch the active block chain to this
bool AddToBlockIndex(CValidationState &state, const CDiskBlockPos &pos);
// Context-independent validity checks
bool CheckBlock(CValidationState &state, bool fCheckPOW=true, bool fCheckMerkleRoot=true) const;
// Store block on disk
// if dbp is provided, the file is known to already reside on disk
bool AcceptBlock(CValidationState &state, CDiskBlockPos *dbp = NULL);
};
class CBlockFileInfo
{
public:
unsigned int nBlocks; // number of blocks stored in file
unsigned int nSize; // number of used bytes of block file
unsigned int nUndoSize; // number of used bytes in the undo file
unsigned int nHeightFirst; // lowest height of block in file
unsigned int nHeightLast; // highest height of block in file
uint64 nTimeFirst; // earliest time of block in file
uint64 nTimeLast; // latest time of block in file
IMPLEMENT_SERIALIZE(
READWRITE(VARINT(nBlocks));
READWRITE(VARINT(nSize));
READWRITE(VARINT(nUndoSize));
READWRITE(VARINT(nHeightFirst));
READWRITE(VARINT(nHeightLast));
READWRITE(VARINT(nTimeFirst));
READWRITE(VARINT(nTimeLast));
)
void SetNull() {
nBlocks = 0;
nSize = 0;
nUndoSize = 0;
nHeightFirst = 0;
nHeightLast = 0;
nTimeFirst = 0;
nTimeLast = 0;
}
CBlockFileInfo() {
SetNull();
}
std::string ToString() const {
return strprintf("CBlockFileInfo(blocks=%u, size=%u, heights=%u...%u, time=%s...%s)", nBlocks, nSize, nHeightFirst, nHeightLast, DateTimeStrFormat("%Y-%m-%d", nTimeFirst).c_str(), DateTimeStrFormat("%Y-%m-%d", nTimeLast).c_str());
}
// update statistics (does not update nSize)
void AddBlock(unsigned int nHeightIn, uint64 nTimeIn) {
if (nBlocks==0 || nHeightFirst > nHeightIn)
nHeightFirst = nHeightIn;
if (nBlocks==0 || nTimeFirst > nTimeIn)
nTimeFirst = nTimeIn;
nBlocks++;
if (nHeightIn > nHeightFirst)
nHeightLast = nHeightIn;
if (nTimeIn > nTimeLast)
nTimeLast = nTimeIn;
}
};
extern CCriticalSection cs_LastBlockFile;
extern CBlockFileInfo infoLastBlockFile;
extern int nLastBlockFile;
enum BlockStatus {
BLOCK_VALID_UNKNOWN = 0,
BLOCK_VALID_HEADER = 1, // parsed, version ok, hash satisfies claimed PoW, 1 <= vtx count <= max, timestamp not in future
BLOCK_VALID_TREE = 2, // parent found, difficulty matches, timestamp >= median previous, checkpoint
BLOCK_VALID_TRANSACTIONS = 3, // only first tx is coinbase, 2 <= coinbase input script length <= 100, transactions valid, no duplicate txids, sigops, size, merkle root
BLOCK_VALID_CHAIN = 4, // outputs do not overspend inputs, no double spends, coinbase output ok, immature coinbase spends, BIP30
BLOCK_VALID_SCRIPTS = 5, // scripts/signatures ok
BLOCK_VALID_MASK = 7,
BLOCK_HAVE_DATA = 8, // full block available in blk*.dat
BLOCK_HAVE_UNDO = 16, // undo data available in rev*.dat
BLOCK_HAVE_MASK = 24,
BLOCK_FAILED_VALID = 32, // stage after last reached validness failed
BLOCK_FAILED_CHILD = 64, // descends from failed block
BLOCK_FAILED_MASK = 96
};
/** The block chain is a tree shaped structure starting with the
* genesis block at the root, with each block potentially having multiple
* candidates to be the next block. pprev and pnext link a path through the
* main/longest chain. A blockindex may have multiple pprev pointing back
* to it, but pnext will only point forward to the longest branch, or will
* be null if the block is not part of the longest chain.
*/
class CBlockIndex
{
public:
// pointer to the hash of the block, if any. memory is owned by this CBlockIndex
const uint256* phashBlock;
// pointer to the index of the predecessor of this block
CBlockIndex* pprev;
// (memory only) pointer to the index of the *active* successor of this block
CBlockIndex* pnext;
// height of the entry in the chain. The genesis block has height 0
int nHeight;
// Which # file this block is stored in (blk?????.dat)
int nFile;
// Byte offset within blk?????.dat where this block's data is stored
unsigned int nDataPos;
// Byte offset within rev?????.dat where this block's undo data is stored
unsigned int nUndoPos;
// (memory only) Total amount of work (expected number of hashes) in the chain up to and including this block
uint256 nChainWork;
// Number of transactions in this block.
// Note: in a potential headers-first mode, this number cannot be relied upon
unsigned int nTx;
// (memory only) Number of transactions in the chain up to and including this block
unsigned int nChainTx; // change to 64-bit type when necessary; won't happen before 2030
// Verification status of this block. See enum BlockStatus
unsigned int nStatus;
// block header
int nVersion;
uint256 hashMerkleRoot;
unsigned int nTime;
unsigned int nBits;
unsigned int nNonce;
CBlockIndex()
{
phashBlock = NULL;
pprev = NULL;
pnext = NULL;
nHeight = 0;
nFile = 0;
nDataPos = 0;
nUndoPos = 0;
nChainWork = 0;
nTx = 0;
nChainTx = 0;
nStatus = 0;
nVersion = 0;
hashMerkleRoot = 0;
nTime = 0;
nBits = 0;
nNonce = 0;
}
CBlockIndex(CBlockHeader& block)
{
phashBlock = NULL;
pprev = NULL;
pnext = NULL;
nHeight = 0;
nFile = 0;
nDataPos = 0;
nUndoPos = 0;
nChainWork = 0;
nTx = 0;
nChainTx = 0;
nStatus = 0;
nVersion = block.nVersion;
hashMerkleRoot = block.hashMerkleRoot;
nTime = block.nTime;
nBits = block.nBits;
nNonce = block.nNonce;
}
CDiskBlockPos GetBlockPos() const {
CDiskBlockPos ret;
if (nStatus & BLOCK_HAVE_DATA) {
ret.nFile = nFile;
ret.nPos = nDataPos;
}
return ret;
}
CDiskBlockPos GetUndoPos() const {
CDiskBlockPos ret;
if (nStatus & BLOCK_HAVE_UNDO) {
ret.nFile = nFile;
ret.nPos = nUndoPos;
}
return ret;
}
CBlockHeader GetBlockHeader() const
{
CBlockHeader block;
block.nVersion = nVersion;
if (pprev)
block.hashPrevBlock = pprev->GetBlockHash();
block.hashMerkleRoot = hashMerkleRoot;
block.nTime = nTime;
block.nBits = nBits;
block.nNonce = nNonce;
return block;
}
uint256 GetBlockHash() const
{
return *phashBlock;
}
int64 GetBlockTime() const
{
return (int64)nTime;
}
CBigNum GetBlockWork() const
{
CBigNum bnTarget;
bnTarget.SetCompact(nBits);
if (bnTarget <= 0)
return 0;
return (CBigNum(1)<<256) / (bnTarget+1);
}
bool IsInMainChain() const
{
return (pnext || this == pindexBest);
}
bool CheckIndex() const
{
/** Scrypt is used for block proof-of-work, but for purposes of performance the index internally uses sha256.
* This check was considered unneccessary given the other safeguards like the genesis and checkpoints. */
return true; // return CheckProofOfWork(GetBlockHash(), nBits);
}
enum { nMedianTimeSpan=11 };
int64 GetMedianTimePast() const
{
int64 pmedian[nMedianTimeSpan];
int64* pbegin = &pmedian[nMedianTimeSpan];
int64* pend = &pmedian[nMedianTimeSpan];
const CBlockIndex* pindex = this;
for (int i = 0; i < nMedianTimeSpan && pindex; i++, pindex = pindex->pprev)
*(--pbegin) = pindex->GetBlockTime();
std::sort(pbegin, pend);
return pbegin[(pend - pbegin)/2];
}
int64 GetMedianTime() const
{
const CBlockIndex* pindex = this;
for (int i = 0; i < nMedianTimeSpan/2; i++)
{
if (!pindex->pnext)
return GetBlockTime();
pindex = pindex->pnext;
}
return pindex->GetMedianTimePast();
}
/**
* Returns true if there are nRequired or more blocks of minVersion or above
* in the last nToCheck blocks, starting at pstart and going backwards.
*/
static bool IsSuperMajority(int minVersion, const CBlockIndex* pstart,
unsigned int nRequired, unsigned int nToCheck);
std::string ToString() const
{
return strprintf("CBlockIndex(pprev=%p, pnext=%p, nHeight=%d, merkle=%s, hashBlock=%s)",
pprev, pnext, nHeight,
hashMerkleRoot.ToString().c_str(),
GetBlockHash().ToString().c_str());
}
void print() const
{
printf("%s\n", ToString().c_str());
}
};
struct CBlockIndexWorkComparator
{
bool operator()(CBlockIndex *pa, CBlockIndex *pb) {
if (pa->nChainWork > pb->nChainWork) return false;
if (pa->nChainWork < pb->nChainWork) return true;
if (pa->GetBlockHash() < pb->GetBlockHash()) return false;
if (pa->GetBlockHash() > pb->GetBlockHash()) return true;
return false; // identical blocks
}
};
/** Used to marshal pointers into hashes for db storage. */
class CDiskBlockIndex : public CBlockIndex
{
public:
uint256 hashPrev;
CDiskBlockIndex() {
hashPrev = 0;
}
explicit CDiskBlockIndex(CBlockIndex* pindex) : CBlockIndex(*pindex) {
hashPrev = (pprev ? pprev->GetBlockHash() : 0);
}
IMPLEMENT_SERIALIZE
(
if (!(nType & SER_GETHASH))
READWRITE(VARINT(nVersion));
READWRITE(VARINT(nHeight));
READWRITE(VARINT(nStatus));
READWRITE(VARINT(nTx));
if (nStatus & (BLOCK_HAVE_DATA | BLOCK_HAVE_UNDO))
READWRITE(VARINT(nFile));
if (nStatus & BLOCK_HAVE_DATA)
READWRITE(VARINT(nDataPos));
if (nStatus & BLOCK_HAVE_UNDO)
READWRITE(VARINT(nUndoPos));
// block header
READWRITE(this->nVersion);
READWRITE(hashPrev);
READWRITE(hashMerkleRoot);
READWRITE(nTime);
READWRITE(nBits);
READWRITE(nNonce);
)
uint256 GetBlockHash() const
{
CBlockHeader block;
block.nVersion = nVersion;
block.hashPrevBlock = hashPrev;
block.hashMerkleRoot = hashMerkleRoot;
block.nTime = nTime;
block.nBits = nBits;
block.nNonce = nNonce;
return block.GetHash();
}
std::string ToString() const
{
std::string str = "CDiskBlockIndex(";
str += CBlockIndex::ToString();
str += strprintf("\n hashBlock=%s, hashPrev=%s)",
GetBlockHash().ToString().c_str(),
hashPrev.ToString().c_str());
return str;
}
void print() const
{
printf("%s\n", ToString().c_str());
}
};
/** Capture information about block/transaction validation */
class CValidationState {
private:
enum mode_state {
MODE_VALID, // everything ok
MODE_INVALID, // network rule violation (DoS value may be set)
MODE_ERROR, // run-time error
} mode;
int nDoS;
bool corruptionPossible;
public:
CValidationState() : mode(MODE_VALID), nDoS(0), corruptionPossible(false) {}
bool DoS(int level, bool ret = false, bool corruptionIn = false) {
if (mode == MODE_ERROR)
return ret;
nDoS += level;
mode = MODE_INVALID;
corruptionPossible = corruptionIn;
return ret;
}
bool Invalid(bool ret = false) {
return DoS(0, ret);
}
bool Error() {
mode = MODE_ERROR;
return false;
}
bool Abort(const std::string &msg) {
AbortNode(msg);
return Error();
}
bool IsValid() {
return mode == MODE_VALID;
}
bool IsInvalid() {
return mode == MODE_INVALID;
}
bool IsError() {
return mode == MODE_ERROR;
}
bool IsInvalid(int &nDoSOut) {
if (IsInvalid()) {
nDoSOut = nDoS;
return true;
}
return false;
}
bool CorruptionPossible() {
return corruptionPossible;
}
};
/** Describes a place in the block chain to another node such that if the
* other node doesn't have the same branch, it can find a recent common trunk.
* The further back it is, the further before the fork it may be.
*/
class CBlockLocator
{
protected:
std::vector<uint256> vHave;
public:
CBlockLocator()
{
}
explicit CBlockLocator(const CBlockIndex* pindex)
{
Set(pindex);
}
explicit CBlockLocator(uint256 hashBlock)
{
std::map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hashBlock);
if (mi != mapBlockIndex.end())
Set((*mi).second);
}
CBlockLocator(const std::vector<uint256>& vHaveIn)
{
vHave = vHaveIn;
}
IMPLEMENT_SERIALIZE
(
if (!(nType & SER_GETHASH))
READWRITE(nVersion);
READWRITE(vHave);
)
void SetNull()
{
vHave.clear();
}
bool IsNull()
{
return vHave.empty();
}
void Set(const CBlockIndex* pindex)
{
vHave.clear();
int nStep = 1;
while (pindex)
{
vHave.push_back(pindex->GetBlockHash());
// Exponentially larger steps back
for (int i = 0; pindex && i < nStep; i++)
pindex = pindex->pprev;
if (vHave.size() > 10)
nStep *= 2;
}
vHave.push_back(hashGenesisBlock);
}
int GetDistanceBack()
{
// Retrace how far back it was in the sender's branch
int nDistance = 0;
int nStep = 1;
BOOST_FOREACH(const uint256& hash, vHave)
{
std::map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hash);
if (mi != mapBlockIndex.end())
{
CBlockIndex* pindex = (*mi).second;
if (pindex->IsInMainChain())
return nDistance;
}
nDistance += nStep;
if (nDistance > 10)
nStep *= 2;
}
return nDistance;
}
CBlockIndex* GetBlockIndex()
{
// Find the first block the caller has in the main chain
BOOST_FOREACH(const uint256& hash, vHave)
{
std::map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hash);
if (mi != mapBlockIndex.end())
{
CBlockIndex* pindex = (*mi).second;
if (pindex->IsInMainChain())
return pindex;
}
}
return pindexGenesisBlock;
}
uint256 GetBlockHash()
{
// Find the first block the caller has in the main chain
BOOST_FOREACH(const uint256& hash, vHave)
{
std::map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hash);
if (mi != mapBlockIndex.end())
{
CBlockIndex* pindex = (*mi).second;
if (pindex->IsInMainChain())
return hash;
}
}
return hashGenesisBlock;
}
int GetHeight()
{
CBlockIndex* pindex = GetBlockIndex();
if (!pindex)
return 0;
return pindex->nHeight;
}
};
class CTxMemPool
{
public:
mutable CCriticalSection cs;
std::map<uint256, CTransaction> mapTx;
std::map<COutPoint, CInPoint> mapNextTx;
bool accept(CValidationState &state, CTransaction &tx, bool fCheckInputs, bool fLimitFree, bool* pfMissingInputs, bool fRejectInsaneFee = false);
bool addUnchecked(const uint256& hash, const CTransaction &tx);
bool remove(const CTransaction &tx, bool fRecursive = false);
bool removeConflicts(const CTransaction &tx);
void clear();
void queryHashes(std::vector<uint256>& vtxid);
void pruneSpent(const uint256& hash, CCoins &coins);
unsigned long size()
{
LOCK(cs);
return mapTx.size();
}
bool exists(uint256 hash)
{
return (mapTx.count(hash) != 0);
}
CTransaction& lookup(uint256 hash)
{
return mapTx[hash];
}
};
extern CTxMemPool mempool;
struct CCoinsStats
{
int nHeight;
uint256 hashBlock;
uint64 nTransactions;
uint64 nTransactionOutputs;
uint64 nSerializedSize;
uint256 hashSerialized;
int64 nTotalAmount;
CCoinsStats() : nHeight(0), hashBlock(0), nTransactions(0), nTransactionOutputs(0), nSerializedSize(0), hashSerialized(0), nTotalAmount(0) {}
};
/** Abstract view on the open txout dataset. */
class CCoinsView
{
public:
// Retrieve the CCoins (unspent transaction outputs) for a given txid
virtual bool GetCoins(const uint256 &txid, CCoins &coins);
// Modify the CCoins for a given txid
virtual bool SetCoins(const uint256 &txid, const CCoins &coins);
// Just check whether we have data for a given txid.
// This may (but cannot always) return true for fully spent transactions
virtual bool HaveCoins(const uint256 &txid);
// Retrieve the block index whose state this CCoinsView currently represents
virtual CBlockIndex *GetBestBlock();
// Modify the currently active block index
virtual bool SetBestBlock(CBlockIndex *pindex);
// Do a bulk modification (multiple SetCoins + one SetBestBlock)
virtual bool BatchWrite(const std::map<uint256, CCoins> &mapCoins, CBlockIndex *pindex);
// Calculate statistics about the unspent transaction output set
virtual bool GetStats(CCoinsStats &stats);
// As we use CCoinsViews polymorphically, have a virtual destructor
virtual ~CCoinsView() {}
};
/** CCoinsView backed by another CCoinsView */
class CCoinsViewBacked : public CCoinsView
{
protected:
CCoinsView *base;
public:
CCoinsViewBacked(CCoinsView &viewIn);
bool GetCoins(const uint256 &txid, CCoins &coins);
bool SetCoins(const uint256 &txid, const CCoins &coins);
bool HaveCoins(const uint256 &txid);
CBlockIndex *GetBestBlock();
bool SetBestBlock(CBlockIndex *pindex);
void SetBackend(CCoinsView &viewIn);
bool BatchWrite(const std::map<uint256, CCoins> &mapCoins, CBlockIndex *pindex);
bool GetStats(CCoinsStats &stats);
};
/** CCoinsView that adds a memory cache for transactions to another CCoinsView */
class CCoinsViewCache : public CCoinsViewBacked
{
protected:
CBlockIndex *pindexTip;
std::map<uint256,CCoins> cacheCoins;
public:
CCoinsViewCache(CCoinsView &baseIn, bool fDummy = false);
// Standard CCoinsView methods
bool GetCoins(const uint256 &txid, CCoins &coins);
bool SetCoins(const uint256 &txid, const CCoins &coins);
bool HaveCoins(const uint256 &txid);
CBlockIndex *GetBestBlock();
bool SetBestBlock(CBlockIndex *pindex);
bool BatchWrite(const std::map<uint256, CCoins> &mapCoins, CBlockIndex *pindex);
// Return a modifiable reference to a CCoins. Check HaveCoins first.
// Many methods explicitly require a CCoinsViewCache because of this method, to reduce
// copying.
CCoins &GetCoins(const uint256 &txid);
// Push the modifications applied to this cache to its base.
// Failure to call this method before destruction will cause the changes to be forgotten.
bool Flush();
// Calculate the size of the cache (in number of transactions)
unsigned int GetCacheSize();
private:
std::map<uint256,CCoins>::iterator FetchCoins(const uint256 &txid);
};
/** CCoinsView that brings transactions from a memorypool into view.
It does not check for spendings by memory pool transactions. */
class CCoinsViewMemPool : public CCoinsViewBacked
{
protected:
CTxMemPool &mempool;
public:
CCoinsViewMemPool(CCoinsView &baseIn, CTxMemPool &mempoolIn);
bool GetCoins(const uint256 &txid, CCoins &coins);
bool HaveCoins(const uint256 &txid);
};
/** Global variable that points to the active CCoinsView (protected by cs_main) */
extern CCoinsViewCache *pcoinsTip;
/** Global variable that points to the active block tree (protected by cs_main) */
extern CBlockTreeDB *pblocktree;
struct CBlockTemplate
{
CBlock block;
std::vector<int64_t> vTxFees;
std::vector<int64_t> vTxSigOps;
};
#if defined(_M_IX86) || defined(__i386__) || defined(__i386) || defined(_M_X64) || defined(__x86_64__) || defined(_M_AMD64)
extern unsigned int cpuid_edx;
#endif
/** Used to relay blocks as header + vector<merkle branch>
* to filtered nodes.
*/
class CMerkleBlock
{
public:
// Public only for unit testing
CBlockHeader header;
CPartialMerkleTree txn;
public:
// Public only for unit testing and relay testing
// (not relayed)
std::vector<std::pair<unsigned int, uint256> > vMatchedTxn;
// Create from a CBlock, filtering transactions according to filter
// Note that this will call IsRelevantAndUpdate on the filter for each transaction,
// thus the filter will likely be modified.
CMerkleBlock(const CBlock& block, CBloomFilter& filter);
IMPLEMENT_SERIALIZE
(
READWRITE(header);
READWRITE(txn);
)
};
#endif
| [
"andrzejczak.michal@outlook.com"
] | andrzejczak.michal@outlook.com |
a296c2d196fff3df8eb8c61194211c78ce2a7b48 | 87085b9ea3a10d92988744bd57b8f6b0621d7dbe | /dependencies/mix.h | 569353c1c8a82e1fbbbfab7f160229f486d79c22 | [] | no_license | fordream/oiramExporter | 85146e68a3c618a560ce563576fb3643712cce27 | 59d0ba49ee4a4f43826a9dbeebde1eea50caeed5 | refs/heads/master | 2021-01-24T19:51:34.925165 | 2015-10-31T13:34:18 | 2015-10-31T13:34:18 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 5,039 | h | #ifndef __MIXRENDER__H
#define __MIXRENDER__H
#include "IHardwareMaterial.h"
#include "3dsmaxport.h"
static Class_ID mixClassID(MIX_CLASS_ID,0);
#define NMIXSUBTEX 3 // number of texture map slots
#define NCOLS 2 // number of color swatches
#define MIX_CLASSNAME _T("")//GetString(IDS_RB_FOG)
//--------------------------------------------------------------
// Mix: A Mix texture map
//--------------------------------------------------------------
#define PB_REF 0
#define SUB1_REF 1
#define SUB2_REF 2
#define SUB3_REF 3
#define PB_TEXOUT 4
class MixDlgProc;
class Mix: public MultiTex {
public:
enum
{
mix_mix, mix_curvea, mix_curveb, mix_usecurve,
mix_color1, mix_color2,
mix_map1, mix_map2, mix_mask,
mix_map1_on, mix_map2_on, mix_mask_on, // main grad params
mix_output
};
static ParamDlg* texoutDlg;
static MixDlgProc *paramDlg;
TexHandle *texHandle[3];
int useSubForTex[3];
int numTexHandlesUsed;
int texOpsType[3];
Interval texHandleValid;
Color col[NCOLS];
IParamBlock2 *pblock; // ref #0
Texmap* subTex[NMIXSUBTEX]; // 3 More refs
BOOL mapOn[NMIXSUBTEX];
TextureOutput *texout; // ref #4
Interval ivalid;
float mix;
BOOL useCurve;
float crvA;
float crvB;
BOOL rollScroll;
public:
BOOL Param1;
Mix();
~Mix() {
DiscardTexHandles();
}
ParamDlg* CreateParamDlg(HWND hwMtlEdit, IMtlParams *imp);
void Update(TimeValue t, Interval& valid);
void Init();
void Reset();
Interval Validity(TimeValue t) { Interval v; Update(t,v); return ivalid; }
void SetOutputLevel(TimeValue t, float v) {texout->SetOutputLevel(t,v); }
void SetColor(int i, Color c, TimeValue t);
void SetMix(float f, TimeValue t);
void SetCrvA(float f, TimeValue t);
void SetCrvB(float f, TimeValue t);
void NotifyChanged();
void SwapInputs();
void EnableStuff();
float mixCurve(float x);
// Evaluate the color of map for the context.
AColor EvalColor(ShadeContext& sc);
float EvalMono(ShadeContext& sc);
AColor EvalFunction(ShadeContext& sc, float u, float v, float du, float dv);
// For Bump mapping, need a perturbation to apply to a normal.
// Leave it up to the Texmap to determine how to do this.
Point3 EvalNormalPerturb(ShadeContext& sc);
// Methods to access texture maps of material
int NumSubTexmaps() { return NMIXSUBTEX; }
Texmap* GetSubTexmap(int i) { return subTex[i]; }
void SetSubTexmap(int i, Texmap *m);
TSTR GetSubTexmapSlotName(int i);
Class_ID ClassID() { return mixClassID; }
SClass_ID SuperClassID() { return TEXMAP_CLASS_ID; }
void GetClassName(TSTR& s) { s= MIX_CLASSNAME; }
void DeleteThis() { delete this; }
int NumSubs() { return 2+NMIXSUBTEX; }
Animatable* SubAnim(int i);
TSTR SubAnimName(int i);
int SubNumToRefNum(int subNum) { return subNum; }
// From ref
int NumRefs() { return 2+NMIXSUBTEX; }
RefTargetHandle GetReference(int i);
void SetReference(int i, RefTargetHandle rtarg);
RefTargetHandle Clone(RemapDir &remap = DefaultRemapDir());
RefResult NotifyRefChanged( Interval changeInt, RefTargetHandle hTarget,
PartID& partID, RefMessage message );
// IO
// BOOL loadOnChecks;
IOResult Save(ISave *isave);
IOResult Load(ILoad *iload);
// JBW: direct ParamBlock access is added
int NumParamBlocks() { return 1; } // return number of ParamBlocks in this instance
IParamBlock2* GetParamBlock(int i) { return pblock; } // return i'th ParamBlock
IParamBlock2* GetParamBlockByID(BlockID id) { return (pblock->ID() == id) ? pblock : NULL; } // return id'd ParamBlock
BOOL SetDlgThing(ParamDlg* dlg);
void DiscardTexHandles() {
for (int i=0; i<3; i++) {
if (texHandle[i]) {
texHandle[i]->DeleteThis();
texHandle[i] = NULL;
}
}
texHandleValid.SetEmpty();
}
// Multiple map in vp support -- DS 4/24/00
BOOL SupportTexDisplay() { return TRUE; }
void ActivateTexDisplay(BOOL onoff);
BOOL SupportsMultiMapsInViewport() { return TRUE; }
void SetupGfxMultiMaps(TimeValue t, Material *mtl, MtlMakerCallback &cb);
// Multiple map code
void StuffAlpha(BITMAPINFO* bi1, BITMAPINFO *bi2, BOOL invert);
void StuffConstAlpha(float falpha, BITMAPINFO *bmi);
void ConstAlphaBlend(BITMAPINFO *bi1, BITMAPINFO *bi2, float a);
void ConstScale(BITMAPINFO *bi, float s);
void AlphaBlendMaps(BITMAPINFO *bi1,BITMAPINFO *bi2,BITMAPINFO *balph);
void FixupAlpha(BITMAPINFO *bi);
void SetTexOps(Material *mtl, int i, int type);
void SetHWTexOps(IHardwareMaterial *pIHWMat, int ntx, int type);
// From Texmap
bool IsLocalOutputMeaningful( ShadeContext& sc ) { return true; }
};
#endif
| [
"yangtuo0429@gmail.com"
] | yangtuo0429@gmail.com |
65277e92c3e3262a576b4a59add4ea8bee24dd4a | b44b4a29367ea8d4663d9158cd37ee002c07fa9a | /src/utils.cpp | 46a8e87ced9df0c5b007ab833a6dbf8640578f54 | [] | no_license | vladnazar0v/NiceObjLoader | c975e4200399669e463f0972abdbd9a7135a712b | e35d2bdef48242508504596bd2685313e62550b6 | refs/heads/master | 2022-12-30T02:05:24.747987 | 2020-10-12T23:47:26 | 2020-10-12T23:47:26 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 919 | cpp | #include <utils.hpp>
#include <algorithm>
#ifdef _WIN32
#include <direct.h>
#define GetCurrentDir _getcwd
#else
#include <unistd.h>
#define GetCurrentDir getcwd
#endif
Camera* Utils::camera = nullptr;
void Utils::initCamera(GLfloat FOV, GLfloat width, GLfloat height, GLfloat nearPlane,
GLfloat farPlane, glm::vec3 camPos, glm::vec3 camFront, glm::vec3 camUp) {
camera = new Camera(FOV, width, height, nearPlane, farPlane, camPos, camFront, camUp);
}
std::string Utils::getCWD() {
char buff[FILENAME_MAX]; //create string buffer to hold path
GetCurrentDir(buff, FILENAME_MAX);
std::string current_working_dir(buff);
return current_working_dir;
}
std::string Utils::getPath(const std::string path) {
auto cwd = Utils::getCWD();
std::transform(cwd.begin(), cwd.end(), cwd.begin(), toupper);
auto i = cwd.find("NICEOBJLOADER");
return getCWD().substr(0,i+13) + path;
} | [
"vladnazarov2@gmail.com"
] | vladnazarov2@gmail.com |
d9e3658e0f0b548e8311666c44e28d4f0c078177 | 88dd4c2c227bab243ce25f908d669e134d6203d5 | /v1.0/main.cpp | ce3cfc0cca11fa7fa7c061bdc280e4b87609d48c | [] | no_license | lzb6666/Interpreter | a31daaa42f7950b6861d762dd55301901eb9335d | 395197353e5380f35e06fcf5dc38b9d0be39036f | refs/heads/master | 2020-03-28T12:46:20.274442 | 2018-12-22T11:13:08 | 2018-12-22T11:13:08 | 148,332,481 | 1 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 1,602 | cpp | #include "KaleidoscopeJIT.h"
#include <algorithm>
#include <cassert>
#include <cctype>
#include <cstdint>
#include <cstdio>
#include <cstdlib>
#include <map>
#include <memory>
#include <string>
#include <utility>
#include <vector>
#include"AST.h"
#include"parser.h"
#include"log.h"
using namespace llvm;
using namespace llvm::orc;
using namespace std;
static void HandleDefinition() {
Log("HandleDefinition");
if (auto FnAST = ParseDefinition()) {
if (auto *FnIR = FnAST->codegen()) {
fprintf(stderr, "Read function definition:");
FnIR->print(errs());
fprintf(stderr, "\n");
}
}
else {
// Skip token for error recovery.
getNextToken();
}
}
static void HandleTopLevelExpression() {
Log("HandleTopLevelExpression");
if (auto FnAST = ParseTopLevelExpr()) {
if (auto *FnIR = FnAST->codegen()) {
fprintf(stderr, "Read top-level expression:");
FnIR->print(errs());
fprintf(stderr, "\n");
}
}
else {
// Skip token for error recovery.
getNextToken();
}
}
static void MainLoop() {
while (true) {
fprintf(stderr, "ready> ");
switch (CurTok) {
case tok_eof:
return;
case ';':
getNextToken();
break;
case tok_func:
HandleDefinition();
break;
default:
HandleTopLevelExpression();
break;
}
}
}
int main() {
BinopPrecedence['<'] = 10;
BinopPrecedence['+'] = 20;
BinopPrecedence['-'] = 20;
BinopPrecedence['*'] = 40;
BinopPrecedence['='] = 60;
fprintf(stderr, "ready> ");
getNextToken();
TheModule = llvm::make_unique<Module>("my cool jit", TheContext);
MainLoop();
TheModule->print(errs(), nullptr);
return 0;
}
| [
"zhongboge@foxmail.com"
] | zhongboge@foxmail.com |
62777d88588c0eb6a56530d768d4f6d867c63592 | b7f3edb5b7c62174bed808079c3b21fb9ea51d52 | /ui/accessibility/platform/ax_platform_node_textchildprovider_win_unittest.cc | ec5adb620d61e536a8cf093ab5c7c4b898c2f788 | [
"BSD-3-Clause"
] | permissive | otcshare/chromium-src | 26a7372773b53b236784c51677c566dc0ad839e4 | 64bee65c921db7e78e25d08f1e98da2668b57be5 | refs/heads/webml | 2023-03-21T03:20:15.377034 | 2020-11-16T01:40:14 | 2020-11-16T01:40:14 | 209,262,645 | 18 | 21 | BSD-3-Clause | 2023-03-23T06:20:07 | 2019-09-18T08:52:07 | null | UTF-8 | C++ | false | false | 15,942 | 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 "ui/accessibility/platform/ax_platform_node_win_unittest.h"
#include "base/win/scoped_bstr.h"
#include "ui/accessibility/platform/ax_fragment_root_win.h"
#include "ui/accessibility/platform/ax_platform_node_textchildprovider_win.h"
#include "ui/accessibility/platform/ax_platform_node_textprovider_win.h"
#include "ui/accessibility/platform/ax_platform_node_textrangeprovider_win.h"
using Microsoft::WRL::ComPtr;
namespace ui {
class AXPlatformNodeTextChildProviderTest : public AXPlatformNodeWinTest {
protected:
// Construct an accessibility tree for testing ITextChildProvider resolution
// from various positions in the tree. The following tree configuration
// is constructed:
//
// root_________________________________________________
// | |
// nontext_child_of_root______ text_child_of_root
// | | |
// nontext_child_of_nontext text_child_of_nontext text_child_of_text
//
// nontext leaf elements are considered as embedded objects and expose a
// character to allow the text pattern navigation to work with them too.
// Because of that, a nontext leaf element is treated as a text element.
void SetUp() override {
ui::AXNodeData root;
root.id = 1;
root.role = ax::mojom::Role::kRootWebArea;
ui::AXNodeData nontext_child_of_root;
nontext_child_of_root.id = 2;
nontext_child_of_root.role = ax::mojom::Role::kGroup;
nontext_child_of_root.SetName("non text child of root.");
root.child_ids.push_back(nontext_child_of_root.id);
ui::AXNodeData text_child_of_root;
text_child_of_root.id = 3;
text_child_of_root.role = ax::mojom::Role::kStaticText;
text_child_of_root.SetName("text child of root.");
root.child_ids.push_back(text_child_of_root.id);
ui::AXNodeData nontext_child_of_nontext;
nontext_child_of_nontext.id = 4;
nontext_child_of_nontext.role = ax::mojom::Role::kGroup;
nontext_child_of_nontext.SetName("nontext child of nontext.");
nontext_child_of_root.child_ids.push_back(nontext_child_of_nontext.id);
ui::AXNodeData text_child_of_nontext;
text_child_of_nontext.id = 5;
text_child_of_nontext.role = ax::mojom::Role::kStaticText;
text_child_of_nontext.SetName("text child of nontext.");
nontext_child_of_root.child_ids.push_back(text_child_of_nontext.id);
ui::AXNodeData text_child_of_text;
text_child_of_text.id = 6;
text_child_of_text.role = ax::mojom::Role::kInlineTextBox;
text_child_of_text.SetName("text child of text.");
text_child_of_root.child_ids.push_back(text_child_of_text.id);
ui::AXTreeUpdate update;
ui::AXTreeData tree_data;
tree_data.tree_id = ui::AXTreeID::CreateNewAXTreeID();
update.tree_data = tree_data;
update.has_tree_data = true;
update.root_id = root.id;
update.nodes = {root,
nontext_child_of_root,
text_child_of_root,
nontext_child_of_nontext,
text_child_of_nontext,
text_child_of_text};
Init(update);
AXNode* root_node = GetRootAsAXNode();
AXNode* nontext_child_of_root_node = root_node->children()[0];
AXNode* text_child_of_root_node = root_node->children()[1];
AXNode* nontext_child_of_nontext_node =
nontext_child_of_root_node->children()[0];
AXNode* text_child_of_nontext_node =
nontext_child_of_root_node->children()[1];
AXNode* text_child_of_text_node = text_child_of_root_node->children()[0];
InitITextChildProvider(root_node, root_provider_raw_,
root_text_child_provider_);
InitITextChildProvider(nontext_child_of_root_node,
nontext_child_of_root_provider_raw_,
nontext_child_of_root_text_child_provider_);
InitITextChildProvider(text_child_of_root_node,
text_child_of_root_text_provider_raw_,
text_child_of_root_text_child_provider_);
InitITextChildProvider(nontext_child_of_nontext_node,
nontext_child_of_nontext_text_provider_raw_,
nontext_child_of_nontext_text_child_provider_);
InitITextChildProvider(text_child_of_nontext_node,
text_child_of_nontext_text_provider_raw_,
text_child_of_nontext_text_child_provider_);
InitITextChildProvider(text_child_of_text_node,
text_child_of_text_text_provider_raw_,
text_child_of_text_text_child_provider_);
}
void InitITextChildProvider(
AXNode* node,
ComPtr<IRawElementProviderSimple>& raw_element_provider,
ComPtr<ITextChildProvider>& text_child_provider) {
raw_element_provider =
QueryInterfaceFromNode<IRawElementProviderSimple>(node);
EXPECT_HRESULT_SUCCEEDED(raw_element_provider->GetPatternProvider(
UIA_TextChildPatternId, &text_child_provider));
// If the element does not support ITextChildProvider, create one anyways
// for testing purposes.
if (!text_child_provider) {
ui::AXPlatformNodeWin* platform_node =
(ui::AXPlatformNodeWin*)raw_element_provider.Get();
ComPtr<ITextChildProvider> new_child_provider =
ui::AXPlatformNodeTextChildProviderWin::Create(platform_node);
new_child_provider->QueryInterface(IID_PPV_ARGS(&text_child_provider));
}
}
ComPtr<IRawElementProviderSimple> root_provider_raw_;
ComPtr<IRawElementProviderSimple> nontext_child_of_root_provider_raw_;
ComPtr<IRawElementProviderSimple> text_child_of_root_text_provider_raw_;
ComPtr<IRawElementProviderSimple> nontext_child_of_nontext_text_provider_raw_;
ComPtr<IRawElementProviderSimple> text_child_of_nontext_text_provider_raw_;
ComPtr<IRawElementProviderSimple> text_child_of_text_text_provider_raw_;
ComPtr<ITextChildProvider> root_text_child_provider_;
ComPtr<ITextChildProvider> nontext_child_of_root_text_child_provider_;
ComPtr<ITextChildProvider> text_child_of_root_text_child_provider_;
ComPtr<ITextChildProvider> nontext_child_of_nontext_text_child_provider_;
ComPtr<ITextChildProvider> text_child_of_nontext_text_child_provider_;
ComPtr<ITextChildProvider> text_child_of_text_text_child_provider_;
};
// ITextChildProvider::TextContainer Tests
//
// For each possible position in the tree verify:
// 1) A text container can/cannot be retrieved if an ancestor does/doesn't
// support the UIA Text control pattern.
// 2) Any retrieved text container is the nearest ancestor text container.
// 3) A Text control can in fact be retrieved from any retrieved text
// container.
TEST_F(AXPlatformNodeTextChildProviderTest,
ITextChildProviderTextContainerFromRoot) {
ComPtr<IRawElementProviderSimple> text_container;
EXPECT_HRESULT_SUCCEEDED(
root_text_child_provider_->get_TextContainer(&text_container));
ASSERT_EQ(nullptr, text_container.Get());
}
TEST_F(AXPlatformNodeTextChildProviderTest,
ITextChildProviderTextContainerFromNontextChildOfRoot) {
ComPtr<IRawElementProviderSimple> text_container;
EXPECT_HRESULT_SUCCEEDED(
nontext_child_of_root_text_child_provider_->get_TextContainer(
&text_container));
ASSERT_NE(nullptr, text_container.Get());
EXPECT_EQ(root_provider_raw_.Get(), text_container.Get());
ComPtr<IUnknown> pattern_provider;
ComPtr<ITextProvider> text_container_text_provider;
text_container->GetPatternProvider(UIA_TextPatternId, &pattern_provider);
ASSERT_NE(nullptr, pattern_provider.Get());
EXPECT_HRESULT_SUCCEEDED(pattern_provider.As(&text_container_text_provider));
}
TEST_F(AXPlatformNodeTextChildProviderTest,
ITextChildProviderTextContainerFromTextChildOfRoot) {
ComPtr<IRawElementProviderSimple> text_container;
EXPECT_HRESULT_SUCCEEDED(
text_child_of_root_text_child_provider_->get_TextContainer(
&text_container));
ASSERT_NE(nullptr, text_container.Get());
EXPECT_EQ(root_provider_raw_.Get(), text_container.Get());
ComPtr<IUnknown> pattern_provider;
ComPtr<ITextProvider> text_container_text_provider;
text_container->GetPatternProvider(UIA_TextPatternId, &pattern_provider);
ASSERT_NE(nullptr, pattern_provider.Get());
EXPECT_HRESULT_SUCCEEDED(pattern_provider.As(&text_container_text_provider));
}
TEST_F(AXPlatformNodeTextChildProviderTest,
ITextChildProviderTextContainerFromNontextChildOfNontext) {
ComPtr<IRawElementProviderSimple> text_container;
EXPECT_HRESULT_SUCCEEDED(
nontext_child_of_nontext_text_child_provider_->get_TextContainer(
&text_container));
ASSERT_NE(nullptr, text_container.Get());
EXPECT_EQ(root_provider_raw_.Get(), text_container.Get());
ComPtr<IUnknown> pattern_provider;
ComPtr<ITextProvider> text_container_text_provider;
text_container->GetPatternProvider(UIA_TextPatternId, &pattern_provider);
ASSERT_NE(nullptr, pattern_provider.Get());
EXPECT_HRESULT_SUCCEEDED(pattern_provider.As(&text_container_text_provider));
}
TEST_F(AXPlatformNodeTextChildProviderTest,
ITextChildProviderTextContainerFromTextChildOfNontext) {
ComPtr<IRawElementProviderSimple> text_container;
EXPECT_HRESULT_SUCCEEDED(
text_child_of_nontext_text_child_provider_->get_TextContainer(
&text_container));
ASSERT_NE(nullptr, text_container.Get());
EXPECT_EQ(root_provider_raw_.Get(), text_container.Get());
ComPtr<IUnknown> pattern_provider;
ComPtr<ITextProvider> text_container_text_provider;
text_container->GetPatternProvider(UIA_TextPatternId, &pattern_provider);
ASSERT_NE(nullptr, pattern_provider.Get());
EXPECT_HRESULT_SUCCEEDED(pattern_provider.As(&text_container_text_provider));
}
TEST_F(AXPlatformNodeTextChildProviderTest,
ITextChildProviderTextContainerFromTextChildOfText) {
ComPtr<IRawElementProviderSimple> text_container;
EXPECT_HRESULT_SUCCEEDED(
text_child_of_text_text_child_provider_->get_TextContainer(
&text_container));
ASSERT_NE(nullptr, text_container.Get());
EXPECT_EQ(text_child_of_root_text_provider_raw_.Get(), text_container.Get());
ComPtr<IUnknown> pattern_provider;
ComPtr<ITextProvider> text_container_text_provider;
text_container->GetPatternProvider(UIA_TextPatternId, &pattern_provider);
ASSERT_NE(nullptr, pattern_provider.Get());
EXPECT_HRESULT_SUCCEEDED(pattern_provider.As(&text_container_text_provider));
}
// ITextChildProvider::TextRange Tests
//
// For each possible position in the tree verify:
// 1) A text range can/cannot be retrieved if an ancestor does/doesn't
// support the UIA Text control pattern.
// 2) Any retrieved text range encloses the child element.
TEST_F(AXPlatformNodeTextChildProviderTest,
ITextChildProviderTextRangeFromRoot) {
ComPtr<ITextRangeProvider> text_range_provider;
EXPECT_HRESULT_SUCCEEDED(
root_text_child_provider_->get_TextRange(&text_range_provider));
EXPECT_EQ(nullptr, text_range_provider.Get());
}
TEST_F(AXPlatformNodeTextChildProviderTest,
ITextChildProviderTextRangeFromNontextChildOfRoot) {
ComPtr<ITextRangeProvider> text_range_provider;
EXPECT_HRESULT_SUCCEEDED(
nontext_child_of_root_text_child_provider_->get_TextRange(
&text_range_provider));
ASSERT_NE(nullptr, text_range_provider.Get());
base::win::ScopedBstr text_content;
EXPECT_HRESULT_SUCCEEDED(
text_range_provider->GetText(-1, text_content.Receive()));
EXPECT_EQ(
0,
wcscmp(text_content.Get(),
(kEmbeddedCharacterAsString + L"text child of nontext.").c_str()));
ComPtr<IRawElementProviderSimple> enclosing_element;
text_range_provider->GetEnclosingElement(&enclosing_element);
EXPECT_EQ(nontext_child_of_root_provider_raw_.Get(), enclosing_element.Get());
}
TEST_F(AXPlatformNodeTextChildProviderTest,
ITextChildProviderTextRangeFromTextChildOfRoot) {
ComPtr<ITextRangeProvider> text_range_provider;
EXPECT_HRESULT_SUCCEEDED(
text_child_of_root_text_child_provider_->get_TextRange(
&text_range_provider));
ASSERT_NE(nullptr, text_range_provider.Get());
base::win::ScopedBstr text_content;
EXPECT_HRESULT_SUCCEEDED(
text_range_provider->GetText(-1, text_content.Receive()));
EXPECT_EQ(0, wcscmp(text_content.Get(), L"text child of text."));
ComPtr<IRawElementProviderSimple> enclosing_element;
text_range_provider->GetEnclosingElement(&enclosing_element);
EXPECT_EQ(text_child_of_root_text_provider_raw_.Get(),
enclosing_element.Get());
}
TEST_F(AXPlatformNodeTextChildProviderTest,
ITextChildProviderTextRangeFromNontextChildOfNontext) {
ComPtr<ITextRangeProvider> text_range_provider;
EXPECT_HRESULT_SUCCEEDED(
nontext_child_of_nontext_text_child_provider_->get_TextRange(
&text_range_provider));
ASSERT_NE(nullptr, text_range_provider.Get());
base::win::ScopedBstr text_content;
EXPECT_HRESULT_SUCCEEDED(
text_range_provider->GetText(-1, text_content.Receive()));
EXPECT_EQ(0, wcscmp(text_content.Get(), kEmbeddedCharacterAsString.c_str()));
ComPtr<IRawElementProviderSimple> enclosing_element;
text_range_provider->GetEnclosingElement(&enclosing_element);
EXPECT_EQ(nontext_child_of_nontext_text_provider_raw_.Get(),
enclosing_element.Get());
}
TEST_F(AXPlatformNodeTextChildProviderTest,
ITextChildProviderTextRangeFromTextChildOfNontext) {
ComPtr<ITextRangeProvider> text_range_provider;
EXPECT_HRESULT_SUCCEEDED(
text_child_of_nontext_text_child_provider_->get_TextRange(
&text_range_provider));
ASSERT_NE(nullptr, text_range_provider.Get());
base::win::ScopedBstr text_content;
EXPECT_HRESULT_SUCCEEDED(
text_range_provider->GetText(-1, text_content.Receive()));
EXPECT_EQ(0, wcscmp(text_content.Get(), L"text child of nontext."));
ComPtr<IRawElementProviderSimple> enclosing_element;
text_range_provider->GetEnclosingElement(&enclosing_element);
EXPECT_EQ(text_child_of_nontext_text_provider_raw_.Get(),
enclosing_element.Get());
}
TEST_F(AXPlatformNodeTextChildProviderTest,
ITextChildProviderTextRangeFromTextChildOfText) {
ComPtr<ITextRangeProvider> text_range_provider;
EXPECT_HRESULT_SUCCEEDED(
text_child_of_text_text_child_provider_->get_TextRange(
&text_range_provider));
ASSERT_NE(nullptr, text_range_provider.Get());
base::win::ScopedBstr text_content;
EXPECT_HRESULT_SUCCEEDED(
text_range_provider->GetText(-1, text_content.Receive()));
EXPECT_EQ(0, wcscmp(text_content.Get(), L"text child of text."));
ComPtr<IRawElementProviderSimple> enclosing_element;
text_range_provider->GetEnclosingElement(&enclosing_element);
EXPECT_EQ(text_child_of_root_text_provider_raw_.Get(),
enclosing_element.Get());
}
// ITextChildProvider Tests - Inactive AX Tree
//
// Test that both ITextChildProvider::GetTextContainer and
// ITextChildProvider::GetTextContainer fail under an inactive AX tree.
TEST_F(AXPlatformNodeTextChildProviderTest,
ITextChildProviderInactiveAccessibilityTree) {
DestroyTree();
// Test that GetTextContainer fails under an inactive tree.
ComPtr<IRawElementProviderSimple> text_container;
HRESULT hr = nontext_child_of_root_text_child_provider_->get_TextContainer(
&text_container);
EXPECT_EQ(static_cast<HRESULT>(UIA_E_ELEMENTNOTAVAILABLE), hr);
// Test that GetTextRange fails under an inactive tree.
ComPtr<ITextRangeProvider> text_range_provider;
hr = nontext_child_of_root_text_child_provider_->get_TextRange(
&text_range_provider);
EXPECT_EQ(static_cast<HRESULT>(UIA_E_ELEMENTNOTAVAILABLE), hr);
}
} // namespace ui
| [
"commit-bot@chromium.org"
] | commit-bot@chromium.org |
7bb6387bc2c2480586b0995f1acc05517d96b319 | dcfbf081cd6e5bf064ec3e970c6b796c00a43ab2 | /Test/LongEmitter.h | dc7af064aa38c92262ab72ac09e78e991078260a | [] | no_license | iluvatar593/spm | d8e46a61950db048daddd1f0f3da6990d6928b9a | 5b8207116fee89c96e378ee7432ee6fc7f5a8e70 | refs/heads/master | 2021-05-03T16:15:14.798468 | 2014-11-12T14:45:08 | 2014-11-12T14:45:08 | 22,917,130 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 339 | h | /*
* LongEmitter.h
*
* Created on: 30/set/2014
* Author: atzoril
*/
#ifndef LONGEMITTER_H_
#define LONGEMITTER_H_
#include "Emitter.hpp"
class LongEmitter: public Emitter<long> {
public:
LongEmitter(long n, unsigned int s):Emitter<long>(n,s) {}
~LongEmitter(){}
virtual void initialize();
};
#endif /* LONGMITTER_H_ */
| [
"aless.lenzi@gmail.com"
] | aless.lenzi@gmail.com |
93a82f4a227fee109d9306dbb2e2feb58577af90 | 21ede326b6cfcf5347ca6772d392d3acca80cfa0 | /ash/assistant/ui/caption_bar.h | a5eb90f59236aae7c5607c4336c620a448ac0bfa | [
"BSD-3-Clause"
] | permissive | csagan5/kiwi | 6eaab0ab4db60468358291956506ad6f889401f8 | eb2015c28925be91b4a3130b3c2bee2f5edc91de | refs/heads/master | 2020-04-04T17:06:54.003121 | 2018-10-24T08:20:01 | 2018-10-24T08:20:01 | 156,107,399 | 2 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,587 | h | // 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.
#ifndef ASH_ASSISTANT_UI_CAPTION_BAR_H_
#define ASH_ASSISTANT_UI_CAPTION_BAR_H_
#include "base/macros.h"
#include "ui/views/controls/button/button.h"
#include "ui/views/view.h"
namespace ash {
// CaptionButtonId -------------------------------------------------------------
enum class CaptionButtonId {
kClose = 1,
kMinimize,
};
// CaptionBarDelegate ----------------------------------------------------------
class CaptionBarDelegate {
public:
// Invoked when the caption button identified by |id| is pressed. Return
// |true| to prevent default behavior from being performed, false otherwise.
virtual bool OnCaptionButtonPressed(CaptionButtonId id) = 0;
protected:
virtual ~CaptionBarDelegate() = default;
};
// CaptionBar ------------------------------------------------------------------
class CaptionBar : public views::View, views::ButtonListener {
public:
CaptionBar();
~CaptionBar() override;
// views::View:
gfx::Size CalculatePreferredSize() const override;
int GetHeightForWidth(int width) const override;
// views::ButtonListener:
void ButtonPressed(views::Button* sender, const ui::Event& event) override;
void set_delegate(CaptionBarDelegate* delegate) { delegate_ = delegate; }
private:
void InitLayout();
CaptionBarDelegate* delegate_ = nullptr;
DISALLOW_COPY_AND_ASSIGN(CaptionBar);
};
} // namespace ash
#endif // ASH_ASSISTANT_UI_CAPTION_BAR_H_
| [
"team@geometry.ee"
] | team@geometry.ee |
dfebdebdb963eaaf527cb768c4b89cafe9e9e8a2 | ef060ebef214f7cd5774f37236b407e92cfd5790 | /INCLUDE/stl_trim_char16.h | 6bacd411641bfbf3da0dc82997a62d32428b24e4 | [
"BSD-2-Clause"
] | permissive | SammyB428/WFC | 4a8af293fc5012db73855e34598a8df163d92a4f | 1709964506b085bde5aa7751d1914d7a68cbea53 | refs/heads/master | 2022-07-26T13:55:46.988837 | 2022-07-08T15:47:28 | 2022-07-08T15:47:28 | 169,485,007 | 2 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 8,102 | h | /* SPDX-License-Identifier: BSD-2-Clause */
#if ! defined( STL_TRIM_CHAR16_HEADER_FILE )
#define STL_TRIM_CHAR16_HEADER_FILE
inline void trim_right(_Inout_ std::u16string& s, _In_ char16_t const character) noexcept
{
if (s.empty() == false)
{
while (character == s.back())
{
s.erase(s.length() - 1, 1);
if (s.empty() == true)
{
return;
}
}
}
}
inline void trim_right(_Inout_ std::u16string& the_string) noexcept
{
if (the_string.empty() == false)
{
while (iswspace(the_string.back()))
{
the_string.resize(the_string.length() - 1);
if (the_string.length() <= 0)
{
return;
}
}
}
}
inline void trim_left(_Inout_ std::u16string& the_string) noexcept
{
auto const string_length{ the_string.length() };
if (string_length > 0)
{
std::size_t number_of_elements_to_erase{ 0 };
while (number_of_elements_to_erase < string_length and
iswspace(the_string.at(number_of_elements_to_erase)))
{
number_of_elements_to_erase++;
}
if (number_of_elements_to_erase >= string_length)
{
the_string.resize(0);
}
else
{
the_string.erase(0, number_of_elements_to_erase);
}
}
}
inline void trim_left(_Inout_ std::u16string& s, _In_ char16_t const character) noexcept
{
auto const string_length{ s.length() };
if (string_length > 0)
{
std::size_t number_of_elements_to_erase{ 0 };
while (number_of_elements_to_erase < string_length and
character == (s.at(number_of_elements_to_erase)))
{
number_of_elements_to_erase++;
}
if (number_of_elements_to_erase >= string_length)
{
s.resize(0);
}
else
{
s.erase(0, number_of_elements_to_erase);
}
}
}
inline void trim(_Inout_ std::u16string& the_string) noexcept
{
trim_right(the_string);
trim_left(the_string);
}
inline void despace(_Inout_ std::u16string& s) noexcept
{
// First see if we need to do anything
auto number_of_characters{ s.length() };
if (number_of_characters < 1)
{
return;
}
bool needs_despacing{ false };
auto character{ s[0] };
if (character == 0x20 or
character == TAB_CHARACTER or
character == CARRIAGE_RETURN or
character == LINE_FEED)
{
needs_despacing = true;
}
else
{
character = s[number_of_characters - 1];
if (character == 0x20 or
character == TAB_CHARACTER or
character == CARRIAGE_RETURN or
character == LINE_FEED)
{
needs_despacing = true;
}
else
{
std::size_t string_index{ 1 };
while (needs_despacing == false and string_index < (number_of_characters - 1))
{
character = s[string_index];
if (character == 0x20 or
character == TAB_CHARACTER or
character == CARRIAGE_RETURN or
character == LINE_FEED)
{
string_index++;
character = s[string_index];
if (character == 0x20 or
character == TAB_CHARACTER or
character == CARRIAGE_RETURN or
character == LINE_FEED)
{
needs_despacing = true;
}
}
string_index++;
}
}
}
if (needs_despacing == false)
{
return;
}
// Well finally, we have something to do.
trim(s); // Get rid of the easy case
number_of_characters = s.length();
bool last_character_added_was_a_space{ false };
std::u16string other_string;
for (auto const string_index : Range(number_of_characters))
{
character = s[string_index];
if (character == 0x20 or
character == TAB_CHARACTER or
character == CARRIAGE_RETURN or
character == LINE_FEED)
{
if (last_character_added_was_a_space == false)
{
other_string.push_back(character);
last_character_added_was_a_space = true;
}
}
else
{
other_string.push_back(character);
last_character_added_was_a_space = false;
}
}
s = other_string;
}
inline _Check_return_ bool trim_quotes(_Inout_ std::u16string& s) noexcept
{
if (s.length() > 1)
{
auto const first_character{ s.front() };
auto const last_character{ s.back() };
if (first_character == last_character)
{
// The string starts and ends with the same character.
if (first_character == '\"')
{
trim_right(s, '\"');
trim_left(s, '\"');
trim(s);
return(true);
}
if (first_character == '\'')
{
trim_right(s, '\'');
trim_left(s, '\'');
trim(s);
return(true);
}
}
return(false); // Nothing was trimmed
}
return(false); // Nothing was trimmed
}
inline void trim_all_quotes(_Inout_ std::u16string& s) noexcept
{
while (trim_quotes(s) == true)
{
;
}
}
inline constexpr [[nodiscard]] std::u16string_view trim_left_view(_In_ std::u16string_view the_string) noexcept
{
auto const string_length{ the_string.length() };
if (string_length > 0)
{
std::size_t number_of_elements_to_erase{ 0 };
while (number_of_elements_to_erase < string_length and
Win32FoundationClasses::is_space_character(the_string.at(number_of_elements_to_erase)))
{
number_of_elements_to_erase++;
}
if (number_of_elements_to_erase >= string_length)
{
return(std::u16string_view(the_string.data(), 0));
}
else
{
return(std::u16string_view(&the_string.data()[number_of_elements_to_erase], string_length - number_of_elements_to_erase));
}
}
return(std::u16string_view(the_string.data(), 0));
}
inline constexpr [[nodiscard]] std::u16string_view trim_left_view(_In_ std::u16string_view s, _In_ char16_t const character) noexcept
{
auto const string_length{ s.length() };
if (string_length > 0)
{
std::size_t number_of_elements_to_erase{ 0 };
while (number_of_elements_to_erase < string_length and
character == (s.at(number_of_elements_to_erase)))
{
number_of_elements_to_erase++;
}
if (number_of_elements_to_erase >= string_length)
{
return(std::u16string_view(s.data(), 0));
}
else
{
return(std::u16string_view(&s.data()[number_of_elements_to_erase], string_length - number_of_elements_to_erase));
}
}
return(std::u16string_view(s.data(), 0));
}
inline constexpr [[nodiscard]] std::u16string_view trim_right_view(_In_ std::u16string_view the_string) noexcept
{
if (the_string.empty() == false)
{
auto string_length{ the_string.length() };
while (Win32FoundationClasses::is_space_character(the_string.at(string_length - 1)))
{
string_length--;
if (string_length <= 0)
{
return(std::u16string_view(the_string.data(), 0));
}
}
return(std::u16string_view(the_string.data(), string_length));
}
return(the_string);
}
inline constexpr [[nodiscard]] std::u16string_view trim_view(_In_ std::u16string_view the_string) noexcept
{
return(trim_left_view(trim_right_view(the_string)));
}
#endif // STL_TRIM_CHAR16_HEADER_FILE
| [
"sam_blackburn@pobox.com"
] | sam_blackburn@pobox.com |
f043e2a86df846d1afa73d308c30a3f78d234cda | 1c1a460f2b53c488dc0c885a4831183a4fbf5055 | /examples/ex03/prime_Eratosthenes.cpp | b0bd9ca0b7c4ddb6e30518b7186e75cc02b8c754 | [] | no_license | llyang/Computing | 2e3fba876b54729420cd2ebb1e298ccf51cf8857 | 130254a9acace74d60274e21eda9566d18cfa816 | refs/heads/master | 2020-03-27T21:19:54.781917 | 2018-12-31T02:24:34 | 2018-12-31T02:24:34 | 147,135,547 | 12 | 14 | null | null | null | null | UTF-8 | C++ | false | false | 414 | cpp | #include <cmath>
#include <iostream>
#include <vector>
using namespace std;
int main()
{
constexpr int max { 100 };
vector<bool> is_prime(max + 1, true);
for (int i = 2; i <= sqrt(max); ++i) {
if (is_prime[i]) {
for (int j = i * i; j <= max; j += i) {
is_prime[j] = false;
}
}
}
for (int i = 2; i <= max; ++i) {
if (is_prime[i]) {
cout << i << '\n';
}
}
}
| [
"lyangl@gmail.com"
] | lyangl@gmail.com |
25540570f4840655dca7df9300b79044e0f18e01 | 0e1513f12262412c585973ea4ccb485d088b1819 | /Editor Source/_Build_/Esenthel/Source/@ObjView.h | c471c06cc8832e87e1e9f2d4991378b53dca9985 | [
"LicenseRef-scancode-warranty-disclaimer",
"LicenseRef-scancode-other-permissive"
] | permissive | elix22/EsenthelEngine | e2f62b68c5c70eb67e20692f0c35232d70a4210b | 2d623b88087c3607447792ad4c97bca8c9d1e056 | refs/heads/master | 2021-01-08T05:09:28.367753 | 2020-06-13T17:01:49 | 2020-06-13T17:01:49 | 241,920,228 | 0 | 0 | null | 2020-06-13T17:01:50 | 2020-02-20T15:32:54 | C | UTF-8 | C++ | false | false | 23,078 | h | /******************************************************************************/
/******************************************************************************
Meshes are stored in:
"Edit" (untransformed, skeleton not set but has BoneMap, parts not merged , only MeshBase available)
"Game" ( transformed, skeleton set with BoneMap, parts merged by material and DrawGroup, only MeshRender available)
Upon opening a mesh in Object Editor, "Edit" version is loaded (and MeshRender created)
every usage of the mesh must be combined with transforming by its current "Game" matrix.
Upon saving a mesh, it's saved as both "Edit" and "Game" versions.
/******************************************************************************/
class ObjView : Viewport4Region
{
enum MODE
{
TRANSFORM ,
PARAM ,
LOD ,
MESH ,
VARIATIONS,
SLOTS ,
BONES ,
SKIN ,
PHYS ,
GROUP ,
REMOVE ,
RAGDOLL ,
BODY ,
BACKGROUND,
};
static cchar8 *mode_t[]
;
enum TRANS_OP
{
TRANS_MOVE,
TRANS_ROT,
TRANS_SCALE,
};
enum SKIN_MODE
{
SKIN_SEL_MESH_PART,
SKIN_SEL_BONE,
SKIN_CHANGE_SKIN,
};
static cchar8 *skin_mode_t[]
;
static cchar8 *skin_mode_desc[]
;
class BackMesh
{
MeshPtr mesh;
Matrix matrix;
void draw();
void drawBlend();
public:
BackMesh();
};
class SlotMesh
{
MeshPtr mesh;
Str8 name;
flt scale;
void set(C MeshPtr &mesh, C Str &name);
void draw(Skeleton &skel);
public:
SlotMesh();
};
class Info : GuiCustom
{
virtual void draw(C GuiPC &gpc)override;
};
class MeshChange : Edit::_Undo::Change
{
class NameWeight
{
Str name;
flt weight;
};
class BoneWeight : Mems<NameWeight>
{
Str8 name;
};
bool sel_only,
can_use_cur_skel_to_saved_skel; // this needs to be disabled if we've flushed skeleton ('saved_skel' was changed)
Mesh data;
ElmMesh mesh_data;
EditSkeleton edit_skel, cur_skel_to_saved_skel;
Skeleton skel;
Matrix mesh_matrix;
Memc<VecI2> sel_vtx, sel_face;
Mems<Rename> bone_renames; // renames applied in this change only
Mems<Str > bone_removals; // removals applied in this change only
Mems<BoneWeight> bone_restores;
void removeBone(C Str &name);
void selOnly();
virtual uint memUsage()C override;
virtual void create(ptr user)override;
void apply(bool undo);
virtual void apply(ptr user)override;
public:
MeshChange();
};
class PhysChange : Edit::_Undo::Change
{
ElmPhys phys_data;
PhysBody data;
virtual void create(ptr user)override;
virtual void apply(ptr user)override;
};
class SkinBrush : BrushClass
{
SkinBrush& create(GuiObj &parent, C Vec2 &rd);
virtual bool hasMsWheelFocus()C override;
};
class BoneRoot
{
Str display;
EditSkeleton::NodePtr node;
};
Mesh mesh; // in original matrix as it was imported
MeshPtr mesh_ptr, // used to hold reference to game mesh (this is needed if we're editing 'mesh' on a temp var, and 'skel' on cache var, this way we can keep 'mesh' cache var in the same state as temp var)
body ; // used to hold reference to body game mesh
Box mesh_box; // mesh box after transformation
Matrix mesh_matrix; // mesh transformation matrix
Matrix phys_part_matrix; // used for axis drawing
Matrix mesh_matrix_prev[Edit::Viewport4::VIEW_NUM], *mesh_matrix_prev_ptr;
PhysBodyPtr phys; // phys body (in 'mesh_matrix')
Skeleton *mesh_skel, mesh_skel_temp, // skeleton of the mesh (in 'mesh_matrix'), if exists points to 'mesh_skel_temp' (otherwise null), it is important to operate on a temporary skeleton, so that modifying skeleton will not affect the existing animations, until it's flushed
*body_skel, // skeleton of the body mesh
saved_skel; // 'mesh_skel' as it is on the disk without any modifications
Matrix saved_skel_matrix; // matrix of 'saved_skel'
EditSkeleton saved_edit_skel,
edit_skel, // always in original matrix as it was imported
cur_skel_to_saved_skel; // this will store mapping from current skeleton to saved skeleton, 'nodes'=saved_skel, 'bones'=mesh_skel
Particles particles;
UID obj_id;
Elm *obj_elm, *mesh_elm, *skel_elm, *phys_elm;
bool has_cur_pos;
Vec cur_pos, axis_vec;
int lit_lod, sel_lod, sel_variation, lit_part, lit_vf_part, lit_vtx, lit_face, trans_axis, // 'lit_vf_part'=part of the ('lit_vtx' or 'lit_face'), 'lit_face' can contain SIGN_BIT for quads
lit_bone, lit_bone_vis, lit_slot, sel_bone, sel_bone_vis, sel_slot, slot_axis, bone_axis, // 'vis' operate on the temporary 'getVisSkel'
lit_phys, sel_phys, phys_axis;
Memc<VecI2> sel_vtx, sel_face; // binary sorted, x=part, y=element, 'sel_face.y' can contain SIGN_BIT for quads
Str8 sel_bone_name, sel_slot_name;
int vtx_dup_mode;
flt vtx_sel_r, edit_time;
Tabs mode;
Button axis, box, show_cur_pos, vtxs, vtxs_front, vtxs_normals, light_dir;
Tabs slot_tabs, bone_tabs, phys_tabs, ragdoll_tabs, trans_tabs;
Memc<SlotMesh> slot_meshes;
Memc<BackMesh> back_meshes;
TransformRegion trans, trans_mesh;
LeafRegion leaf;
LodRegion lod;
GroupRegion group;
Info info;
ParamEditor param_edit;
bool changed_obj, changed_mesh, changed_skel, changed_phys;
TimeStamp mesh_file_time, skel_file_time;
Button mesh_undo, mesh_redo, locate, phys_undo, phys_redo, phys_box, phys_ball, phys_capsule, phys_tube, phys_convex[5], phys_mesh, phys_del, goto_phys_mtrl, goto_body, goto_group, clear_background;
Memx<Property> phys_props, body_props, group_props;
Tabs vtx_face_sel_mode, lod_tabs, variation_tabs, skin_tabs, bone_move_tabs;
Text vtx_face_sel_text, background_alpha_t, bone_root_t;
Slider background_alpha;
ComboBox mesh_ops, skin_ops, slot_ops, bone_ops, phys_ops, bone_root, bone_children, bone_children_rot;
Memc<BoneRoot> bone_root_data;
TextWhite ts;
MeshParts mesh_parts;
MeshVariations mesh_variations;
AdjustBoneOrns adjust_bone_orns;
SkinBrush skin_brush;
Menu menu;
Memc<UID> menu_ids;
Edit::Undo<MeshChange> mesh_undos; bool mesh_undos_undo;
Edit::Undo<PhysChange> phys_undos; void undoVis();
ObjView();
// get
bool selected()C;
bool lodEditDist ()C;
bool lodDrawAtDist()C;
bool customDrawMatrix()C;
bool partVisible(int p, C MeshPart &part, bool allow_lit=true)C;
bool partOp (int p)C;
bool partSel(int p)C;
bool frontFace(C Vec &pos, C Vec *nrm, C Matrix &cam)C;
bool editMeshParts()C;
bool transMesh ()C;
bool showBoxes ()C;
bool showMainBox ()C;
Matrix transformMatrix()C;
Matrix transformMatrix(bool sel)C;
Circle vtxSelCircle()C;
bool showVtxSelCircle();
bool showChangeSkin ()C;
bool showChangeSkinShape();
Shape changeSkinShape()C;
int boneTabs()C;
int boneAxis()C;
flt posScale()C;
flt posEps()C;
flt vtxDupPosEps()C;
Vec selMeshCenter()C;
Skeleton* getVisSkel();
void setMatrixAtDist(Matrix &matrix, flt dist);
static void Render();
void render();
static void Draw(Viewport &viewport);
void draw(Edit::Viewport4::View&view);
static void LodChanged(ObjView &editor);
static void VariationChanged(ObjView &editor);
static void ModeChanged(ObjView &editor);
static void Mode1 (ObjView &editor);
static void Mode2 (ObjView &editor);
static void Mode3 (ObjView &editor);
static void Mode4 (ObjView &editor);
static void Mode5 (ObjView &editor);
static void Mode6 (ObjView &editor);
static void Mode7 (ObjView &editor);
static void Mode8 (ObjView &editor);
static void Mode9 (ObjView &editor);
static void Mode0 (ObjView &editor);
static void ModeS0 (ObjView &editor);
static void ModeS1 (ObjView &editor);
static void ModeS2 (ObjView &editor);
static void ModeS3 (ObjView &editor);
static void ModeS4 (ObjView &editor);
static void ModeS5 (ObjView &editor);
static void ModeS6 (ObjView &editor);
static void ModeS7 (ObjView &editor);
static void ModeS8 (ObjView &editor);
static void ModeS9 (ObjView &editor);
static void ModeS10 (ObjView &editor);
static void ModeS11 (ObjView &editor);
static void Identity (ObjView &editor);
static void LightMode (ObjView &editor);
static void PrevObj (ObjView &editor);
static void NextObj (ObjView &editor);
static void ShowBox (ObjView &editor);
static void ShowCur (ObjView &editor);
static void VtxsChanged (ObjView &editor);
static void MeshDelete (ObjView &editor); void meshDelete ();
static void MeshSplit (ObjView &editor); void meshSplit ();
static void MeshAlignXZ (ObjView &editor); void meshAlign(bool xz);
static void MeshAlign (ObjView &editor);
static void MeshWeldPos (ObjView &editor); void meshWeldPos (); void meshWeldPos(flt pos_eps);
static void MeshSetPos (ObjView &editor); void meshSetPos ();
static void MeshReverse (ObjView &editor); void meshReverse ();
static void MeshReverseNrm (ObjView &editor); void meshReverseNrm();
static void MeshSetNormalN (ObjView &editor); void meshSetNrm(uint vtx_test);
static void MeshSetNormalT (ObjView &editor);
static void MeshSetNormalP (ObjView &editor);
static void MeshSetNormal (ObjView &editor);
static void MeshSetNormalH (ObjView &editor); void meshSetNrmH();
static void MeshNormalY (ObjView &editor); void meshNrmY ();
static void MeshSetVtxAO (ObjView &editor);
static void MeshCreateFace (ObjView &editor); void meshCreateFace();
static void MeshMergeFaces (ObjView &editor); void meshMergeFaces();
static void MeshRotQuads (ObjView &editor); void meshRotQuads ();
static void MeshQuadToTri (ObjView &editor); void meshQuadToTri ();
static void MeshTesselate (ObjView &editor); void meshTesselate ();
static void MeshSubdivide (ObjView &editor); void meshSubdivide ();
static void MeshColorBrght (ObjView &editor); void meshColorBrght();
static void MeshDelDblSide (ObjView &editor); void meshDelDblSide();
static void MeshSeparate1 (ObjView &editor); void meshSeparate1 ();
static void MeshSeparateN (ObjView &editor); void meshSeparateN ();
static void MeshCopyParts (ObjView &editor); void meshCopyParts ();
static void SetBody (ObjView &editor);
static void AnimTargetObj (ObjView &editor);
static void MeshSkinFull (ObjView &editor); void meshSkinFull ();
static void MeshSkinFullP (ObjView &editor); void meshSkinFullP ();
static void MeshSkinFullU (ObjView &editor); void meshSkinFullU ();
static void MeshSkinAuto (ObjView &editor); void meshSkinAuto ();
static void MeshEditSel (ObjView &editor);
static void MeshVFS0 (ObjView &editor);
static void MeshVFS1 (ObjView &editor);
static void MeshVFS2 (ObjView &editor);
static void MeshVFS3 (ObjView &editor);
static void ShowVtxs (ObjView &editor);
static void ShowVtxsF (ObjView &editor);
static void ShowVtxsN (ObjView &editor);
static void GotoPhMtrl (ObjView &editor);
static void ClearPhMtrl (ObjView &editor);
static void GotoBody (ObjView &editor);
static void ClearBody (ObjView &editor);
static void GotoGroups (ObjView &editor);
static void ClearGroups (ObjView &editor);
static void ClearBack (ObjView &editor);
static void MeshRemVtxTex1 (ObjView &editor);
static void MeshRemVtxTex2 (ObjView &editor);
static void MeshRemVtxTex12(ObjView &editor);
static void MeshRemVtxColor(ObjView &editor);
static void MeshRemVtxSkin (ObjView &editor);
void modeS(int i);
void remVtx(uint flag, C MaterialPtr &mtrl=null, bool only_selected=false);
static void MeshUndo(ObjView &editor);
static void MeshRedo(ObjView &editor);
static void Locate(ObjView &editor);
// get
flt absLodDist(C MeshLod&lod );
flt lodDist(C MeshLod&lod );
void lodDist( MeshLod&lod, flt dist);
void setLodDist( MeshLod&lod, flt dist);
C MeshLod& getLod()C;
MeshLod& getLod();
C MeshLod& getDrawLod()C;
MeshLod& getDrawLod();
C MeshPart* getPart(int i)C;
MeshPart* getPart(int i);
int getPart(GuiObj *go, C Vec2 &screen_pos, Vec *hit_pos=null);
int getVtxFace(GuiObj *go, C Vec2 &screen_pos, int *hit_vtx=null, int *hit_face=null, Vec *hit_pos=null);
void getVtxs(GuiObj *go, C Shape &shape, MemPtr<VecI2> vtxs); // 'vtxs' will be sorted
void getSkel(GuiObj *go, C Vec2 &screen_pos, int *bone_i, int *slot_i);
void getSkelSlot(C Vec2 &screen_pos);
int getPhys(GuiObj *go, C Vec2 &screen_pos);
MeshPart* validateDup(int part);
void getVtxNeighbors(MemPtr<int> vtxs, int vtx, int part);
void getFaceNeighbors(MemPtr<int> faces, int face, int part);
void getSelectedVtxs(MemPtr<VecI2> vtxs, bool from_vtxs=true, bool from_faces=true);
// set
void getSamePos(int part, int vtx, MemPtr<VecI2> vtxs);
void includeSamePos(int part, MemPtr<VecI2> vtxs); // !! assumes that 'vtxs' is sorted and valid (point to valid indexes) !!
void selVFClear();
void litSelVFClear();
void selVFSet(int part, int vtx, int face, bool same_pos=true);
void selVFToggle(int part, int vtx, int face, bool same_pos=true);
void selVFInclude(int part, int vtx, int face, bool same_pos=true);
void selVFExclude(int part, int vtx, int face, bool same_pos=true);
void selVFDo();
void selVFDo(bool include, bool same_pos=true);
void selUndo();
// create
void setMenu();
void setMenu(Node<MenuElm> &menu, C Str &prefix);
ObjView& create();
void createMesh();
virtual void resize()override;
void setShader();
// operations
void flushObj();
void flushMeshSkel(SAVE_MODE save_mode=SAVE_DEFAULT);
void flushPhys();
void flush(SAVE_MODE save_mode=SAVE_DEFAULT);
void setChangedObj ( );
void setChangedMesh(bool file, bool box=true);
void setChangedSkel(bool bone );
void setChangedPhys( );
void setBox ( );
void gotoPhysMtrl();
void gotoBody();
void gotoDrawGroupEnum();
void setPhysMtrl(C UID &mtrl_id);
void setBody(C UID &body_id);
void setDrawGroupEnum(C UID &enum_id);
void animTargetObj();
void resetTransform();
void setTransform(C Matrix &matrix);
void applyTransform(C Matrix &matrix);
void skinChanged();
void selectedChanged();
bool selectionZoom(flt &dist);
virtual void camCenter(bool zoom)override;
void reloadObj();
void syncObj();
void reloadMeshSkel();
void reloadPhys();
void reload();
Str nodeDisplayName(int node_i)C;
void addBoneRootData(int parent, int max_depth);
void setBoneRootTextSize();
void toGuiSkel();
void toGuiPhys();
void toGui();
void set(Elm *elm);
void activate(Elm *elm);
void toggle(Elm *elm);
void resetDrawGroupEnum();
void enumChanged(C UID &enum_id);
void meshVariationChanged();
void elmChanged(C UID &elm_id);
void meshChanged();
void skelTransformChanged();
void erasing(C UID &elm_id);
Elm* getMeshElm();
Elm* getSkelElm();
void dragPhysMtrl(Memc<UID> &elms);
void dragDrawGroup(Memc<UID> &elms);
void dragBody(Memc<UID> &elms);
void setAutoTanBin(C MaterialPtr &material);
void setMaterial(int part_i, C MaterialPtr &material);
void drag(Memc<UID> &elms, GuiObj* &focus_obj, C Vec2 &screen_pos);
void drop(Memc<Str> &names, GuiObj *focus_obj, C Vec2 &screen_pos);
void animate(C AnimSkel &anim_skel, bool transform_anims=true, C UID &ignore_anim_id=UIDZero);
void animate(C Animation &anim, flt anim_time, bool transform_anims=true, C UID &ignore_anim_id=UIDZero);
virtual void update(C GuiPC &gpc)override;
static void Add(Str &s, cchar8 *t);
void drawInfo(C GuiPC &gpc);
/////////////////////////////////////////
// MESH
/////////////////////////////////////////
int visibleVariation()C;
int selVariation()C;
void selVariation(int variation, SET_MODE mode=SET_DEFAULT);
int selLod()C;
void selLod(int lod);
void eraseLOD(int i);
void disableLOD(int i);
void updateMesh();
/////////////////////////////////////////
// SLOT
/////////////////////////////////////////
static void SlotModeChanged(ObjView &editor);
static void SlotCopy(ObjView &editor);
static void SlotPaste(ObjView &editor);
static void SlotReplace(ObjView &editor);
void slotRot(flt x, flt y, flt z);
static void SlotRotX (ObjView &editor);
static void SlotRotXN(ObjView &editor);
static void SlotRotY (ObjView &editor);
static void SlotRotYN(ObjView &editor);
static void SlotRotZ (ObjView &editor);
static void SlotRotZN(ObjView &editor);
static void SlotSetSelMirror(ObjView &editor);
static void SlotSetMirrorSel(ObjView &editor);
void slotSetSelMirror(bool set_other);
enum SLOT_MODE
{
SLOT_ADD,
SLOT_DEL,
SLOT_MOVE,
SLOT_ROT,
SLOT_SCALE,
SLOT_RENAME,
SLOT_PARENT,
};
static cchar8 *slot_desc[]
;
void createSlots();
static void DragSlotsSlot(ptr slot_index, GuiObj *go, C Vec2 &screen_pos);
static void DragSlotsBone(ptr bone_index, GuiObj *go, C Vec2 &screen_pos);
void updateSlots();
void renameSlot(int index, C Str &old_name, C Str &new_name);
void putMeshToSlot(C MeshPtr &mesh, int slot_index);
/////////////////////////////////////////
// BONE
/////////////////////////////////////////
static cchar8 *del_root_bone_dialog_id;
static void DelRootBone(ObjView &editor);
void delRootBone();
void delBone(int bone_i);
static void BoneModeChanged(ObjView &editor); //if(editor.bone_tabs()!=BONE_MOVE && editor.bone_tabs()!=BONE_ROT && editor.bone_tabs()!=BONE_SCALE)editor.selBone(-1);}
static void BoneRootChanged(ObjView &editor);
static void SkelCopy (ObjView &editor);
static void SkelPaste(ObjView &editor);
static void SkelReplace(ObjView &editor);
static void SkelSetSelMirror(ObjView &editor);
static void SkelSetMirrorSel(ObjView &editor);
void skelSetSelMirror(bool set_other);
static void RotBoneRoll(ObjView &editor);
static void AdjustBoneOrnsDo(ObjView &editor);
static void SkelDelBones (ObjView &editor);
void skelDelBones ();
static void SkelDelLeafBones(ObjView &editor);
void skelDelLeafBones();
enum BONE_MODE
{
BONE_ADD,
BONE_DEL,
BONE_MOVE,
BONE_ROT,
BONE_SCALE,
BONE_RENAME,
BONE_PARENT,
};
static cchar8 *bone_desc[]
;
enum BONE_MOVE_MODE
{
BONE_MOVE_START,
BONE_MOVE_END ,
};
static cchar8 *bone_move_desc[]
;
enum BONE_CHILDREN_MODE
{
BONE_CHILDREN_NONE ,
BONE_CHILDREN_NEAREST,
BONE_CHILDREN_ALL ,
};
static cchar8 *bone_child_desc[]
;
static cchar8 *bone_child_rot_desc[]
;
void clearBones();
void selectLit ();
int boneToVis(int i);
int visToBone(int i);
void selBone(int i);
void createBones();
static void DragBonesBone(ptr bone_index, GuiObj *go, C Vec2 &screen_pos);
void updateBones();
bool renameBone(C Str &old_name, C Str &new_name);
/////////////////////////////////////////
// PHYS
/////////////////////////////////////////
enum PHYS_MODE
{
PHYS_DEL,
PHYS_MOVE,
PHYS_ROT,
PHYS_SCALE,
PHYS_TOGGLE,
};
static cchar8 *phys_desc[]
;
static void PhysUndo(ObjView &editor);
static void PhysRedo(ObjView &editor);
static void PhysChanged(ObjView &editor);
static void NewBox (ObjView &editor);
static void NewBall (ObjView &editor);
static void NewCapsule(ObjView &editor);
static void NewTube (ObjView &editor);
static void Convex8 (ObjView &editor);
static void Convex16 (ObjView &editor);
static void Convex24 (ObjView &editor);
static void Convex32 (ObjView &editor);
static void Convex64 (ObjView &editor);
static void PhysMesh (ObjView &editor);
static void PhysDel (ObjView &editor);
static void PhysCopy (ObjView &editor);
static Str PhysDensity(C ObjView &editor );
static void PhysDensity( ObjView &editor, C Str &text);
Elm* getPhysElm();
bool hasPhysMeshOrConvex();
void physMesh(MeshBase &mesh);
void physSetConvex(int max_vtxs);
void physSetMesh();
void physCopy();
void physDel();
void createPhys();
void setPhysPartMatrix();
void setPhys(int part);
void updatePhys();
/////////////////////////////////////////
// RAGDOLL
/////////////////////////////////////////
enum RAGDOLL_MODE
{
RAGDOLL_TOGGLE,
RAGDOLL_SCALE ,
RAGDOLL_MOVE ,
};
static cchar8 *ragdoll_desc[]
;
void createRagdoll();
void updateRagdoll();
};
/******************************************************************************/
/******************************************************************************/
extern ObjView ObjEdit;
/******************************************************************************/
| [
"esenthel@hotmail.com"
] | esenthel@hotmail.com |
072257a7052a38a42fa70a79f970bc88c66c4845 | c214bd644fb0fa44b56fc188526ca2fd24da3123 | /source/MeClimate.ino | 5e52598fa8fb1d52a7dbc0f3ae0e9c7fb8f93d79 | [
"MIT"
] | permissive | alex-kozin/meclimate | d831db5f69d1a0f17db0bfb1d65650186d5d949b | 26c11d26fbad5f5795b99725855db542c0703e7f | refs/heads/master | 2023-01-28T08:31:45.479806 | 2020-12-04T06:11:31 | 2020-12-04T06:11:31 | 318,419,001 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 28,435 | ino | // ****************************************************
// Регулятор температуры и освещения (курсовая работа)
//
// ****************************************************
// Arduino --- GSM-module
// 5V >--------> 5V
// GND >-------> GND
// GND >-------> BOOT
// D9 >--------> TXD
// D8 >--------> RXD
#include <EEPROM.h>
#include <SoftwareSerial.h>
SoftwareSerial ESPport(10, 11);
//-------------------- RX, TX
#define BUFFER_SIZE 128 //размер буфера Wi-Fi
char buffer[BUFFER_SIZE]; //буфер обмена Wi-Fi
int reset_pin = 12; //пин кнопки возврата к заводским настройкам
int speak_pin = 7; //пин льезокерамического излучателя
int red_pin = 6; //пин превышения верхней границы температуры (красный с/д)
int yel_pin = 5; //желтый с/д аварии - превышение разумных пределов температуры
int gre_pin = 4; //зелёный с/д индикации состояния регулятора температуры
int blu_pin = 3; //пин занижения нижней границы температуры (синий с/д)
int whi_pin = 2; //выходной пин регулятора освещения (белый светодиод)
int t_pin = 5; //аналоговый пин датчика температуры
int light_pin = 4; //аналоговый пин датчика освещённости
//Объявление переменных датчика ТМР36 при напряжении 5V tk=(t+50)*2.048
int tk_max = 200; //температура: максимальная 50
int tk_high = 170; //температура: верхняя_граница 35
int tk_now; //текущее значение температуры
int tk_low = 130; //температура: нижняя_граница 15
int tk_min = 100; //температура: минимальная 0
int t_counter = 300; //интервал нормализации температуры (сек)
//Объявление и инициализация переменных Фоторезистора VT90N2 при напряжении 5V
int light_low; //освещённость: нижняя_граница (темно)
int light_now; //освещённость в настоящий момент
//Объявление прочих переменных
long t_begin; //стартовое значение мсек
bool S_or_W; //переключатель канала связи с регулятором
char pusk; //команда Разрешения/Запрета работы регулятора
int yel_ind; //управление желтым светодиодом
int gre_ind; //управление зелёным светодиодом
bool sendSms; //разрешение на отправку смс
char telnum[12]; //номер телефона для отправки СМС
void setup() //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
{
//EEPROM.write(0,255);
if (EEPROM.read(0) == 255)
{
//начальная инициализация
tk_max = 200; //температура: максимальная 50
EEPROM_intWrite(tk_max,1);
tk_high = 170; //температура: верхняя_граница 35
EEPROM_intWrite(tk_high,3);
tk_low = 130; //температура: нижняя_граница 15
EEPROM_intWrite(tk_low,5);
tk_min = 100; //температура: минимальная 0
EEPROM_intWrite(tk_min,7);
t_counter = 300; //интервал нормализации температуры (сек)
EEPROM_intWrite(t_counter,9);
light_low = 600; //освещённость: нижняя_граница (темно)
EEPROM_intWrite(light_low,11);
pusk = 'K'; //команда Разрешения(N)/Запрета(K) работы регулятора
EEPROM.write(13,0);
EEPROM.write(14,1);
String temp = "380989617943";
for(int i = 0; i<12; i++)
{
telnum[i] = temp[i];
EEPROM.write(15+i, temp[i]);
}
EEPROM.write(0, 0);
void(* resetFunc) (void) = 0; // объявляем функцию reset
resetFunc(); //вызываем reset
}
else
{
tk_max = EEPROM_intRead(1);
tk_high = EEPROM_intRead(3);
tk_low = EEPROM_intRead(5);
tk_min = EEPROM_intRead(7);
t_counter = EEPROM_intRead(9);
light_low = EEPROM_intRead(11);
if(EEPROM.read(13)==0)
pusk = 'K';
else
pusk = 'N';
sendSms = EEPROM.read(14);
for(int i = 0; i < 12; i++)
{
telnum[i] = EEPROM.read(15+i);
}
}
//Инициализация переменных
yel_ind = -1; //>0 - зажечь; <0 - потушить; 0 - не трогать
gre_ind = -1; //>0 - зажечь; <0 - потушить; 0 - не трогать
t_begin = 0; //сбросить интервал
S_or_W = false; //1(true)=Serial или 0(false)=Wi-Fi канал связи с регулятором
//Инициализация портов и пинов
pinMode(reset_pin, INPUT); //режим пина возврата заводских настроек
pinMode(red_pin,OUTPUT); //режим пина охлаждателя (красный с/д)
pinMode(yel_pin,OUTPUT); //режим пина аварии (желтый с/д)
pinMode(gre_pin,OUTPUT); //режим пина регулятора температуры (зеленый с/д)
pinMode(blu_pin,OUTPUT); //режим пина нагревателя (голубой с/д)
pinMode(whi_pin,OUTPUT); //режим пина управления освещённостью (белый с/д)
pinMode(speak_pin,OUTPUT); //режим пина пьезокерамического излучателя
digitalWrite(reset_pin, HIGH); //слушаем кнопку рестарта
digitalWrite(red_pin,LOW); //выключить охлаждатель
digitalWrite(yel_pin,LOW); //выключить желтый с/д
digitalWrite(gre_pin,LOW); //выключить зеленый с/д
digitalWrite(blu_pin,LOW); //выключить нагреватель
digitalWrite(whi_pin,LOW); //выключить освещение
Serial.begin(9600); //инициализация COM-порта
while (!Serial) {;} //ожидание подключения родного USB-СОМ-порта
Serial.println("Please wait some seconds ...");
//---------------------------------------------------
//Настройка связи с ESP-иодулем и инициализация Wi-Fi
//---------------------------------------------------
Serial.println(Get_Resp("AT+RESTORE",3000)); //перезагрузка ESP
Serial.println(Get_Resp("AT+CIOBAUD=9600",300)); //установка скорости
ESPport.begin(9600); // ESP8266
Serial.println(Get_Resp("AT+CWMODE=3",300)); //смешаный режим
Serial.println(Get_Resp("AT+CIPSERVER=0", 300)); //остановить сервер (если он был запущен)
Serial.println(Get_Resp("AT+CIPMUX=0",300)); //single connection
Serial.println(Get_Resp("AT+CIPMODE=0",300)); //сквозной режим передачи данных
Serial.println(Get_Resp("AT+CIPMUX=1",300)); // multiple connection
Serial.println(Get_Resp("AT+CWSAP=\"MeClimate\",\"\",2,0",1000)); //идентификатор сети,пароль,канал,режим шифрования
Serial.println(Get_Resp("AT+CIPAP=\"192.168.0.222\"", 300)); //IP-адрес
Serial.println(Get_Resp("AT+CIPSERVER=1,888", 300)); //запустить сервер на порту 888
Serial.println(Get_Resp("AT+CIPSTO=7200", 300)); // таймаут сервера в сек
for(int i = 0; i < 40; i++)
{
Serial.println(EEPROM.read(i));
}
Clear_Soft_Port(); //очистить буфер Soft-порта
Clear_Serial_Port(); //очистить буфер Serial-порта
Play_Start(); //проиграть стартовую мелодию
}
void loop() //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
{
//Обработка перезапуска
if(digitalRead(reset_pin)==LOW)
{
EEPROM.write(0,255);
void(* resetFunc) (void) = 0; // объявляем функцию reset
resetFunc(); //вызываем reset
}
//~~~~~~ Опрос датчиков
tk_now = analogRead(t_pin); //читаем код сигнала датчика температуры
light_now = analogRead(light_pin); //читаем код сигнала датчика освещения
if (S_or_W)
{ //связь с регулятором по ПРОВОДАМ
Get_Serial(); //ввод команд и параметров регулирования через Serial
}
else
{ //связь с регулятором через WI-FI
Get_Soft(); //ввод команд и параметров регулирования через SoftwareSerial
}
//~~~~~~ Основной исполнительный блок регулятора
if (pusk == 'N') //если есть разрешение на работу
{
//обработка показаний датчика освещённости
if (light_now < light_low) digitalWrite(whi_pin,HIGH); //включаем освещение
else digitalWrite(whi_pin,LOW); //отключаем освещение
//обработка показаний датчика температуры
if (tk_now > tk_max || tk_now < tk_min) //авария - температура вне разумных границ
{ //ВЫКЛЮЧИТЬ ВСЁ И БИТЬ ТРЕВОГУ
digitalWrite(red_pin,LOW); //вык.охлаждатель
digitalWrite(blu_pin,LOW); //вык.нагреватель
t_begin = 0;
if(sendSms)
GsmSend("Warning! Your home temperature is out of limits!");
}
if (tk_now > tk_high || tk_now < tk_low) //тек.температура требует коррекции
{
if (tk_now > tk_high) //надо включать охлаждатель
{
digitalWrite(blu_pin,LOW); //выключить нагреватель
digitalWrite(red_pin,HIGH); //включить охлаждатель
//проверить не превышен ли интервал нормализации температуры
if (t_begin == 0) //начало процесса охлаждения
{
t_begin = millis();
EEPROM.write(14,1);
sendSms = true;
}
else if (abs(millis() - t_begin)/1000 > t_counter) //превышен интервал
{
gre_ind *= (-1); //начать мигать
delay(500);
if(sendSms)
GsmSend("Warning! Your home temperature is out of limits!");
playNote('C', 500); //и подавать звук
}
}
if (tk_now < tk_low) //надо включать нагреватель
{
digitalWrite(red_pin,LOW); //выключить охлаждатель
digitalWrite(blu_pin,HIGH); //включить нагреватель
//проверить не превышен ли интервал нормализации температуры
if (t_begin == 0) //начало процесса нагревания
{
t_begin = millis();
EEPROM.write(14,1);
sendSms = true;
}
else if (abs(millis() - t_begin)/1000 > t_counter) //превышен интервал
{
gre_ind *= (-1); //начать мигать
delay(500);
if(sendSms)
GsmSend("Warning! Your home temperature is out of limits!");
playNote('c', 500); //и подавать звук
}
}
}
else //температура в норме
{
digitalWrite(red_pin,LOW); //выключить охлаждатель
digitalWrite(blu_pin,LOW); //выключить нагреватель
t_begin = 0; //сбросить интервал
gre_ind = 1; //установить признак нормальной температуры
yel_ind = -1;
EEPROM.write(14,1);
sendSms = true;
}
}
else if (pusk == 'K') //~~~~~~~~~~~~~~~~~~~~ команда прекратить работу регулятора
{
if(sendSms == false)
{
yel_ind *= (-1); //начать мигать
playNote('C', 100); //подать звук
playNote('b', 100); //подать звук
playNote('a', 100); //подать звук
delay(200);
}
else
{
digitalWrite(red_pin,LOW); //вык.охлаждатель
digitalWrite(blu_pin,LOW); //вык.нагреватель
digitalWrite(whi_pin,LOW); //вык.освещение
digitalWrite(yel_pin,LOW); //вык.желтый индик-р
digitalWrite(gre_pin,LOW); //вык.зеленый индик-р
yel_ind = -1; //признак = погасить с/д
gre_ind = -1; //признак = погасить с/д
t_begin = 0; //сбросить интервал
EEPROM.write(14,1);
sendSms = true;
}
}
//индикация параметров
if (gre_ind > 0) digitalWrite(gre_pin,HIGH); //зажечь индикатор нормы
if (gre_ind < 0) digitalWrite(gre_pin,LOW); //погасить индикатор нормы
if (yel_ind > 0) digitalWrite(yel_pin,HIGH); //зажечь индикатор аварии
if (yel_ind < 0) digitalWrite(yel_pin,LOW); //погасить индикатор аварии
if (S_or_W) delay(200); //задержка цикла опроса при канале связи Serial
} //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//~~~ Ввод параметров регулирования через SoftSerial
void Get_Soft()
{
int ch_id, packet_len;
char *pb, inp_v, rrr[70] = "", ccc[8] = "";
ESPport.readBytesUntil('\n', buffer, BUFFER_SIZE); //читаем порт до 0x0A
if(strncmp(buffer, "+IPD,", 5)==0) //если есть идентификатор принятых данных
{
sscanf(buffer+5, "%d,%d", &ch_id, &packet_len); //№_канала_WiFi, длина_данных
if (packet_len > 0) //если длина принятых данных > 0
{
pb = buffer+5; //пропускаем №_канала + длину и ...
while(*pb != ':') pb++;//ищем начало принятых данных
pb++; //становимся в их начало
inp_v = pb[0]; //запоминаем команду
if (inp_v == 'S') //переход на работу через Serial (по проводам)
{
Clear_Soft_Port(); //очистить буфер Soft-порта
Clear_Serial_Port(); //очистить буфер Serial-порта
S_or_W = true; //изменить режим обмена
playNote('C', 100); //подать звук
}
//пуск/останов регулятора
if (inp_v == 'N' || inp_v == 'K')
{
pusk = inp_v; //запомнить команду
if(inp_v == 'N')
EEPROM.write(13,1);
else
EEPROM.write(13,0);
playNote('c', 100); //подать звук
}
if(inp_v == 'R'){
void(* resetFunc) (void) = 0; // объявляем функцию reset
resetFunc(); //вызываем reset
}
if(inp_v == 'P'){
playNote('c', 100); //подать звук
for(int i = 0; i < 12; i++)
{
pb++;
telnum[i] = pb[0];
EEPROM.write(15+i, telnum[i]);
}
delay(200);
}
if(inp_v == 'Q'){
ESPport.print("AT+CIPSEND="); // ответ клиенту
ESPport.print(ch_id); //номер конекта клиента
ESPport.print(",");
ESPport.println(12); //длина передаваемых данных
delay(20);
if(ESPport.find(">")) //есть приглашение на передачу
{
for(int i = 0; i < 12; i++)
{
telnum[i] = EEPROM.read(15+i);
}
ESPport.print(telnum);
Serial.println(telnum);
for(int i = 0; i < 40; i++)
{
Serial.println(EEPROM.read(i));
}
playNote('c', 100); //подать звук
}
delay(200);
}
if(inp_v=='O'){
ESPport.print("AT+CIPSEND="); // ответ клиенту
ESPport.print(ch_id); //номер конекта клиента
ESPport.print(",");
ESPport.println(1); //длина передаваемых данных
delay(20);
if(ESPport.find(">")) //есть приглашение на передачу
{
int val = EEPROM.read(13);
if(val == 0)
{
ESPport.print('K'); //передать данные через Wi-Fi
}
else
{
ESPport.print('N'); //передать данные через Wi-Fi
}
delay(200);
playNote('a', 100); //подать звук
}
}
//установить параметры регулировки температуры/освещения
if (inp_v == 'A' || inp_v == 'L' || inp_v == 'H' || inp_v == 'Z' || inp_v == 'X' || inp_v == 'C')
{ int val = 0;
while (true)
{
if (pb[0] >= '0' && pb[0] <= '9') //формирование значения параметра
{ val *= 10;
val += (pb[0] & 15);
}
if (pb[0] == '.') //запомнить значение сформированного параметра
{
if (inp_v == 'Z')
{
tk_max = val;
EEPROM_intWrite(val,1);
}
if (inp_v == 'H')
{
tk_high = val;
EEPROM_intWrite(val,3);
}
if (inp_v == 'L')
{
tk_low = val;
EEPROM_intWrite(val,5);
}
if (inp_v == 'A')
{
tk_min = val;
EEPROM_intWrite(val,7);
}
if (inp_v == 'C')
{
t_counter = val;
EEPROM_intWrite(val,9);
}
if (inp_v == 'X')
{
light_low = val;
EEPROM_intWrite(val,11);
}
pb++;
val = 0;
inp_v = pb[0];
playNote('e', 100); //подать звук
}
if (pb[0] == '\n') //закончить обработку строки параметров
{ inp_v = ' ';
break;
}
pb++;
}
}
//получить состояние/данные от регулятора
if (inp_v == 'I')
{
strcat(rrr,"A"); itoa(tk_min,ccc,10); strcat(rrr,ccc); strcat(rrr,".");
strcat(rrr,"L"); itoa(tk_low,ccc,10); strcat(rrr,ccc); strcat(rrr,".");
strcat(rrr,"T"); itoa(tk_now,ccc,10); strcat(rrr,ccc); strcat(rrr,".");
strcat(rrr,"H"); itoa(tk_high,ccc,10); strcat(rrr,ccc); strcat(rrr,".");
strcat(rrr,"Z"); itoa(tk_max,ccc,10); strcat(rrr,ccc); strcat(rrr,".");
strcat(rrr,"X"); itoa(light_low,ccc,10); strcat(rrr,ccc); strcat(rrr,".");
strcat(rrr,"Y"); itoa(light_now,ccc,10); strcat(rrr,ccc); strcat(rrr,".");
strcat(rrr,"C"); itoa(t_counter,ccc,10); strcat(rrr,ccc); strcat(rrr,".");
strcat(rrr,"\r\n");
ESPport.print("AT+CIPSEND="); // ответ клиенту
ESPport.print(ch_id); //номер конекта клиента
ESPport.print(",");
ESPport.println(strlen(rrr)); //длина передаваемых данных
delay(20);
if(ESPport.find(">")) //есть приглашение на передачу
{
ESPport.print(rrr); //передать данные через Wi-Fi
delay(200);
playNote('a', 100); //подать звук
}
}
}
}
Clear_Buffer(); //очистить буфер и порт
Clear_Soft_Port();
}
//~~~ Oтправка АТ-команд через ESPport и чтение ответа
String Get_Resp(String AT_Command, int wait)
{ String tmpData;
ESPport.println(AT_Command);
delay(wait);
while (ESPport.available() >0 )
{ char c = ESPport.read();
tmpData += c;
tmpData.trim();
}
return tmpData;
}
//~~~ Oчистка буфера Soft-порта (ESPport)
void Clear_Soft_Port()
{ while ( ESPport.available() > 0 )
{ ESPport.read();
}
}
//~~~ Oчистка буфера Setial-порта
void Clear_Serial_Port()
{ while ( Serial.available() > 0 )
{ Serial.read();
}
}
//~~~ Очистка буфера Wi-Fi
void Clear_Buffer() {
for (int i =0;i<BUFFER_SIZE;i++ )
{ buffer[i]=0;
}
}
//~~~ Ввод команд и параметров регулирования через SerialPort
void Get_Serial()
{ char inp_v; //принятый символ
int tkk; //принятый параметр
if (Serial.available()) //если есть принятый символ,
{
inp_v = Serial.read(); //то читаем его и сохраняем в inp_v
if (inp_v == 'W') //переход на работу по Wi-Fi
{
Clear_Soft_Port(); //очистить буфер Soft-порта
Clear_Serial_Port(); //очистить буфер Serial-порта
S_or_W = false; //изменить режим обмена
playNote('C', 100); //подать звук
}
//пуск-останов регулятора
if (inp_v == 'N' || inp_v == 'K')
{
pusk = inp_v; //запомнить команду
playNote('c', 100); //подать звук
}
//установить параметры регулировки температуры/освещения
if (inp_v == 'A' || inp_v == 'L' || inp_v == 'H' || inp_v == 'Z' || inp_v == 'X' || inp_v == 'C')
{ tkk = inp_v; //запомним тип параметра
int val = 0; //здесь будет сформировано значение параметра
while (true) //читаем значение параметра до появления точки
{ if (Serial.available())
{ inp_v = Serial.read();
if (inp_v == '.') break; //конец ввода значения параметра
val *= 10;
val += (inp_v & 15); //формирования численного значения параметра
}
}
if (tkk == 'A') tk_min = val; //запоминание значения параметра
if (tkk == 'L') tk_low = val; //в соответствующей переменной
if (tkk == 'H') tk_high = val;//запоминание значения параметра
if (tkk == 'Z') tk_max = val; //в соответствующей переменной
if (tkk == 'X') light_low = val; //запоминание значения параметра
if (tkk == 'C') t_counter = val; //запоминание значения параметра
playNote('e', 100); //подать звук
}
//получить состояние/данные от регулятора
if (inp_v == 'I')
{
Serial.print("A"); Serial.print(tk_min); Serial.print(".");
Serial.print("L"); Serial.print(tk_low); Serial.print(".");
Serial.print("T"); Serial.print(tk_now); Serial.print(".");
Serial.print("H"); Serial.print(tk_high); Serial.print(".");
Serial.print("Z"); Serial.print(tk_max); Serial.print(".");
Serial.print("X"); Serial.print(light_low); Serial.print(".");
Serial.print("Y"); Serial.print(light_now); Serial.print(".");
Serial.print("C"); Serial.print(t_counter); Serial.print(".");
Serial.println();
playNote('a', 100); //подать звук
}
}
}
//~~~ Вывод звука заданной частоты (tone) и длительности (duration)
void playTone(int tone, int duration)
{
for (long i = 0; i < duration * 1000L; i += tone * 2)
{
digitalWrite(speak_pin, HIGH);
delayMicroseconds(tone);
digitalWrite(speak_pin, LOW);
delayMicroseconds(tone);
}
}
//~~~ Озвучивание ноты (note) заданной длительности (duration)
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 };
//воспроизвести тон соответствующей ноты
for (int i = 0; i < 8; i++)
{
if (names[i] == note)
{
playTone(tones[i], duration);
}
}
}
void EEPROM_intWrite(int num, int cellnum)//Запись данных в постоянную память
{
byte high = highByte(num); // старший байт
byte low = lowByte(num); // младший байт
EEPROM.write(cellnum, high); // записываем в ячейку 1 старший байт
EEPROM.write(cellnum+1, low); // записываем в ячейку 2 младший байт
}
int EEPROM_intRead(int cellnum)//Чтение данных из постоянной памяти
{
byte high = EEPROM.read(cellnum); // читаем старший байт
byte low = EEPROM.read(cellnum+1); // читаем младший байт
int value = word(high,low);// объединяем их в значение
return value;
}
void GsmSend(String message)
{
EEPROM.write(14,0);
EEPROM.write(13,0);
SoftwareSerial gsm(9, 8); // на контроллере RX, TX
gsm.begin(115200); //скорость работы UART модема
gsm.println("AT+CPIN=\"1111\""); //PIN-код SIM-карты
while(true) //ждем подключение модема к GSM-сети
{
gsm.println("AT+COPS?");
if (gsm.find("0")) break; //сеть найдена, модем подключен к ней
delay(500);
}
//~~~~~~~~~ Oтправка SMS ~~~~~~~~~
gsm.println("AT+CMGF=1"); //текстовый режим (латиница)
delay(100);
gsm.println("AT+CSCS=\"GSM\""); //кодировка текста - ASCII
delay(100);
char phone[12];
for(int i =0; i< 12; i++)
{
phone[i] = EEPROM.read(15+i);
}
gsm.println("AT+CMGS=\"" + String(phone).substring(0,12) + "\""); //номер телефона
Serial.println("AT+CMGS=\"" + String(phone).substring(0,12) + "\"");
delay(100);
gsm.print(message); //текст SMS-сообщения
gsm.print((char)26); //символ завершающий передачу
delay(300);
void(* resetFunc) (void) = 0; // объявляем функцию reset
resetFunc(); //вызываем reset
}
//~~~ Стартовая мелодия
void Play_Start()
{
playNote('c', 50);
playNote('d', 50);
playNote('e', 50);
playNote('f', 50);
playNote('g', 50);
playNote('a', 50);
playNote('b', 50);
playNote('C', 50);
}
| [
"alexandr.job@yahoo.com"
] | alexandr.job@yahoo.com |
c9f27c1d91a78f59878300bbb91b0e9361920b77 | 3718472c16426c01a9b0515fdb9a53c9c3b99f83 | /keymanager/customtreeview.cpp | 10732f15678c44963025ee61b4ac3f8aa958bc19 | [] | no_license | QtWorks/keymanager_new | 944ea550aa8faff7e2beae55b5b3106b1244f36b | 89a3740be829ec371afd4b7a50a4993d0b97e55a | refs/heads/master | 2020-05-17T17:51:17.102809 | 2019-03-12T22:02:05 | 2019-03-12T22:02:05 | 183,866,748 | 0 | 1 | null | 2019-04-28T06:36:07 | 2019-04-28T06:36:07 | null | UTF-8 | C++ | false | false | 392 | cpp | // Qt
#include <QMouseEvent>
// Application
#include "customtreeview.h"
//-------------------------------------------------------------------------------------------------
CustomTreeView::CustomTreeView(QWidget *pParent) : QTreeView(pParent)
{
}
//-------------------------------------------------------------------------------------------------
CustomTreeView::~CustomTreeView()
{
}
| [
"legallfranck@yahoo.com"
] | legallfranck@yahoo.com |
7f284d9b12df43c7b3436858a6e0bb442f535bff | 85492e0c5629087bb604f458420657592f05701a | /题目/norepeatstr/mysolution.cpp | 760b9b652dd6e3b901c23d5c7a67fee1c6adb0ac | [] | no_license | lihuaweishiyigehaoren/leetcode | 3ec0a7ea07128544b1c18d7f537135a8d8625477 | d92bd898f80832b8fdc73a34cf80b6121d122109 | refs/heads/master | 2020-04-09T23:01:13.666211 | 2019-09-16T00:56:56 | 2019-09-16T00:56:56 | 160,645,019 | 2 | 1 | null | 2019-04-15T12:44:18 | 2018-12-06T08:42:08 | C++ | UTF-8 | C++ | false | false | 2,706 | cpp | /*
无重复字符串计算
给定一个字符串，请你找出其中不含有重复字符的 最长子串 的长度。
示例 1:
输入: "abcabcbb"
输出: 3
解释: 因为无重复字符的最长子串是 "abc"，所以其长度为 3。
示例 2:
输入: "bbbbb"
输出: 1
解释: 因为无重复字符的最长子串是 "b"，所以其长度为 1。
示例 3:
输入: "pwwkew"
输出: 3
解释: 因为无重复字符的最长子串是 "wke"，所以其长度为 3。
请注意，你的答案必须是 子串 的长度，"pwke" 是一个子序列，不是子串。
*/
#include <string>
#include <iostream>
using namespace std;
class Solution {
public:
int lengthOfLongestSubstring(string s) {
/*理解错误，理解成无重复字符长度了*/
// int count = 0;
// string now = s;
// while(now != "")
// {
// string now_copy = "";
// for(unsigned int index=0;index<now.size();index=index+1)
// {
// char a = now[0];
// if(now[index]!=a){
// now_copy.push_back(now[index]);
// }
// }
// now = now_copy;
// count++;
// }
// return count;
int count = 0;
int len = s.length();
while(len != 0){
int diff = s.length()-len;
for(int index=0;index<diff+1;index++)
{
for(int start=index;start<len+index;start++)
{
// 判断字符是否重复
char a = s[start];
int init_count = 0;
for(int child_start=index;child_start<len+index;child_start++)
{
if(s[child_start]==a) init_count++;
}
if(init_count>1){
break;
}
else
{
if(start==len+index-1)
{
count = len;
len=1;
index = diff;
// 为什么要加这个break，我自己也很懵逼
break;
}
}
}
}
len--;
}
return count;
}
};
int main(){
// string test_string = "pwwkew";
//test2
// string test_string = "abcabcbb";
//test3
string test_string = "bbbbbb";
Solution a;
int count = a.lengthOfLongestSubstring(test_string);
cout<<count<<endl;
return 0;
} | [
"1206909328@qq.com"
] | 1206909328@qq.com |
fd238bc2b7dd5e636d3ab9da994f261ebf347e56 | 45b286742deac8638ec06e00c888e9554f5637d4 | /libraries/libym_verilog/elaborator/ei/EiParamAssign.cc | 87c9f20073cb55c1cda5afad5bb9f34744ea5365 | [] | no_license | yusuke-matsunaga/minimaleda | 0800200f42474a2dbe08d94d977678d67ee085d1 | e0619bfd34baf3ca27c23d2f705067297209104a | refs/heads/master | 2021-01-20T20:03:15.199896 | 2016-08-02T03:43:11 | 2016-08-02T03:43:11 | 64,721,871 | 5 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 5,362 | cc |
/// @file libym_verilog/elb_impl/EiParamAssign.cc
/// @brief EiParamAssign の実装ファイル
/// @author Yusuke Matsunaga (松永 裕介)
///
/// $Id: EiParamAssign.cc 2507 2009-10-17 16:24:02Z matsunaga $
///
/// Copyright (C) 2005-2010 Yusuke Matsunaga
/// All rights reserved.
#include "EiFactory.h"
#include "EiParamAssign.h"
#include "ElbParameter.h"
#include "ElbExpr.h"
#include "ym_verilog/pt/PtItem.h"
#include "ym_verilog/pt/PtMisc.h"
BEGIN_NAMESPACE_YM_VERILOG
//////////////////////////////////////////////////////////////////////
// EiFactory の生成関数
//////////////////////////////////////////////////////////////////////
// @brief パラメータ割り当て文を生成する．
// @param[in] module 親のモジュール
// @param[in] param 対象の parameter
// @param[in] rhs 割り当て式の右辺
// @param[in] named_con 名前による割り当ての時 true
ElbParamAssign*
EiFactory::new_ParamAssign(const VlModule* module,
const PtBase* pt_obj,
ElbDecl* param,
ElbExpr* rhs,
bool named_con)
{
EiParamAssign* pa = NULL;
if ( named_con ) {
void* p = mAlloc.get_memory(sizeof(EiParamAssign));
pa = new (p) EiParamAssign(module, pt_obj, param, rhs);
}
else {
void* p = mAlloc.get_memory(sizeof(EiParamAssign2));
pa = new (p) EiParamAssign2(module, pt_obj, param, rhs);
}
return pa;
}
// @brief defparam 文を生成する．
// @param[in] module 親のモジュール
// @param[in] pt_header パース木の defparam ヘッダ
// @param[in] pt_item パース木の defparam 定義
// @param[in] param 対象の parameter
// @param[in] rhs 割り当て式の右辺
ElbDefParam*
EiFactory::new_DefParam(const VlModule* module,
const PtItem* pt_header,
const PtDefParam* pt_defparam,
ElbDecl* param,
ElbExpr* rhs)
{
void* p = mAlloc.get_memory(sizeof(EiDefParam));
EiDefParam* defparam = new (p) EiDefParam(module, pt_header, pt_defparam,
param, rhs);
return defparam;
}
//////////////////////////////////////////////////////////////////////
// クラス EiParamAssign
//////////////////////////////////////////////////////////////////////
// @brief コンストラクタ
// @param[in] parent 親のモジュール
// @param[in] pt_obj パース木中の対応する要素
// @param[in] param 対象の parameter
// @param[in] rhs 割り当て式の右辺
EiParamAssign::EiParamAssign(const VlModule* parent,
const PtBase* pt_obj,
ElbDecl* param,
ElbExpr* rhs) :
mModule(parent),
mPtObj(pt_obj),
mLhs(param),
mRhs(rhs)
{
}
// @brief デストラクタ
EiParamAssign::~EiParamAssign()
{
}
// @brief 型の取得
tVpiObjType
EiParamAssign::type() const
{
return kVpiParamAssign;
}
// @brief ファイル位置を返す．
FileRegion
EiParamAssign::file_region() const
{
return mPtObj->file_region();
}
// @brief 親のモジュールを返す．
const VlModule*
EiParamAssign::parent() const
{
return mModule;
}
// @brief 左辺値を返す．
const VlDecl*
EiParamAssign::lhs() const
{
return mLhs;
}
// @brief 右辺値を返す．
const VlExpr*
EiParamAssign::rhs() const
{
return mRhs;
}
// @brief 名前による接続の場合に true を返す．
bool
EiParamAssign::is_conn_by_name() const
{
return false;
}
//////////////////////////////////////////////////////////////////////
// クラス EiParamAssign2
//////////////////////////////////////////////////////////////////////
// @brief コンストラクタ
// @param[in] parent 親のモジュール
// @param[in] pt_obj パース木中の対応する要素
// @param[in] param 対象の parameter
// @param[in] rhs 割り当て式の右辺
EiParamAssign2::EiParamAssign2(const VlModule* parent,
const PtBase* pt_obj,
ElbDecl* param,
ElbExpr* rhs) :
EiParamAssign(parent, pt_obj, param, rhs)
{
}
// @brief デストラクタ
EiParamAssign2::~EiParamAssign2()
{
}
// @brief 名前による接続の場合に true を返す．
bool
EiParamAssign2::is_conn_by_name() const
{
return true;
}
//////////////////////////////////////////////////////////////////////
// クラス EiDefParam
//////////////////////////////////////////////////////////////////////
// @brief コンストラクタ
// @param[in] parent 親のモジュール
// @param[in] pt_header パース木の defparam ヘッダ
// @param[in] pt_item パース木の defparam 定義
// @param[in] param 対象の parameter
// @param[in] rhs 割り当て式の右辺
EiDefParam::EiDefParam(const VlModule* parent,
const PtItem* pt_header,
const PtDefParam* pt_defparam,
ElbDecl* param,
ElbExpr* rhs) :
mModule(parent),
mPtHead(pt_header),
mPtDefParam(pt_defparam),
mLhs(param),
mRhs(rhs)
{
}
// @brief デストラクタ
EiDefParam::~EiDefParam()
{
}
// @brief 型の取得
tVpiObjType
EiDefParam::type() const
{
return kVpiDefParam;
}
// @brief ファイル位置を返す．
FileRegion
EiDefParam::file_region() const
{
return mPtDefParam->file_region();
}
// @brief 親のモジュールを返す．
const VlModule*
EiDefParam::parent() const
{
return mModule;
}
// @brief 左辺値を返す．
const VlDecl*
EiDefParam::lhs() const
{
return mLhs;
}
// @brief 右辺値を返す．
const VlExpr*
EiDefParam::rhs() const
{
return mRhs;
}
END_NAMESPACE_YM_VERILOG
| [
"yusuke_matsunaga@ieee.org"
] | yusuke_matsunaga@ieee.org |
7230a5884641af47aa543cb1f3e427fa32151094 | ce134fa129dc7a6d151191d69977d0660e1eacec | /src/include/StreamingService.h | 4ca5e859592732ad3bfecfad1c220f2827c9934c | [] | no_license | CesarJimenezVilleda02/Final-OOP-project-Streaming-service | 2eac00d33c0bf9e9da249de7891f6b93d30b8096 | eeda92af0512fd7f6bc1d8c528dc61421107edc7 | refs/heads/master | 2023-06-28T17:54:46.454110 | 2021-08-02T01:20:01 | 2021-08-02T01:20:01 | 391,781,355 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,213 | h | #ifndef STREAMINGSERVICE_H
#define STREAM_SERVICE_H
#include <vector>
#include <string>
#include "./Video.h"
#include "./Movie.h"
#include "./Series.h"
#include "./Episode.h"
using namespace std;
class StreamingService {
private:
vector <Video*> content;
// vector <Movie*> allMovies;
// vector <Series*> allSeries;
string defaultDataFileLocation;
public:
StreamingService();
void initApp();
bool loadData();
bool loadData(string fileName);
bool displayTitle(string title);
bool displayMedia(string genre);
bool displayMedia(int rating);
bool displayMovies(int rating);
bool displaySeries(int rating);
bool rateVideo(string title);
int getSeriesEpisodes(string rawSeriesData);
void createAddMovie(string rawMovieData);
void createAddSeries(string rawSeriesData, vector <string> rawEpisodesdata);
Episode createEpisode(string rawEpisodeData);
vector <Video*> getContent();
// vector <Movie*> getMovies();
// vector <Series*> getSeries();
string getDefaultDataFileLocation();
};
#endif // !STREAMINGSERVICE_H | [
"65324745+CesarJimenezVilleda02@users.noreply.github.com"
] | 65324745+CesarJimenezVilleda02@users.noreply.github.com |
10500d724534b3ba2016a14f6ad8c66536aec5d7 | 1044ba75cab1fc6825c9e038c1650d7791d27811 | /CppJava/Project3/Project3/소멸자.cpp | 100c44f515d03ee6a7aca05dd45b4e97e8cd6313 | [] | no_license | KitchenGun/BitClass | 9191a7ffabe68fc8d3dc45d142b56970cf74445d | 63283f48214c5af0f252e24be64cb55660e3d7d1 | refs/heads/master | 2023-02-23T07:32:57.627968 | 2021-01-25T14:48:33 | 2021-01-25T14:48:33 | 249,423,206 | 0 | 0 | null | null | null | null | UHC | C++ | false | false | 615 | cpp | //소멸자
#include<iostream>
using namespace std;
struct Data
{
public:
Data()
{
cout << "Data()" << endl;
}
Data(int n)
{
cout << "Data(int)" << endl;
}
~Data()
{
cout << "~Data()" << endl;
}
};
int main()
{
Data d1;//1개 호출
//Data n3[5];//5개 호출
//Data n4('a', 10);//1개 호출
//Data n5[5] = { Data(10),Data('a',10) };//5개 호출
Data* n6;//0개 호출
//n6 = new Data;//1개 호출
//힙메모리에 생성
//delete n6;//해당주소에 생성된 객체 소멸
//n6 = new Data(10);//1개 호출
//delete n6;
n6 = new Data[5];//5개 호출
delete[] n6;
return 0;
} | [
"kitchengun124@gmail.com"
] | kitchengun124@gmail.com |
16417057e71065dca458cc9beae007cefcc4d697 | d4c74a8001451840f3efb87f15856cdb9d5e9eb6 | /gvsoc/gvsoc/models/pulp/udma/spim/udma_spim_v3.hpp | dfe65f45f89f44a2df3d3047ef4c2dbe93cb24bd | [
"Apache-2.0"
] | permissive | danieldennett/gap_sdk | 3e4b4d187f03a28a761b08aed36a5e6a06f48e8d | 5667c899025a3a152dbf91e5c18e5b3e422d4ea6 | refs/heads/master | 2020-12-19T19:17:40.083131 | 2020-02-27T14:51:48 | 2020-02-27T14:51:48 | 235,814,026 | 1 | 0 | Apache-2.0 | 2020-01-23T14:39:59 | 2020-01-23T14:39:58 | null | UTF-8 | C++ | false | false | 4,529 | hpp | /*
* Copyright (C) 2018 ETH Zurich and University of Bologna
*
* 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.
*/
/*
* Authors: Germain Haugou, ETH (germain.haugou@iis.ee.ethz.ch)
*/
#ifndef __PULP_UDMA_UDMA_SPIM_V3_IMPL_HPP__
#define __PULP_UDMA_UDMA_SPIM_V3_IMPL_HPP__
#include <vp/vp.hpp>
#include <vp/itf/io.hpp>
#include <vp/itf/qspim.hpp>
#include <vp/itf/uart.hpp>
#include <vp/itf/cpi.hpp>
#include <vp/itf/wire.hpp>
#include <vp/itf/hyper.hpp>
#include <stdio.h>
#include <string.h>
#include <vector>
#include "archi/udma/udma_v3.h"
/*
* SPIM
*/
class Spim_periph_v3;
class Spim_v3_rx_channel : public Udma_rx_channel
{
public:
Spim_v3_rx_channel(udma *top, Spim_periph_v3 *periph, int id, string name) : Udma_rx_channel(top, id, name), periph(periph) {}
void reset(bool active);
void handle_rx_bits(int data_0, int data_1, int data_2, int data_3, int mask);
private:
Spim_periph_v3 *periph;
int current_byte;
int current_bit;
};
class Spim_v3_tx_channel : public Udma_tx_channel
{
public:
Spim_v3_tx_channel(udma *top, Spim_periph_v3 *periph, int id, string name);
void handle_ready_reqs();
void check_state();
private:
void reset(bool active);
Spim_periph_v3 *periph;
static void handle_pending_word(void *__this, vp::clock_event *event);
void handle_data(uint32_t data);
vp::clock_event *pending_word_event;
uint32_t tx_pending_word; // Word received by last L2 req
bool has_tx_pending_word; // Tell if a TX pending word is present
vp::io_req *pending_req;
};
class Spim_v3_cmd_channel : public Udma_tx_channel
{
public:
Spim_v3_cmd_channel(udma *top, Spim_periph_v3 *periph, int id, string name);
void handle_ready_reqs();
void check_state();
private:
void reset(bool active);
static void handle_pending_word(void *__this, vp::clock_event *event);
void handle_eot(bool cs_keep);
void handle_data(uint32_t data);
bool push_tx_to_spi(uint32_t value, int nb_bits);
bool push_rx_to_spi(int nb_bits);
vp::clock_event *pending_word_event;
Spim_periph_v3 *periph;
bool has_tx_pending_word; // Tell if a TX pending word is present
uint32_t tx_pending_word; // Word received by last L2 req
vp::io_req *pending_req;
uint32_t command;
int cs;
bool gen_eot_with_evt;
int qpi;
int lsb_first;
int bitsword;
int wordtrans;
};
class Spim_periph_v3 : public Udma_periph
{
friend class Spim_v3_cmd_channel;
friend class Spim_v3_rx_channel;
friend class Spim_v3_tx_channel;
public:
Spim_periph_v3(udma *top, int id, int itf_id);
static void slave_sync(void *_this, int data_0, int data_1, int data_2, int data_3, int mask);
void reset(bool active);
vp::io_req_status_e custom_req(vp::io_req *req, uint64_t offset);
static void handle_spi_pending_word(void *__this, vp::clock_event *event);
void check_state();
bool push_tx_to_spi(uint32_t value, int nb_bits, int qpi, int lsb_first, int bitsword, int wordtrans);
bool push_rx_to_spi(int nb_bits, int qpi, int lsb_first, int bitsword, int wordtrans);
protected:
vp::clock_event *pending_spi_word_event;
vp::qspim_master qspim_itf;
int clkdiv;
bool waiting_rx;
bool waiting_tx;
bool waiting_tx_flush;
bool is_full_duplex;
int cmd_pending_bits;
int nb_received_bits;
uint32_t rx_pending_word;
uint32_t tx_pending_word;
int eot_event;
int qpi;
int lsb_first;
int bitsword;
int wordtrans;
int spi_qpi;
int spi_lsb_first;
int spi_bitsword;
int spi_wordtrans;
int tx_pending_bits;
uint32_t spi_tx_pending_word; // Word being flushed to spi pads
int spi_tx_pending_bits; // Tell how many bits are ready to be sent to SPI pads
int spi_rx_pending_bits; // Tell how many bits should be received from spi pads
int64_t next_bit_cycle;
uint32_t rx_received_bits;
int rx_bit_offset;
int rx_counter_bits;
int rx_counter_transf;
int tx_bit_offset;
int tx_counter_bits;
int tx_counter_transf;
};
#endif | [
"noreply@github.com"
] | noreply@github.com |
f5993a680ed28662b717f914a9ed3e1081fd6cab | e2f5f3d713e72595abc962b9383875ecb2bb09db | /src/CnvCallingReport.cc | 938a256a6c958e7dbfdaa646e8d80ddd725567c6 | [] | no_license | ginsbach/noise-free-cnv | d611dc7a6a1b53ed2117be8d04981c146b2fb41d | aa033c802e95380aa4a9fde4bd8edd0cd16dce25 | refs/heads/main | 2023-01-08T12:58:54.766809 | 2020-11-15T22:54:14 | 2020-11-15T22:54:14 | 312,846,481 | 0 | 2 | null | null | null | null | UTF-8 | C++ | false | false | 4,498 | cc | /*
* CnvCalling.hh - this File is part of noise-free-cnv.
*
* Copyright 2010-2013 Philip Ginsbach <philip.develop@gmail.com>
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program 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 this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include "CnvCallingReport.hh"
#include "CnvSequence.hh"
#include <iostream>
#include <cmath>
/* This file defines the ReportEntry class and the create_report_html_function.
- ReportEntry is a class used to represent CNVs. Objects of this class are
being generated by the calling functions defined in CnvCalling.hh.
- create_report_html generates a html file that displays all the CNVs that
the function receives as an array of ReportEntrys in a human-readable form.
The calling part of noise-free-cnv is largely experimental and not included
in the GUI program noise-free-cnv-gtk. */
namespace Cnv { namespace Call {
void create_report_html(const Sequence& seq,
std::vector<ReportEntry>& entr, std::ostream& os)
{
std::sort(entr.begin(), entr.end());
std::vector<ReportEntry>::const_iterator iter=entr.begin();
os<<"<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.0//EN\">\n"
"\n"
"<html lang=\"en-US\">\n"
"<head>\n"
" <meta http-equiv=\"content-type\" content=\"text/html;charset=UTF-8\">\n"
" <title>noise-free-cnv report file</title>\n"
" <meta name=\"description\" content=\"noise-free-cnv report file\">\n"
"</head>\n"
"\n"
"<body>\n"
" <h1>noise-free-cnv report</h1>\n\n"
" <table style=\"border-spacing:0;border-collapse:collapse\">\n\n";
for(unsigned chromo=0; chromo<=22; ++chromo)
{
if(iter!=entr.end()&&iter->chromosome==chromo)
{
os<<" <tr><td colspan=\"4\" style=\"text-align:center\"><h2>chromosome "<<chromo<<"</h2></td></tr>\n";
for(; iter!=entr.end()&&iter->chromosome==chromo; ++iter)
{
os<<" <tr>\n";
if(iter->type==0)
os<<" <td rowspan=\"2\"><strong>deletion, n=0</strong></td>\n";
else if(iter->type==1)
os<<" <td rowspan=\"2\"><strong>deletion</strong></td>\n";
else if(iter->type==3)
os<<" <td rowspan=\"2\"><strong>duplication</strong></td>\n";
else if(iter->type==4)
os<<" <td rowspan=\"2\"><strong>duplication, n=4</strong></td>\n";
else
os<<" <td rowspan=\"2\"><strong>other</strong></td>\n";
os.precision(2); os<<std::fixed;
os<<" <td style=\"text-align:center\">"<<iter->start_id<<" / <strong>"<<iter->start_pos<<"</strong></td>\n"
" <td style=\"text-align:center\"><strong>"<<iter->end_pos-iter->start_pos+1<<"</strong> ( "<<iter->end_number-iter->start_number+1<<" )</td>\n"
" <td style=\"text-align:center\"><strong>"<<iter->end_pos<<"</strong> / "<<iter->end_id<<"</td>\n"
" </tr><tr>\n"
" <td><table style=\"width:200px;background-color:#F6CECE;font-size:small;border-spacing:0\"><tr>\n"
" <td style=\"background-color:#CEF6CE\">"<<iter->score_enter*100.0<<"</td>\n"
" <td style=\"width:"<<::fmax(100.0-(iter->score_enter*100.0), 1.0)<<"%\"></td>\n"
" </tr></table></td>\n"
" <td><table style=\"width:200px;background-color:#F6CECE;font-size:small;border-spacing:0\"><tr>\n"
" <td style=\"background-color:#CEF6CE\">"<<iter->score_inner*100.0<<"</td>\n"
" <td style=\"width:"<<::fmax(100.0-(iter->score_inner*100.0), 1.0)<<"%\"></td>\n"
" </tr></table></td>\n"
" <td><table style=\"width:200px;background-color:#F6CECE;font-size:small;border-spacing:0\"><tr>\n"
" <td style=\"background-color:#CEF6CE\">"<<iter->score_leave*100.0<<"</td>\n"
" <td style=\"width:"<<::fmax(100.0-(iter->score_leave*100.0), 1.0)<<"%\"></td>\n"
" </tr></table></td>\n"
" </tr>\n";
os.unsetf(std::ios_base::floatfield);
}
os<<"\n";
}
}
os<<" </table>\n"
"</body>\n"
"</html>\n";
}
}}
| [
"philip.ginsbach@ed.ac.uk"
] | philip.ginsbach@ed.ac.uk |
e303a2d94dbaf683369895879808f3cf22ccf138 | 8d0e110a189566ef28186d50693a6318ba30c23d | /Chat.cpp | 5b336449a5dfde13e77aded163d7288ab695ae89 | [] | no_license | ViuTheLumberjack/chat | 65c9ae43dabefb0472688451ec5f4450650a9b5f | 1be89f1fa0f766b8cfc1dd212cb0bc59719eac13 | refs/heads/main | 2023-08-11T18:37:30.013835 | 2021-09-15T16:48:11 | 2021-09-15T16:48:11 | 404,110,647 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,075 | cpp | //
// Created by シルブー on 07/09/2021.
//
#include <algorithm>
#include <stdexcept>
#include "Chat.h"
#include "Register.h"
Chat::Chat(std::pair<User, User> users) : users(std::move(users)) {};
Chat::Chat(std::string first, std::string second) : users({first}, {second}) {};
bool Chat::operator==(const Chat &rhs) const {
return (users == rhs.users || (users.first == rhs.users.second && users.second == rhs.users.first));
}
bool Chat::operator!=(const Chat &rhs) const {
return !(rhs == *this);
}
// add Exception
void Chat::addMessage(const Message &message) {
auto u1 = users.first;
auto u2 = users.second;
if(u1 == message.getSender() || u2 == message.getSender()){
notifyObservers(message);
messages.emplace_back(message);
} else throw std::invalid_argument("Inserito Utente non appartenente alla chat");
}
void Chat::removeMessage(const Message &message) {
messages.remove_if([=](auto to_remove) { return message == to_remove; });
}
size_t Chat::size() const{
return messages.size();
}
void Chat::readMessage(Message &message) {
message.setRead(true);
}
void Chat::readAll(){
for (auto &item : messages){
if(!item.isRead())
item.setRead(true);
}
}
int Chat::countUnread() const {
int unreadMessages = static_cast<int>(std::count_if(messages.begin(), messages.end(), [](const Message &msg) { return !msg.isRead(); }));
return unreadMessages;
}
void Chat::notifyObservers(const Message &msg) {
testMock = !testMock;
for (auto &observer : obs) {
observer->update(msg);
}
}
void Chat::attachObserver(const std::shared_ptr<Observer> o) {
obs.emplace_back(o);
}
void Chat::detachObserver(const std::shared_ptr<Observer> o) {
obs.remove(o);
}
size_t Chat::getObserverNum() const{
return obs.size();
}
std::string Chat::toString(){
std::string dump;
dump += users.first.getUsername() + " -- " + users.second.getUsername() + "\n";
for (auto obj : messages) {
dump += obj.toString() + "\n";
}
return dump;
}
| [
"silviu48vatamanelu@gmail.com"
] | silviu48vatamanelu@gmail.com |
19d639ddc5cbb5c181f8312c94c65015c1d7c80e | f51e58a2207712bb786e814df3b990094f524277 | /fetch_common/src/my_utility.cpp | 0e454fb4b1c73b3c76e06084ba93cf76a3cdd92c | [] | no_license | hairizaman/momantu_fetch | 7f0fba35770f75a95ac9db736e251bcf03ec6096 | c6aabf6d8cec43820d8955825c6c1d43b542b698 | refs/heads/master | 2022-12-25T06:46:40.315186 | 2020-09-01T15:50:23 | 2020-10-07T15:03:46 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 4,216 | cpp | #include "my_utility.h"
MyUtility::MyUtility(ros::NodeHandle& nodehandle):nh_(nodehandle){
if (nh_.getParam("base_frame", base_frame_)) {ROS_INFO("Got param: %s", base_frame_.c_str());}
else {ROS_ERROR("Failed to get param 'base_frame'");}
if (nh_.getParam("eef_frame", eef_frame_)) {ROS_INFO("Got param: %s", eef_frame_.c_str());}
else {ROS_ERROR("Failed to get param 'eef_frame'");}
if (nh_.getParam("eef_parent_frame", eef_parent_frame_)) {ROS_INFO("Got param: %s", eef_parent_frame_.c_str());}
else {ROS_ERROR("Failed to get param 'eef_parent_frame'");}
std::string tf_error;
ros::Time last_error = ros::Time::now();
while (ros::ok() && !tf_.waitForTransform(base_frame_, eef_frame_, ros::Time(), ros::Duration(0.1), \
ros::Duration(0.01), &tf_error)) {
ros::spinOnce();
if (last_error + ros::Duration(5.0) < ros::Time::now()) {
last_error = ros::Time::now();
}
tf_error.clear();
}
}
bool MyUtility::GetGripperPose(tf::Transform& TS, std::string obj_frame_){
bool flag = true;
tf::StampedTransform transform_base_obj;
try {
tf_.lookupTransform( base_frame_, obj_frame_, //the transform from frame /object_predicted to frame /base_link.
ros::Time(0), transform_base_obj);
}
catch (tf::TransformException ex){
ROS_ERROR("%s",ex.what());
ros::Duration(1.0).sleep();
flag = false;
}
tf::StampedTransform transform_wrist_gri;
try{
tf_.lookupTransform(eef_parent_frame_, eef_frame_, //the transform from gripper frame to wrist frame (0.16645,0,0)
ros::Time(0), transform_wrist_gri);
}
catch (tf::TransformException ex){
ROS_ERROR("%s",ex.what());
ros::Duration(1.0).sleep();
flag = false;
}
if (flag == true){
TS = multi_transforms(transform_base_obj, transform_wrist_gri);
return true;
}
else{return false;}
}
bool MyUtility::GetPlacePosition(tf::Transform& TS, std::string obj_frame_){
bool flag = true;
tf::StampedTransform transform_base_obj;
try {
tf_.lookupTransform( base_frame_, obj_frame_, //the transform from frame /object_predicted to frame /base_link.
ros::Time(0), transform_base_obj);
}
catch (tf::TransformException ex){
ROS_ERROR("%s",ex.what());
ros::Duration(1.0).sleep();
flag = false;
}
tf::Transform coordinate = transform_base_obj;
tf::Quaternion q(0, 0, 0, 1);
tf::Vector3 v(0, 0, 0.2);
tf::Transform relative_pos(q, v);
TS = coordinate * relative_pos;
return true;
}
bool MyUtility::GetObjPose(tf::Transform& TS, std::string obj_frame_){
bool flag = true;
tf::StampedTransform transform_base_obj;
try {
tf_.lookupTransform( base_frame_, obj_frame_, //the transform from frame /object_predicted to frame /base_link.
ros::Time(0), transform_base_obj);
TS = transform_base_obj;
ros::Duration(3.0).sleep();
}
catch (tf::TransformException ex){
ROS_ERROR("%s",ex.what());
ros::Duration(1.0).sleep();
flag = false;
}
return flag;
}
tf::Transform MyUtility::multi_transforms(tf::StampedTransform T1, tf::StampedTransform T2)
{
tf::Transform T2i = (T2.inverse());
tf::Transform T_res;
T_res = T2i*T1;
tf::StampedTransform TS;
TS.setData(T_res);
tf::Quaternion q1= T_res.getRotation();
tf::Vector3 v1 = T1.getOrigin();
tf::Vector3 vr = T_res.getOrigin();
tf::Matrix3x3 M1;
M1.setRotation(q1);
tf::Vector3 v6,v7,v8;
v6=M1[0];
v7=M1[1];
v8=M1[2];
std::cout<<"translation1:"<<v1[0]<<","<<v1[1]<<","<<v1[2]<<std::endl;
std::cout<<"translationr:"<<vr[0]<<","<<vr[1]<<","<<vr[2]<<std::endl;
std::cout<<"rotation:"<<v6[0]<<","<<v6[1]<<","<<v6[2]<<std::endl;
std::cout<<" "<<v7[0]<<","<<v7[1]<<","<<v7[2]<<std::endl;
std::cout<<" "<<v8[0]<<","<<v8[1]<<","<<v8[2]<<std::endl;
std::cout<<std::endl;
ros::WallDuration(1.0).sleep();
return T_res;
}
MyUtility::~MyUtility(){};
| [
"zhangyizheng1996@gmail.com"
] | zhangyizheng1996@gmail.com |
46ada36cdff16a2594d7cf72782bbefc1e3fdbff | 25059d297eb2bb31cd09eeaad96148ed7790dda6 | /Node.cpp | 53a3b73d5b9c31320379688b51f6a4de2a46a498 | [] | no_license | shamonj03/SpaceGame | 90fe2f61f8f0b0f4f175830369b49c32ab104ba7 | 5d4f22b61091c3eab0003b546984434c6ad43d3d | refs/heads/master | 2020-03-10T10:14:01.533010 | 2018-05-09T02:41:54 | 2018-05-09T02:41:54 | 129,327,874 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 94 | cpp |
#include "Node.h"
Node::Node(glm::vec3 position_) : position(position_) {}
Node::~Node() {} | [
"shamonj03@users.noreply.github.com"
] | shamonj03@users.noreply.github.com |
f30d1e11722c765bab2674b04365938f311234db | f8566b29af572e5339f34ba27af5ddcda6121f1d | /GameplayRecipies/Intermediate/Build/Win64/UE4Editor/Inc/GameplayRecipies/ActionGameMode.generated.h | 22d7fd62587c91d9ace5f39a3f086784d7221863 | [] | no_license | gurshane/Unreal_Gameplay_Recipes | 9ecf7ff24965d27916c883dd1b93e998d4ab1462 | bbdb750713585a77f09545a1a667c6db155e76e8 | refs/heads/master | 2020-12-02T17:58:56.493054 | 2017-08-10T18:34:35 | 2017-08-10T18:34:35 | 96,455,728 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 4,442 | h | // Copyright 1998-2017 Epic Games, Inc. All Rights Reserved.
/*===========================================================================
Generated code exported from UnrealHeaderTool.
DO NOT modify this manually! Edit the corresponding .h files instead!
===========================================================================*/
#include "ObjectMacros.h"
#include "ScriptMacros.h"
PRAGMA_DISABLE_DEPRECATION_WARNINGS
#ifdef GAMEPLAYRECIPIES_ActionGameMode_generated_h
#error "ActionGameMode.generated.h already included, missing '#pragma once' in ActionGameMode.h"
#endif
#define GAMEPLAYRECIPIES_ActionGameMode_generated_h
#define GameplayRecipies_Source_GameplayRecipies_ActionGameMode_h_17_RPC_WRAPPERS
#define GameplayRecipies_Source_GameplayRecipies_ActionGameMode_h_17_RPC_WRAPPERS_NO_PURE_DECLS
#define GameplayRecipies_Source_GameplayRecipies_ActionGameMode_h_17_INCLASS_NO_PURE_DECLS \
private: \
static void StaticRegisterNativesAActionGameMode(); \
friend GAMEPLAYRECIPIES_API class UClass* Z_Construct_UClass_AActionGameMode(); \
public: \
DECLARE_CLASS(AActionGameMode, AGameModeBase, COMPILED_IN_FLAGS(0 | CLASS_Transient), 0, TEXT("/Script/GameplayRecipies"), NO_API) \
DECLARE_SERIALIZER(AActionGameMode) \
enum {IsIntrinsic=COMPILED_IN_INTRINSIC};
#define GameplayRecipies_Source_GameplayRecipies_ActionGameMode_h_17_INCLASS \
private: \
static void StaticRegisterNativesAActionGameMode(); \
friend GAMEPLAYRECIPIES_API class UClass* Z_Construct_UClass_AActionGameMode(); \
public: \
DECLARE_CLASS(AActionGameMode, AGameModeBase, COMPILED_IN_FLAGS(0 | CLASS_Transient), 0, TEXT("/Script/GameplayRecipies"), NO_API) \
DECLARE_SERIALIZER(AActionGameMode) \
enum {IsIntrinsic=COMPILED_IN_INTRINSIC};
#define GameplayRecipies_Source_GameplayRecipies_ActionGameMode_h_17_STANDARD_CONSTRUCTORS \
/** Standard constructor, called after all reflected properties have been initialized */ \
NO_API AActionGameMode(const FObjectInitializer& ObjectInitializer = FObjectInitializer::Get()); \
DEFINE_DEFAULT_OBJECT_INITIALIZER_CONSTRUCTOR_CALL(AActionGameMode) \
DECLARE_VTABLE_PTR_HELPER_CTOR(NO_API, AActionGameMode); \
DEFINE_VTABLE_PTR_HELPER_CTOR_CALLER(AActionGameMode); \
private: \
/** Private move- and copy-constructors, should never be used */ \
NO_API AActionGameMode(AActionGameMode&&); \
NO_API AActionGameMode(const AActionGameMode&); \
public:
#define GameplayRecipies_Source_GameplayRecipies_ActionGameMode_h_17_ENHANCED_CONSTRUCTORS \
/** Standard constructor, called after all reflected properties have been initialized */ \
NO_API AActionGameMode(const FObjectInitializer& ObjectInitializer = FObjectInitializer::Get()) : Super(ObjectInitializer) { }; \
private: \
/** Private move- and copy-constructors, should never be used */ \
NO_API AActionGameMode(AActionGameMode&&); \
NO_API AActionGameMode(const AActionGameMode&); \
public: \
DECLARE_VTABLE_PTR_HELPER_CTOR(NO_API, AActionGameMode); \
DEFINE_VTABLE_PTR_HELPER_CTOR_CALLER(AActionGameMode); \
DEFINE_DEFAULT_OBJECT_INITIALIZER_CONSTRUCTOR_CALL(AActionGameMode)
#define GameplayRecipies_Source_GameplayRecipies_ActionGameMode_h_17_PRIVATE_PROPERTY_OFFSET
#define GameplayRecipies_Source_GameplayRecipies_ActionGameMode_h_14_PROLOG
#define GameplayRecipies_Source_GameplayRecipies_ActionGameMode_h_17_GENERATED_BODY_LEGACY \
PRAGMA_DISABLE_DEPRECATION_WARNINGS \
public: \
GameplayRecipies_Source_GameplayRecipies_ActionGameMode_h_17_PRIVATE_PROPERTY_OFFSET \
GameplayRecipies_Source_GameplayRecipies_ActionGameMode_h_17_RPC_WRAPPERS \
GameplayRecipies_Source_GameplayRecipies_ActionGameMode_h_17_INCLASS \
GameplayRecipies_Source_GameplayRecipies_ActionGameMode_h_17_STANDARD_CONSTRUCTORS \
public: \
PRAGMA_ENABLE_DEPRECATION_WARNINGS
#define GameplayRecipies_Source_GameplayRecipies_ActionGameMode_h_17_GENERATED_BODY \
PRAGMA_DISABLE_DEPRECATION_WARNINGS \
public: \
GameplayRecipies_Source_GameplayRecipies_ActionGameMode_h_17_PRIVATE_PROPERTY_OFFSET \
GameplayRecipies_Source_GameplayRecipies_ActionGameMode_h_17_RPC_WRAPPERS_NO_PURE_DECLS \
GameplayRecipies_Source_GameplayRecipies_ActionGameMode_h_17_INCLASS_NO_PURE_DECLS \
GameplayRecipies_Source_GameplayRecipies_ActionGameMode_h_17_ENHANCED_CONSTRUCTORS \
private: \
PRAGMA_ENABLE_DEPRECATION_WARNINGS
#undef CURRENT_FILE_ID
#define CURRENT_FILE_ID GameplayRecipies_Source_GameplayRecipies_ActionGameMode_h
PRAGMA_ENABLE_DEPRECATION_WARNINGS
| [
"gurshane.sidhu@mail.mcgill.ca"
] | gurshane.sidhu@mail.mcgill.ca |
00a89ff0816e26663d57555a2c19e895f770f04b | ca5bb1a7244d4dbbda74c1110409f02cfbe22a92 | /src/os/Time.cpp | cec5b015a5447fe4ff46a05d3a952fe27c30da20 | [
"BSD-2-Clause"
] | permissive | jrahm/Ulfberht | feb39af1725ff6ee67cc23006e7bd3b2a431ae0c | 159a4424dead614d4e331851af8ecea4c4daacfe | refs/heads/master | 2021-01-10T09:22:49.187248 | 2015-07-19T08:11:22 | 2015-07-19T08:11:22 | 36,199,424 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,958 | cpp | #include <ulfberht/os/Time.hpp>
#include <cstdlib>
#ifdef __MACH__
#include <mach/mach.h>
#include <mach/clock.h>
#include <mach/mach_error.h>
#endif
namespace os {
void Time::microsInFuture( struct timespec* ts, timeout_t micros ) {
#ifdef __MACH__
clock_serv_t cclock;
mach_timespec_t mts;
host_get_clock_service(mach_host_self(), CALENDAR_CLOCK, &cclock);
clock_get_time(cclock, &mts);
mach_port_deallocate(mach_task_self(), cclock);
ts->tv_sec = mts.tv_sec;
ts->tv_nsec = mts.tv_nsec;
#else
clock_gettime(CLOCK_REALTIME, ts);
#endif
timeout_t nsec = ts->tv_nsec + micros * 1000;
timeout_t nsec_mod = nsec % 1000000000;
ts->tv_nsec = nsec;
ts->tv_sec += nsec / 1000000000;
ts->tv_nsec = nsec_mod;
}
void Time::fromMicros( struct timespec& ts, timeout_t timeout ) {
lldiv_t ret = lldiv( timeout * 1000, 1000000000) ;
ts.tv_sec = ret.quot ;
ts.tv_nsec = ret.rem ;
}
timeout_t Time::toMicros( struct timespec& ts ) {
return (ts.tv_sec * 1000000000 + ts.tv_nsec) / 1000 ;
}
timeout_t Time::sleep( timeout_t timeout ) {
struct timespec ts ;
struct timespec ts_out ;
Time::fromMicros( ts, timeout ) ;
nanosleep( &ts, &ts_out ) ;
return toMicros( ts_out ) ;
}
timeout_t Time::relativeToAbsoluteTime( timeout_t relative ) {
return relative + currentTimeMicros();
}
timeout_t Time::absoluteTimeToRelativeTime( timeout_t absolute ) {
return absolute - currentTimeMicros();
}
timeout_t Time::currentTimeMicros() {
#ifdef __MACH__
clock_serv_t cclock;
mach_timespec_t mts;
host_get_clock_service(mach_host_self(), CALENDAR_CLOCK, &cclock);
clock_get_time(cclock, &mts);
mach_port_deallocate(mach_task_self(), cclock);
#else
struct timespec mts;
clock_gettime(CLOCK_REALTIME, &mts);
#endif
return (u64_t)mts.tv_nsec / 1000ll + (u64_t)mts.tv_sec * 1000000ll;
}
timeout_t Time::uptime() {
static timeout_t start = currentTimeMicros();
return currentTimeMicros() - start ;
}
}
| [
"joshuarahm@gmail.com"
] | joshuarahm@gmail.com |
8518976cd021716ecb94f8d512fbbbe1f3fa3b94 | fe11f21bd261126e9b24892a17009464f6664d8a | /A2OJ1900/60-453B.cpp | 3e1b28f9d149291e1b233212337f849ef364d2ec | [] | no_license | AnimeshSinha1309/coding-contests | 1139c6f1aa8713135e1da7988db6295839f59841 | 471d5d05cbddcbad5e440130fc155489192a4ea7 | refs/heads/master | 2022-12-14T16:38:14.482806 | 2020-09-14T14:24:44 | 2020-09-14T14:24:44 | 243,180,848 | 0 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 1,311 | cpp | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef vector<long long> vll;
typedef pair<long long, long long> pll;
typedef vector<vector<long long>> mll;
typedef vector<pair<long long, long long>> vpl;
typedef long double ld;
typedef vector<long double> vld;
typedef vector<vector<long double>> mld;
typedef vector<bool> vbl;
typedef vector<vector<bool>> mbl;
#define minimize(a, b) (a = min(a, b))
#define maximize(a, b) (a = max(a, b))
const long long MOD = 1e9 + 7;
template <typename Type>
istream &operator>>(istream &in, vector<Type> &vec) {
ll n = vec.size();
for (int i = 0; i < n; i++)
in >> vec[i];
return in;
}
template <typename Type>
ostream &operator<<(ostream &out, vector<Type> &vec) {
for (auto val : vec)
out << val << " ";
out << endl;
return out;
}
int main() {
ll n;
cin >> n;
vll a(n);
cin >> a;
vll primes = {2, 3, 5, 7, 11, 13, 17, 19, 23,
29, 31, 37, 41, 43, 47, 53, 59};
ll pn = primes.size();
// DP with Bitmask
vll dp(1 << n, 0);
dp[0] = 1;
for (int available = 0; available < (1 << pn); available++) {
bitset<17> available_set(available);
for (ll use = 0; use < n; use++) {
}
}
cout << dp[(1 << n) - 1] << endl;
} | [
"animeshsinha1309@gmail.com"
] | animeshsinha1309@gmail.com |
9b1fda21ae9353d01ad2ddf2e59a927fd14f309f | 515e8fa18f0b98f6eb5a4a8a0c8143ffc860e987 | /src/Omega_h_int_iterator.hpp | 15700498c5027ba17cf9ad347c88f94a6fbef99f | [
"BSD-2-Clause",
"BSD-2-Clause-Views"
] | permissive | tamaradanceva/omega_h | 6b7a6b1720fd42bd63713ad87f835b8e4648d65b | a94d8910d02a4a3152908fa2beb44f408c60d3e8 | refs/heads/master | 2021-06-22T22:11:52.302820 | 2019-09-03T20:24:16 | 2019-09-03T20:24:16 | 158,231,540 | 0 | 0 | NOASSERTION | 2018-11-19T13:53:01 | 2018-11-19T13:53:01 | null | UTF-8 | C++ | false | false | 2,415 | hpp | #ifndef OMEGA_H_INT_ITERATOR_HPP
#define OMEGA_H_INT_ITERATOR_HPP
#include <Omega_h_defines.hpp>
#include <iterator>
namespace Omega_h {
class IntIterator {
LO i;
public:
using value_type = LO;
using difference_type = LO;
using reference = LO const&;
using pointer = LO const*;
using iterator_category = std::random_access_iterator_tag;
OMEGA_H_INLINE IntIterator() noexcept = default;
OMEGA_H_INLINE IntIterator(LO i_in) noexcept : i(i_in) {}
OMEGA_H_INLINE bool operator==(IntIterator const& other) const noexcept {
return i == other.i;
}
OMEGA_H_INLINE bool operator!=(IntIterator const& other) const noexcept {
return i != other.i;
}
OMEGA_H_INLINE reference operator*() const noexcept { return i; }
OMEGA_H_INLINE pointer operator->() const noexcept { return &i; }
OMEGA_H_INLINE IntIterator& operator++() noexcept {
++i;
return *this;
}
OMEGA_H_INLINE IntIterator operator++(int) noexcept {
auto ret = *this;
++i;
return ret;
}
OMEGA_H_INLINE IntIterator& operator--() noexcept {
--i;
return *this;
}
OMEGA_H_INLINE IntIterator operator--(int) noexcept {
auto ret = *this;
--i;
return ret;
}
OMEGA_H_INLINE IntIterator& operator+=(difference_type n) noexcept {
i += n;
return *this;
}
OMEGA_H_INLINE IntIterator& operator-=(difference_type n) noexcept {
i -= n;
return *this;
}
OMEGA_H_INLINE IntIterator operator+(difference_type n) const noexcept {
return IntIterator(i + n);
}
OMEGA_H_INLINE IntIterator operator-(difference_type n) const noexcept {
return IntIterator(i - n);
}
OMEGA_H_INLINE difference_type operator-(IntIterator const& other) const
noexcept {
return i - other.i;
}
OMEGA_H_INLINE value_type operator[](difference_type n) const noexcept {
return i + n;
}
OMEGA_H_INLINE bool operator<(IntIterator const& other) const noexcept {
return i < other.i;
}
OMEGA_H_INLINE bool operator>(IntIterator const& other) const noexcept {
return i > other.i;
}
OMEGA_H_INLINE bool operator<=(IntIterator const& other) const noexcept {
return i <= other.i;
}
OMEGA_H_INLINE bool operator>=(IntIterator const& other) const noexcept {
return i >= other.i;
}
};
OMEGA_H_INLINE IntIterator operator+(
IntIterator::difference_type n, IntIterator it) noexcept {
return it + n;
}
} // namespace Omega_h
#endif
| [
"daibane@sandia.gov"
] | daibane@sandia.gov |
9bd6eb0da83714fb71a93ea53dbf8d07b54db2b7 | f9be1d8e2abaff6f0febf2ad6b76ac57b329a785 | /src/qt/rpcconsole.h | 6d94ee4a3305937049e30e7e6e8a04276ca50de0 | [
"MIT",
"Apache-2.0"
] | permissive | jonspock/tessa | 47e1f6444d4e04322c703df570c4e02ef0616de6 | 1a1b64b05510dffa8221b193b014dc7ccb9fbe4a | refs/heads/master | 2020-05-14T21:53:33.144627 | 2018-10-04T04:26:31 | 2018-10-04T04:26:31 | 181,966,556 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 4,375 | h | // Copyright (c) 2011-2014 The Bitcoin developers
// Copyright (c) 2017-2018 The PIVX developers
// Copyright (c) 2018 The TessaChain developers
// Distributed under the MIT/X11 software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
#ifndef BITCOIN_QT_RPCCONSOLE_H
#define BITCOIN_QT_RPCCONSOLE_H
#include "guiutil.h"
#include "peertablemodel.h"
#include "net.h"
#include <QCompleter>
#include <QDialog>
class ClientModel;
class RPCTimerInterface;
namespace Ui {
class RPCConsole;
}
QT_BEGIN_NAMESPACE
class QMenu;
class QItemSelection;
QT_END_NAMESPACE
/** Local Bitcoin RPC console. */
class RPCConsole : public QDialog {
Q_OBJECT
public:
explicit RPCConsole(QWidget* parent);
~RPCConsole();
void setClientModel(ClientModel* model);
enum MessageClass { MC_ERROR, MC_DEBUG, CMD_REQUEST, CMD_REPLY, CMD_ERROR };
protected:
virtual bool eventFilter(QObject* obj, QEvent* event);
private slots:
void on_lineEdit_returnPressed();
void on_tabWidget_currentChanged(int index);
/** open the debug.log from the current datadir */
void on_openDebugLogfileButton_clicked();
/** change the time range of the network traffic graph */
void on_sldGraphRange_valueChanged(int value);
/** update traffic statistics */
void updateTrafficStats(quint64 totalBytesIn, quint64 totalBytesOut);
void resizeEvent(QResizeEvent* event);
void showEvent(QShowEvent* event);
void hideEvent(QHideEvent* event);
/** Show custom context menu on Peers tab */
void showPeersTableContextMenu(const QPoint& point);
/** Show custom context menu on Bans tab */
void showBanTableContextMenu(const QPoint& point);
/** Hides ban table if no bans are present */
void showOrHideBanTableIfRequired();
/** clear the selected node */
void clearSelectedNode();
public slots:
void clear();
/** Wallet repair options */
void walletSalvage();
void walletRescan();
void walletZaptxes1();
void walletZaptxes2();
void walletUpgrade();
void walletReindex();
void walletResync();
void reject();
void message(int category, const QString& message, bool html = false);
/** Set number of connections shown in the UI */
void setNumConnections(int count);
/** Set number of blocks shown in the UI */
void setNumBlocks(int count);
/** Go forward or back in history */
void browseHistory(int offset);
/** Scroll console view to end */
void scrollToEnd();
/** Switch to info tab and show */
void showInfo();
/** Switch to console tab and show */
void showConsole();
/** Switch to network tab and show */
void showNetwork();
/** Switch to peers tab and show */
void showPeers();
/** Switch to wallet-repair tab and show */
void showRepair();
/** Open external (default) editor with club.conf */
void showConfEditor();
/** Handle selection of peer in peers list */
void peerSelected(const QItemSelection& selected, const QItemSelection& deselected);
/** Handle updated peer information */
void peerLayoutChanged();
/** Disconnect a selected node on the Peers tab */
void disconnectSelectedNode();
/** Ban a selected node on the Peers tab */
void banSelectedNode(int bantime);
/** Unban a selected node on the Bans tab */
void unbanSelectedNode();
/** Show folder with wallet backups in default browser */
void showBackups();
signals:
// For RPC command executor
void stopExecutor();
void cmdRequest(const QString& command);
/** Get restart command-line parameters and handle restart */
void handleRestart(QStringList args);
private:
static QString FormatBytes(quint64 bytes);
void startExecutor();
void setTrafficGraphRange(int mins);
/** Build parameter list for restart */
void buildParameterlist(QString arg);
/** show detailed information on ui about selected node */
void updateNodeDetail(const CNodeCombinedStats* stats);
enum ColumnWidths {
ADDRESS_COLUMN_WIDTH = 170,
SUBVERSION_COLUMN_WIDTH = 140,
PING_COLUMN_WIDTH = 80,
BANSUBNET_COLUMN_WIDTH = 200,
BANTIME_COLUMN_WIDTH = 250
};
Ui::RPCConsole* ui;
ClientModel* clientModel;
QStringList history;
int historyPtr;
NodeId cachedNodeid;
QCompleter* autoCompleter;
QMenu* peersTableContextMenu;
QMenu* banTableContextMenu;
RPCTimerInterface* rpcTimerInterface;
};
#endif // BITCOIN_QT_RPCCONSOLE_H
| [
"jonspock@gmail.com"
] | jonspock@gmail.com |
b133696d564816b20ca61fc94911b379afa9df30 | ffa66ab4b13172986b56fe8f5a4814f676a89901 | /sprint06/t00/app/main.cpp | 752c30421b3062b3108163e29bd7e5a8607d3f59 | [] | no_license | zhukovskyV/cpp_marathon | c1359228835a0fd35e949dc9b231dd33b0c59b3f | 9d7727fcdca1329408e28e19eaf2ca9d682118f8 | refs/heads/master | 2022-12-26T21:04:28.114484 | 2020-10-11T15:01:27 | 2020-10-11T15:01:27 | 303,145,483 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 880 | cpp | #include "Food/ApplePie.h"
#include "Food/HoneyNut.h"
#include "Food/PoisonedFood.h"
#include "Food/SweetRoll.h"
#include "Wizard/MightyWizard.h"
int main() {
std::string name = "Elderic";
MightyWizard wizard(name);
FoodItem* piePtr = new ApplePie;
FoodItem* rollPtr = new SweetRoll;
FoodItem* nutPtr = new HoneyNut;
FoodItem* poisonPtr = new PoisonedFood;
auto& pieRef = *piePtr;
auto& rollRef = *rollPtr;
auto& nutRef = *nutPtr;
auto& poisonRef = *poisonPtr;
wizard.checkFood(piePtr);
wizard.checkFood(rollPtr);
wizard.checkFood(nutPtr);
wizard.checkFood(poisonPtr);
wizard.checkFood(nullptr);
wizard.checkFood(pieRef);
wizard.checkFood(rollRef);
wizard.checkFood(nutRef);
wizard.checkFood(poisonRef);
delete piePtr;
delete rollPtr;
delete nutPtr;
delete poisonPtr;
return 0;
}
| [
"jukovskiyv96@gmail.com"
] | jukovskiyv96@gmail.com |
eba8980dc0d8efe172714c98f37bb9fd50849aec | 23a9831194ba4564b52b2d7b2ccd9c9af72e2d63 | /extractor/include/opt-pass.hpp | 222ec1925cec30871e70c660ac351e872d9b702c | [] | no_license | Kaiyuan-Zhang/Gallium-public | 167447c327c0b79df5874e40acd5a2b42f558f80 | 9b49c8c5b8e421883f783814329e43c0a09087e5 | refs/heads/master | 2023-03-15T02:13:38.572553 | 2021-03-11T05:43:26 | 2021-03-11T05:43:26 | 275,299,704 | 24 | 6 | null | null | null | null | UTF-8 | C++ | false | false | 908 | hpp | #ifndef _OPT_PASS_HPP_
#define _OPT_PASS_HPP_
#include "llvm-incl.hpp"
#include "target-lang.hpp"
#include <memory>
#include <vector>
#include <unordered_map>
struct CompileCtx {
llvm::LLVMContext llvm_ctx;
llvm::SMDiagnostic err;
std::unique_ptr<llvm::Module> module;
std::unordered_map<std::string,
std::shared_ptr<Target::BasicBlock>> blocks;
std::vector<std::string> entry_blocks;
CompileCtx(const std::string &fn);
void load_blocks(const std::string &func_name);
};
using PartitionT = std::set<InstID, InstIDCmp>;
struct PartitionTHasher : std::unary_function<PartitionT, std::size_t> {
std::size_t operator()(const PartitionT &part) const;
};
std::vector<PartitionT>
find_partitions(const std::unordered_map<std::string, Target::BasicBlock *> &blocks,
const std::vector<std::string> &entries);
#endif /* _OPT_PASS_HPP_ */
| [
"kaiyuanz@cs.washington.edu"
] | kaiyuanz@cs.washington.edu |
e3453b6e5095368ce8124956b4a9b0110e4311cb | a27f23500c50d14da7665b7d012beee2eafe2e1a | /Card.cpp | bcf66d84a77d1fd80162b1c0987eb5ab360a7fa8 | [] | no_license | Jenishhd/SolitairePrime | 2db4ef68d2d2b6ee4e9aea83a11cf11dd089e283 | 6d8afc075bdcf109d847ffb12fb7cca294eaa746 | refs/heads/master | 2021-01-03T00:47:45.320395 | 2020-02-11T19:06:40 | 2020-02-11T19:06:40 | 239,843,491 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 626 | cpp | /* Jenish Thanki 018089303
* CECS 282-05
* Project 1 Solitaire Prime
* Due Feb 11,2020 */
#include <iostream>
#include "Card.h"
Card:: Card(){}
Card:: Card(char r, char s){
rank = r;
suit = s;
}
int Card::getValue(){
if(rank == 'K' || rank == 'Q' || rank == 'J' || rank == 'T' ){
return 10;
}
else if(rank == 'A'){
return 1;
}
else
return (rank - '0');
}
void Card::setCard(char r, char s) {
rank = r;
suit = s;
}
void Card:: showCard() {
if(rank == 'T')
std:: cout << 10 << suit<< ", ";
else
std:: cout << rank << suit<< ", ";
}
| [
"jenishhd@gmail.com"
] | jenishhd@gmail.com |
8d7f24a535fbd9be71aa8ed7a1aac037615e2043 | 5c30eb987fd4f7d2bbcee01ff67c1457b2cf24af | /dpct-experiment/mcubes/vegasT.dp.hpp | 16596ac0f8d40476cac6fe992657e0c74ca13692 | [
"BSD-3-Clause"
] | permissive | marcpaterno/gpuintegration | 51d04ea3d70c3e9b12467db172b4c8c7ff3e3d6f | 42b558a5504609f21a2e0121d41daf24498d7f28 | refs/heads/master | 2023-08-09T20:26:51.369094 | 2023-07-25T15:25:08 | 2023-07-25T15:25:08 | 253,514,762 | 7 | 1 | NOASSERTION | 2023-03-13T20:27:36 | 2020-04-06T14:01:59 | C++ | UTF-8 | C++ | false | false | 32,116 | hpp | #ifndef VEGAS_VEGAS_T_CUH
#define VEGAS_VEGAS_T_CUH
//__device__ long idum = -1;
#define OUTFILEVAR 0
#include <CL/sycl.hpp>
#include <dpct/dpct.hpp>
#include "pagani/quad/quad.h"
#include "pagani/quad/util/Volume.dp.hpp"
#include "pagani/quad/util/cudaApply.dp.hpp"
#include "pagani/quad/util/cudaArray.dp.hpp"
#include "mcubes/seqCodesDefs.hh"
#include "pagani/quad/util/cudaMemoryUtil.h"
#include "mcubes/vegas_utils.dp.hpp"
#include "mcubes/verbose_utils.dp.hpp"
#include <assert.h>
#include <chrono>
#include <ctime>
//#include <oneapi/mkl.hpp>
//#include <oneapi/mkl/rng/device.hpp>
#include <fstream>
#include <inttypes.h>
#include <iostream>
#include <math.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string>
//#define TINY 1.0e-200
#define WARP_SIZE 32
#define BLOCK_DIM_X 128
#define cudaCheckError() \
{ int e = 0; }
namespace cuda_mcubes {
#define NR_END 1
#define IM1 2147483563
#define IM2 2147483399
#define AM (1.0 / IM1)
#define IMM1 (IM1 - 1)
#define IA1 40014
#define IA2 40692
#define IQ1 53668
#define IQ2 52774
#define IR1 12211
#define IR2 3791
#define NTAB 32
#define NDIV (1 + IMM1 / NTAB)
#define EPS 1.2e-7
#define RNMX (1.0 - EPS)
double
ran2(long* idum)
{
int j;
long k;
static long idum2 = 123456789;
static long iy = 0;
static long iv[NTAB];
double temp;
if (*idum <= 0) {
if (-(*idum) < 1)
*idum = 1;
else
*idum = -(*idum);
idum2 = (*idum);
for (j = NTAB + 7; j >= 0; j--) {
k = (*idum) / IQ1;
*idum = IA1 * (*idum - k * IQ1) - k * IR1;
if (*idum < 0)
*idum += IM1;
if (j < NTAB)
iv[j] = *idum;
}
iy = iv[0];
}
k = (*idum) / IQ1;
*idum = IA1 * (*idum - k * IQ1) - k * IR1;
if (*idum < 0)
*idum += IM1;
k = idum2 / IQ2;
idum2 = IA2 * (idum2 - k * IQ2) - k * IR2;
if (idum2 < 0)
idum2 += IM2;
j = iy / NDIV;
iy = iv[j] - idum2;
iv[j] = *idum;
if (iy < 1)
iy += IMM1;
if ((temp = AM * iy) > RNMX)
return RNMX;
else
return temp;
}
__inline__ double
warpReduceSum(double val, sycl::nd_item<3> item_ct1)
{
// could there be an issue if block has fewer than 32 threads running?
// at least with 1 thread and warpReduceSm commneted out, we still ahve
// chi-sq issues and worse absolute error
val += sycl::shift_group_left(item_ct1.get_sub_group(), val, 16);
val += sycl::shift_group_left(item_ct1.get_sub_group(), val, 8);
val += sycl::shift_group_left(item_ct1.get_sub_group(), val, 4);
val += sycl::shift_group_left(item_ct1.get_sub_group(), val, 2);
val += sycl::shift_group_left(item_ct1.get_sub_group(), val, 1);
return val;
}
__inline__ double
blockReduceSum(double val, sycl::nd_item<3> item_ct1, double *shared)
{
// Shared mem for 32 partial sums
int lane = item_ct1.get_local_id(2) %
item_ct1.get_sub_group().get_local_range().get(0);
int wid = item_ct1.get_local_id(2) /
item_ct1.get_sub_group().get_local_range().get(0);
val = warpReduceSum(val, item_ct1); // Each warp performs partial reduction
if (lane == 0)
shared[wid] = val; // Write reduced value to shared memory
item_ct1.barrier(); // Wait for all partial reductions
// read from shared memory only if that warp existed
val = (item_ct1.get_local_id(2) <
item_ct1.get_local_range().get(2) /
item_ct1.get_sub_group().get_local_range().get(0))
? shared[lane]
: 0;
if (wid == 0) {
val = warpReduceSum(val, item_ct1); // Final reduce within first warp
// printf("[%i] final reduction for block warp %i reduction:%.15e\n",
// blockIdx.x, threadIdx.x, val);
}
item_ct1.barrier(); // added by Ioannis due to cuda-memcheck racecheck
// reporting race between read/write
return val;
}
__inline__ void
get_indx(uint32_t ms, uint32_t* da, int ND, int NINTV)
{
// called like : get_indx(m * chunkSize, &kg[1], ndim, ng);
uint32_t dp[Internal_Vegas_Params::get_MXDIM()];
uint32_t j, t0, t1;
uint32_t m = ms;
dp[0] = 1;
dp[1] = NINTV;
for (j = 0; j < ND - 2; j++) {
dp[j + 2] = dp[j + 1] * NINTV;
}
for (j = 0; j < ND; j++) {
t0 = dp[ND - j - 1];
t1 = m / t0;
da[j] = 1 + t1;
m = m - t1 * t0;
}
}
void
Test_get_indx(int ndim,
int ng,
uint32_t totalNumThreads,
int chunkSize,
int it,
std::ofstream& interval_myfile)
{
constexpr int mxdim_p1 = Internal_Vegas_Params::get_MXDIM_p1();
if (it == 1)
interval_myfile << "m, kg[1], kg[2], kg[3], it\n";
for (uint32_t m = 0; m < totalNumThreads; m++) {
uint32_t kg[mxdim_p1];
get_indx(m, &kg[1], ndim, ng);
interval_myfile << m << ",";
for (int ii = 1; ii <= ndim; ii++)
interval_myfile << kg[ii] << ",";
interval_myfile << it << "\n";
}
}
template <int ndim>
__inline__ void
Setup_Integrand_Eval(Custom_generator* rand_num_generator,
double xnd,
double dxg,
const double* const xi,
const double* const regn,
const double* const dx,
const uint32_t* const kg,
int* const ia,
double* const x,
double& wgt,
int npg,
int sampleID,
uint32_t cube_id,
double* randoms = nullptr)
{
constexpr int ndmx = Internal_Vegas_Params::get_NDMX();
constexpr int ndmx1 = Internal_Vegas_Params::get_NDMX_p1();
for (int j = 1; j <= ndim; j++) {
const double ran00 = (*rand_num_generator)();
// if constexpr(DEBUG_MCUBES) {
// if(randoms != nullptr){
// size_t nums_per_cube = npg*ndim;
// size_t nums_per_sample = ndim;
// size_t index = cube_id*nums_per_cube +
// nums_per_sample*(sampleID-1) + j-1;
// //randoms[index] = ran00;
// }
// }
// kg[j]-ran00 this essentially determines how far left or how far right
// in the interval is the bin we are drawing randomly, but it's expressed
// as a percentage. random numbers close to zero mean to the right of the
// interval random numbers close to one mean to the left of the interval we
// multiply by dxg, which represents how many bins per interval there are
// this multiplication scales to which of the 500 bins this lands on.
// thus, we are essentially choosing randomly and with equal probability
// which of the bins that correspond to the interval, will we choose for
// the sample point we are trying to generate this means that when we are
// processing a sub-cube, we are choosing randomly selecting one of the
// available bins that overlap with the interval
const double xn = (kg[j] - ran00) * dxg + 1.0;
double rc = 0., xo = 0.;
ia[j] = IMAX(IMIN((int)(xn), ndmx), 1);
if (ia[j] > 1) {
xo = (xi[j * ndmx1 + ia[j]]) - (xi[j * ndmx1 + ia[j] - 1]); // bin
// length
rc = (xi[j * ndmx1 + ia[j] - 1]) +
(xn - ia[j]) * xo; // scaling ran00 to bin bounds
} else {
xo = (xi[j * ndmx1 + ia[j]]);
rc = (xn - ia[j]) * xo;
}
x[j] = regn[j] + rc * (dx[j]);
wgt *= xo * xnd; // xnd is number of bins, xo is the length of the bin,
// xjac is 1/num_calls
}
}
template <typename IntegT,
int ndim>
void
Process_npg_samples(IntegT* d_integrand,
int npg,
double xnd,
double xjac,
Custom_generator* rand_num_generator, //replace type here
double dxg,
const double* const regn,
const double* const dx,
const double* const xi,
const uint32_t* const kg,
int* const ia,
double* const x,
double& wgt,
double* d,
double& fb,
double& f2b,
uint32_t cube_id)
{
constexpr int mxdim_p1 = Internal_Vegas_Params::get_MXDIM_p1();
for (int k = 1; k <= npg; k++) {
double wgt = xjac;
Setup_Integrand_Eval<ndim>(
rand_num_generator,
xnd,
dxg,
xi,
regn,
dx,
kg,
ia,
x,
wgt,
npg,
k,
cube_id);
gpu::cudaArray<double, ndim> xx;
for (int i = 0; i < ndim; i++) {
xx[i] = x[i + 1];
}
const double tmp = gpu::apply(*d_integrand, xx);
const double f = wgt * tmp;
// if constexpr(DEBUG_MCUBES){
// if(funcevals != nullptr){
// size_t nums_evals_per_cube = npg;
// size_t index = cube_id*nums_evals_per_cube + (k-1);
// //funcevals[index] = f;
// }
// }
double f2 = f * f;
fb += f;
f2b += f2;
#pragma unroll 2
for (int j = 1; j <= ndim; j++) {
dpct::atomic_fetch_add(&d[ia[j] * mxdim_p1 + j], f2);
}
}
}
template <typename IntegT,
int ndim>
__inline__ void
Process_chunks(IntegT* d_integrand,
int chunkSize,
int lastChunk,
int ng,
int npg,
Custom_generator* rand_num_generator,
double dxg,
double xnd,
double xjac,
const double* const regn,
const double* const dx,
const double* const xi,
uint32_t* const kg,
int* const ia,
double* const x,
double& wgt,
double* d,
double& fbg,
double& f2bg,
size_t cube_id_offset)
{
for (int t = 0; t < chunkSize; t++) {
double fb = 0.,
f2b = 0.0; // init to zero for each interval processed by thread
uint32_t cube_id = cube_id_offset + t;
// can't use if(is_same<GeneratorType, Custom_generator>) in device code
// can't do if statement checking whether typename GeneratorType ==
// Curand_generator if constexpr (mcubes::is_same<GeneratorType,
// Custom_generator>())
rand_num_generator->SetSeed(cube_id);
Process_npg_samples<IntegT, ndim>(
d_integrand,
npg,
xnd,
xjac,
rand_num_generator,
dxg,
regn,
dx,
xi,
kg,
ia,
x,
wgt,
d,
fb,
f2b,
cube_id);
f2b = sycl::sqrt(f2b * npg);
f2b = (f2b - fb) * (f2b + fb);
if (f2b <= 0.0) {
f2b = TINY;
}
fbg += fb;
f2bg += f2b;
for (int k = ndim; k >= 1; k--) {
kg[k] %= ng;
if (++kg[k] != 1)
break;
}
}
}
template <typename IntegT,
int ndim>
void
vegas_kernel(IntegT* d_integrand,
int ng,
int npg,
double xjac,
double dxg,
double* result_dev,
double xnd,
double* xi,
double* d,
double* dx,
double* regn,
int ncubes,
int iter,
double sc,
double sci,
double ing,
int chunkSize,
uint32_t totalNumThreads,
int LastChunk,
unsigned int seed_init,
sycl::nd_item<3> item_ct1,
double *shared)
{
constexpr int mxdim_p1 = Internal_Vegas_Params::get_MXDIM_p1();
uint32_t m = item_ct1.get_group(2) * item_ct1.get_local_range().get(2) +
item_ct1.get_local_id(2);
uint32_t tx = item_ct1.get_local_id(2);
double wgt;
uint32_t kg[mxdim_p1];
int ia[mxdim_p1];
double x[mxdim_p1];
double fbg = 0., f2bg = 0.;
if (m < totalNumThreads) {
size_t cube_id_offset =
(item_ct1.get_group(2) * item_ct1.get_local_range().get(2) +
item_ct1.get_local_id(2)) *
chunkSize;
if (m == totalNumThreads - 1)
chunkSize = LastChunk;
Custom_generator rand_num_generator(seed_init);
get_indx(cube_id_offset, &kg[1], ndim, ng);
Process_chunks<IntegT, ndim>(
d_integrand,
chunkSize,
LastChunk,
ng,
npg,
&rand_num_generator,
dxg,
xnd,
xjac,
regn,
dx,
xi,
kg,
ia,
x,
wgt,
d,
fbg,
f2bg,
cube_id_offset);
}
// testing if synch is needed
item_ct1.barrier();
fbg = blockReduceSum(fbg, item_ct1, shared);
f2bg = blockReduceSum(f2bg, item_ct1, shared);
if (tx == 0) {
dpct::atomic_fetch_add(&result_dev[0], fbg);
dpct::atomic_fetch_add(&result_dev[1], f2bg);
}
// end of subcube if
}
template <typename IntegT,
int ndim>
void
vegas_kernelF(IntegT* d_integrand,
int ng,
int npg,
double xjac,
double dxg,
double* result_dev,
double xnd,
double* xi,
double* d,
double* dx,
double* regn,
int ncubes,
int iter,
double sc,
double sci,
double ing, // not needed?
int chunkSize,
uint32_t totalNumThreads,
int LastChunk,
unsigned int seed_init,
sycl::nd_item<3> item_ct1,
double *shared)
{
constexpr int ndmx = Internal_Vegas_Params::get_NDMX();
constexpr int ndmx_p1 = Internal_Vegas_Params::get_NDMX_p1();
constexpr int mxdim_p1 = Internal_Vegas_Params::get_MXDIM_p1();
uint32_t m = item_ct1.get_group(2) * item_ct1.get_local_range().get(2) +
item_ct1.get_local_id(2);
int tx = item_ct1.get_local_id(2);
size_t cube_id_offset =
(item_ct1.get_group(2) * item_ct1.get_local_range().get(2) +
item_ct1.get_local_id(2)) *
chunkSize;
double fb, f2b, wgt, xn, xo, rc, f, f2, ran00;
uint32_t kg[mxdim_p1];
int iaj;
double x[mxdim_p1];
int k, j;
double fbg = 0., f2bg = 0.;
if (m < totalNumThreads) {
if (m == totalNumThreads - 1)
chunkSize = LastChunk;
//use the actual random generator compatible with oneAPI, no need for templates and abstractions to take different generators
Custom_generator rand_num_generator(seed_init);
fbg = f2bg = 0.0;
get_indx(cube_id_offset, &kg[1], ndim, ng);
for (int t = 0; t < chunkSize; t++) {
fb = f2b = 0.0;
for (k = 1; k <= npg; k++) {
wgt = xjac;
for (j = 1; j <= ndim; j++) {
ran00 = rand_num_generator();
xn = (kg[j] - ran00) * dxg + 1.0;
iaj = IMAX(IMIN((int)(xn), ndmx), 1);
if (iaj > 1) {
xo = xi[j * ndmx_p1 + iaj] - xi[j * ndmx_p1 + iaj - 1];
rc = xi[j * ndmx_p1 + iaj - 1] + (xn - iaj) * xo;
} else {
xo = xi[j * ndmx_p1 + iaj];
rc = (xn - iaj) * xo;
}
x[j] = regn[j] + rc * dx[j];
wgt *= xo * xnd;
}
double tmp;
gpu::cudaArray<double, ndim> xx;
for (int i = 0; i < ndim; i++) {
xx[i] = x[i + 1];
}
tmp = gpu::apply(*d_integrand, xx);
f = wgt * tmp;
f2 = f * f;
fb += f;
f2b += f2;
} // end of npg loop
f2b = sycl::sqrt(f2b * npg);
// double example = f2b;
f2b = (f2b - fb) * (f2b + fb);
if (f2b <= 0.0)
f2b = TINY;
fbg += fb;
f2bg += f2b;
for (int k = ndim; k >= 1; k--) {
kg[k] %= ng;
if (++kg[k] != 1)
break;
}
} // end of chunk for loop
}
fbg = blockReduceSum(fbg, item_ct1, shared);
f2bg = blockReduceSum(f2bg, item_ct1, shared);
if (tx == 0) {
// printf("Block %i done\n", blockIdx.x);
dpct::atomic_fetch_add(&result_dev[0], fbg);
dpct::atomic_fetch_add(&result_dev[1], f2bg);
}
// end of subcube if
}
__inline__ void
rebin(double rc, int nd, double r[], double xin[], double xi[])
{
int i, k = 0;
double dr = 0.0, xn = 0.0, xo = 0.0;
for (i = 1; i < nd; i++) {
while (rc > dr) {
dr += r[++k];
}
if (k > 1)
xo = xi[k - 1];
xn = xi[k];
dr -= rc;
xin[i] = xn - (xn - xo) * dr / r[k];
}
for (i = 1; i < nd; i++)
xi[i] = xin[i];
xi[nd] = 1.0;
}
template <typename IntegT,
int ndim>
void
vegas(IntegT integrand,
double epsrel,
double epsabs,
double ncall,
double* tgral,
double* sd,
double* chi2a,
int* status,
size_t* iters,
int titer,
int itmax,
int skip,
quad::Volume<double, ndim> const* vol)
{
dpct::device_ext &dev_ct1 = dpct::get_current_device();
sycl::queue &q_ct1 = dev_ct1.default_queue();
//Display Device Name
std::cout << "Device: " << q_ct1.get_device().get_info<sycl::info::device::name>() << "\n";
// Mcubes_state mcubes_state(ncall, ndim);
// all of the ofstreams below will be removed, replaced by DataLogger
auto t0 = std::chrono::high_resolution_clock::now();
constexpr int ndmx = Internal_Vegas_Params::get_NDMX();
constexpr int ndmx_p1 = Internal_Vegas_Params::get_NDMX_p1();
constexpr int mxdim_p1 = Internal_Vegas_Params::get_MXDIM_p1();
IntegT* d_integrand = quad::cuda_copy_to_managed(integrand);
double regn[2 * mxdim_p1];
for (int j = 1; j <= ndim; j++) {
regn[j] = vol->lows[j - 1];
regn[j + ndim] = vol->highs[j - 1];
}
int i, it, j, nd, ndo, ng, npg;
double calls, dv2g, dxg, rc, ti, tsi, wgt, xjac, xn, xnd, xo;
double k, ncubes;
double schi, si, swgt;
double result[2];
double *d, *dt, *dx, *r, *x, *xi, *xin;
int* ia;
d =
(double*)malloc(sizeof(double) * (ndmx_p1) * (mxdim_p1)); // contributions
dt = (double*)malloc(sizeof(double) * (mxdim_p1)); // for cpu-only
dx = (double*)malloc(sizeof(double) *
(mxdim_p1)); // length of integ-space at each dim
r = (double*)malloc(sizeof(double) * (ndmx_p1));
x = (double*)malloc(sizeof(double) * (mxdim_p1));
xi = (double*)malloc(sizeof(double) * (mxdim_p1) *
(ndmx_p1)); // right bin coord
xin = (double*)malloc(sizeof(double) * (ndmx_p1));
ia = (int*)malloc(sizeof(int) * (mxdim_p1));
// code works only for (2 * ng - NDMX) >= 0)
ndo = 1;
for (j = 1; j <= ndim; j++) {
xi[j * ndmx_p1 + 1] =
1.0; // this index is the first for each bin for each dimension
}
si = swgt = schi = 0.0;
nd = ndmx;
ng = 1;
ng = (int)pow(ncall / 2.0 + 0.25, 1.0 / ndim); // why do we add .25?
for (k = 1, i = 1; i < ndim; i++) {
k *= ng;
}
double sci = 1.0 / k; // I dont' think that's used anywhere
double sc = k; // I dont' think that's used either
k *= ng;
ncubes = k;
npg = IMAX(ncall / k, 2);
// assert(npg == Compute_samples_per_cube(ncall, ncubes)); //to replace line
// directly above assert(ncubes == ComputeNcubes(ncall, ndim)); //to replace
// line directly above
calls = (double)npg * (double)k;
dxg = 1.0 / ng;
double ing = dxg;
for (dv2g = 1, i = 1; i <= ndim; i++)
dv2g *= dxg;
dv2g = (calls * dv2g * calls * dv2g) / npg / npg / (npg - 1.0);
xnd = nd;
dxg *= xnd;
xjac = 1.0 / calls;
for (j = 1; j <= ndim; j++) {
dx[j] = regn[j + ndim] - regn[j];
xjac *= dx[j];
}
for (i = 1; i <= IMAX(nd, ndo); i++)
r[i] = 1.0;
for (j = 1; j <= ndim; j++) {
rebin(ndo / xnd, nd, r, xin, &xi[j * ndmx_p1]);
}
ndo = nd;
double *d_dev, *dx_dev, *x_dev, *xi_dev, *regn_dev, *result_dev;
int* ia_dev;
result_dev = sycl::malloc_device<double>(2, q_ct1);
cudaCheckError();
d_dev = (double *)sycl::malloc_device(
sizeof(double) * (ndmx_p1) * (mxdim_p1), q_ct1);
cudaCheckError();
dx_dev = sycl::malloc_device<double>((mxdim_p1), q_ct1);
cudaCheckError();
x_dev = sycl::malloc_device<double>((mxdim_p1), q_ct1);
cudaCheckError();
xi_dev = (double *)sycl::malloc_device(
sizeof(double) * (mxdim_p1) * (ndmx_p1), q_ct1);
cudaCheckError();
regn_dev = sycl::malloc_device<double>(((ndim * 2) + 1), q_ct1);
cudaCheckError();
ia_dev = sycl::malloc_device<int>((mxdim_p1), q_ct1);
cudaCheckError();
q_ct1.memcpy(dx_dev, dx, sizeof(double) * (mxdim_p1)).wait();
cudaCheckError();
q_ct1.memcpy(x_dev, x, sizeof(double) * (mxdim_p1)).wait();
cudaCheckError();
q_ct1.memcpy(regn_dev, regn, sizeof(double) * ((ndim * 2) + 1)).wait();
cudaCheckError();
q_ct1.memset(ia_dev, 0, sizeof(int) * (mxdim_p1)).wait();
int chunkSize = GetChunkSize(ncall);
uint32_t totalNumThreads =
(uint32_t)((ncubes) / chunkSize);
uint32_t totalCubes = totalNumThreads * chunkSize; // even-split cubes
int extra = ncubes - totalCubes; // left-over cubes
int LastChunk = extra + chunkSize; // last chunk of last thread
uint32_t nBlocks =
((uint32_t)(((ncubes + BLOCK_DIM_X - 1) / BLOCK_DIM_X)) / chunkSize) +
1; // compute blocks based on chunk_size, ncubes, and block_dim_x
uint32_t nThreads = BLOCK_DIM_X;
for (it = 1; it <= itmax && (*status) == 1; (*iters)++, it++) {
ti = tsi = 0.0;
for (j = 1; j <= ndim; j++) {
for (i = 1; i <= nd; i++)
d[i * mxdim_p1 + j] = 0.0;
}
q_ct1.memcpy(xi_dev, xi, sizeof(double) * (mxdim_p1) * (ndmx_p1)).wait();
cudaCheckError(); // bin bounds
q_ct1.memset(d_dev, 0, sizeof(double) * (ndmx_p1) * (mxdim_p1))
.wait(); // bin contributions
q_ct1.memset(result_dev, 0, 2 * sizeof(double)).wait();
using MilliSeconds =
std::chrono::duration<double, std::chrono::milliseconds::period>;
MilliSeconds time_diff = std::chrono::high_resolution_clock::now() - t0;
unsigned int seed = static_cast<unsigned int>(time_diff.count()) +
static_cast<unsigned int>(it);
q_ct1.submit([&](sycl::handler &cgh) {
sycl::accessor<double, 1, sycl::access_mode::read_write,
sycl::access::target::local>
shared_acc_ct1(sycl::range<1>(32), cgh);
cgh.parallel_for(
sycl::nd_range<3>(sycl::range<3>(1, 1, nBlocks) * sycl::range<3>(1, 1, nThreads), sycl::range<3>(1, 1, nThreads)),
[=](sycl::nd_item<3> item_ct1) [[intel::reqd_sub_group_size(32)]] {
vegas_kernel<IntegT, ndim>(
d_integrand, ng, npg, xjac, dxg, result_dev, xnd, xi_dev,
d_dev, dx_dev, regn_dev, ncubes, it, sc, sci, ing,
chunkSize, totalNumThreads, LastChunk, seed + it, item_ct1,
shared_acc_ct1.get_pointer());
});
});
q_ct1.memcpy(xi, xi_dev, sizeof(double) * (mxdim_p1) * (ndmx_p1)).wait();
cudaCheckError();
q_ct1.memcpy(d, d_dev, sizeof(double) * (ndmx_p1) * (mxdim_p1)).wait();
cudaCheckError(); // we do need to the contributions for the rebinning
q_ct1.memcpy(result, result_dev, sizeof(double) * 2).wait();
ti = result[0];
tsi = result[1];
tsi *= dv2g;
// printf("-------------------------------------------\n");
// printf("iter %d integ = %.15e std = %.15e var:%.15e dv2g:%f\n", it,
// ti, sqrt(tsi), tsi, dv2g);
if (it > skip) {
wgt = 1.0 / tsi;
si += wgt * ti;
schi += wgt * ti * ti;
swgt += wgt;
*tgral = si / swgt;
*chi2a = (schi - si * (*tgral)) / (static_cast<double>(it) - 0.9999);
if (*chi2a < 0.0)
*chi2a = 0.0;
*sd = sqrt(1.0 / swgt);
tsi = sqrt(tsi);
*status = GetStatus(*tgral, *sd, it, epsrel, epsabs);
// printf("%i %.15f +- %.15f iteration: %.15f +- %.15f chi:%.15f\n", it,
// *tgral, *sd, ti, sqrt(tsi), *chi2a);
}
// replace above with datalogger.print();
for (j = 1; j <= ndim; j++) {
xo = d[1 * mxdim_p1 + j]; // bin 1 of dim j
xn = d[2 * mxdim_p1 + j]; // bin 2 of dim j
d[1 * mxdim_p1 + j] = (xo + xn) / 2.0;
dt[j] = d[1 * mxdim_p1 + j]; // set dt sum to contribution of bin 1
for (i = 2; i < nd; i++) {
rc = xo + xn;
xo = xn;
xn = d[(i + 1) * mxdim_p1 + j];
d[i * mxdim_p1 + j] = (rc + xn) / 3.0;
dt[j] += d[i * mxdim_p1 + j];
}
d[nd * mxdim_p1 + j] = (xo + xn) / 2.0; // do bin nd last
dt[j] += d[nd * mxdim_p1 + j];
}
for (j = 1; j <= ndim; j++) {
if (dt[j] > 0.0) { // enter if there is any contribution only
rc = 0.0;
for (i = 1; i <= nd; i++) {
// if(d[i*mxdim_p1+j]<TINY) d[i*mxdim_p1+j]=TINY;
// if(d[i*mxdim_p1+j]<TINY) printf("d[%i]:%.15e\n", i*mxdim_p1+j,
// d[i*mxdim_p1+j]); printf("d[%i]:%.15e\n", i*mxdim_p1+j,
// d[i*mxdim_p1+j]);
r[i] = pow((1.0 - d[i * mxdim_p1 + j] / dt[j]) /
(log(dt[j]) - log(d[i * mxdim_p1 + j])),
Internal_Vegas_Params::get_ALPH());
rc += r[i]; // rc is it the total number of sub-increments
}
rebin(
rc / xnd,
nd,
r,
xin,
&xi[j * ndmx_p1]); // first bin of each dimension is at a diff index
}
}
} // end of iterations
// Start of iterations without adjustment
q_ct1.memcpy(xi_dev, xi, sizeof(double) * (mxdim_p1) * (ndmx_p1)).wait();
cudaCheckError();
for (it = itmax + 1; it <= titer && (*status); (*iters)++, it++) {
ti = tsi = 0.0;
q_ct1.memset(result_dev, 0, 2 * sizeof(double)).wait();
using MilliSeconds =
std::chrono::duration<double, std::chrono::milliseconds::period>;
MilliSeconds time_diff = std::chrono::high_resolution_clock::now() - t0;
unsigned int seed = static_cast<unsigned int>(time_diff.count()) +
static_cast<unsigned int>(it);
q_ct1.submit([&](sycl::handler &cgh) {
sycl::accessor<double, 1, sycl::access_mode::read_write,
sycl::access::target::local>
shared_acc_ct1(sycl::range<1>(32), cgh);
cgh.parallel_for(
sycl::nd_range<3>(sycl::range<3>(1, 1, nBlocks) *
sycl::range<3>(1, 1, nThreads),
sycl::range<3>(1, 1, nThreads)),
[=](sycl::nd_item<3> item_ct1) [[intel::reqd_sub_group_size(32)]] {
vegas_kernelF<IntegT, ndim>(
d_integrand, ng, npg, xjac, dxg, result_dev, xnd, xi_dev,
d_dev, dx_dev, regn_dev, ncubes, it, sc, sci, ing,
chunkSize, totalNumThreads, LastChunk, seed + it, item_ct1,
shared_acc_ct1.get_pointer());
});
});
q_ct1.memcpy(result, result_dev, sizeof(double) * 2).wait();
ti = result[0];
tsi = result[1];
tsi *= dv2g;
// printf("iter %d integ = %.15e std = %.15e var:%.15e dv2g:%f\n", it,
// ti, sqrt(tsi), tsi, dv2g);
wgt = 1.0 / tsi;
si += wgt * ti;
schi += wgt * ti * ti;
swgt += wgt;
*tgral = si / swgt;
*chi2a = (schi - si * (*tgral)) / (it - 0.9999);
if (*chi2a < 0.0)
*chi2a = 0.0;
*sd = sqrt(1.0 / swgt);
tsi = sqrt(tsi);
*status = GetStatus(*tgral, *sd, it, epsrel, epsabs);
// printf("%i, %.15f, %.15f, %.15f, %.15f, %.15f\n", it, *tgral, *sd, ti,
// sqrt(tsi), *chi2a);
// printf("cummulative ti:%5d, integral: %.15e, sd:%.4e,chi_sq:%9.2g\n",
// it, *tgral, *sd, *chi2a);
} // end of iterations
free(d);
free(dt);
free(dx);
free(ia);
free(x);
free(xi);
free(xin);
free(r);
sycl::free(d_dev, q_ct1);
sycl::free(dx_dev, q_ct1);
sycl::free(ia_dev, q_ct1);
sycl::free(x_dev, q_ct1);
sycl::free(xi_dev, q_ct1);
sycl::free(regn_dev, q_ct1);
sycl::free(result_dev, q_ct1);
d_integrand->~IntegT();
sycl::free(d_integrand, q_ct1);
}
template <typename IntegT,
int NDIM>
cuhreResult<double>
integrate(IntegT ig,
double epsrel,
double epsabs,
double ncall,
quad::Volume<double, NDIM> const* volume,
int totalIters = 15,
int adjustIters = 15,
int skipIters = 5)
{
cuhreResult<double> result;
result.status = 1;
vegas<IntegT, NDIM>(ig,
epsrel,
epsabs,
ncall,
&result.estimate,
&result.errorest,
&result.chi_sq,
&result.status,
&result.iters,
totalIters,
adjustIters,
skipIters,
volume);
return result;
}
template <typename IntegT,
int NDIM>
cuhreResult<double>
simple_integrate(IntegT integrand,
double epsrel,
double epsabs,
double ncall,
quad::Volume<double, NDIM> const* volume,
int totalIters = 15,
int adjustIters = 15,
int skipIters = 5)
{
cuhreResult<double> result;
result.status = 1;
do {
vegas<IntegT, NDIM>(integrand,
epsrel,
epsabs,
ncall,
&result.estimate,
&result.errorest,
&result.chi_sq,
&result.status,
&result.iters,
totalIters,
adjustIters,
skipIters,
volume);
} while (result.status == 1 && AdjustParams(ncall, totalIters) == true);
return result;
}
}
#endif
| [
"isaki001@odu.edu"
] | isaki001@odu.edu |
188f48f6f9d7a2bfc87956bd1ecca0045e824884 | bb91f7320eb15f7d666e8d197a70ec2103187da1 | /1001ConvertTemperature/main.cpp | 250a85a9f48756cd2c4b07a001c13b47eec30c14 | [] | no_license | wpcwzy/NOI-Practice | 37c61918fc262248041c6680244047de98ac7aef | 327969587830b664b8a37eb66c69672fd4d44a07 | refs/heads/master | 2020-04-18T06:55:47.895066 | 2019-01-24T13:39:22 | 2019-01-24T13:39:22 | 167,340,203 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 175 | cpp | #include <iostream>
#include <stdio.h>
using namespace std;
int main() {
float inputTemp;
cin >> inputTemp;
printf("%.4lf",(inputTemp-32.0)/1.8);
return 0;
} | [
"wpc.369623245@live.cn"
] | wpc.369623245@live.cn |
046f8a93a526ecd62ec921bca68f4456e1aba399 | 12bc97012ce19a10899c1eeb6457a70f0a43dcca | /1219/實習161.cpp | 73bb7e5c588964e0df6c970b011132610ac5b40a | [] | no_license | Alice10241998/1081_nsysu_C-lab | 00c1ae662c8f93d59cd680ebf0568d4a907d44a2 | 46d9d2bac2bd42b5297d72e95361b67904b7d66c | refs/heads/main | 2023-08-22T09:25:48.160408 | 2021-10-13T07:13:06 | 2021-10-13T07:13:06 | null | 0 | 0 | null | null | null | null | BIG5 | C++ | false | false | 533 | cpp | #include<stdio.h>
#include<stdlib.h>
struct student
{
int math,eng;
char name[3];
float avg;
};
void score(struct student a[])
{
int i;
for(i=0;i<3;i++)
printf("%d.%s平均%.2lf分\n",i+1,a[i].name,a[i].avg);
}
int main()
{
int i;
struct student a[3];
for(i=0;i<3;i++)
{
printf("請輸入姓名:");
scanf("%s",&a[i].name);
printf("請輸入數學成績:");
scanf("%d",&a[i].math);
printf("請輸入英文成績:");
scanf("%d",&a[i].eng);
a[i].avg=float(a[i].math+a[i].eng)/2;
}
score(a);
return 0;
}
| [
"amy990105@gmail.com"
] | amy990105@gmail.com |
37be1b40d829db44d5823343aad2128760290a7e | 598fcb098af368fe6abafa01b47143e9b62c70a9 | /society/main.cpp | d0c9597e0d93411018ae45939b362cfbe7e267e9 | [] | no_license | asdfvar/projekt | a04e076401295e63f7ca8cb7c3a99440a4cebf5b | 1bf3fe7ec22e351a069e34fae2cad041242e6873 | refs/heads/master | 2021-04-18T23:14:36.694161 | 2020-06-06T23:04:29 | 2020-06-06T23:04:29 | 37,008,482 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,347 | cpp | #include <GL/glut.h>
#include <GL/glu.h>
#include <GL/gl.h>
#include <GL/glext.h>
#include <iostream>
#include "facade.h"
/* Define the interface with openGL */
Facade facade;
/***********************
** Display to screen **
***********************/
void display(void)
{
facade.display ();
}
/*********************
** Idle processing **
*********************/
void idle(void)
{
facade.idle ();
}
/*****************
*** Mouse click **
******************
** button
** GLUT_LEFT_BUTTON
** GLUT_MIDDLE_BUTTON
** GLUT_RIGHT_BUTTON
** state
** GLUT_UP
** GLUT_DOWN
*/
void mouseClick (
int button,
int state,
int x,
int y)
{
facade.mouseClick (button, state, x, y);
}
/**************************
** Active mouse control **
**************************/
void mouseMotion(int x, int y)
{
facade.mouseMotion (x, y);
}
/***************************
*** Passive mouse control **
****************************
** GLUT_WINDOW_X X location in pixels (relative to the screen origin)
** of the current window
** GLUT_WINDOW_Y Y location in pixels (relative to the screen origin)
** of the current window
** GLUT_WINDOW_WIDTH Width in pixels of the current window
** GLUT_WINDOW_HEIGHT Height in pixels of the current window
*/
void mousePassive (int x, int y)
{
facade.mousePassive (x, y);
}
/*****************
** Keyboard up **
*****************/
void keyboardUp (unsigned char key, int x, int y)
{
facade.keyboardUp (key, x, y);
}
/*******************
** Keyboard down **
*******************/
void keyboardDown (unsigned char key, int x, int y)
{
if (key == 'q') exit (1);
facade.keyboardDown (key, x, y);
}
// Special key values
void specialFunc(int key, int x, int y)
{
facade.specialFunc (key, x, y);
}
void specialUpFunc(int key, int x, int y)
{
facade.specialUpFunc (key, x, y);
}
/**********
** Main **
**********/
int main (int argc, char** argv)
{
int windowsizex = 800;
int windowsizey = 800;
glutInit (&argc, argv);
glutInitDisplayMode (GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH);
glutInitWindowSize (windowsizex, windowsizey);
glutInitWindowPosition (50, 50);
glutCreateWindow ("whee");
glutSetKeyRepeat (GLUT_KEY_REPEAT_OFF);
float light_ambient[] = { 0.2, 0.2, 0.2, 1.0 };
float light_diffuse[] = { 0.8, 0.8, 0.8, 1.0 };
float light_specular[] = { 0.8, 0.8, 0.8, 1.0 };
float light_position[] = { 0.0, 0.0, 1.0, 0.0 };
glLightfv (GL_LIGHT0, GL_AMBIENT, light_ambient );
glLightfv (GL_LIGHT0, GL_DIFFUSE, light_diffuse );
glLightfv (GL_LIGHT0, GL_SPECULAR, light_specular);
glLightfv (GL_LIGHT0, GL_POSITION, light_position);
glEnable (GL_LIGHT0 );
glEnable (GL_LESS );
glEnable (GL_DEPTH_TEST );
glEnable (GL_LIGHTING );
glEnable (GL_COLOR_MATERIAL);
glDepthFunc (GL_LESS);
glutDisplayFunc (display );
glutMouseFunc (mouseClick );
glutMotionFunc (mouseMotion );
glutPassiveMotionFunc (mousePassive );
glutKeyboardUpFunc (keyboardUp );
glutKeyboardFunc (keyboardDown );
glutSpecialFunc (specialFunc );
glutSpecialUpFunc (specialUpFunc);
glutIdleFunc (idle );
glutMainLoop();
return 0;
}
| [
"asdfvar@gmail.com"
] | asdfvar@gmail.com |
e10d0cea445b4bf6e168f869c1de747d73933877 | f5dcd9d70dbde783ecdd09cbc532a5e19b54c7d4 | /src/test/test_virtacoin.cpp | c92e5176c80ceabf21822f1fb53a4f9ea2e8044d | [
"MIT"
] | permissive | DevRatnu/VirtaCoinProject | 6dfcddf553af565d1315ae7c8cd93765f9097821 | bdc536321f70fa5d51077ed2e66394518a44ede8 | refs/heads/master | 2023-01-10T04:58:26.912176 | 2021-08-27T08:06:32 | 2021-08-27T08:06:32 | 99,586,449 | 2 | 0 | null | 2017-08-07T14:25:25 | 2017-08-07T14:25:25 | null | UTF-8 | C++ | false | false | 1,990 | cpp | #define BOOST_TEST_MODULE VirtaCoin Test Suite
#include "main.h"
#include "txdb.h"
#include "ui_interface.h"
#include "util.h"
#ifdef ENABLE_WALLET
#include "db.h"
#include "wallet.h"
#endif
#include <boost/filesystem.hpp>
#include <boost/test/unit_test.hpp>
CWallet* pwalletMain;
extern bool fPrintToConsole;
extern void noui_connect();
struct TestingSetup {
CCoinsViewDB *pcoinsdbview;
boost::filesystem::path pathTemp;
boost::thread_group threadGroup;
TestingSetup() {
fPrintToDebugLog = false; // don't want to write to debug.log file
noui_connect();
#ifdef ENABLE_WALLET
bitdb.MakeMock();
#endif
pathTemp = GetTempPath() / strprintf("test_virtacoin_%lu_%i", (unsigned long)GetTime(), (int)(GetRand(100000)));
boost::filesystem::create_directories(pathTemp);
mapArgs["-datadir"] = pathTemp.string();
pblocktree = new CBlockTreeDB(1 << 20, true);
pcoinsdbview = new CCoinsViewDB(1 << 23, true);
pcoinsTip = new CCoinsViewCache(*pcoinsdbview);
InitBlockIndex();
#ifdef ENABLE_WALLET
bool fFirstRun;
pwalletMain = new CWallet("wallet.dat");
pwalletMain->LoadWallet(fFirstRun);
RegisterWallet(pwalletMain);
#endif
nScriptCheckThreads = 3;
for (int i=0; i < nScriptCheckThreads-1; i++)
threadGroup.create_thread(&ThreadScriptCheck);
RegisterNodeSignals(GetNodeSignals());
}
~TestingSetup()
{
threadGroup.interrupt_all();
threadGroup.join_all();
UnregisterNodeSignals(GetNodeSignals());
#ifdef ENABLE_WALLET
delete pwalletMain;
pwalletMain = NULL;
#endif
delete pcoinsTip;
delete pcoinsdbview;
delete pblocktree;
#ifdef ENABLE_WALLET
bitdb.Flush(true);
#endif
boost::filesystem::remove_all(pathTemp);
}
};
BOOST_GLOBAL_FIXTURE(TestingSetup);
void Shutdown(void* parg)
{
exit(0);
}
void StartShutdown()
{
exit(0);
}
| [
"virtacoin@users.noreply.github.com"
] | virtacoin@users.noreply.github.com |
8283be1b0b7d4eaf57108f9ebf05999fb790e718 | 51021a6aecf17df60a7b620308fcbea58bc7460a | /conf/ui_channelsaddsets.h | 4f16bf9dcd6f22209261d88faecd9cc76a9b3592 | [] | no_license | Neomer/energo | 53d5cf877821ab8e4848c38b24c8d82a71772ee6 | 32f4712fb30bba1a8875e9c085f0ff1f7ffa19f7 | refs/heads/master | 2020-09-24T14:42:13.850898 | 2019-12-06T06:48:01 | 2019-12-06T06:48:01 | 225,782,992 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 6,330 | h | /********************************************************************************
** Form generated from reading UI file 'channelsaddsets.ui'
**
** Created by: Qt User Interface Compiler version 4.8.6
**
** WARNING! All changes made in this file will be lost when recompiling UI file!
********************************************************************************/
#ifndef UI_CHANNELSADDSETS_H
#define UI_CHANNELSADDSETS_H
#include <QtCore/QVariant>
#include <QtGui/QAction>
#include <QtGui/QApplication>
#include <QtGui/QButtonGroup>
#include <QtGui/QGridLayout>
#include <QtGui/QHBoxLayout>
#include <QtGui/QHeaderView>
#include <QtGui/QLabel>
#include <QtGui/QLineEdit>
#include <QtGui/QPushButton>
#include <QtGui/QSpacerItem>
#include <QtGui/QVBoxLayout>
#include <QtGui/QWidget>
QT_BEGIN_NAMESPACE
class Ui_ChannelsAddSets
{
public:
QWidget *horizontalLayoutWidget;
QHBoxLayout *mainLayout;
QGridLayout *gridLayout;
QLabel *label;
QHBoxLayout *horizontalLayout_2;
QSpacerItem *horizontalSpacer;
QPushButton *cmdSave;
QPushButton *cmdDrop;
QLabel *label_2;
QHBoxLayout *horizontalLayout_3;
QLineEdit *txtName;
QSpacerItem *horizontalSpacer_2;
QHBoxLayout *horizontalLayout_4;
QVBoxLayout *verticalLayout;
QPushButton *cmdAddSchedule;
QSpacerItem *horizontalSpacer_3;
QSpacerItem *verticalSpacer;
void setupUi(QWidget *ChannelsAddSets)
{
if (ChannelsAddSets->objectName().isEmpty())
ChannelsAddSets->setObjectName(QString::fromUtf8("ChannelsAddSets"));
ChannelsAddSets->resize(704, 571);
horizontalLayoutWidget = new QWidget(ChannelsAddSets);
horizontalLayoutWidget->setObjectName(QString::fromUtf8("horizontalLayoutWidget"));
horizontalLayoutWidget->setGeometry(QRect(10, 0, 651, 561));
mainLayout = new QHBoxLayout(horizontalLayoutWidget);
mainLayout->setObjectName(QString::fromUtf8("mainLayout"));
mainLayout->setContentsMargins(10, 6, 6, 6);
gridLayout = new QGridLayout();
gridLayout->setObjectName(QString::fromUtf8("gridLayout"));
gridLayout->setContentsMargins(6, 6, 6, 6);
label = new QLabel(horizontalLayoutWidget);
label->setObjectName(QString::fromUtf8("label"));
label->setAlignment(Qt::AlignRight|Qt::AlignTop|Qt::AlignTrailing);
gridLayout->addWidget(label, 0, 0, 1, 1);
horizontalLayout_2 = new QHBoxLayout();
horizontalLayout_2->setObjectName(QString::fromUtf8("horizontalLayout_2"));
horizontalLayout_2->setContentsMargins(5, 5, 5, 5);
horizontalSpacer = new QSpacerItem(40, 20, QSizePolicy::Expanding, QSizePolicy::Minimum);
horizontalLayout_2->addItem(horizontalSpacer);
cmdSave = new QPushButton(horizontalLayoutWidget);
cmdSave->setObjectName(QString::fromUtf8("cmdSave"));
horizontalLayout_2->addWidget(cmdSave);
cmdDrop = new QPushButton(horizontalLayoutWidget);
cmdDrop->setObjectName(QString::fromUtf8("cmdDrop"));
horizontalLayout_2->addWidget(cmdDrop);
gridLayout->addLayout(horizontalLayout_2, 4, 1, 1, 1);
label_2 = new QLabel(horizontalLayoutWidget);
label_2->setObjectName(QString::fromUtf8("label_2"));
label_2->setAlignment(Qt::AlignRight|Qt::AlignTop|Qt::AlignTrailing);
gridLayout->addWidget(label_2, 1, 0, 1, 1);
horizontalLayout_3 = new QHBoxLayout();
horizontalLayout_3->setObjectName(QString::fromUtf8("horizontalLayout_3"));
txtName = new QLineEdit(horizontalLayoutWidget);
txtName->setObjectName(QString::fromUtf8("txtName"));
horizontalLayout_3->addWidget(txtName);
horizontalSpacer_2 = new QSpacerItem(40, 20, QSizePolicy::Expanding, QSizePolicy::Minimum);
horizontalLayout_3->addItem(horizontalSpacer_2);
gridLayout->addLayout(horizontalLayout_3, 0, 1, 1, 1);
horizontalLayout_4 = new QHBoxLayout();
horizontalLayout_4->setObjectName(QString::fromUtf8("horizontalLayout_4"));
verticalLayout = new QVBoxLayout();
verticalLayout->setObjectName(QString::fromUtf8("verticalLayout"));
verticalLayout->setContentsMargins(-1, -1, 6, -1);
cmdAddSchedule = new QPushButton(horizontalLayoutWidget);
cmdAddSchedule->setObjectName(QString::fromUtf8("cmdAddSchedule"));
verticalLayout->addWidget(cmdAddSchedule);
horizontalLayout_4->addLayout(verticalLayout);
horizontalSpacer_3 = new QSpacerItem(40, 20, QSizePolicy::Expanding, QSizePolicy::Minimum);
horizontalLayout_4->addItem(horizontalSpacer_3);
gridLayout->addLayout(horizontalLayout_4, 1, 1, 1, 1);
verticalSpacer = new QSpacerItem(20, 40, QSizePolicy::Minimum, QSizePolicy::Expanding);
gridLayout->addItem(verticalSpacer, 2, 1, 1, 1);
mainLayout->addLayout(gridLayout);
retranslateUi(ChannelsAddSets);
QMetaObject::connectSlotsByName(ChannelsAddSets);
} // setupUi
void retranslateUi(QWidget *ChannelsAddSets)
{
ChannelsAddSets->setWindowTitle(QApplication::translate("ChannelsAddSets", "Form", 0, QApplication::UnicodeUTF8));
label->setText(QApplication::translate("ChannelsAddSets", "\320\235\320\260\320\270\320\274\320\265\320\275\320\276\320\262\320\260\320\275\320\270\320\265:", 0, QApplication::UnicodeUTF8));
cmdSave->setText(QApplication::translate("ChannelsAddSets", "\320\241\320\276\321\205\321\200\320\260\320\275\320\270\321\202\321\214", 0, QApplication::UnicodeUTF8));
cmdDrop->setText(QApplication::translate("ChannelsAddSets", "\320\241\320\261\321\200\320\276\321\201\320\270\321\202\321\214", 0, QApplication::UnicodeUTF8));
label_2->setText(QApplication::translate("ChannelsAddSets", "\320\224\320\265\320\271\321\201\321\202\320\262\320\270\321\217:", 0, QApplication::UnicodeUTF8));
cmdAddSchedule->setText(QApplication::translate("ChannelsAddSets", "\320\224\320\276\320\261\320\260\320\262\320\270\321\202\321\214 \320\267\320\260\320\264\320\260\320\275\320\270\320\265", 0, QApplication::UnicodeUTF8));
} // retranslateUi
};
namespace Ui {
class ChannelsAddSets: public Ui_ChannelsAddSets {};
} // namespace Ui
QT_END_NAMESPACE
#endif // UI_CHANNELSADDSETS_H
| [
"vinokurov@elewise.com"
] | vinokurov@elewise.com |
dd481762ecbfcc6121d2fa5b27764edd0b755695 | f407b7fb9b5f0933e798a36696ae9ec3fb4e96c6 | /tests/webdav_interface_test.cpp | 6d1ef48f49637228b29f6237dd9e9d9456118cf8 | [
"BSD-3-Clause"
] | permissive | FinalLevel/libs | 322378df38483972a0ccbe221f3b0c914506fdec | 2f40a9d987a80d5dc8fde85d6226a385959fd0a2 | refs/heads/master | 2021-01-17T15:10:05.397637 | 2020-09-16T21:11:56 | 2020-09-16T21:15:36 | 16,046,386 | 1 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 7,108 | cpp | //
// Copyright (c) 2014 Final Level
// Author: Denys Misko <gdraal@gmail.com>
// Distributed under BSD (3-Clause) License (See
// accompanying file LICENSE)
//
// Description: WebDAV interface class unit tests
///////////////////////////////////////////////////////////////////////////////
#include <boost/test/unit_test.hpp>
#include "mock_http_util.hpp"
#include "webdav_interface.hpp"
#include "socket.hpp"
#include "accept_thread.hpp"
#include "compatibility.hpp"
using namespace fl::network;
using namespace fl::events;
using namespace fl::http;
BOOST_AUTO_TEST_SUITE( WebDavInterafaceTest )
class MockGetWebDavInterface : public WebDavInterface
{
public:
MockGetWebDavInterface()
{
}
static std::string ANSWER;
protected:
static TStatus _status;
virtual EFormResult _formGet(BString &networkBuffer, class HttpEvent *http) override
{
networkBuffer << ANSWER;
return EFormResult::RESULT_OK_KEEP_ALIVE;
}
};
std::string MockGetWebDavInterface::ANSWER("HTTP/1.1 200 OK\r\nContent-Type: text/xml; charset=\"utf-8\"\r\n\
Connection: Keep-Alive\r\nContent-Length: 0000000010\r\n\r\n1234567890");
BOOST_AUTO_TEST_CASE( GetCheck )
{
HttpMockEventFactory<MockGetWebDavInterface> factory;
TestHttpEventFramework testEventFramework(&factory);
BString request;
request << "GET /test HTTP/1.1\r\n";
request << "Content-length: " << 0 << "\r\n";
request << "\r\n";
Socket conn;
BOOST_REQUIRE(testEventFramework.connect(conn));
BString answer(MockGetWebDavInterface::ANSWER.size() + 1);
BOOST_REQUIRE(testEventFramework.doRequest(conn, request, answer));
BOOST_REQUIRE(answer == MockGetWebDavInterface::ANSWER.c_str());
request.clear();
request << "GET /test HTTP/1.1\r\n";
request << "Content-length: " << 0 << "\r\n";
request << "\r\n";
answer.clear();
BOOST_REQUIRE(testEventFramework.doRequest(conn, request, answer));
BOOST_REQUIRE(answer == MockGetWebDavInterface::ANSWER.c_str());
}
class MockPutWebDavInterface : public WebDavInterface
{
public:
MockPutWebDavInterface()
{
}
static std::string ANSWER;
static std::string SMALL_FILE;
typedef uint8_t TStatus;
static const TStatus ST_PUT = 0x1;
static const TStatus ST_FILE_PUT = 0x2;
static bool checkStatus()
{
return _status == (ST_PUT | ST_FILE_PUT);
}
protected:
static TStatus _status;
virtual EFormResult _formPut(BString &networkBuffer, class HttpEvent *http) override
{
auto result = WebDavInterface::_formPut(networkBuffer, http);
if (WebDavInterface::_status & ST_POST_SPLITED) {
_error = ERROR_400_BAD_REQUEST;
if (!_postTmpFile.descr())
return EFormResult::RESULT_ERROR;
auto fileSize = _postTmpFile.fileSize();
if (fileSize != (ssize_t)(_maxPostInMemmorySize + 1))
return EFormResult::RESULT_ERROR;
_postTmpFile.seek(0, SEEK_SET);
BString data;
char *buf = data.reserveBuffer(fileSize);
if (_postTmpFile.read(buf, fileSize) != fileSize)
return EFormResult::RESULT_ERROR;
for (int i = 0; i < fileSize; i++)
if (buf[i] != ('0' + (i % 32)))
return EFormResult::RESULT_ERROR;
_error = ERROR_200_OK;
_status |= ST_FILE_PUT;
return result;
} else {
if (_putData.c_str() == MockPutWebDavInterface::SMALL_FILE) {
_status |= ST_PUT;
return result;
}
}
_error = ERROR_400_BAD_REQUEST;
return EFormResult::RESULT_ERROR;
}
};
std::string MockPutWebDavInterface::ANSWER("HTTP/1.1 201 Created\r\nContent-Type: text/xml; charset=\"utf-8\"\r\n\
Connection: Keep-Alive\r\nContent-Length: 0000000000\r\n\r\n");
std::string MockPutWebDavInterface::SMALL_FILE("Small test file\n");
MockPutWebDavInterface::TStatus MockPutWebDavInterface::_status = 0;
BOOST_AUTO_TEST_CASE( PutCheck )
{
HttpMockEventFactory<MockPutWebDavInterface> factory;
TestHttpEventFramework testEventFramework(&factory);
BString request;
request << "PUT /test HTTP/1.1\r\n";
request << "Content-length: " << MockPutWebDavInterface::SMALL_FILE.size() << "\r\n";
request << "\r\n" << MockPutWebDavInterface::SMALL_FILE;
Socket conn;
BOOST_REQUIRE(testEventFramework.connect(conn));
BString answer(MockPutWebDavInterface::ANSWER.size() + 1);
BOOST_REQUIRE(testEventFramework.doRequest(conn, request, answer));
BOOST_REQUIRE(answer == MockPutWebDavInterface::ANSWER.c_str());
request.clear();
BString testData;
testData.clear();
auto dataSize = WebDavInterface::maxPostInMemmorySize() + 1;
auto pData = testData.reserveBuffer(dataSize);
for (size_t i = 0; i < dataSize; i++) {
pData[i] = '0' + (i % 32);
}
request << "PUT /test HTTP/1.1\r\n";
request << "Content-length: " << testData.size() << "\r\n";
request << "\r\n" << testData;
answer.clear();
BOOST_REQUIRE(testEventFramework.doRequest(conn, request, answer));
BOOST_REQUIRE(answer == MockPutWebDavInterface::ANSWER.c_str());
BOOST_REQUIRE(MockPutWebDavInterface::checkStatus());
}
class MockMinimalWebDavInterface : public WebDavInterface
{
public:
MockMinimalWebDavInterface()
{
}
static std::string OPTIONS_ANSWER;
protected:
virtual bool _put(const char *dataStart)
{
_error = ERROR_400_BAD_REQUEST;
return false;
}
virtual bool _putFile()
{
_error = ERROR_400_BAD_REQUEST;
return false;
}
};
std::string MockMinimalWebDavInterface::OPTIONS_ANSWER("HTTP/1.1 200 OK\r\nContent-Type: text/xml; charset=\"utf-8\"\r\n\
Connection: Keep-Alive\r\nContent-Length: 0000000000\r\n\
Allow: OPTIONS, GET, HEAD, POST, PUT, DELETE\r\n\
Allow: MKCOL, PROPFIND, PROPPATCH\r\n\
DAV: 1\r\n\r\n");
BOOST_AUTO_TEST_CASE( MinimalCheck )
{
HttpMockEventFactory<MockMinimalWebDavInterface> factory;
TestHttpEventFramework testEventFramework(&factory);
BString request;
request << "OPTIONS /test/ HTTP/1.1\r\n";
request << "Content-length: " << 0 << "\r\n";
request << "\r\n\r\n";
Socket conn;
BOOST_REQUIRE(testEventFramework.connect(conn));
BString answer(MockMinimalWebDavInterface::OPTIONS_ANSWER.size() + 1);
BOOST_REQUIRE(testEventFramework.doRequest(conn, request, answer));
BOOST_REQUIRE(answer == MockMinimalWebDavInterface::OPTIONS_ANSWER.c_str());
BString xmlData;
xmlData << "<?xml version=\"1.0\" encoding=\"UTF-8\" ?>\n\
<propfind xmlns=\"DAV:\">\
<prop>\
<supported-method-set/>\
</prop>\
</propfind>";
request.clear();
request << "PROPFIND /test/ HTTP/1.1\r\n";
request << "Depth: 0\r\nContent-Type: text/xml; charset=\"utf-8\"\r\nContent-length: " << xmlData.size() << "\r\n";
request << "\r\n\r\n" << xmlData;
answer.clear();
BOOST_REQUIRE(testEventFramework.doRequest(conn, request, answer));
BOOST_REQUIRE(strstr(answer.c_str(), "HTTP/1.1 207 Multi-Status\r\n") != NULL);
}
class FormErrorCheckWebDavInterface : public WebDavInterface
{
public:
FormErrorCheckWebDavInterface()
{
}
void set507Error()
{
_error = ERROR_507_INSUFFICIENT_STORAGE;
}
};
BOOST_AUTO_TEST_CASE( FormErrorCheck )
{
FormErrorCheckWebDavInterface interface;
BString answer;
interface.set507Error();
interface.formError(answer, NULL);
std::string ERROR_507_STR("HTTP/1.1 507 Insufficient Storage\r\n");
BOOST_CHECK(!memcmp(answer.c_str(), ERROR_507_STR.c_str(), ERROR_507_STR.size()));
}
BOOST_AUTO_TEST_SUITE_END() | [
"gdraal@gmail.com"
] | gdraal@gmail.com |
940f8b40ff4f7ab0641b732141402937b0199070 | 09a20466c1650ab4beb6554ceabc8649a7540c06 | /core/lib/soci/core/use.h | a1d225a220e9a4172b4796bc212dee8cac587e2f | [
"MIT",
"BSL-1.0"
] | permissive | LedgerHQ/lib-ledger-core | 2f1153655ed7c116b866d2b21920a8a3017f5d96 | ad1e271b5f61e92f663ff08c337acc8b107fc85f | refs/heads/main | 2023-07-09T18:24:41.408616 | 2023-07-06T13:09:06 | 2023-07-06T13:09:06 | 68,716,694 | 99 | 99 | MIT | 2023-06-30T08:36:20 | 2016-09-20T13:51:06 | C++ | UTF-8 | C++ | false | false | 2,245 | h | //
// Copyright (C) 2004-2008 Maciej Sobczak, Stephen Hutton
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
#ifndef SOCI_USE_H_INCLUDED
#define SOCI_USE_H_INCLUDED
#include "soci-backend.h"
namespace soci
{
namespace details
{
template <typename T, typename Indicator>
struct use_container
{
use_container(T &_t, Indicator &_ind, const std::string &_name)
: t(_t), ind(_ind), name(_name) {}
T &t;
Indicator &ind;
const std::string &name;
};
typedef void no_indicator;
template <typename T>
struct use_container<T, no_indicator>
{
use_container(T &_t, const std::string &_name)
: t(_t), name(_name) {}
T &t;
const std::string &name;
};
} // namespace details
template <typename T>
details::use_container<T, details::no_indicator> use(T &t, const std::string &name = std::string())
{ return details::use_container<T, details::no_indicator>(t, name); }
template <typename T>
details::use_container<const T, details::no_indicator> use(T const &t, const std::string &name = std::string())
{ return details::use_container<const T, details::no_indicator>(t, name); }
template <typename T>
details::use_container<T, indicator> use(T &t, indicator & ind, std::string const &name = std::string())
{ return details::use_container<T, indicator>(t, ind, name); }
template <typename T>
details::use_container<const T, indicator> use(T const &t, indicator & ind, std::string const &name = std::string())
{ return details::use_container<const T, indicator>(t, ind, name); }
// vector containers
template <typename T>
details::use_container<T, std::vector<indicator> >
use(T &t, std::vector<indicator> & ind, const std::string &name = std::string())
{ return details::use_container<T, std::vector<indicator> >(t, ind, name); }
template <typename T>
details::use_container<std::vector<T>, details::no_indicator >
use(std::vector<T> &t, const std::string &name = std::string())
{ return details::use_container<std::vector<T>, details::no_indicator>(t, name); }
} // namespace soci
#endif // SOCI_USE_H_INCLUDED
| [
"pollastri.p@gmail.com"
] | pollastri.p@gmail.com |
7c72560b70acca44ec51a48b9a84d94e655af732 | 88285ceef5821170f233ff9f77f4bafdaad2e0b5 | /Transpose matrix.cpp | 5ed1360b961101a58bc7fe999ef00937d4ade325 | [] | no_license | Farhan-19/Tugas_Kuliah-StrukturData | 6dbfb1e86a12da1a6ce9037b01dec5698101422e | 0eda3b22f01d774e7de6d6c0e97cbfff021f9c60 | refs/heads/master | 2022-04-13T20:39:28.658721 | 2020-04-06T14:49:40 | 2020-04-06T14:49:40 | 241,260,838 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 786 | cpp | #include <conio.h>
#include <iostream>
#include <math.h>
#include <windows.h>
using namespace std;
int main (int argc, char *argv[])
{
int A[2][2]={4, 2, 8, 10},T[2][2];
cout<< "======================================================="<<endl;
cout<< " Tranpose Matriks 2x2"<<endl;
cout<< "======================================================="<<endl;
cout <<endl<<"matriks A : "<<endl;
for(int i=0;i<2;i++){
for(int j=0;j<2;j++){
cout << A[i][j]<<" ";
}
cout<<endl;
}
cout << endl << "Transpose Matriks : "<< endl;
for(int i=0;i<2;i++){
for(int j=0;j<2;j++){
T[j][i] = A[i][j];
}
}
for(int i=0;i<2;i++){
for(int j=0;j<2;j++){
cout << T[i][j]<<" ";
}
cout << endl;
}
system ("PAUSE");
return 0;
}
| [
"noreply@github.com"
] | noreply@github.com |
04aa65e76bdd0b69a9a8c1f0cdaa5fcdaf27ab72 | 536656cd89e4fa3a92b5dcab28657d60d1d244bd | /content/browser/service_worker/service_worker_disk_cache.h | fcf52f57b60fe14e3506c16aa65ca84b64712cb7 | [
"BSD-3-Clause"
] | permissive | ECS-251-W2020/chromium | 79caebf50443f297557d9510620bf8d44a68399a | ac814e85cb870a6b569e184c7a60a70ff3cb19f9 | refs/heads/master | 2022-08-19T17:42:46.887573 | 2020-03-18T06:08:44 | 2020-03-18T06:08:44 | 248,141,336 | 7 | 8 | BSD-3-Clause | 2022-07-06T20:32:48 | 2020-03-18T04:52:18 | null | UTF-8 | C++ | false | false | 2,004 | h | // Copyright 2014 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef CONTENT_BROWSER_SERVICE_WORKER_SERVICE_WORKER_DISK_CACHE_H_
#define CONTENT_BROWSER_SERVICE_WORKER_SERVICE_WORKER_DISK_CACHE_H_
#include <stdint.h>
#include "base/memory/weak_ptr.h"
#include "content/browser/appcache/appcache_disk_cache.h"
#include "content/browser/appcache/appcache_disk_cache_ops.h"
#include "content/common/content_export.h"
namespace content {
// Wholesale reusage of the appcache code for response reading,
// writing, and storage. See the corresponding class in that
// library for doc comments and other details.
// TODO(michaeln): If this reuse sticks, refactor/move the
// resused classes to a more common location.
class CONTENT_EXPORT ServiceWorkerDiskCache : public AppCacheDiskCache {
public:
ServiceWorkerDiskCache();
};
class CONTENT_EXPORT ServiceWorkerResponseReader
: public AppCacheResponseReader {
protected:
// Should only be constructed by the storage class.
friend class ServiceWorkerStorage;
ServiceWorkerResponseReader(int64_t resource_id,
base::WeakPtr<AppCacheDiskCache> disk_cache);
};
class CONTENT_EXPORT ServiceWorkerResponseWriter
: public AppCacheResponseWriter {
protected:
// Should only be constructed by the storage class.
friend class ServiceWorkerStorage;
ServiceWorkerResponseWriter(int64_t resource_id,
base::WeakPtr<AppCacheDiskCache> disk_cache);
};
class CONTENT_EXPORT ServiceWorkerResponseMetadataWriter
: public AppCacheResponseMetadataWriter {
protected:
// Should only be constructed by the storage class.
friend class ServiceWorkerStorage;
ServiceWorkerResponseMetadataWriter(
int64_t resource_id,
base::WeakPtr<AppCacheDiskCache> disk_cache);
};
} // namespace content
#endif // CONTENT_BROWSER_SERVICE_WORKER_SERVICE_WORKER_DISK_CACHE_H_
| [
"pcding@ucdavis.edu"
] | pcding@ucdavis.edu |
d8d1c2cdd41d64cd4bb55c8ab9dd157e774d3cf3 | 552beffb39d296e35161c153be30c41fa5a989f0 | /VisionProcessingFramework/src/plugin_manager_wnd.cpp | d0ef91b870abfcc3bd4b400d901c00ff69d3a23c | [] | no_license | toriumi/toritest | c6cfaecabef28a30775deec1377e126580b65227 | 4259049746a694ee9a5939d45b6916015317fb34 | refs/heads/master | 2021-01-17T15:56:46.434527 | 2017-03-26T16:00:30 | 2017-03-26T16:00:30 | 82,935,382 | 0 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 10,286 | cpp | /**
* @file plugin_manager_wnd.cpp
* @brief Source for PluginManagerWnd class
* @author Vision Processing Community
* @copyright 2016 Vision Processing Community. All rights reserved.
*/
#include "./plugin_manager_wnd.h"
#include <string>
#include <vector>
#include "./logger.h"
#include "./plugin_edit_canvas.h"
#include "./plugin_manager_wnd_define.h"
BEGIN_EVENT_TABLE(PluginManagerWnd, wxFrame)
EVT_CLOSE(PluginManagerWnd::OnClose)
EVT_BUTTON(kButtonReloadId, PluginManagerWnd::OnReloadPluginList)
EVT_BUTTON(kButtonCommonId, PluginManagerWnd::OnOpenPluginSettingsWnd)
EVT_BUTTON(kButtonSavePluginFlowId, PluginManagerWnd::OnSavePluginFlow)
EVT_BUTTON(kButtonLoadPluginFlowId, PluginManagerWnd::OnLoadPluginFlow)
END_EVENT_TABLE()
/**
* @brief
* Constructor.
* @param plugin_manager [in] pointer to the plugin_manager class.
* @param thread_running_cycle_manager [in] pointer to the
* ThreadRunningCycleManager class.
*/
PluginManagerWnd::PluginManagerWnd(
PluginManager *plugin_manager,
ThreadRunningCycleManager *thread_running_cycle_manager)
: wxFrame(NULL, kWndId, wxT(kWndTitle), wxPoint(kWndPointX, kWndPointY),
wxSize(kWndSizeW, kWndSizeH), wxDEFAULT_FRAME_STYLE) {
/* PluginManager class object creation.*/
plugin_manager_ = plugin_manager;
/* UI creation */
list_box_plugin_list_ =
new wxListBox(this, kListBoxPluginListId, wxDefaultPosition,
wxSize(kListBoxPluginListSizeW, kListBoxPluginListSizeH));
button_reload_ =
new wxButton(this, kButtonReloadId, wxT(kButtonReloadName),
wxPoint(kButtonReloadPointX, kButtonReloadPointY),
wxSize(kButtonReloadSizeW, kButtonReloadSizeH));
button_plugin_settings_ =
new wxButton(this, kButtonCommonId, wxT(kButtonCommonName),
wxPoint(kButtonCommonPointX, kButtonCommonPointY),
wxSize(kButtonCommonSizeW, kButtonCommonSizeH));
button_save_plugin_flow_ = new wxButton(
this, kButtonSavePluginFlowId, wxT(kStaticTextSaveFlowName),
wxPoint(kButtonReloadPointX + kButtonReloadSizeW +
(kEditCanvasScreenWidth - kButtonSaveLoadFlowSizeW * 2),
kButtonReloadPointY),
wxSize(kButtonSaveLoadFlowSizeW, kButtonReloadSizeH));
button_load_plugin_flow_ = new wxButton(
this, kButtonLoadPluginFlowId, wxT(kStaticTextLoadFlowName),
wxPoint(kButtonReloadPointX + kButtonReloadSizeW +
(kEditCanvasScreenWidth - kButtonSaveLoadFlowSizeW),
kButtonReloadPointY),
wxSize(kButtonSaveLoadFlowSizeW, kButtonReloadSizeH));
flow_edit_canvas_ =
new PluginEditCanvas(this, wxID_ANY, thread_running_cycle_manager);
flow_edit_canvas_->SetPluginManagerInfo(plugin_manager);
flow_edit_canvas_->Show(true);
wxBoxSizer *sizer_top = new wxBoxSizer(wxVERTICAL);
wxBoxSizer *sizer_button_col1 = new wxBoxSizer(wxHORIZONTAL);
wxBoxSizer *sizer_button_col2 = new wxBoxSizer(wxHORIZONTAL);
sizer_button_col1->Add(button_plugin_settings_, 0, wxALL, 3);
sizer_button_col1->Add(button_reload_, 0, wxALL, 3);
sizer_button_col2->Add(button_save_plugin_flow_, 0, wxALL, 3);
sizer_button_col2->Add(button_load_plugin_flow_, 0, wxALL, 3);
wxFlexGridSizer *sizer_flex = new wxFlexGridSizer(2, 3);
sizer_flex->Add(new wxStaticText(this, kStaticTextPluginListId,
wxT(kStaticTextPluginListName)),
0, wxALIGN_LEFT | wxALL, 3);
sizer_flex->Add(
new wxStaticText(this, kStaticTextFlowId, wxT(kStaticTextFlowName)), 0,
wxALIGN_LEFT | wxALL, 3);
sizer_flex->Add(list_box_plugin_list_, 0, wxEXPAND | wxALIGN_LEFT | wxALL, 3);
sizer_flex->Add(flow_edit_canvas_, 0, wxEXPAND | wxALIGN_LEFT | wxALL, 3);
sizer_flex->Add(sizer_button_col1, 0, wxALIGN_RIGHT | wxALL, 3);
sizer_flex->Add(sizer_button_col2, 0, wxALIGN_RIGHT | wxALL, 3);
sizer_flex->AddGrowableCol(1);
sizer_flex->AddGrowableRow(1);
sizer_top->Add(sizer_flex, 1, wxALL | wxEXPAND);
SetSizerAndFit(sizer_top);
this->SetSize(wxSize(kWndSizeW, kWndSizeH));
}
/**
* @brief
* Destructor.
*/
PluginManagerWnd::~PluginManagerWnd() { delete flow_edit_canvas_; }
void PluginManagerWnd::OnClose(wxCloseEvent &event) {
this->Show(false);
flow_edit_canvas_->Reset();
}
void PluginManagerWnd::OnReloadPluginList(wxCommandEvent &event) {
DEBUG_PRINT("PluginManagerWnd::OnReloadPluginList\n");
LOG_STATUS("Reload all plugins");
flow_edit_canvas_->Reset();
ReloadPluginListFromFile();
}
void PluginManagerWnd::OnOpenPluginSettingsWnd(wxCommandEvent &event) {
unsigned int list_selection_num = wxNOT_FOUND;
std::string plugin_name;
PluginBase *plugin;
DEBUG_PRINT("PluginManagerWnd::OnOpenCommonSettings\n");
list_selection_num = list_box_plugin_list_->GetSelection();
if (list_selection_num != wxNOT_FOUND) {
plugin_name = std::string(
list_box_plugin_list_->GetString(list_selection_num).mb_str());
plugin = plugin_manager_->GetPlugin(plugin_name);
plugin->OpenSettingWindow(image_proc_state_);
}
}
/**
* @brief
* Add a plugin into the list box.
* @param plugin_name [in] name of the target plugin.
*/
void PluginManagerWnd::AddPluginNameToPluginList(
const std::string plugin_name) {
wxArrayString wx_array_string;
wxString wx_string(plugin_name.c_str(), wxConvUTF8);
wx_array_string.Add(wx_string);
list_box_plugin_list_->InsertItems(wx_array_string, 0);
}
/**
* @brief
* Remove a plugin from the list box.
* @param plugin_name [in] name of the target plugin.
*/
void PluginManagerWnd::RemovePluginNameFromPluginList(
const std::string plugin_name) {
wxString wx_string(plugin_name.c_str(), wxConvUTF8);
int index = wxNOT_FOUND;
index = list_box_plugin_list_->FindString(wx_string);
if (index != wxNOT_FOUND) {
list_box_plugin_list_->Delete(index);
}
}
/**
* @brief
* Find a plugin from the list box.
* @param plugin_name [in] name of the target plugin.
* @return true, if the plugin is found.
*/
bool PluginManagerWnd::FindPluginNameFromPluginList(
const std::string plugin_name) {
wxString wx_string(plugin_name.c_str(), wxConvUTF8);
int index = wxNOT_FOUND;
index = list_box_plugin_list_->FindString(wx_string);
if (index == wxNOT_FOUND) {
return false;
}
return true;
}
/**
* @brief
* Remove all plugin from the list box.
*/
void PluginManagerWnd::RemoveAllPluginNameFromPluginList(void) {
list_box_plugin_list_->Clear();
}
/**
* @brief
* Set the ImageProcessingState.
* @param image_proc_state [in] ImageProcessingState.
* @return image processing state.
*/
void PluginManagerWnd::set_image_proc_state(
ImageProcessingState image_proc_state) {
image_proc_state_ = image_proc_state;
if (image_proc_state_ == kStop) {
button_reload_->Enable(true);
flow_edit_canvas_->Enable(true);
button_save_plugin_flow_->Enable(true);
button_load_plugin_flow_->Enable(true);
} else if ((image_proc_state_ == kRun) || (image_proc_state_ == kPause)) {
button_reload_->Disable();
flow_edit_canvas_->Reset();
button_save_plugin_flow_->Disable();
button_load_plugin_flow_->Disable();
}
flow_edit_canvas_->set_image_proc_state(image_proc_state);
flow_edit_canvas_->PostUpdateCanvasEvent();
}
/**
* @brief
* Get the ImageProcessingState.
* @return image processing state.
*/
ImageProcessingState PluginManagerWnd::image_proc_state(void) {
return image_proc_state_;
}
/**
* @brief
* Replad all plugins.
* @return image processing state.
*/
void PluginManagerWnd::ReloadPluginListFromFile(void) {
std::string prev_root_plugin_name = "";
// get root plugin name before reload process.
if (plugin_manager_->root_plugin() != NULL) {
prev_root_plugin_name = plugin_manager_->root_plugin()->plugin_name();
} else {
return;
}
/* Reload Plugin list.*/
plugin_manager_->LoadPlugins(kPluginPath, true);
/* Set root plugin according to the following priority. */
/* 1.Previous root plugin */
/* 2.Bin plugin */
/* 3.Sensor plugin */
/* If these plugins do not exist, not set root plugin. */
PluginBase *prev_root_plugin =
plugin_manager_->GetPlugin(prev_root_plugin_name);
bool is_success = false;
if (prev_root_plugin != NULL) {
if (prev_root_plugin_name != "") {
is_success = plugin_manager_->set_root_plugin(prev_root_plugin_name);
if (is_success) {
DEBUG_PRINT(
"PluginManagerWnd::ReloadPluginList update root plugin(same as "
"prev) success.\n");
} else {
DEBUG_PRINT(
"PluginManagerWnd::ReloadPluginList update root plugin(same as "
"prev) fail.\n");
}
}
}
flow_edit_canvas_->SetPluginManagerInfo(plugin_manager_);
flow_edit_canvas_->PostUpdateCanvasEvent();
}
/**
* @brief
* Reset a list box and canvas.
* @return image processing state.
*/
void PluginManagerWnd::ResetPluginList(void) {
flow_edit_canvas_->RemovePluginFlowList(wxPoint(0, 0));
/* RemoveAllPluginNameFromPluginList();*/
flow_edit_canvas_->SetPluginManagerInfo(plugin_manager_);
flow_edit_canvas_->PostUpdateCanvasEvent();
}
void PluginManagerWnd::OnSavePluginFlow(wxCommandEvent &event) {
LOG_STATUS("Save plugin flow");
wxFileDialog *SaveDialog = new wxFileDialog(
this, _("Save flow file"), wxEmptyString, wxEmptyString, wxT("*.flow"),
wxFD_SAVE | wxFD_OVERWRITE_PROMPT, wxDefaultPosition);
/* Creates a "open file" dialog*/
if (SaveDialog->ShowModal() == wxID_OK) {
wxString wxPathName;
/* file open*/
wxPathName = SaveDialog->GetPath();
if (wxPathName.Find(wxT(".flow")) == wxNOT_FOUND) {
wxPathName += wxT(".flow");
}
flow_edit_canvas_->SavePluginFlowToFile(wxPathName);
}
}
void PluginManagerWnd::OnLoadPluginFlow(wxCommandEvent &event) {
LOG_STATUS("Load plugin flow");
wxFileDialog *LoadDialog = new wxFileDialog(
this, _("Choose a file to open"), wxEmptyString, wxEmptyString,
wxT("*.flow"), wxFD_OPEN, wxDefaultPosition);
/* Creates a "open file" dialog*/
if (LoadDialog->ShowModal() == wxID_OK) {
wxString wxPathName;
/* file open*/
wxPathName = LoadDialog->GetPath();
flow_edit_canvas_->LoadPluginFlowFromFile(wxPathName);
}
}
| [
"initial.st@gmail.com"
] | initial.st@gmail.com |
b6209237d2772a059fc5a300e395ad48e3a5586d | 80c35a3cf98cc9614a2904953179ee975d2a7ec3 | /source/engine/renderer/static_model_renderer.cpp | d1a03cec29617bc7ccb97fa501c1408f31db4cf6 | [] | no_license | aiekick/fast_vulkan | 6e723730fef5432c75cbfa5f874f7bec7f4ca124 | ccbddcda964fd268ff4adde0a866a4d9c082478a | refs/heads/master | 2022-02-26T16:01:49.084272 | 2019-09-28T20:45:41 | 2019-09-30T03:59:46 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 11,381 | cpp | #include "static_model_renderer.h"
#include <assert.h>
#include "../mesh/util.h"
#include "../app/system_mgr.h"
#include "../debug_draw/debug_draw.hpp"
namespace renderer
{
StaticModelRenderer::StaticModelRenderer(std::shared_ptr<vkapi::Context> vkCtx, std::shared_ptr<camera::FreeCamera> camera)
: d_vkCtx(vkCtx)
, d_camera(camera)
{
assert(d_camera);
assert(d_vkCtx);
d_viewport = vkCtx->viewport();
d_renderArea = vkCtx->renderArea();
d_mvp.model = glm::mat4(1.0f);
d_mvp.view = d_camera->view();
d_mvp.proj = d_camera->proj();
}
StaticModelRenderer::~StaticModelRenderer()
{
if (d_vertexInput.vbo)
{
//d_vkCtx->vkDevice().destroySampler(d_ubo.cubemapSampler);
//d_vkCtx->vkDevice().destroyImageView(d_ubo.cubemapView);
d_vkCtx->vkDevice().destroyDescriptorSetLayout(d_ubo.descriptorSetLayout);
d_vkCtx->vkDevice().freeDescriptorSets(d_vkCtx->vkDescriptorPool(), d_ubo.descriptorSet);
d_vkCtx->vkDevice().destroyPipelineLayout(d_ubo.pipelineLayout);
d_vkCtx->vkDevice().destroyPipeline(d_pipeline.pipeline);
if (d_pipeline.pipelineCache)
{
d_vkCtx->vkDevice().destroyPipelineCache(d_pipeline.pipelineCache);
}
d_vkCtx->vkDevice().destroyShaderModule(d_pipeline.vs);
d_vkCtx->vkDevice().destroyShaderModule(d_pipeline.fs);
}
}
void StaticModelRenderer::setCamera(std::shared_ptr<camera::FreeCamera> cam)
{
assert(cam);
d_camera = cam;
}
void StaticModelRenderer::setViewport(int x, int y, int width, int height)
{
d_viewport.x = x;
d_viewport.y = y;
d_viewport.width = width;
d_viewport.height = height;
}
void StaticModelRenderer::setModel(std::shared_ptr<mesh::StaticModel> model, const glm::mat4& transform)
{
d_input.smodel = model;
d_input.transform = transform;
//d_mvp.model = transform;
}
bool StaticModelRenderer::build(bool clear_host_data)
{
if (!d_input.smodel)
{
SDL_Log("set input first");
return false;
}
if (!buildVBO())
{
return false;
}
buildIBO();
buildUBO();
buildPipeline();
if (clear_host_data)
{
d_input.smodel = nullptr;
}
}
void StaticModelRenderer::render()
{
if (!d_vertexInput.vbo)
{
SDL_Log("did not have vbo built, skip rendering.");
return;
}
d_mvp.view = d_camera->view();
d_mvp.proj = d_camera->proj();
d_vkCtx->upload(*d_ubo.mvp_buffer, &d_mvp, sizeof(MVP));
auto cmd = d_vkCtx->commandBuffer();
cmd.setViewport(0, 1, &d_viewport);
cmd.setScissor(0, 1, &d_renderArea);
cmd.bindPipeline(vk::PipelineBindPoint::eGraphics, d_pipeline.pipeline);
cmd.bindDescriptorSets(
vk::PipelineBindPoint::eGraphics,
d_ubo.pipelineLayout,
0, d_ubo.descriptorSet,
nullptr
);
for (int i = 0; i < d_vertexInput.offsets.size(); ++i)
{
cmd.bindVertexBuffers(0, d_vertexInput.vbo->buffer, d_vertexInput.offsets[i]);
cmd.bindIndexBuffer(d_indexInput.ibos[i]->buffer, 0, vk::IndexType::eUint32);
cmd.drawIndexed(d_indexInput.index_count[i], 1, 0, 0, 0);
}
//d_tree->traverse([this](const glm::vec3& min, const glm::vec3& max, std::vector<octree::DrawMeshData>* data) {
// static glm::vec3 color(1.0, 0.0, 0.0);
// dd::aabb(*((ddVec3_In*)& min), *((ddVec3_In*)& max), *((ddVec3_In*)& color));
// if (data)
// {
// auto& stuff = *data;
// for (auto& elem : stuff)
// {
// //cmd.bindVertexBuffers(0, elem.vbo->buffer, elem.vbo_offset);
// //cmd.bindIndexBuffer(elem.ibo->buffer, vk::DeviceSize(0), vk::IndexType::eUint32);
// //cmd.drawIndexed(elem.draw_index_count, 1, 0,/* elem.vbo_offset*/0, 0);
// }
// }
// return true;
//});
}
// HELPERS
bool StaticModelRenderer::buildVBO()
{
std::vector<mesh::Vertex> result;
std::vector<mesh::Vertex> tmp;
std::size_t offset = 0;
for (auto& mesh : d_input.smodel->meshes())
{
mesh::Utility::transformPointCloud(*mesh, d_input.transform);
mesh::Utility::computeNormals(*mesh, true);
mesh::Utility::createVertexArray(*mesh, tmp);
d_vertexInput.offsets.push_back(offset);
std::copy(tmp.begin(), tmp.end(), std::back_inserter(result));
offset += tmp.size() * sizeof(mesh::Vertex);
}
offset = 0;
d_vertexInput.inputBinding.binding = 0;
d_vertexInput.inputBinding.stride = sizeof(mesh::Vertex);
d_vertexInput.inputBinding.inputRate = vk::VertexInputRate::eVertex;
d_vertexInput.inputAttributes.resize(3);
d_vertexInput.inputAttributes[0].binding = 0;
d_vertexInput.inputAttributes[0].location = 0;
d_vertexInput.inputAttributes[0].format = vk::Format::eR32G32B32Sfloat;
d_vertexInput.inputAttributes[0].offset = offset;
offset += sizeof(mesh::Position);
d_vertexInput.inputAttributes[1].binding = 0;
d_vertexInput.inputAttributes[1].location = 1;
d_vertexInput.inputAttributes[1].format = vk::Format::eR32G32B32Sfloat;
d_vertexInput.inputAttributes[1].offset = offset;
offset += sizeof(mesh::Normal);
d_vertexInput.inputAttributes[2].binding = 0;
d_vertexInput.inputAttributes[2].location = 2;
d_vertexInput.inputAttributes[2].format = vk::Format::eR32G32B32A32Sfloat;
d_vertexInput.inputAttributes[2].offset = offset;
offset += sizeof(mesh::Color);
//d_vertexInput.inputAttributes[3].binding = 0;
//d_vertexInput.inputAttributes[3].location = 3;
//d_vertexInput.inputAttributes[3].format = vk::Format::eR32G32Sfloat;
//d_vertexInput.inputAttributes[3].offset = offset;
//offset += sizeof(mesh::UV);
// TODO:
d_vertexInput.vbo = d_vkCtx->createVertexBufferObject(result);
d_vertexInput.inputState = vk::PipelineVertexInputStateCreateInfo(
vk::PipelineVertexInputStateCreateFlags(),
1,
&d_vertexInput.inputBinding,
static_cast<uint32_t>(d_vertexInput.inputAttributes.size()),
d_vertexInput.inputAttributes.data()
);
//d_tree = std::make_unique<octree::DrawMeshOctree>(glm::vec3{ -1000.0f, -1000.0f, -1000.0f }, 2000.0f, 10);
//for (size_t i = 0; i < d_input.smodel->meshes().size(); ++i)
//{
// auto& mesh = d_input.smodel->meshes()[i];
// auto& vertices = mesh->positions;
// auto& indices = mesh->indices;
// for (size_t ii = 0; ii < indices.size(); ii += 3)
// {
// auto pt = vertices[indices[ii]];
// octree::DrawMeshOctree::ErrorCode err;
// auto& data = d_tree->push(pt, err);
// data.resize(d_input.smodel->meshes().size());
// data[i].vbo = d_vertexInput.vbo;
// data[i].vbo_offset = d_vertexInput.offsets[i];
// if (err == 0)
// {
// data[i].ibo_host.push_back(indices[ii]);
// data[i].ibo_host.push_back(indices[ii + 1]);
// data[i].ibo_host.push_back(indices[ii + 2]);
// }
// }
//}
//d_tree->linearProcess([this](octree::DrawMeshNode& node) {
// assert(node.childrenFlags == 0);
// //for (auto& elem : *node.data)
// //{
// // elem.ibo = d_vkCtx->createIndexBufferObject(elem.ibo_host);
// // elem.draw_index_count = elem.ibo_host.size();
// // elem.ibo_host.clear();
// //}
//}, true);
return true;
}
void StaticModelRenderer::buildIBO()
{
auto& meshes = d_input.smodel->meshes();
for (int i = 0; i < meshes.size(); ++i)
{
d_indexInput.index_count.push_back(meshes[i]->indices.size());
d_indexInput.ibos.push_back(d_vkCtx->createIndexBufferObject(meshes[i]->indices));
}
}
void StaticModelRenderer::buildUBO()
{
d_ubo.mvp_buffer = d_vkCtx->createUniformBufferObject(sizeof(MVP));
d_ubo.layoutBindings = {
vk::DescriptorSetLayoutBinding(
0, vk::DescriptorType::eUniformBuffer,
1, vk::ShaderStageFlagBits::eVertex
)
};
d_ubo.descriptorSetLayout =
d_vkCtx->vkDevice().createDescriptorSetLayout(vk::DescriptorSetLayoutCreateInfo(
vk::DescriptorSetLayoutCreateFlags(),
static_cast<uint32_t>(d_ubo.layoutBindings.size()),
d_ubo.layoutBindings.data()
));
d_ubo.descriptorSet =
d_vkCtx->vkDevice().allocateDescriptorSets(vk::DescriptorSetAllocateInfo(
d_vkCtx->vkDescriptorPool(),
1, &d_ubo.descriptorSetLayout
))[0];
//vk::PushConstantRange pushConstantRange(
// vk::ShaderStageFlagBits::eFragment,
// 0, sizeof(float)
//);
d_ubo.pipelineLayout =
d_vkCtx->vkDevice().createPipelineLayout(vk::PipelineLayoutCreateInfo(
vk::PipelineLayoutCreateFlags(),
1, &d_ubo.descriptorSetLayout,
0, nullptr
));
d_ubo.mvp_buffer_info.buffer = d_ubo.mvp_buffer->buffer;
d_ubo.mvp_buffer_info.range = sizeof(MVP);
d_ubo.mvp_buffer_info.offset = 0;
d_ubo.writeDescriptorSets = {
vk::WriteDescriptorSet(d_ubo.descriptorSet, 0, 0, 1,
vk::DescriptorType::eUniformBuffer, nullptr, &d_ubo.mvp_buffer_info
)
};
d_vkCtx->vkDevice().updateDescriptorSets(d_ubo.writeDescriptorSets, nullptr);
}
void StaticModelRenderer::buildPipeline()
{
//shader
//TODO:
d_pipeline.vs = d_vkCtx->createShaderModule(
app::SystemMgr::instance().settings().shader_dir + "model.vert.spv"
);
d_pipeline.fs = d_vkCtx->createShaderModule(
app::SystemMgr::instance().settings().shader_dir + "model.frag.spv"
);
d_pipeline.shaderCreateInfos = {
vk::PipelineShaderStageCreateInfo(
vk::PipelineShaderStageCreateFlags(),
vk::ShaderStageFlagBits::eVertex,
d_pipeline.vs, "main"
),
vk::PipelineShaderStageCreateInfo(
vk::PipelineShaderStageCreateFlags(),
vk::ShaderStageFlagBits::eFragment,
d_pipeline.fs, "main"
)
};
// setup fix functions
auto assemblyState = vk::PipelineInputAssemblyStateCreateInfo(
vk::PipelineInputAssemblyStateCreateFlags(),
vk::PrimitiveTopology::eTriangleList
);
auto viewportState = vk::PipelineViewportStateCreateInfo(
vk::PipelineViewportStateCreateFlags(),
1, &d_viewport,
1, &d_renderArea
);
auto rasterState = vk::PipelineRasterizationStateCreateInfo(
vk::PipelineRasterizationStateCreateFlags(),
VK_FALSE,
VK_FALSE,
vk::PolygonMode::eFill,
vk::CullModeFlagBits::eNone,
vk::FrontFace::eCounterClockwise,
VK_FALSE,
0,
0,
0,
1.0f
);
auto multisampleState = vk::PipelineMultisampleStateCreateInfo(
vk::PipelineMultisampleStateCreateFlags(),
vk::SampleCountFlagBits::e1
);
auto depthStencilState = vk::PipelineDepthStencilStateCreateInfo(
vk::PipelineDepthStencilStateCreateFlags(),
VK_TRUE,
VK_TRUE,
vk::CompareOp::eLessOrEqual,
VK_FALSE,
VK_FALSE,
vk::StencilOpState(),
vk::StencilOpState(),
0,
0
);
auto colorBlendAttachment = vk::PipelineColorBlendAttachmentState(
VK_FALSE,
vk::BlendFactor::eZero,
vk::BlendFactor::eOne,
vk::BlendOp::eAdd,
vk::BlendFactor::eZero,
vk::BlendFactor::eZero,
vk::BlendOp::eAdd,
vk::ColorComponentFlags(vk::ColorComponentFlagBits::eR |
vk::ColorComponentFlagBits::eG |
vk::ColorComponentFlagBits::eB |
vk::ColorComponentFlagBits::eA)
);
auto colorBlendState = vk::PipelineColorBlendStateCreateInfo(
vk::PipelineColorBlendStateCreateFlags(),
VK_FALSE,
vk::LogicOp::eClear,
1, &colorBlendAttachment
);
auto dynamicStateList = std::vector<vk::DynamicState>{
vk::DynamicState::eViewport,
vk::DynamicState::eScissor,
};
auto dynamicState = vk::PipelineDynamicStateCreateInfo(
vk::PipelineDynamicStateCreateFlags(),
static_cast<uint32_t>(dynamicStateList.size()),
dynamicStateList.data()
);
d_pipeline.pipeline = d_vkCtx->vkDevice().createGraphicsPipeline(
d_pipeline.pipelineCache,
vk::GraphicsPipelineCreateInfo(
vk::PipelineCreateFlags(),
static_cast<uint32_t>(d_pipeline.shaderCreateInfos.size()),
d_pipeline.shaderCreateInfos.data(),
&d_vertexInput.inputState,
&assemblyState,
nullptr,
&viewportState,
&rasterState,
&multisampleState,
&depthStencilState,
&colorBlendState,
&dynamicState,
d_ubo.pipelineLayout,
d_vkCtx->defaultRenderPass(),
0
)
);
}
} // end namespace renderer | [
"bobluoluo@hotmail.com"
] | bobluoluo@hotmail.com |
d36a38669d11e606d8b30aa94f25128eca64585f | 1ee3043a86bd681ac591d68b404c6924604d90fb | /src/util_opengl.cpp | 725aa5de8a0d600e104c0e4118f9883349e34c2e | [] | no_license | bosouza/ship-fight | 2e1008efacd3b24dc260759cf78df558d464ac68 | d80988c51ef56b40296c6397414b8edb52c66f9f | refs/heads/master | 2022-06-10T03:36:39.247384 | 2019-12-09T23:05:43 | 2019-12-09T23:05:43 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,005 | cpp | #include <util_opengl.h>
#include <bits/stdc++.h>
#define GLEW_STATIC
#include "GL/glew.h"
#include "GLFW/glfw3.h"
std::string readFile(const char *filePath)
{
std::string content;
std::ifstream fileStream(filePath, std::ios::in);
if (!fileStream.is_open())
{
std::cerr << "Could not read file " << filePath << ". File does not exist." << std::endl;
return "";
}
std::string line = "";
while (!fileStream.eof())
{
std::getline(fileStream, line);
content.append(line + "\n");
}
fileStream.close();
return content;
}
void testCompileShader(unsigned int shader)
{
int success;
char infoLog[512];
glGetShaderiv(shader, GL_COMPILE_STATUS, &success);
if (!success)
{
glGetShaderInfoLog(shader, 512, NULL, infoLog);
std::cout << "shader compilation failed" << std::endl
<< infoLog << std::endl;
throw;
}
}
//TODO: make this a void function (for some reason the glProgram doesn't compile if I change the return type)
std::string testCompileProgram(unsigned int program)
{
int success;
char infoLog[512];
glGetProgramiv(program, GL_COMPILE_STATUS, &success);
if (!success)
{
glGetProgramInfoLog(program, 512, NULL, infoLog);
std::cout << "program compilation failed" << std::endl
<< infoLog << std::endl;
throw;
}
return "";
}
// void testCompileProgram(unsigned int program)
// {
// int success;
// char infoLog[512];
// glGetProgramiv(program, GL_COMPILE_STATUS, &success);
// if (!success)
// {
// glGetProgramInfoLog(program, 512, NULL, infoLog);
// std::cout << "program compilation failed" << std::endl
// << infoLog << std::endl;
// throw;
// }
// }
unsigned int createVertexShader(const char *path)
{
return createShader(GL_VERTEX_SHADER, path);
}
unsigned int createFragShader(const char *path)
{
return createShader(GL_FRAGMENT_SHADER, path);
}
unsigned int createShader(unsigned int type, const char *path)
{
std::string src = readFile(path);
const char *src_ptr = src.c_str();
unsigned int shaderID;
shaderID = glCreateShader(type);
glShaderSource(shaderID, 1, &src_ptr, NULL);
glCompileShader(shaderID);
try
{
testCompileShader(shaderID);
}
catch (std::string e)
{
std::cout << path << ": " << e;
throw;
}
return shaderID;
}
unsigned int createVBO(float buffer[], unsigned int size)
{
unsigned int VBO;
glGenBuffers(1, &VBO);
glBindBuffer(GL_ARRAY_BUFFER, VBO);
glBufferData(GL_ARRAY_BUFFER, size * sizeof(float), buffer, GL_STATIC_DRAW);
return VBO;
}
unsigned int createAndBindVAO()
{
unsigned int VAO;
glGenVertexArrays(1, &VAO);
glBindVertexArray(VAO);
return VAO;
}
void bindViewport(viewport v)
{
glViewport(v.lowerLeftCorner.first, v.lowerLeftCorner.second, v.width, v.height);
} | [
"bruno.souza@sap.com"
] | bruno.souza@sap.com |
c2d8328d6a677ae6dbd7ed87e3d122236862d9a4 | 56fadd70c1311a2a1914a4d25e732b466bc44d62 | /problems/graphs-exercises/incidence-matrix/directed-graph-successors-predecessors-neighbours-of-a-node.cpp | 0767db61cbea0b3425cd0771e16b6500ac860e35 | [] | no_license | dandelionn/algorithms | f618f2df0e3c1836fb2add8e948aaf2c053036f9 | 895f5270617ebb894810c3d263de7626acf4b675 | refs/heads/master | 2021-06-22T01:59:21.256980 | 2020-11-12T20:56:49 | 2020-11-12T20:56:49 | 134,471,219 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 998 | cpp | #include <iostream>
#include <fstream>
using namespace std;
ifstream f("graf6.in");
void succesori(int a[][20],int n,int m,int y,int s[])
{
int g=0,i,j;
for(j=1;j<=m;j++)
if(a[y][j]==-1)
for(i=1;i<=n;i++)
if(i!=y&&a[i][j]==1)
s[i]=1;
}
void predecesori(int a[][20],int n,int m,int y,int p[])
{
int g=0,i,j,nr=0;
for(j=1;j<=m;j++)
if(a[y][j]==1)
for(i=1;i<=n;i++)
if(i!=y&&a[i][j]==-1)
p[i]=1;
}
void vecini(int s[],int p[],int n)
{
int k;
for(k=1;k<=n;k++)
if(s[k]||p[k])
cout<<k<<' ';
}
int main()
{
int a[20][20],n,m,i,j,y,s[20],p[20];
f>>n>>m;
for(i=1;i<=n;i++)
for(j=1;j<=m;j++)
f>>a[i][j];
for(i=1;i<=n;i++)
{s[i]=0;p[i]=0;}
cout<<"nodul ";cin>>y;
succesori(a,n,m,y,s);
predecesori(a,n,m,y,p);
cout<<"Vecinii nodului "<<y<<" sunt: ";
vecini(s,p,n);
f.close();
}
| [
"michea.paul@yahoo.com"
] | michea.paul@yahoo.com |
3773ee887c4e6458b16cb6e6b7f34ab003048e87 | 8a71e93f6dcda2428999143370d5fe4219327d3f | /solutions/QvrF6spF.cpp | 5ef5887f6015ed5fea78d7ce31b8714f22376dc8 | [
"MIT"
] | permissive | randauto/cpp-solutions | 21dce36fd4e10dbea3945d37be0cb2510210d446 | 627397fb887654e9f5ee64cfb73d708f6f6706f7 | refs/heads/main | 2023-09-02T11:15:20.336637 | 2021-11-18T01:03:00 | 2021-11-18T01:03:00 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 860 | cpp | /*
Sưu tầm bởi @nguyenvanhieuvn
Thực hành nhiều bài tập hơn tại https://luyencode.net/
*/
#include<stdio.h>
#include<conio.h>
float deQuy(int n) // đệ quy
{
if(n == 1)
return 0.5;
return deQuy(n - 1) + 1.0 / (n * (n + 1));
}
float deQuyDuoi(int n, float x = 0.5) // đệ quy đuôi
{
if(n == 1)
return x;
return deQuyDuoi(n - 1, x + 1.0 / (n * (n + 1)));
}
float khuDeQuy(int n) // khử đệ quy
{
int i = 1;
float S = 0;
while(i <= n)
{
S = S + 1.0 / (i * (i + 1));
i++;
}
return S;
}
int main()
{
int n;
printf("\nNhap n: "); scanf("%d", &n);
printf("\nDe quy(%d) = %f", n, deQuy(n));
printf("\nDe quy duoi(%d) = %f", n, deQuyDuoi(n));
printf("\nKhu de quy(%d) = %f", n, khuDeQuy(n));
getch();
return 0;
} | [
"hieunv.dev@gmail.com"
] | hieunv.dev@gmail.com |
c49f810649e531847130d5d1c35e8eeed7faa925 | 20bbc0c224f86faa9634ee696c5ec04c095ce174 | /2---mdgp/integer_matrix_entries/MSA/main_grouping_sa.cpp | 90c36f47b4c4fe0cc9a438e5d86f9c3752d2a7b0 | [] | no_license | wangyang2014/Combinatorial-optimization | 51a282d1b8162e3e25b9e004fa489516dbed6f04 | cb1cfb9c312468d3bc140b76b4a741337cde62df | refs/heads/master | 2020-04-08T23:26:08.274495 | 2018-11-30T13:05:36 | 2018-11-30T13:05:36 | 159,824,321 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,696 | cpp | #include <alloc.h>
#include <process.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
typedef struct
{long value; /* solution value */
double time_to_best; /* time to the SA best solution, secs */
double total_time; /* total time, secs */
}Results;
void grouping_sa(char *,char *,double,long,Results *);
void main(int argc,char **argv)
{FILE *out;
Results *pres;
char in_file_name[80];
char out_file_name[80];
char out_file_name_init[80];
char summary_file_name[80];
char bkv_string[80];
int i,j,k;
int count;
long time_limit;
long max_value=-1,best_known_value=0;
long dif_best;
double seeds [11]={0, 1000, 2000, 3000, 4000, 5000, 6000, 7000,
8000, 9000, 10000};
char numbs[31][2]={ {'0'}, {'1'}, {'2'}, {'3'}, {'4'}, {'5'},
{'6'}, {'7'}, {'8'}, {'9'}, {'1','0'} };
char res_ext[4]={'.', 'r', 'e', 's'};
double av_value=0.,av_time=0.,av_time_tot=0.;
double dif_aver;
if (argc<=3) {printf(" specify data, output and summary files");exit(1);}
strcpy(in_file_name,argv[1]);
strcpy(out_file_name_init,argv[2]);
strcpy(summary_file_name,argv[3]);
if (argc==5)
{strcpy(bkv_string,argv[4]);best_known_value=atol(bkv_string);}
pres=(Results *)calloc(1,sizeof(Results));
if ((out=fopen(summary_file_name,"w"))==NULL)
{printf(" fopen failed for output %s",summary_file_name);exit(1);}
time_limit=600;count=10;
for (i=1;i<=count;i++)
{strcpy(out_file_name,out_file_name_init);
k=strlen(out_file_name);
out_file_name[k]='_';k++;
if (i<10) out_file_name[k]=numbs[i][0];
else {out_file_name[k]=numbs[i][0];k++;out_file_name[k]=numbs[i][1];}
for (j=0;j<=3;j++) out_file_name[k+j+1]=res_ext[j];
out_file_name[k+j+1]='\0';
grouping_sa(in_file_name,out_file_name,seeds[i],time_limit,pres);
fprintf(out," %8ld %8lf %8lf\n",pres->value,
pres->time_to_best,pres->total_time);
av_value+=pres->value;
av_time+=pres->time_to_best;av_time_tot+=pres->total_time;
if (pres->value>max_value) max_value=pres->value;
}
av_value/=count;av_time/=count;av_time_tot/=count;
fprintf(out,"----------------------------------------\n");
fprintf(out,"%11.3lf %11.3lf %11.3lf\n",av_value,av_time,av_time_tot);
fprintf(out,"maximum value over all runs = %8ld \n",max_value);
if (argc==5)
{dif_best=best_known_value-max_value;dif_aver=best_known_value-av_value;
fprintf(out,"best known value = %8ld \n",best_known_value);
fprintf(out,"dif_best = %8ld dif_aver = %8lf\n",dif_best,dif_aver);
}
free(pres);
fclose(out);
}
| [
"wangyang_cs2014@163.com"
] | wangyang_cs2014@163.com |
75645b81df4a770a10330faaf963c655523172d7 | 5fa6538165b42d8f8f9010ffefd7eb19559afa64 | /PA2/src/engine.cpp | 0c581aaeda83b387611ddba51896cd02c3c22536 | [] | no_license | david4jsus/cs480Valenzuela | 6f9eb8a20893dafff23dddef6c5ef9196f9fda96 | 47f88938bcf2754834132b2bf65a09a714593eeb | refs/heads/master | 2021-12-10T07:15:00.360964 | 2021-12-06T22:33:09 | 2021-12-06T22:33:09 | 146,481,540 | 0 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 4,098 | cpp | #include "engine.h"
#include "imgui.h"
#include "imgui_impl_sdl.h"
#include "imgui_impl_opengl3.h"
Engine::Engine(string name, int width, int height)
{
m_WINDOW_NAME = name;
m_WINDOW_WIDTH = width;
m_WINDOW_HEIGHT = height;
m_FULLSCREEN = false;
}
Engine::Engine(string name)
{
m_WINDOW_NAME = name;
m_WINDOW_HEIGHT = 0;
m_WINDOW_WIDTH = 0;
m_FULLSCREEN = true;
imgui_demo = false;
}
Engine::~Engine()
{
// Dear ImGui cleanup
ImGui_ImplOpenGL3_Shutdown();
ImGui_ImplSDL2_Shutdown();
ImGui::DestroyContext();
delete m_window;
delete m_graphics;
m_window = NULL;
m_graphics = NULL;
}
bool Engine::Initialize()
{
// Start a window
m_window = new Window();
if(!m_window->Initialize(m_WINDOW_NAME, &m_WINDOW_WIDTH, &m_WINDOW_HEIGHT))
{
printf("The window failed to initialize.\n");
return false;
}
// Start the graphics
m_graphics = new Graphics();
if(!m_graphics->Initialize(m_WINDOW_WIDTH, m_WINDOW_HEIGHT))
{
printf("The graphics failed to initialize.\n");
return false;
}
// Set the time
m_currentTimeMillis = GetCurrentTimeMillis();
// Setup Dear ImGui binding
IMGUI_CHECKVERSION();
ImGui::CreateContext();
ImGuiIO& imgui_io = ImGui::GetIO(); (void)imgui_io;
ImGui_ImplSDL2_InitForOpenGL(m_window->getSDLWindow(), m_window->getGLContext());
ImGui_ImplOpenGL3_Init("#version 130"); // GL 3.0 + GLSL 130
ImGui::StyleColorsDark(); // Setup style
// No errors
return true;
}
void Engine::Run()
{
m_running = true;
while(m_running)
{
// Update the DT
m_DT = getDT();
// Check input
while(SDL_PollEvent(&m_event) != 0)
{
ImGui_ImplSDL2_ProcessEvent(&m_event); // Dear ImGui input
Keyboard();
Mouse();
}
// Start Dear ImGui frame
ImGui_ImplOpenGL3_NewFrame();
ImGui_ImplSDL2_NewFrame(m_window->getSDLWindow());
ImGui::NewFrame();
// Demo ImGUI window
ImGui::ShowDemoWindow(&imgui_demo);
/*{
ImGui::Begin("Hello, world!");
ImGui::Text("Some text");
ImGui::End();
}*/
// Dear ImGui rendering
//ImVec4 clear_color = ImVec4(0.45f, 0.55, 0.60f, 1.00f);
ImGui::Render();
//SDL_GL_MakeCurrent(m_window->getSDLWindow(), m_window->getGLContext());
//glViewport(0, 0, 500, 500);
//glClearColor(clear_color.x, clear_color.y, clear_color.z, clear_color.w);
//glClear(GL_COLOR_BUFFER_BIT);
ImGui_ImplOpenGL3_RenderDrawData(ImGui::GetDrawData());
// Update and render the graphics
m_graphics->Update(m_DT);
m_graphics->Render();
// Swap to the Window
m_window->Swap();
}
}
void Engine::Keyboard()
{
if (m_event.type == SDL_QUIT)
{
m_running = false;
}
else if (m_event.type == SDL_KEYDOWN)
{
// Handle key down events here
if (m_event.key.keysym.sym == SDLK_ESCAPE) // Quit program
{
m_running = false;
}
if (m_event.key.keysym.sym == SDLK_a) // Reverse direction of rotation of cube
{
m_graphics->getCube()->reverseDirection();
}
if (m_event.key.keysym.sym == SDLK_s) // Stop cube orbit
{
m_graphics->getCube()->toggleOrbit();
}
if (m_event.key.keysym.sym == SDLK_d) // Stop cube rotation
{
m_graphics->getCube()->toggleRotation();
}
}
}
void Engine::Mouse()
{
if (m_event.type == SDL_QUIT)
{
m_running = false;
}
else if (m_event.type == SDL_MOUSEBUTTONDOWN)
{
// Handle mouse down events here
if (m_event.button.button == SDL_BUTTON_LEFT) // Reverse direction of rotation of cube
{
m_graphics->getCube()->reverseDirection();
}
}
}
unsigned int Engine::getDT()
{
long long TimeNowMillis = GetCurrentTimeMillis();
assert(TimeNowMillis >= m_currentTimeMillis);
unsigned int DeltaTimeMillis = (unsigned int)(TimeNowMillis - m_currentTimeMillis);
m_currentTimeMillis = TimeNowMillis;
return DeltaTimeMillis;
}
long long Engine::GetCurrentTimeMillis()
{
timeval t;
gettimeofday(&t, NULL);
long long ret = t.tv_sec * 1000 + t.tv_usec / 1000;
return ret;
}
| [
"david4jsus@gmail.com"
] | david4jsus@gmail.com |
ffadf9d0d23054f2615e820939ff044e55b48892 | 4f09c29f290d90219931f2e31bd1d8e1b6f9924f | /src/qt/guiutil.h | 16929cca8e5356eb2fe41b0152dd6d88fb4a3ec4 | [
"MIT"
] | permissive | jagaricoin-project/jagaricoin | 24916e58bb103eb5ab81155cdbe0a643251d724f | bc65110d5d685cc5eacf6feab820c15556ede23f | refs/heads/master | 2021-04-30T03:26:29.434025 | 2018-05-22T05:51:35 | 2018-05-22T05:51:35 | 121,515,515 | 1 | 0 | MIT | 2018-11-07T13:38:58 | 2018-02-14T13:45:46 | C++ | UTF-8 | C++ | false | false | 9,060 | h | // Copyright (c) 2011-2016 The Bitcoin Core developers
// Distributed under the MIT software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
#ifndef BITCOIN_QT_GUIUTIL_H
#define BITCOIN_QT_GUIUTIL_H
#include "amount.h"
#include "fs.h"
#include <QEvent>
#include <QHeaderView>
#include <QMessageBox>
#include <QObject>
#include <QProgressBar>
#include <QString>
#include <QTableView>
#include <QLabel>
class QValidatedLineEdit;
class SendCoinsRecipient;
QT_BEGIN_NAMESPACE
class QAbstractItemView;
class QDateTime;
class QFont;
class QLineEdit;
class QUrl;
class QWidget;
QT_END_NAMESPACE
/** Utility functions used by the Bitcoin Qt UI.
*/
namespace GUIUtil
{
// Create human-readable string from date
QString dateTimeStr(const QDateTime &datetime);
QString dateTimeStr(qint64 nTime);
// Return a monospace font
QFont fixedPitchFont();
// Set up widgets for address and amounts
void setupAddressWidget(QValidatedLineEdit *widget, QWidget *parent);
void setupAmountWidget(QLineEdit *widget, QWidget *parent);
// Parse "bitcoin:" URI into recipient object, return true on successful parsing
bool parseBitcoinURI(const QUrl &uri, SendCoinsRecipient *out);
bool parseBitcoinURI(QString uri, SendCoinsRecipient *out);
QString formatBitcoinURI(const SendCoinsRecipient &info);
// Returns true if given address+amount meets "dust" definition
bool isDust(const QString& address, const CAmount& amount);
// HTML escaping for rich text controls
QString HtmlEscape(const QString& str, bool fMultiLine=false);
QString HtmlEscape(const std::string& str, bool fMultiLine=false);
/** Copy a field of the currently selected entry of a view to the clipboard. Does nothing if nothing
is selected.
@param[in] column Data column to extract from the model
@param[in] role Data role to extract from the model
@see TransactionView::copyLabel, TransactionView::copyAmount, TransactionView::copyAddress
*/
void copyEntryData(QAbstractItemView *view, int column, int role=Qt::EditRole);
/** Return a field of the currently selected entry as a QString. Does nothing if nothing
is selected.
@param[in] column Data column to extract from the model
@see TransactionView::copyLabel, TransactionView::copyAmount, TransactionView::copyAddress
*/
QList<QModelIndex> getEntryData(QAbstractItemView *view, int column);
void setClipboard(const QString& str);
/** Get save filename, mimics QFileDialog::getSaveFileName, except that it appends a default suffix
when no suffix is provided by the user.
@param[in] parent Parent window (or 0)
@param[in] caption Window caption (or empty, for default)
@param[in] dir Starting directory (or empty, to default to documents directory)
@param[in] filter Filter specification such as "Comma Separated Files (*.csv)"
@param[out] selectedSuffixOut Pointer to return the suffix (file type) that was selected (or 0).
Can be useful when choosing the save file format based on suffix.
*/
QString getSaveFileName(QWidget *parent, const QString &caption, const QString &dir,
const QString &filter,
QString *selectedSuffixOut);
/** Get open filename, convenience wrapper for QFileDialog::getOpenFileName.
@param[in] parent Parent window (or 0)
@param[in] caption Window caption (or empty, for default)
@param[in] dir Starting directory (or empty, to default to documents directory)
@param[in] filter Filter specification such as "Comma Separated Files (*.csv)"
@param[out] selectedSuffixOut Pointer to return the suffix (file type) that was selected (or 0).
Can be useful when choosing the save file format based on suffix.
*/
QString getOpenFileName(QWidget *parent, const QString &caption, const QString &dir,
const QString &filter,
QString *selectedSuffixOut);
/** Get connection type to call object slot in GUI thread with invokeMethod. The call will be blocking.
@returns If called from the GUI thread, return a Qt::DirectConnection.
If called from another thread, return a Qt::BlockingQueuedConnection.
*/
Qt::ConnectionType blockingGUIThreadConnection();
// Determine whether a widget is hidden behind other windows
bool isObscured(QWidget *w);
// Open debug.log
void openDebugLogfile();
// Open the config file
bool openBitcoinConf();
// Browse backup folder
void showBackups();
// Replace invalid default fonts with known good ones
void SubstituteFonts(const QString& language);
/** Qt event filter that intercepts ToolTipChange events, and replaces the tooltip with a rich text
representation if needed. This assures that Qt can word-wrap long tooltip messages.
Tooltips longer than the provided size threshold (in characters) are wrapped.
*/
class ToolTipToRichTextFilter : public QObject
{
Q_OBJECT
public:
explicit ToolTipToRichTextFilter(int size_threshold, QObject *parent = 0);
protected:
bool eventFilter(QObject *obj, QEvent *evt);
private:
int size_threshold;
};
/**
* Makes a QTableView last column feel as if it was being resized from its left border.
* Also makes sure the column widths are never larger than the table's viewport.
* In Qt, all columns are resizable from the right, but it's not intuitive resizing the last column from the right.
* Usually our second to last columns behave as if stretched, and when on strech mode, columns aren't resizable
* interactively or programmatically.
*
* This helper object takes care of this issue.
*
*/
class TableViewLastColumnResizingFixer: public QObject
{
Q_OBJECT
public:
TableViewLastColumnResizingFixer(QTableView* table, int lastColMinimumWidth, int allColsMinimumWidth, QObject *parent);
void stretchColumnWidth(int column);
private:
QTableView* tableView;
int lastColumnMinimumWidth;
int allColumnsMinimumWidth;
int lastColumnIndex;
int columnCount;
int secondToLastColumnIndex;
void adjustTableColumnsWidth();
int getAvailableWidthForColumn(int column);
int getColumnsWidth();
void connectViewHeadersSignals();
void disconnectViewHeadersSignals();
void setViewHeaderResizeMode(int logicalIndex, QHeaderView::ResizeMode resizeMode);
void resizeColumn(int nColumnIndex, int width);
private Q_SLOTS:
void on_sectionResized(int logicalIndex, int oldSize, int newSize);
void on_geometriesChanged();
};
bool GetStartOnSystemStartup();
bool SetStartOnSystemStartup(bool fAutoStart);
/* Convert QString to OS specific boost path through UTF-8 */
fs::path qstringToBoostPath(const QString &path);
/* Convert OS specific boost path to QString through UTF-8 */
QString boostPathToQString(const fs::path &path);
/* Convert seconds into a QString with days, hours, mins, secs */
QString formatDurationStr(int secs);
/* Format CNodeStats.nServices bitmask into a user-readable string */
QString formatServicesStr(quint64 mask);
/* Format a CNodeCombinedStats.dPingTime into a user-readable string or display N/A, if 0*/
QString formatPingTime(double dPingTime);
/* Format a CNodeCombinedStats.nTimeOffset into a user-readable string. */
QString formatTimeOffset(int64_t nTimeOffset);
QString formatNiceTimeOffset(qint64 secs);
class ClickableLabel : public QLabel
{
Q_OBJECT
Q_SIGNALS:
/** Emitted when the label is clicked. The relative mouse coordinates of the click are
* passed to the signal.
*/
void clicked(const QPoint& point);
protected:
void mouseReleaseEvent(QMouseEvent *event);
};
class ClickableProgressBar : public QProgressBar
{
Q_OBJECT
Q_SIGNALS:
/** Emitted when the progressbar is clicked. The relative mouse coordinates of the click are
* passed to the signal.
*/
void clicked(const QPoint& point);
protected:
void mouseReleaseEvent(QMouseEvent *event);
};
#if defined(Q_OS_MAC) && QT_VERSION >= 0x050000
// workaround for Qt OSX Bug:
// https://bugreports.qt-project.org/browse/QTBUG-15631
// QProgressBar uses around 10% CPU even when app is in background
class ProgressBar : public ClickableProgressBar
{
bool event(QEvent *e) {
return (e->type() != QEvent::StyleAnimationUpdate) ? QProgressBar::event(e) : false;
}
};
#else
typedef ClickableProgressBar ProgressBar;
#endif
} // namespace GUIUtil
#endif // BITCOIN_QT_GUIUTIL_H
| [
"jagaricoin@gmail.com"
] | jagaricoin@gmail.com |
59e58f43e1c853f2ea888ed2aa0ef1bf5c723403 | 9b2ef6d9a1c977b197497c437c34ced3eeb614d5 | /ext/DirectXTK12/include/GraphicsMemory.h | b977ec8af7de91aa8877dd1900e90411878c7494 | [
"MIT"
] | permissive | LASTEXILE-CH/Kaguya | 019050da60c15ac970534d0b80497f5dc2cb813f | 8020f18ff74e1f0ae7f16ebd82383c81fc319907 | refs/heads/master | 2023-04-03T10:57:28.511072 | 2021-04-18T11:12:11 | 2021-04-18T11:12:11 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 7,331 | h | //--------------------------------------------------------------------------------------
// File: GraphicsMemory.h
//
// Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT License.
//
// http://go.microsoft.com/fwlink/?LinkID=615561
//--------------------------------------------------------------------------------------
#pragma once
#ifdef _GAMING_XBOX_SCARLETT
#include <d3d12_xs.h>
#elif (defined(_XBOX_ONE) && defined(_TITLE)) || defined(_GAMING_XBOX)
#include <d3d12_x.h>
#else
#include <d3d12.h>
#endif
#include <cstddef>
#include <cstring>
#include <memory>
namespace DirectX
{
class LinearAllocatorPage;
// Works a little like a smart pointer. The memory will only be fenced by the GPU once the pointer
// has been invalidated or the user explicitly marks it for fencing.
class GraphicsResource
{
public:
GraphicsResource() noexcept;
GraphicsResource(
_In_ LinearAllocatorPage* page,
_In_ D3D12_GPU_VIRTUAL_ADDRESS gpuAddress,
_In_ ID3D12Resource* resource,
_In_ void* memory,
_In_ size_t offset,
_In_ size_t size) noexcept;
GraphicsResource(GraphicsResource&& other) noexcept;
GraphicsResource&& operator= (GraphicsResource&&) noexcept;
GraphicsResource(const GraphicsResource&) = delete;
GraphicsResource& operator= (const GraphicsResource&) = delete;
~GraphicsResource();
D3D12_GPU_VIRTUAL_ADDRESS GpuAddress() const noexcept { return mGpuAddress; }
ID3D12Resource* Resource() const noexcept { return mResource; }
void* Memory() const noexcept { return mMemory; }
size_t ResourceOffset() const noexcept { return mBufferOffset; }
size_t Size() const noexcept { return mSize; }
explicit operator bool () const noexcept { return mResource != nullptr; }
// Clear the pointer. Using operator -> will produce bad results.
void __cdecl Reset() noexcept;
void __cdecl Reset(GraphicsResource&&) noexcept;
private:
LinearAllocatorPage* mPage;
D3D12_GPU_VIRTUAL_ADDRESS mGpuAddress;
ID3D12Resource* mResource;
void* mMemory;
size_t mBufferOffset;
size_t mSize;
};
class SharedGraphicsResource
{
public:
SharedGraphicsResource() noexcept;
SharedGraphicsResource(SharedGraphicsResource&&) noexcept;
SharedGraphicsResource&& operator= (SharedGraphicsResource&&) noexcept;
SharedGraphicsResource(GraphicsResource&&);
SharedGraphicsResource&& operator= (GraphicsResource&&);
SharedGraphicsResource(const SharedGraphicsResource&) noexcept;
SharedGraphicsResource& operator= (const SharedGraphicsResource&) noexcept;
SharedGraphicsResource(const GraphicsResource&) = delete;
SharedGraphicsResource& operator= (const GraphicsResource&) = delete;
~SharedGraphicsResource();
D3D12_GPU_VIRTUAL_ADDRESS GpuAddress() const noexcept { return mSharedResource->GpuAddress(); }
ID3D12Resource* Resource() const noexcept { return mSharedResource->Resource(); }
void* Memory() const noexcept { return mSharedResource->Memory(); }
size_t ResourceOffset() const noexcept { return mSharedResource->ResourceOffset(); }
size_t Size() const noexcept { return mSharedResource->Size(); }
explicit operator bool () const noexcept { return mSharedResource != nullptr; }
bool operator == (const SharedGraphicsResource& other) const noexcept { return mSharedResource.get() == other.mSharedResource.get(); }
bool operator != (const SharedGraphicsResource& other) const noexcept { return mSharedResource.get() != other.mSharedResource.get(); }
// Clear the pointer. Using operator -> will produce bad results.
void __cdecl Reset() noexcept;
void __cdecl Reset(GraphicsResource&&);
void __cdecl Reset(SharedGraphicsResource&&) noexcept;
void __cdecl Reset(const SharedGraphicsResource& resource) noexcept;
private:
std::shared_ptr<GraphicsResource> mSharedResource;
};
//----------------------------------------------------------------------------------
struct GraphicsMemoryStatistics
{
size_t committedMemory; // Bytes of memory currently committed/in-flight
size_t totalMemory; // Total bytes of memory used by the allocators
size_t totalPages; // Total page count
size_t peakCommitedMemory; // Peak commited memory value since last reset
size_t peakTotalMemory; // Peak total bytes
size_t peakTotalPages; // Peak total page count
};
//----------------------------------------------------------------------------------
class GraphicsMemory
{
public:
explicit GraphicsMemory(_In_ ID3D12Device* device);
GraphicsMemory(GraphicsMemory&& moveFrom) noexcept;
GraphicsMemory& operator= (GraphicsMemory&& moveFrom) noexcept;
GraphicsMemory(GraphicsMemory const&) = delete;
GraphicsMemory& operator=(GraphicsMemory const&) = delete;
virtual ~GraphicsMemory();
// Make sure to keep the GraphicsResource handle alive as long as you need to access
// the memory on the CPU. For example, do not simply cache GpuAddress() and discard
// the GraphicsResource object, or your memory may be overwritten later.
GraphicsResource __cdecl Allocate(size_t size, size_t alignment = 16);
// Special overload of Allocate that aligns to D3D12 constant buffer alignment requirements
template<typename T> GraphicsResource AllocateConstant()
{
const size_t alignment = D3D12_CONSTANT_BUFFER_DATA_PLACEMENT_ALIGNMENT;
const size_t alignedSize = (sizeof(T) + alignment - 1) & ~(alignment - 1);
return Allocate(alignedSize, alignment);
}
template<typename T> GraphicsResource AllocateConstant(const T& setData)
{
GraphicsResource alloc = AllocateConstant<T>();
memcpy(alloc.Memory(), &setData, sizeof(T));
return alloc;
}
// Submits all the pending one-shot memory to the GPU.
// The memory will be recycled once the GPU is done with it.
void __cdecl Commit(_In_ ID3D12CommandQueue* commandQueue);
// This frees up any unused memory.
// If you want to make sure all memory is reclaimed, idle the GPU before calling this.
// It is not recommended that you call this unless absolutely necessary (e.g. your
// memory budget changes at run-time, or perhaps you're changing levels in your game.)
void __cdecl GarbageCollect();
// Memory statistics
GraphicsMemoryStatistics __cdecl GetStatistics();
void __cdecl ResetStatistics();
// Singleton
// Should only use nullptr for single GPU scenarios; mGPU requires a specific device
static GraphicsMemory& __cdecl Get(_In_opt_ ID3D12Device* device = nullptr);
private:
// Private implementation.
class Impl;
std::unique_ptr<Impl> pImpl;
};
}
| [
"kcloudy0717@gmail.com"
] | kcloudy0717@gmail.com |
03fbf569d7d16790b4d886b22bb2a1e2e7556b5f | cf04960d9fcc5bee7f7bbd09da217b615af57d12 | /01uebung/errors.cc | 014bd9a7bed7576927684d2c24d3647c7d75a242 | [] | no_license | philz2109/ipk-exercises | 0960b38803401c73c34503f0189a89ac40311edb | 9ed1c8210837bd26ef4cae2b3d3ff0341e2f6ab5 | refs/heads/master | 2023-03-18T17:41:17.560120 | 2021-03-09T12:49:57 | 2021-03-09T12:49:57 | 315,298,588 | 0 | 0 | null | 2020-11-23T12:50:23 | 2020-11-23T11:49:12 | C++ | UTF-8 | C++ | false | false | 133 | cc | #include <iostream>
int main(int argc, char** argv){
std::cout << "Typing is difficult" << std::endl;
int ret = 0;
return ret;
} | [
"fabi.walli.fw@gmail.com"
] | fabi.walli.fw@gmail.com |
86b93c9a6989ecff9c3a8468378fba51514aed31 | 019cfc2c3dc17476ddb86a9eaaf3ff28c5f12c8d | /AGChallenge/Optimizer.cpp | a2b30404984bd22cbcc7ab2ec4fa90f02ce86e70 | [] | no_license | simonusher/p3-ag-challenge | 0a247aa047f92dd815d9db3e9ac118907c720da9 | 9d52c23af084ddafa1f796db8679cd6543e7ddee | refs/heads/main | 2023-04-21T21:57:26.861801 | 2021-05-09T12:04:16 | 2021-05-09T12:04:16 | 365,325,861 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 878 | cpp | #include "Optimizer.h"
#include <cfloat>
#include <iostream>
#include <windows.h>
using namespace std;
COptimizer::COptimizer(CEvaluator &cEvaluator)
: c_evaluator(cEvaluator)
{
vector<int> domain{ 0, 1 };
this->pyramid = new Pyramid(domain, cEvaluator);
d_current_best_fitness = 0;
}
COptimizer::~COptimizer() {
delete pyramid;
}
//COptimizer::COptimizer(CEvaluator &cEvaluator)
void COptimizer::vInitialize()
{
d_current_best_fitness = -DBL_MAX;
v_current_best.clear();
}//void COptimizer::vInitialize()
void COptimizer::vRunIteration()
{
this->pyramid->runSingleIteration();
double newFitness = pyramid->getBestFitness();
if (newFitness > d_current_best_fitness) {
d_current_best_fitness = newFitness;
v_current_best = pyramid->getBestSolution();
}
std::cout << "BEST FITNESS: " << d_current_best_fitness << std::endl;
}//void COptimizer::vRunIteration() | [
"swozniak6@gmail.com"
] | swozniak6@gmail.com |
9c452403c3866e844007ed9325465f1015e08680 | c3fbfd6d249a63304b6080ce13c68fa6d5271326 | /Spudbot1Revival/src/main/cpp/Commands/CarrigeUpCommand.cpp | a4b3ddd0aefc5bdc06c31ae2b5772e66d679461e | [] | no_license | SteelRidgeRobotics/2019Build | 0318b736ff4e24d80d5ea2c26df4e94795364679 | c221192ea47d19388ffd6c5f485e4d9c742ffd16 | refs/heads/master | 2020-04-16T16:56:00.909280 | 2019-11-08T01:21:06 | 2019-11-08T01:21:06 | 165,755,983 | 0 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 1,535 | cpp | // RobotBuilder Version: 2.0
//
// This file was generated by RobotBuilder. It contains sections of
// code that are automatically generated and assigned by robotbuilder.
// These sections will be updated in the future when you export to
// C++ from RobotBuilder. Do not put any code or make any change in
// the blocks indicating autogenerated code or it will be lost on an
// update. Deleting the comments indicating the section will prevent
// it from being updated in the future.
#include "Commands/CarrigeUpCommand.h"
// BEGIN AUTOGENERATED CODE, SOURCE=ROBOTBUILDER ID=CONSTRUCTOR
CarrigeUpCommand::CarrigeUpCommand(): frc::Command() {
// Use requires() here to declare subsystem dependencies
// eg. requires(Robot::chassis.get());
// BEGIN AUTOGENERATED CODE, SOURCE=ROBOTBUILDER ID=REQUIRES
Requires(Robot::carrige.get());
// END AUTOGENERATED CODE, SOURCE=ROBOTBUILDER ID=REQUIRES
}// END AUTOGENERATED CODE, SOURCE=ROBOTBUILDER ID=CONSTRUCTOR
// Called just before this Command runs the first time
void CarrigeUpCommand::Initialize() {
}
// Called repeatedly when this Command is scheduled to run
void CarrigeUpCommand::Execute() {
}
// Make this return true when this Command no longer needs to run execute()
bool CarrigeUpCommand::IsFinished() {
return false;
}
// Called once after isFinished returns true
void CarrigeUpCommand::End() {
}
// Called when another command which requires one or more of the same
// subsystems is scheduled to run
void CarrigeUpCommand::Interrupted() {
}
| [
"Nerf12402@users.noreply.github.com"
] | Nerf12402@users.noreply.github.com |
05054cc77bb936aa250ce3a494a84432fa7ed044 | 1f97e0af9cbe9f0d595288e8a58e0791dbbfb69f | /src/GUI/GUI/GoBang.h | ba1cdb71dfcf66159b5815ffd315c8b92ae62a85 | [] | no_license | Ctiely/mcts_gobang | b547439f6d4f99b68e85df1b942c0b31777834b2 | 3e21c32faeafad3f3023a686250c1347fa019082 | refs/heads/master | 2020-03-28T04:06:02.473448 | 2018-11-06T14:42:39 | 2018-11-06T14:42:39 | 147,693,679 | 3 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,717 | h | #ifndef GOBANG_H
#define GOBANG_H
#include <vector>
#include <utility>
#include <QIcon>
#include <QLabel>
#include <QWidget>
#include <QThread>
#include <QPalette>
#include <QPainter>
#include <QMouseEvent>
#include <QMessageBox>
#include "MCTSThread.h"
#include "../../env/Board.h"
#include "../../MCTS/MCTSPlayer.h"
#include "../../MCTS_alphago_zero/MCTSPlayer_alphago_zero.h"
const int WIDTH = 700;
const int HEIGHT = 700;
const int MARGIN = 68;
const double GRID = (WIDTH - 2 * MARGIN) / (9 - 1);
const int PIECE = 60;
const int WIDTH_FULL = 540;
const int HEIGHT_FULL = 540;
const int MARGIN_FULL = 25;
const double GRID_FULL = (WIDTH_FULL - 2 * MARGIN_FULL) / (15 - 1);
const int PIECE_FULL = 35;
const int EMPTY = -1;
const int BLACK = 0;
const int WHITE = 1;
class Pieces : public QLabel {
Q_OBJECT
public:
Pieces(QWidget * parent = 0);
};
class GoBang : public QWidget
{
Q_OBJECT
public:
GoBang(QWidget *parent = 0,
unsigned int size=9,
bool alphago_play=false,
std::string model_path="");
~GoBang();
void init();
Board board;
QPalette * palette;
const QPixmap * black;
const QPixmap * white;
std::vector<Pieces *> pieces;
bool ai_done;
int piece_now;
unsigned int step;
void mousePressEvent(QMouseEvent * e);
void draw(int i, int j);
pair<double, double> coordinate_transform_map2pixel(int i, int j);
pair<int, int> coordinate_transform_pixel2map(double x, double y);
void gameover(int winner);
void paintEvent(QPaintEvent * e);
public slots:
void ai_draw(unsigned int action);
private:
double x, y;
bool alphago_play;
string model_path;
};
#endif // GOBANG_H
| [
"814868906@qq.com"
] | 814868906@qq.com |
1e51864c3de08ac66b587df43654f0a7fc91c49a | c95a83e1a741b8c0eb810dd018d91060e5872dd8 | /Game/ObjectDLL/ObjectShared/DebrisFuncs.cpp | 473e688e60b2814ebfdbed5452ce07b94c220532 | [] | no_license | rickyharis39/nolf2 | ba0b56e2abb076e60d97fc7a2a8ee7be4394266c | 0da0603dc961e73ac734ff365bfbfb8abb9b9b04 | refs/heads/master | 2021-01-01T17:21:00.678517 | 2011-07-23T12:11:19 | 2011-07-23T12:11:19 | 38,495,312 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,255 | cpp | // ----------------------------------------------------------------------- //
//
// MODULE : DebrisFuncs.cpp
//
// PURPOSE : Misc functions for creating debris
//
// CREATED : 6/29/98
//
// (c) 1998-2000 Monolith Productions, Inc. All Rights Reserved
//
// ----------------------------------------------------------------------- //
// Includes...
#include "stdafx.h"
#include "ltserverobj.h"
#include "DebrisFuncs.h"
#include "SFXMsgIds.h"
#include "DebrisMgr.h"
#ifndef __PSX2
CDebrisMgrPlugin s_DebrisMgrPlugin;
#endif // !__PSX2
#define DEBRIS_PROPERTY_NAME "DebrisType"
// ----------------------------------------------------------------------- //
//
// ROUTINE: CreateDebris()
//
// PURPOSE: Create client-side debris...
//
// ----------------------------------------------------------------------- //
static void CreateDebris(CLIENTDEBRIS & cd)
{
if (!g_pLTServer) return;
CAutoMessage cMsg;
cMsg.Writeuint8(SFX_DEBRIS_ID);
cMsg.WriteLTRotation(cd.rRot);
cMsg.WriteCompPos(cd.vPos);
cMsg.Writeuint8(cd.nDebrisId);
g_pLTServer->SendSFXMessage(cMsg.Read(), cd.vPos, 0);
}
// ----------------------------------------------------------------------- //
//
// ROUTINE: CreatePropDebris()
//
// PURPOSE: Create client-side debris for props...
//
// ----------------------------------------------------------------------- //
void CreatePropDebris( const LTVector &vPos, const LTVector &vDir, uint8 nDebrisId )
{
CLIENTDEBRIS cd;
cd.rRot = LTRotation(vDir, LTVector(0.0f, 1.0f, 0.0f));
cd.vPos = vPos;
cd.nDebrisId = nDebrisId;
::CreateDebris(cd);
}
// ----------------------------------------------------------------------- //
//
// ROUTINE: GetDebrisProperties()
//
// PURPOSE: Determine the debris properties (This should only be
// called during an object's ReadProp function if the object
// added the ADD_DEBRISTYPE_PROPERTY macro).
//
// ----------------------------------------------------------------------- //
void GetDebrisProperties(uint8 & nDebrisId)
{
if (!g_pLTServer) return;
GenericProp genProp;
if (g_pLTServer->GetPropGeneric(DEBRIS_PROPERTY_NAME, &genProp) == LT_OK)
{
DEBRIS* pDebris = g_pDebrisMgr->GetDebris(genProp.m_String);
if (pDebris)
{
nDebrisId = pDebris->nId;
}
}
}
// ----------------------------------------------------------------------- //
//
// ROUTINE: CDebrisPlugin::PreHook_EditStringList()
//
// PURPOSE: Fill in property string list
//
// ----------------------------------------------------------------------- //
#ifndef __PSX2
LTRESULT CDebrisPlugin::PreHook_EditStringList(const char* szRezPath, const char* szPropName, char** aszStrings, uint32* pcStrings, const uint32 cMaxStrings, const uint32 cMaxStringLength)
{
// See if we can handle the property...
if (_strcmpi(DEBRIS_PROPERTY_NAME, szPropName) == 0)
{
s_DebrisMgrPlugin.PreHook_EditStringList(szRezPath, szPropName,
aszStrings, pcStrings, cMaxStrings, cMaxStringLength);
if (!s_DebrisMgrPlugin.PopulateStringList(aszStrings, pcStrings,
cMaxStrings, cMaxStringLength)) return LT_UNSUPPORTED;
return LT_OK;
}
return LT_UNSUPPORTED;
}
#endif // !__PSX2 | [
"vytautasrask@gmail.com"
] | vytautasrask@gmail.com |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.