blob_id
stringlengths 40
40
| directory_id
stringlengths 40
40
| path
stringlengths 3
264
| content_id
stringlengths 40
40
| detected_licenses
listlengths 0
85
| license_type
stringclasses 2
values | repo_name
stringlengths 5
140
| snapshot_id
stringlengths 40
40
| revision_id
stringlengths 40
40
| branch_name
stringclasses 986
values | visit_date
timestamp[us] | revision_date
timestamp[us] | committer_date
timestamp[us] | github_id
int64 3.89k
681M
⌀ | star_events_count
int64 0
209k
| fork_events_count
int64 0
110k
| gha_license_id
stringclasses 23
values | gha_event_created_at
timestamp[us] | gha_created_at
timestamp[us] | gha_language
stringclasses 145
values | src_encoding
stringclasses 34
values | language
stringclasses 1
value | is_vendor
bool 1
class | is_generated
bool 2
classes | length_bytes
int64 3
10.4M
| extension
stringclasses 122
values | content
stringlengths 3
10.4M
| authors
listlengths 1
1
| author_id
stringlengths 0
158
|
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
2d5f0ca7b756836b7dde13dac4761475a8edd61b
|
6b857a6c42b5de1e42b6890b43a7749ce9d910f7
|
/server_tuple_impl.h
|
aa7e1a6dfaded1ce091fdb89d09bef56a8f872b2
|
[
"Apache-2.0"
] |
permissive
|
YuvaAthur/private-join-and-compute
|
ffdc2362b065f286367c52e92c9e9a3e7597ab5a
|
6e65a0ad939ac25b3ea9c235b968c1cc4bc9d3b0
|
refs/heads/master
| 2021-06-23T11:35:07.973817
| 2020-12-01T21:25:46
| 2020-12-01T21:25:46
| 193,827,000
| 0
| 1
|
Apache-2.0
| 2019-06-26T04:02:35
| 2019-06-26T04:02:35
| null |
UTF-8
|
C++
| false
| false
| 4,056
|
h
|
/*
* Extension to server_impl for sharing 2 business data columns
* Author: Yuva Athur
* Created Date: Nov. 10. 2020
*
*
* Follows the same implementation approach as PrivateIntersectionSumProtocolServerImpl
* Created a new class instead - inheritance is not straight forward
*
*
*/
#ifndef OPEN_SOURCE_PRIVATE_INTERSECTION_SUM_SERVER_TUPLE_IMPL_H_
#define OPEN_SOURCE_PRIVATE_INTERSECTION_SUM_SERVER_TUPLE_IMPL_H_
#include "crypto/context.h"
#include "crypto/paillier.h"
#include "match.pb.h"
#include "message_sink.h"
#include "private_intersection_sum.pb.h"
#include "private_join_and_compute.pb.h"
#include "protocol_server.h"
#include "util/status.inc"
#include "crypto/ec_commutative_cipher.h"
// Microsoft SEAL Integration
#include "seal/seal.h"
namespace private_join_and_compute {
// The "server side" of the intersection-sum protocol. This represents the
// party that will receive the size of the intersection as its output. The
// values that will be summed are supplied by the other party; this party will
// only supply set elements as its inputs.
class PrivateIntersectionSumProtocolServerTupleImpl : public ProtocolServer {
public:
PrivateIntersectionSumProtocolServerTupleImpl(::private_join_and_compute::Context* ctx,
std::vector<std::string> inputs,const int32_t use_seal)
: ctx_(ctx), inputs_(std::move(inputs)),use_seal_(use_seal) {
setupSEAL();
}
~PrivateIntersectionSumProtocolServerTupleImpl() override = default;
// Executes the next Server round and creates a response.
//
// If the ClientMessage is StartProtocol, a ServerRoundOne will be sent to the
// message sink, containing the encrypted server identifiers.
//
// If the ClientMessage is ClientRoundOne, a ServerRoundTwo will be sent to
// the message sink, containing the intersection size, and encrypted
// intersection-sum.
//
// Fails with InvalidArgument if the message is not a
// PrivateIntersectionSumClientMessage of the expected round, or if the
// message is otherwise not as expected. Forwards all other failures
// encountered.
Status Handle(const ClientMessage& request,
MessageSink<ServerMessage>* server_message_sink) override;
bool protocol_finished() override { return protocol_finished_; }
// Utility function, used for testing.
ECCommutativeCipher* GetECCipher() { return ec_cipher_.get(); }
protected:
// YAR: Microsoft SEAL integration
// Set up member variables
// Context parms is a constant between client & server
Status setupSEAL();
// Encrypts the server's identifiers.
StatusOr<PrivateIntersectionSumServerMessage::ServerRoundOne> EncryptSet();
// YAR::Add : Refactoring the encrypting part of the client message
virtual StatusOr<std::vector<EncryptedElement>> EncryptClientSet(
const private_join_and_compute::EncryptedSet encryptedSet);
//YAR::Add : Refactoring to extend to vector of values
virtual StatusOr<std::vector<BigNum>> IntersectionAggregates(
const PublicPaillier& public_paillier,
const std::vector<EncryptedElement>& intersection);
// Computes the intersection size and encrypted intersection_sum.
StatusOr<PrivateIntersectionSumServerMessage::ServerRoundTwo>
ComputeIntersection(const PrivateIntersectionSumClientMessage::ClientRoundOne&
client_message);
Context* ctx_; // not owned
std::unique_ptr<ECCommutativeCipher> ec_cipher_;
// inputs_ will first contain the plaintext server identifiers, and later
// contain the encrypted server identifiers.
std::vector<std::string> inputs_;
bool protocol_finished_ = false;
//compute methods
int32_t op_1_;
int32_t op_2_;
//seal encryption
int32_t use_seal_;
seal::EncryptionParameters parms_;
std::shared_ptr<seal::SEALContext> context_;
seal::Ciphertext seal_agg_1_;
seal::Ciphertext seal_agg_2_;
};
} // namespace private_join_and_compute
#endif // OPEN_SOURCE_PRIVATE_INTERSECTION_SUM_SERVER_TUPLE_IMPL_H_
|
[
"yuvaraj.a.r@gmail.com"
] |
yuvaraj.a.r@gmail.com
|
dd036182698a18c2e63af4358a0c00488ddecd64
|
e24e5cc39131782a2edb3b205eb05e59c07f5ac1
|
/utils/files.cpp
|
06f71df235a132fbf2101e45319f750653e8e385
|
[
"BSD-3-Clause",
"LicenseRef-scancode-unknown-license-reference"
] |
permissive
|
JanSvejda/nitwit-validator
|
1a14055637ad0a1239bee24edf8d8a3926034583
|
b8b709b450c33fb6d70f1aecedf93dced718ea91
|
refs/heads/master
| 2020-08-06T01:43:42.680306
| 2019-10-02T11:23:01
| 2019-10-02T11:23:01
| null | 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 728
|
cpp
|
//
// Created by jan on 3.4.19.
//
#include "files.hpp"
char *readFile(const char *FileName)
{
struct stat FileInfo;
char *ReadText;
FILE *InFile;
int BytesRead;
if (stat(FileName, &FileInfo))
printf("Cannot read file %s\n", FileName);
ReadText = static_cast<char *>(malloc(FileInfo.st_size + 1));
if (ReadText == nullptr)
printf("Out of memory!\n");
InFile = fopen(FileName, "r");
if (InFile == nullptr)
printf("Cannot read file %s\n", FileName);
BytesRead = fread(ReadText, 1, FileInfo.st_size, InFile);
if (BytesRead == 0)
printf("Cannot read file %s\n", FileName);
ReadText[BytesRead] = '\0';
fclose(InFile);
return ReadText;
}
|
[
"jenda.svejda@gmail.com"
] |
jenda.svejda@gmail.com
|
aab1b516679d57d5ed1c053208adf6bbfc95180d
|
30a3380be7fc9f06bdae3ea5a7508ae52aae3c82
|
/examples/DuckDNS_Client/DuckDNS_Client.ino
|
749a98fb36a271fe69b1d6dd7e2c390b3747a5a5
|
[
"MIT"
] |
permissive
|
seco/EasyDDNS
|
bda1c48626b74f4843e4cc3a745f3bdb56fe46fe
|
2d50bceea418005f0d36ecc44c1a0052076e67f2
|
refs/heads/master
| 2021-01-20T02:41:36.915398
| 2017-04-25T14:38:58
| 2017-04-25T14:38:58
| null | 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 883
|
ino
|
/*
######### DuckDNS Update Client for ESP8266 ##########
This Example Explains the Use of EasyDDNS Library with DuckDNS Service
and Checks for New IP Every 10 Seconds.
Author: Ayush Sharma
*/
#include <EasyDDNS.h>
#include <ESP8266WiFi.h>
#include <ESP8266HTTPClient.h>
const char* ssid = "your-ssid";
const char* password = "your-password";
WiFiServer server(80);
EasyDDNS DDNS;
void setup() {
Serial.begin(115200);
WiFi.mode(WIFI_STA);
WiFi.begin(ssid, password);
while (WiFi.status() != WL_CONNECTED) {
delay(500);
Serial.print(".");
}
Serial.println(WiFi.localIP()); // Print the IP address
server.begin();
DDNS.service("duckdns"); // Enter your DDNS Service Name - "duckdns" / "noip"
DDNS.DuckClient("domain","token"); // Enter ddns Domain & Token | Example - "esp.duckdns.org","1234567"
}
void loop() {
DDNS.update(10000); // Check for New Ip Every 10 Seconds.
}
|
[
"hobbyists.stop@gmail.com"
] |
hobbyists.stop@gmail.com
|
014c3022f9c5d7ae1a3ebe9797b6fd2e2dfc3ffd
|
a023fa60d0f5c06e217dd1d11b4ce5356e9307bd
|
/lennardjones.cpp
|
99f5d8255964b1a54e168cd3d53bfbd3715af83f
|
[] |
no_license
|
Joaakerh/molecular-dynamics-fys3150
|
ba4e98e222eb160340496acbc82bb25b1958265a
|
36326e914ab0b40888fa3b8107a5c5f724795f7a
|
refs/heads/master
| 2020-04-10T00:56:37.469086
| 2018-12-06T17:48:57
| 2018-12-06T17:48:57
| 160,700,688
| 0
| 0
| null | 2018-12-06T16:19:01
| 2018-12-06T16:19:00
| null |
UTF-8
|
C++
| false
| false
| 517
|
cpp
|
#include "lennardjones.h"
#include "system.h"
double LennardJones::potentialEnergy() const
{
return m_potentialEnergy;
}
double LennardJones::sigma() const
{
return m_sigma;
}
void LennardJones::setSigma(double sigma)
{
m_sigma = sigma;
}
double LennardJones::epsilon() const
{
return m_epsilon;
}
void LennardJones::setEpsilon(double epsilon)
{
m_epsilon = epsilon;
}
void LennardJones::calculateForces(System &system)
{
m_potentialEnergy = 0; // Remember to compute this in the loop
}
|
[
"andershaf@gmail.com"
] |
andershaf@gmail.com
|
adaee7e13eb0a6c0d38c2d2a73386668eec049c4
|
aaba6d264025d7ff1a7874b3e329c61ecec01bd6
|
/POJ/1013/1013.cpp
|
b677b8d8460307f190e8275ee358b4d13057a353
|
[] |
no_license
|
liuzixing/scut
|
b8118c3f0fea497a6babbe1ccbed94f2997b07d3
|
930c90abbabc98ac0bff4cb4fcde2c46f92a2937
|
refs/heads/master
| 2020-06-09T06:59:29.230684
| 2014-03-19T11:29:52
| 2014-03-19T11:29:52
| null | 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 1,667
|
cpp
|
#include <iostream>
#include <cstring>
#include <fstream>
using namespace std;
struct condition
{
char l[12],r[12],op[5];
};
bool check(condition judge[],int k,int horl)
{
int a[13] = {0},i,j;
a[k] = horl;
int pd = 0;
bool flag = true;
for (i = 0; i < 3; i++)
{
int suml = 0,sumr = 0;
int len = strlen(judge[i].l);
for (j = 0; j < len;j++)
{
suml += a[judge[i].l[j] - 'A' + 1];
sumr += a[judge[i].r[j] - 'A' + 1];
if (judge[i].l[j] - 'A' + 1 == k)
{
pd++;
}
if (judge[i].r[j] - 'A' + 1 == k)
{
pd++;
}
}
switch (judge[i].op[0])
{
case 'e': if (suml == sumr)
{
continue;
}
else
{
flag = false;
};break;
case 'u': if (suml >= sumr)
{
continue;
}
else
{
flag = false;
};break;
case 'd': if (suml <= sumr)
{
continue;
}
else
{
flag = false;
};break;
}
}
if (!pd)
{
flag = false;
}
return (flag);
}
int main()
{
int n,i;
ifstream fin ("test.in");
fin >> n;
while (n)
{
n--;
condition judge[4];
fin >> judge[0].l >> judge[0].r >> judge[0].op;
fin >> judge[1].l >> judge[1].r >> judge[1].op;
fin >> judge[2].l >> judge[2].r >> judge[2].op;
for (i = 1; i < 13;i++)
{
if (check(judge,i,-1))
{
cout << char ('A' + i - 1) <<" is the counterfeit coin and it is light." << endl;
break;
}
if (check(judge,i,1))
{
cout << char ('A' + i - 1) <<" is the counterfeit coin and it is heavy." << endl;
break;
}
}
}
}
|
[
"liucising@gmail.com"
] |
liucising@gmail.com
|
f62bf8ddcb717a0a2a78cea52fc05731bbb02c80
|
ce2ad63cbfd38aea75d262f1d29225e097bfc2d5
|
/src/Zone.h
|
b78d2667e8bcf3d085f4307e62f843e12094965e
|
[
"LicenseRef-scancode-public-domain",
"MIT"
] |
permissive
|
matlus/MultizoneThermostat
|
d4d3cc5ecf367df594299f48ef3d6a2a184ee8ed
|
c20cfe8acb9831c7675ea30675c46b589a14cec9
|
refs/heads/master
| 2021-01-22T07:58:15.049725
| 2019-05-13T00:42:53
| 2019-05-13T00:42:53
| 102,319,853
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 420
|
h
|
#pragma once
#ifndef Zone_h
#define Zone_h
#include <memory>
class Zone {
public:
Zone(const char *name, const float temperature, const float humidity);
Zone(const Zone &other);
Zone(Zone &&other) noexcept;
~Zone();
Zone &operator=(const Zone &other) noexcept;
Zone &operator=(Zone &&other) noexcept;
std::unique_ptr<char[]> name = nullptr;
float temperature = 0.0f;
float humidity = 0.0f;
};
#endif
|
[
"shiv.kmr003@gmail.com"
] |
shiv.kmr003@gmail.com
|
c0f5cf69c2dcae3aaa6013b9eeab9202d1ec87cb
|
30e1dc84fe8c54d26ef4a1aff000a83af6f612be
|
/src/external/boost/boost_1_68_0/boost/spirit/home/classic/symbols/typeof.hpp
|
cb62c8090ebf4638c3cf190c95aa9fdde5c047d7
|
[
"BSL-1.0",
"BSD-3-Clause"
] |
permissive
|
Sitispeaks/turicreate
|
0bda7c21ee97f5ae7dc09502f6a72abcb729536d
|
d42280b16cb466a608e7e723d8edfbe5977253b6
|
refs/heads/main
| 2023-05-19T17:55:21.938724
| 2021-06-14T17:53:17
| 2021-06-14T17:53:17
| 385,034,849
| 1
| 0
|
BSD-3-Clause
| 2021-07-11T19:23:21
| 2021-07-11T19:23:20
| null |
UTF-8
|
C++
| false
| false
| 980
|
hpp
|
/*=============================================================================
Copyright (c) 2006 Tobias Schwinger
http://spirit.sourceforge.net/
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)
=============================================================================*/
#if !defined(BOOST_SPIRIT_SYMBOLS_TYPEOF_HPP)
#define BOOST_SPIRIT_SYMBOLS_TYPEOF_HPP
#include <boost/typeof/typeof.hpp>
#include <boost/spirit/home/classic/symbols/symbols_fwd.hpp>
#include BOOST_TYPEOF_INCREMENT_REGISTRATION_GROUP()
BOOST_TYPEOF_REGISTER_TEMPLATE(BOOST_SPIRIT_CLASSIC_NS::symbols,3)
BOOST_TYPEOF_REGISTER_TEMPLATE(BOOST_SPIRIT_CLASSIC_NS::symbol_inserter,2)
BOOST_TYPEOF_REGISTER_TEMPLATE(BOOST_SPIRIT_CLASSIC_NS::impl::tst,2)
BOOST_TYPEOF_REGISTER_TEMPLATE(BOOST_SPIRIT_CLASSIC_NS::symbols,2)
BOOST_TYPEOF_REGISTER_TEMPLATE(BOOST_SPIRIT_CLASSIC_NS::symbols,1)
#endif
|
[
"znation@apple.com"
] |
znation@apple.com
|
c1dac528011c06c22f122152ed828c239b21ce73
|
2e5a87af3332a36f031d718594d3ee0525c90c40
|
/shield/ViewTree.h
|
ee3fdeffbb19261f825b8dd6ccd086cc09b0eed8
|
[] |
no_license
|
kxf3199/shield
|
a2d5400d7ae1344f1dd6b53b5fb37c014dafeeb8
|
56bce1ab4d921d10af8e9093a2237ece73382e0a
|
refs/heads/master
| 2021-01-11T20:05:16.219948
| 2017-01-19T16:44:16
| 2017-01-19T16:44:16
| 79,469,568
| 0
| 0
| null | null | null | null |
GB18030
|
C++
| false
| false
| 726
|
h
|
#pragma once
/////////////////////////////////////////////////////////////////////////////
// CViewTree 窗口
#define FILE_VIEW 1
#define CLASS_VIEW 2
struct STR_treeNode
{
bool m_bFolder;
bool m_bFile;
bool m_bHasChild;
STR_treeNode()
{
m_bFolder = false;
m_bHasChild = false;
}
};
class CViewTree : public CTreeCtrl
{
// 构造
public:
CViewTree();
afx_msg void OnClick(NMHDR* pNMHDR, LRESULT* pResult);
afx_msg void OnDblClk(NMHDR* pNMHDR, LRESULT* pResult);
// 重写
protected:
virtual BOOL OnNotify(WPARAM wParam, LPARAM lParam, LRESULT* pResult);
CViewTree* m_tree;
void Click(NMHDR* pNMHDR, LRESULT* pResult,UINT uFlags);
// 实现
public:
virtual ~CViewTree();
protected:
DECLARE_MESSAGE_MAP()
};
|
[
"happy_kuang@qq.com"
] |
happy_kuang@qq.com
|
19301375d6d7a72932a38f486daefc9e45eca567
|
c80bd757f18735452eef1f0f7cd7bd305d4313c7
|
/src/Core/Algorithms/Legacy/Fields/MeshData/SetMeshNodes.cc
|
02e31f7ccd7bad4a412e498e9547673977188199
|
[
"MIT"
] |
permissive
|
kenlouie/SCIRunGUIPrototype
|
956449f4b4ce3ed76ccc1fa23a6656f084c3a9b1
|
062ff605839b076177c4e50f08cf36d83a6a9220
|
refs/heads/master
| 2020-12-25T03:11:44.510875
| 2013-10-01T05:51:39
| 2013-10-01T05:51:39
| null | 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 3,914
|
cc
|
/*
For more information, please see: http://software.sci.utah.edu
The MIT License
Copyright (c) 2009 Scientific Computing and Imaging Institute,
University of Utah.
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 <Core/Datatypes/Legacy/Field/FieldInformation.h>
#include <Core/Algorithms/Legacy/Fields/MeshData/SetMeshNodes.h>
#include <Core/Algorithms/Legacy/Fields/ConvertMeshType/ConvertMeshToIrregularMesh.h>
#include <Core/Datatypes/Legacy/Field/VMesh.h>
#include <Core/Algorithms/Base/AlgorithmPreconditions.h>
#include <Core/Datatypes/DenseMatrix.h>
#include <Core/Datatypes/PropertyManagerExtensions.h>
using namespace SCIRun;
using namespace SCIRun::Core::Algorithms::Fields;
using namespace SCIRun::Core::Geometry;
using namespace SCIRun::Core::Utility;
using namespace SCIRun::Core::Algorithms;
using namespace SCIRun::Core::Datatypes;
bool
SetMeshNodesAlgo::run(FieldHandle input, DenseMatrixHandle matrix, FieldHandle& output) const
{
ScopedAlgorithmStatusReporter asr(this, "SetMeshNodes");
if (!input)
{
error("No input source field");
return (false);
}
if (!matrix)
{
error("No input source matrix");
return (false);
}
VMesh::size_type numnodes = input->vmesh()->num_nodes();
// try to see whether the matrix dimensions fit the mesh size
if (!(matrix->nrows() == numnodes) ||
!(matrix->ncols() == 3))
{
error("Matrix dimensions do not match any of the fields dimensions");
return (false);
}
FieldInformation fi(input);
if (fi.is_regularmesh())
{
//TODO: worth separating out into factory call for mocking purposes? probably not, just keep the concrete dependence
ConvertMeshToIrregularMeshAlgo algo;
algo.setUpdaterFunc(getUpdaterFunc());
if (!algo.run(input,output))
return (false);
}
else
{
output.reset(input->deep_clone());
}
CopyProperties(*input, *output);
VMesh* mesh = output->vmesh();
VMesh::size_type size = mesh->num_nodes();
Point p;
int cnt =0;
for (VMesh::Node::index_type i=0; i<size; ++i)
{
p.x( (*matrix)(i, 0) );
p.y( (*matrix)(i, 1) );
p.z( (*matrix)(i, 2) );
mesh->set_point(p,i);
cnt++; if (cnt == 400) {cnt=0; update_progress_max(i,size); }
}
return (true);
}
AlgorithmInputName SetMeshNodesAlgo::InputField("InputField");
AlgorithmInputName SetMeshNodesAlgo::MatrixNodes("MatrixNodes");
AlgorithmOutputName SetMeshNodesAlgo::OutputField("OutputField");
AlgorithmOutput SetMeshNodesAlgo::run_generic(const AlgorithmInput& input) const
{
auto inputField = input.get<Field>(InputField);
auto nodes = input.get<DenseMatrix>(MatrixNodes);
FieldHandle outputField;
if (!run(inputField, nodes, outputField))
THROW_ALGORITHM_PROCESSING_ERROR("False returned on legacy run call.");
AlgorithmOutput output;
output[OutputField] = outputField;
return output;
}
|
[
"dwhite@sci.utah.edu"
] |
dwhite@sci.utah.edu
|
a200af0795ce24d48d332efa685c269f2ea87ba6
|
091afb7001e86146209397ea362da70ffd63a916
|
/inst/include/nt2/include/functions/ldiv.hpp
|
ff2867bcbbe1ba9d5386d710b3691ff1ef77ef72
|
[] |
no_license
|
RcppCore/RcppNT2
|
f156b58c08863243f259d1e609c9a7a8cf669990
|
cd7e548daa2d679b6ccebe19744b9a36f1e9139c
|
refs/heads/master
| 2021-01-10T16:15:16.861239
| 2016-02-02T22:18:25
| 2016-02-02T22:18:25
| 50,460,545
| 15
| 1
| null | 2019-11-15T22:08:50
| 2016-01-26T21:29:34
|
C++
|
UTF-8
|
C++
| false
| false
| 158
|
hpp
|
#ifndef NT2_INCLUDE_FUNCTIONS_LDIV_HPP_INCLUDED
#define NT2_INCLUDE_FUNCTIONS_LDIV_HPP_INCLUDED
#include <nt2/arithmetic/include/functions/ldiv.hpp>
#endif
|
[
"kevinushey@gmail.com"
] |
kevinushey@gmail.com
|
0656a2df1d0463c1b30c297a357f76ceb90a4784
|
5ac691580c49d8cf494d5b98c342bb11f3ff6514
|
/Codeforces/1360/1360A.cpp
|
83765edea4180d39c6a4695a1b471d3d878e4f0e
|
[] |
no_license
|
sweatpotato13/Algorithm-Solving
|
e68411a4f430d0517df4ae63fc70d1a014d8b3ba
|
b2f8cbb914866d2055727b9872f65d7d270ba31b
|
refs/heads/master
| 2023-03-29T23:44:53.814519
| 2023-03-21T23:09:59
| 2023-03-21T23:09:59
| 253,355,531
| 3
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 525
|
cpp
|
#pragma warning(disable : 4996)
#include <bits/stdc++.h>
#define all(x) (x).begin(), (x).end()
using namespace std;
typedef long long ll;
typedef pair<ll,ll> pll;
// https://codeforces.com/problemset/problem/1360/A
int main(){
ios::sync_with_stdio(false);
cin.tie(nullptr);
ll t;
cin >> t;
while(t--){
ll ans = 0;
ll e,s;
cin >> e >> s;
if(e > s) swap(e,s);
if(e == s){
ans = 4*e*e;
}
else{
if(e <= s/2){
ans = s*s;
}
else{
ans = 4*e*e;
}
}
cout << ans << "\n";
}
return 0;
}
|
[
"sweatpotato13@gmail.com"
] |
sweatpotato13@gmail.com
|
3263e370651cb849fb886353a3b3624af5f6b2fa
|
ec3ab4474201bdcd9bdacd8ea3877f6a46feb6b7
|
/lib/csvfix/csvfix/src/csved_dsv.cpp
|
bb685ac0e2942694ef70e6d271df238573fcec23
|
[
"MIT"
] |
permissive
|
purinda/csvfix
|
68e26ce734a25e8f5b5bf829350bf9352acbd788
|
bef09c85d78b1447965f76b1a38f1922cad2bd6e
|
refs/heads/master
| 2016-09-06T07:10:13.679335
| 2014-04-08T12:27:45
| 2014-04-08T12:27:45
| 18,459,389
| 2
| 1
| null | 2014-04-06T06:04:42
| 2014-04-05T03:45:49
|
D
|
UTF-8
|
C++
| false
| false
| 9,017
|
cpp
|
//---------------------------------------------------------------------------
// csved_dsv.cpp
//
// delimitter separated values (DSV) read/write
//
// Copyright (C) 2009 Neil Butterworth
//---------------------------------------------------------------------------
#include "a_base.h"
#include "a_collect.h"
#include "csved_cli.h"
#include "csved_dsv.h"
#include "csved_strings.h"
using std::string;
using std::vector;
namespace CSVED {
//----------------------------------------------------------------------------
// Default field delimitter
//----------------------------------------------------------------------------
const char DEF_DELIM = '|';
//---------------------------------------------------------------------------
// Register read & write command
//---------------------------------------------------------------------------
static RegisterCommand <DSVReadCommand> rc1_(
CMD_DSVR,
"convert DSV (delimiter separated variables) data to CSV"
);
static RegisterCommand <DSVWriteCommand> rc2_(
CMD_DSVW,
"convert CSV to DSV format"
);
//----------------------------------------------------------------------------
// Help text
//----------------------------------------------------------------------------
const char * const DSVR_HELP = {
"convert data in delimiter-separated variables format to CSV\n"
"usage: csvfix read_dsv [flags] [files ...]\n"
"where flags are:\n"
" -f fields\tspecify list of fields to convert (default is all)\n"
" -s sep\tspecify DSV separator character (default is pipe symbol)\n"
" -csv\t\ttreat field contents as CSV (double quotes are special)\n"
" -cm\t\tcollapse multiple separators into single instance\n"
"#SMQ,IBL,OFL"
};
const char * const DSVW_HELP = {
"convert data in CSV format to delimiter-separated variables format\n"
"usage: csvfix write_dsv [flags] [files ...]\n"
"where flags are:\n"
" -f fields\tspecify list of fields to convert (default is all)\n"
" -s sep\tspecify DSV separator character (default is pipe symbol)\n"
"#IFN,IBL,OFL,SEP,SKIP"
};
//---------------------------------------------------------------------------
// Base handles field list and delimitter
//---------------------------------------------------------------------------
DSVBase :: DSVBase( const string & name, const string & desc,
const string & help )
: Command( name, desc, help ), mDelim( DEF_DELIM ) {
AddFlag( ALib::CommandLineFlag( FLAG_SEP, false, 1 ) );
AddFlag( ALib::CommandLineFlag( FLAG_COLS, false, 1 ) );
}
//----------------------------------------------------------------------------
// Get field delimiter = default is pipe character.
//----------------------------------------------------------------------------
char DSVBase :: Delim() const {
return mDelim;
}
//----------------------------------------------------------------------------
// Read command line flags. The most problematic is the one that specifies
// the field separator. This defaults to '|', but any single character can be
// used. To specify a tab-separated file, use -s '\t'.
//----------------------------------------------------------------------------
void DSVBase :: ReadFlags( const ALib::CommandLine & cl ) {
string delim = cl.GetValue( FLAG_SEP, ALib::Str( DEF_DELIM ) );
if ( delim.size() == 0 ) {
CSVTHROW( "Separator specified by " << FLAG_SEP
<< " cannot be empty" );
}
else if ( delim.size() == 1 ) {
mDelim = delim[0];
}
else if ( delim.size() == 2 && delim[0] == '\\' ) {
if ( delim[1] == 't' ) {
mDelim = '\t';
}
else {
CSVTHROW( "Bad escaped separator specified by " << FLAG_SEP );
}
}
else {
CSVTHROW( "Bad separator specified by " << FLAG_SEP );
}
string fields = cl.GetValue( FLAG_COLS, "" );
CommaListToIndex( ALib::CommaList( fields ), mFields );
}
//----------------------------------------------------------------------------
// Convert input to output using fields list.
//----------------------------------------------------------------------------
void DSVBase :: BuildCSVRow( const CSVRow & in, CSVRow & out ) const {
if ( mFields.size() == 0 ) {
out = in;
}
else {
out.clear();
for ( unsigned int i = 0; i < mFields.size(); i++ ) {
unsigned int f = mFields[ i ];
if ( f < in.size() ) {
out.push_back( in[ f ] );
}
else {
out.push_back( "" );
}
}
}
}
//------------------------------------------------------------------------
// Standard command ctor
//---------------------------------------------------------------------------
DSVReadCommand :: DSVReadCommand( const string & name,
const string & desc )
: DSVBase( name, desc, DSVR_HELP ), mIsCSV( false ), mCollapseSep( false ) {
AddFlag( ALib::CommandLineFlag( FLAG_CSV, false, 0 ) );
AddFlag( ALib::CommandLineFlag( FLAG_CMULTI, false, 0 ) );
}
//---------------------------------------------------------------------------
// Read lines from input, parse them as DSV and output as CSV
//---------------------------------------------------------------------------
int DSVReadCommand :: Execute( ALib::CommandLine & cmd ) {
ReadFlags( cmd );
mIsCSV = cmd.HasFlag( FLAG_CSV );
mCollapseSep = cmd.HasFlag( FLAG_CMULTI );
IOManager io( cmd );
CSVRow row;
string line;
while( io.ReadLine( line ) ) {
ParseDSV( line, row );
io.WriteRow( row );
}
return 0;
}
//----------------------------------------------------------------------------
// Helper to unquote possibly quoted CSV data.
//----------------------------------------------------------------------------
string DSVReadCommand :: Unquote( const string & s ) const {
if ( ! mIsCSV ) {
return s;
}
string t = ALib::UnQuote( s );
if ( t.find( "\"" ) == std::string::npos ) {
return t;
}
string t2;
for ( unsigned int i = 0; i < t.size(); i++ ) {
char c = t.at(i);
if ( c == '"' && ALib::Peek( t, i + 1 ) == '"' ) {
t2 += '"';
i++;
}
else {
t2 += c;
}
}
return t2;
}
//---------------------------------------------------------------------------
// Chop line up into fields seoarated by mDelim. The delimiter can be
// escaped with a backslash. If the mCollapseSep flag is set, multiple
// occurences of a separator are treated as a single one.
//---------------------------------------------------------------------------
void DSVReadCommand :: ParseDSV( const string & line, CSVRow & rv ) {
CSVRow row;
unsigned int pos = 0, len = line.size();
string val;
while( pos < len ) {
char c = line[ pos++ ];
if ( c == Delim() ) {
while( mCollapseSep && ALib::Peek( line, pos ) == Delim() ) {
pos++;
}
row.push_back( Unquote( val ) );
val = "";
}
else if ( c == '\\' ) {
if ( pos == len ) {
CSVTHROW( "Escape at end of line" );
}
else {
val += line[ pos++ ];
}
}
else {
val += c;
}
}
row.push_back( Unquote( val ) );
BuildCSVRow( row, rv );
}
//---------------------------------------------------------------------------
// Standard command ctor
//---------------------------------------------------------------------------
DSVWriteCommand :: DSVWriteCommand( const string & name,
const string & desc )
: DSVBase( name, desc, DSVW_HELP ) {
}
//---------------------------------------------------------------------------
// Read CSV rows and output them as DSV
//---------------------------------------------------------------------------
int DSVWriteCommand :: Execute( ALib::CommandLine & cmd ) {
GetSkipOptions( cmd );
ReadFlags( cmd );
IOManager io( cmd );
CSVRow row;
while( io.ReadCSV( row ) ) {
if ( ! Skip( row ) ) {
io.Out() << MakeDSV( row ) << "\n";
}
}
return 0;
}
//---------------------------------------------------------------------------
// Build DSV row
//---------------------------------------------------------------------------
string DSVWriteCommand :: MakeDSV( const CSVRow & in ) {
CSVRow row;
BuildCSVRow( in, row );
string line;
for ( unsigned int i = 0; i < row.size(); i++ ) {
line += MakeField( row[i] );
if ( i != row.size() - 1 ) {
line += Delim();
}
}
return line;
}
//---------------------------------------------------------------------------
// Create field contaents, quoting any delimiter
//---------------------------------------------------------------------------
string DSVWriteCommand :: MakeField( const string & val ) {
if ( val.find( Delim() ) == std::string::npos ) {
return val;
}
else {
string t;
for ( unsigned int i = 0; i < val.size(); i++ ) {
char c = val[i];
if ( c == Delim() || c == '\\' ) {
t += '\\';
}
t += c;
}
return t;
}
}
//------------------------------------------------------------------------
} // end namespace
// end
|
[
"purinda@gmail.com"
] |
purinda@gmail.com
|
c01adfc46915d84914c4bd44d924c3ed313bc3ce
|
e7a9a9321b6dca5821a8622d7400556500563bc9
|
/303_Range_Sum_Query_Immutable.cc
|
c64d20773ea7b648b7911030ef64b706273d5eea
|
[] |
no_license
|
cpppy/leetcode
|
0933f11e5de038dcb94d1aa8394a3fab230ea49b
|
4edb308097ba7f8cdc46e6856ca98757eee6fa0f
|
refs/heads/master
| 2020-05-22T03:59:18.464763
| 2016-09-21T12:33:54
| 2016-09-21T12:33:54
| 65,656,516
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 568
|
cc
|
class NumArray {
public:
NumArray(vector<int> &nums) {
if(nums.size()==0) return;
int tmp=0;
for(int i=0;i<nums.size();++i){
tmp+=nums[i];
sums.push_back(tmp);
}
}
int sumRange(int i, int j) {
if(i>j) return 0;
if(i==0) return sums[j];
else return sums[j]-sums[i-1];
}
private:
vector<int> sums;
};
// Your NumArray object will be instantiated and called as such:
// NumArray numArray(nums);
// numArray.sumRange(0, 1);
// numArray.sumRange(1, 2);
|
[
"noreply@github.com"
] |
cpppy.noreply@github.com
|
3c556299c8a9e13e5704c949d188bf1036bde831
|
32a5ddaff9ec16fbd155b6da8d752b5eb8f8f8ee
|
/include/dll/neural/dyn_batch_normalization_layer_2d.inl
|
8a0120b3bf0a6e76ba64bbb736ccdbe702922a13
|
[
"MIT",
"LicenseRef-scancode-unknown-license-reference"
] |
permissive
|
tony32769/dll
|
2920d4c9170272bdf8760a4bb59f23007a79ce23
|
83a7ee111ca4a7175efd9b8dab24492bc6057af2
|
refs/heads/master
| 2021-03-22T04:39:56.579475
| 2017-09-05T13:55:31
| 2017-09-05T13:55:31
| null | 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 10,533
|
inl
|
//=======================================================================
// Copyright (c) 2014-2017 Baptiste Wicht
// Distributed under the terms of the MIT License.
// (See accompanying file LICENSE or copy at
// http://opensource.org/licenses/MIT)
//=======================================================================
#pragma once
#include "dll/neural_layer.hpp"
namespace dll {
/*!
* \brief Batch Normalization layer
*/
template <typename Desc>
struct dyn_batch_normalization_2d_layer : neural_layer<dyn_batch_normalization_2d_layer<Desc>, Desc> {
using desc = Desc; ///< The descriptor type
using base_type = neural_layer<dyn_batch_normalization_2d_layer<Desc>, Desc>; ///< The base type
using weight = typename desc::weight; ///< The data type of the layer
static constexpr weight e = 1e-8; ///< Epsilon for numerical stability
using input_one_t = etl::dyn_matrix<weight, 1>; ///< The type of one input
using output_one_t = etl::dyn_matrix<weight, 1>; ///< The type of one output
using input_t = std::vector<input_one_t>; ///< The type of the input
using output_t = std::vector<output_one_t>; ///< The type of the output
etl::dyn_matrix<weight, 1> gamma;
etl::dyn_matrix<weight, 1> beta;
etl::dyn_matrix<weight, 1> mean;
etl::dyn_matrix<weight, 1> var;
etl::dyn_matrix<weight, 1> last_mean;
etl::dyn_matrix<weight, 1> last_var;
etl::dyn_matrix<weight, 1> inv_var;
etl::dyn_matrix<weight, 2> input_pre; /// B x Input
weight momentum = 0.9;
//Backup gamma and beta
std::unique_ptr<etl::dyn_matrix<weight, 1>> bak_gamma; ///< Backup gamma
std::unique_ptr<etl::dyn_matrix<weight, 1>> bak_beta; ///< Backup beta
size_t Input = 0;
dyn_batch_normalization_2d_layer() : base_type() {
// Nothing else to init
}
void init_layer(size_t Input){
this->Input = Input;
gamma = etl::dyn_vector<weight>(Input);
beta = etl::dyn_vector<weight>(Input);
mean = etl::dyn_vector<weight>(Input);
var = etl::dyn_vector<weight>(Input);
last_mean = etl::dyn_vector<weight>(Input);
last_var = etl::dyn_vector<weight>(Input);
inv_var = etl::dyn_vector<weight>(Input);
// Initializate the weights
gamma = 1.0;
beta = 0.0;
}
/*!
* \brief Returns a string representation of the layer
*/
static std::string to_short_string() {
return "batch_norm";
}
/*!
* \brief Return the number of trainable parameters of this network.
* \return The the number of trainable parameters of this network.
*/
size_t parameters() const noexcept {
return 4 * Input;
}
/*!
* \brief Return the size of the input of this layer
* \return The size of the input of this layer
*/
size_t input_size() const noexcept {
return Input;
}
/*!
* \brief Return the size of the output of this layer
* \return The size of the output of this layer
*/
size_t output_size() const noexcept {
return Input;
}
using base_type::test_forward_batch;
using base_type::train_forward_batch;
/*!
* \brief Apply the layer to the batch of input
* \param output The batch of output
* \param input The batch of input to apply the layer to
*/
template <typename Input, typename Output>
void forward_batch(Output& output, const Input& input) const {
test_forward_batch(output, input);
}
/*!
* \brief Apply the layer to the batch of input
* \param output The batch of output
* \param input The batch of input to apply the layer to
*/
template <typename Input, typename Output>
void test_forward_batch(Output& output, const Input& input) const {
const auto B = etl::dim<0>(input);
auto inv_var = etl::force_temporary(1.0 / etl::sqrt(var + e));
for(size_t b = 0; b < B; ++b){
output(b) = (gamma >> ((input(b) - mean) >> inv_var)) + beta;
}
}
/*!
* \brief Apply the layer to the batch of input
* \param output The batch of output
* \param input The batch of input to apply the layer to
*/
template <typename Input, typename Output>
void train_forward_batch(Output& output, const Input& input) {
const auto B = etl::dim<0>(input);
last_mean = etl::mean_l(input);
auto last_mean_rep = etl::rep_l(last_mean, B);
last_var = etl::mean_l((input - last_mean_rep) >> (input - last_mean_rep));
inv_var = 1.0 / etl::sqrt(last_var + e);
input_pre.inherit_if_null(input);
for(size_t b = 0; b < B; ++b){
input_pre(b) = (input(b) - last_mean) >> inv_var;
output(b) = (gamma >> input_pre(b)) + beta;
}
// Update the current mean and variance
mean = momentum * mean + (1.0 - momentum) * last_mean;
var = momentum * var + (1.0 - momentum) * (B / (B - 1) * last_var);
}
/*!
* \brief Adapt the errors, called before backpropagation of the errors.
*
* This must be used by layers that have both an activation fnction and a non-linearity.
*
* \param context the training context
*/
template<typename C>
void adapt_errors(C& context) const {
cpp_unused(context);
}
/*!
* \brief Backpropagate the errors to the previous layers
* \param output The ETL expression into which write the output
* \param context The training context
*/
template<typename H, typename C>
void backward_batch(H&& output, C& context) const {
const auto B = etl::dim<0>(context.input);
auto dxhat = etl::force_temporary(context.errors >> etl::rep_l(gamma, B));
auto dxhat_l = etl::force_temporary(etl::sum_l(dxhat));
auto dxhat_xhat_l = etl::force_temporary(etl::sum_l(dxhat >> input_pre));
for(size_t b = 0; b < B; ++b){
output(b) = (1.0 / B) >> inv_var >> (B * dxhat(b) - dxhat_l - (input_pre(b) >> dxhat_xhat_l));
}
}
/*!
* \brief Compute the gradients for this layer, if any
* \param context The trainng context
*/
template<typename C>
void compute_gradients(C& context) const {
// Gradients of gamma
std::get<0>(context.up.context)->grad = etl::sum_l(input_pre >> context.errors);
// Gradients of beta
std::get<1>(context.up.context)->grad = etl::sum_l(context.errors);
}
/*!
* \brief Prepare one empty output for this layer
* \return an empty ETL matrix suitable to store one output of this layer
*
* \tparam Input The type of one Input
*/
template <typename InputType>
output_one_t prepare_one_output() const {
return output_one_t(Input);
}
/*!
* \brief Prepare a set of empty outputs for this layer
* \param samples The number of samples to prepare the output for
* \return a container containing empty ETL matrices suitable to store samples output of this layer
* \tparam Input The type of one input
*/
template <typename InputType>
output_t prepare_output(size_t samples) const {
output_t output;
output.reserve(samples);
for(size_t i = 0; i < samples; ++i){
output.emplace_back(Input);
}
return output;
}
/*!
* \brief Initialize the dynamic version of the layer from the
* fast version of the layer
* \param dyn Reference to the dynamic version of the layer that
* needs to be initialized
*/
template<typename DRBM>
static void dyn_init(DRBM&){
//Nothing to change
}
/*!
* \brief Returns the trainable variables of this layer.
* \return a tuple containing references to the variables of this layer
*/
decltype(auto) trainable_parameters(){
return std::make_tuple(std::ref(gamma), std::ref(beta));
}
/*!
* \brief Backup the weights in the secondary weights matrix
*/
void backup_weights() {
unique_safe_get(bak_gamma) = gamma;
unique_safe_get(bak_beta) = beta;
}
/*!
* \brief Restore the weights from the secondary weights matrix
*/
void restore_weights() {
gamma = *bak_gamma;
beta = *bak_beta;
}
};
// Declare the traits for the layer
template<typename Desc>
struct layer_base_traits<dyn_batch_normalization_2d_layer<Desc>> {
static constexpr bool is_neural = true; ///< Indicates if the layer is a neural layer
static constexpr bool is_dense = false; ///< Indicates if the layer is dense
static constexpr bool is_conv = false; ///< Indicates if the layer is convolutional
static constexpr bool is_deconv = false; ///< Indicates if the layer is deconvolutional
static constexpr bool is_standard = false; ///< Indicates if the layer is standard
static constexpr bool is_rbm = false; ///< Indicates if the layer is RBM
static constexpr bool is_pooling = false; ///< Indicates if the layer is a pooling layer
static constexpr bool is_unpooling = false; ///< Indicates if the layer is an unpooling laye
static constexpr bool is_transform = false; ///< Indicates if the layer is a transform layer
static constexpr bool is_dynamic = true; ///< Indicates if the layer is dynamic
static constexpr bool pretrain_last = false; ///< Indicates if the layer is dynamic
static constexpr bool sgd_supported = true; ///< Indicates if the layer is supported by SGD
};
/*!
* \brief Specialization of sgd_context for dyn_batch_normalization_2d_layer
*/
template <typename DBN, typename Desc, size_t L>
struct sgd_context<DBN, dyn_batch_normalization_2d_layer<Desc>, L> {
using layer_t = dyn_batch_normalization_2d_layer<Desc>; ///< The current layer type
using weight = typename layer_t::weight; ///< The data type for this layer
static constexpr auto batch_size = DBN::batch_size;
etl::dyn_matrix<weight, 2> input; ///< A batch of input
etl::dyn_matrix<weight, 2> output; ///< A batch of output
etl::dyn_matrix<weight, 2> errors; ///< A batch of errors
sgd_context(layer_t& layer) : input(batch_size, layer.Input), output(batch_size, layer.Input), errors(batch_size, layer.Input) {}
};
} //end of dll namespace
|
[
"baptiste.wicht@gmail.com"
] |
baptiste.wicht@gmail.com
|
57b65573bc652be66c04e865ed71f97b410d2b63
|
ccca8e70c78f4543a11e156b5bd7b528366fb36d
|
/include/Fraction.h
|
d533e189726e4bd527ec0b8988bf88044e674bc1
|
[] |
no_license
|
tndumarevskaya/Ex07
|
ad5971f0077e42f94a6b559c606d18c1287fd152
|
8187838f093128a9b4c24adeca8786a74ebb25ab
|
refs/heads/main
| 2023-01-22T07:00:24.315368
| 2020-12-05T13:20:41
| 2020-12-05T13:20:41
| 317,471,225
| 0
| 0
| null | 2020-12-01T08:17:58
| 2020-12-01T08:17:58
| null |
UTF-8
|
C++
| false
| false
| 774
|
h
|
// Copyright 2020 Dumarevskaya
#ifndef INCLUDE_FRACTION_H_
#define INCKUDE_FRACTION_H_
#include <iostream>
#include <cstring>
#include <string>
class Fraction {
private:
int numerator;
int denominator;
public:
explicit Fraction(int num = 0, int den = 1):
numerator{num}, denominator{den}{};
Fraction(const Fraction& new_f):
numerator{ new_f.numerator }, denominator{ new_f.denominator }{};
std::string getValue();
int getNumerator();
int getDenominator();
Fraction operator+(const Fraction& frac);
Fraction operator-(const Fraction& frac);
Fraction operator*(const Fraction& frac);
Fraction operator/(const Fraction& frac);
Fraction& operator=(const Fraction& frac);
protected:
Fraction normalize();
};
#endif // INCLUDE_FRACTION_H_
|
[
"dumtanya2009@gmail.com"
] |
dumtanya2009@gmail.com
|
5fec11f0d4125949f74164badc8e9b5d6893a4df
|
80acc9d99296cbcb2fcac8f38fb7b5da98dbaa49
|
/Lab_MelissaMansilla/MyForm.cpp
|
d37512fcc5a8a62f30ab9ec91d1a36de374cc694
|
[] |
no_license
|
Mansi1108/Lab_6MelissaMansilla
|
08e5434c78cfe52bc3fa6e4b2286c0189d2d7b88
|
cc05f23ba9b8553d28c9605c3c092843650a69fe
|
refs/heads/master
| 2020-09-16T04:49:10.831849
| 2019-11-24T00:11:06
| 2019-11-24T00:11:06
| 223,657,645
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 304
|
cpp
|
#include "MyForm.h"
using namespace System;
using namespace System::Windows::Forms;
[STAThreadAttribute]
int main(array<String^>^ args) {
Application::EnableVisualStyles();
Application::SetCompatibleTextRenderingDefault(false);
LabMelissaMansilla::MyForm form;
Application::Run(%form);
return 0;
}
|
[
"mansillamelissa@gmail.com"
] |
mansillamelissa@gmail.com
|
3683b6563e989a70ff11a72b8f42fb8a9c9c8444
|
b44250e01cf3528f79e4b0969cf598bee6341840
|
/src/include/cutlass-ori/gemm/warp/mma_tensor_op_tile_iterator.h
|
9d4d81d49dbed7146920c83aade64c2db8f094f8
|
[] |
no_license
|
xzgz/cuda-study
|
c821322ba3101883766fe8d256ba8137ecdf609f
|
37a88d80be6a3bf121cd4d769e6f1dc37c3ae038
|
refs/heads/master
| 2023-08-05T22:16:54.191302
| 2023-07-24T10:04:48
| 2023-07-24T10:04:48
| 211,104,935
| 0
| 0
| null | 2023-05-03T10:27:26
| 2019-09-26T14:09:26
|
C++
|
UTF-8
|
C++
| false
| false
| 125,256
|
h
|
/***************************************************************************************************
* Copyright (c) 2017-2021, NVIDIA CORPORATION. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are permitted
* provided that the following conditions are met:
* * Redistributions of source code must retain the above copyright notice, this list of
* conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright notice, this list of
* conditions and the following disclaimer in the documentation and/or other materials
* provided with the distribution.
* * Neither the name of the NVIDIA CORPORATION nor the names of its contributors may be used
* to endorse or promote products derived from this software without specific prior written
* permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
* FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NVIDIA CORPORATION BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
* OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
* STRICT LIABILITY, OR TOR (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
**************************************************************************************************/
/*! \file
\brief Defines iterators used by warp-level matrix multiply operations targeting Tensor Cores.
*/
#pragma once
#include "cutlass/cutlass.h"
#include "cutlass/array.h"
#include "cutlass/numeric_types.h"
#include "cutlass/tensor_ref.h"
#include "cutlass/matrix_shape.h"
#include "cutlass/arch/memory_sm75.h"
#include "cutlass/gemm/gemm.h"
#include "cutlass/layout/matrix.h"
#include "cutlass/layout/tensor.h"
#include "cutlass/layout/pitch_linear.h"
#include "cutlass/layout/tensor_op_multiplicand_sm75.h"
#include "cutlass/platform/platform.h"
#include "cutlass/fast_math.h"
////////////////////////////////////////////////////////////////////////////////
namespace cutlass {
namespace gemm {
namespace warp {
////////////////////////////////////////////////////////////////////////////////
template <
/// Size of the matrix to load (concept: MatrixShape)
typename Shape_,
/// Operand identity
Operand Operand,
/// Data type of A elements
typename Element_,
/// Layout of operand
typename Layout_,
/// Shape of one matrix production operation (concept: GemmShape)
typename InstructionShape_,
/// Delta between *MMA operations (in units of *MMA operations, concept:
/// MatrixShape)
int OpDelta_,
/// Number of threads participating in one matrix operation
int Threads,
/// Number of partitions along K dimension
int PartitionsK_ = 1>
class MmaTensorOpMultiplicandTileIterator;
////////////////////////////////////////////////////////////////////////////////
/// This tile iterator is specialized for 32-thread TensorOps. It uses LDSM to load from shared
/// memory and therefore must be initialized with a TensorRef to shared memory.
///
/// Satisfies:
/// ReadableRandomAccessContiguousTileIteratorConcept
///
template <
/// Size of the matrix to load (concept: PitchLinearShape)
typename Shape_,
/// Identifies A or B multiplicand
Operand Operand_,
/// Data type of elements
typename Element_,
/// Shape of one matrix product operation (concept: PitchLinearShape)
typename InstructionShape_,
/// Interval between adjacent *MMA instructions (in units of MMA
/// instructions)
int OpDelta_,
/// Number of partitions along K dimension
int PartitionsK_>
class MmaTensorOpMultiplicandTileIterator<
Shape_, Operand_, Element_,
cutlass::layout::TensorOpMultiplicandCongruous<sizeof_bits<Element_>::value,
64>,
InstructionShape_, OpDelta_, 32, PartitionsK_> {
public:
/// Shape of tile to load (concept: PitchLinearShape)
using Shape = Shape_;
/// Operand tag
static Operand const kOperand = Operand_;
static_assert(kOperand == Operand::kA || kOperand== Operand::kB,
"MmaTensorOpMultiplicandIterator may only be instantiated for A or B operands to warp-level Mma.");
/// Element type
using Element = Element_;
/// Layout of source tile
using Layout = cutlass::layout::TensorOpMultiplicandCongruous<
sizeof_bits<Element_>::value, 64>;
/// Shape of one matrix product operation (concept: GemmShape)
using InstructionShape = InstructionShape_;
/// Delta between *MMA operations (in units of *MMA operations, concept: MatrixShape)
static int const kOpDelta = OpDelta_;
/// Number of participating threads
static int const kThreads = 32;
/// Number of partitions along K dimension
static int const kPartitionsK = PartitionsK_;
/// TensorRef type for loading element from a tensor
using TensorRef = TensorRef<Element, Layout>;
/// Index type
using Index = typename TensorRef::Index;
/// Long Index type
using LongIndex = typename TensorRef::LongIndex;
/// Coordinate for an element in the tensor
using TensorCoord = typename TensorRef::TensorCoord;
/// Internal structure of iterator - made public to enable introspection
struct Policy {
static_assert(
!(Shape::kContiguous % InstructionShape::kContiguous),
"Shape of warp-level Mma must be divisible by operator shape.");
// Determine number of elements along outer dimension per individual LDSM op
static int const kLdsmOpOuter = Layout::kElementsPerAccess;
static int const kLdsmOpInner = 8;
static_assert(!(Shape::kContiguous % kLdsmOpOuter),
"Shape of warp-level mma must be divisible by LDSM's fundamental tile size.");
static_assert(!(Shape::kStrided % kLdsmOpInner),
"Shape of warp-level mma must be divisible by LDSM's fundamental tile size.");
/// Shape of one individual LDSM instruction
static int const LdsmShapeStrided =
InstructionShape::kStrided / kLdsmOpInner;
static int const LdsmShapeContiguous = 4 / LdsmShapeStrided;
using LdsmShape =
layout::PitchLinearShape<LdsmShapeContiguous, LdsmShapeStrided>;
/// Number and arrangement of LDSM instructions
using LdsmIterations = layout::PitchLinearShape<
Shape::kContiguous / Layout::kElementsPerAccess / LdsmShapeContiguous,
1>;
/// Number of groups for each tile
static int const kGroupsPerTile =
Shape::kStrided / InstructionShape::kStrided;
};
private:
/// Not working on this feature at the moment.
static_assert(kOpDelta == 1,
"Alternative arrangements not supported at present.");
/// Number of internal pointers needed to reference shared memory
static int const kPointerCount =
Layout::TileShape::kContiguous / Policy::LdsmShape::kContiguous;
/// Pointer type used for accesses
using AccessType = Array<Element, Layout::kElementsPerAccess>;
/// Internal counter used to jump to next K partition
int k_group_idx_;
public:
//
// Derived quantities
//
/// Fragment object holding a thread's part of a tile
using Fragment =
Array<Element, Shape::kContiguous * InstructionShape::kStrided / kThreads>;
private:
/// Layout object storing stride values
Index stride_;
/// Shared memory base pointers - not advanced
AccessType const *pointer_[kPointerCount];
/// Byte offset incremented as iterator advances
Index byte_offset_;
public:
/// Default ctor constructs null iterator
CUTLASS_HOST_DEVICE
MmaTensorOpMultiplicandTileIterator(): stride_(0), byte_offset_(0) { }
/// Constructor from TensorRef
CUTLASS_DEVICE
MmaTensorOpMultiplicandTileIterator(
TensorRef const &ref,
int lane_id
):
stride_(ref.stride(0) / Layout::kElementsPerAccess), byte_offset_(0),
k_group_idx_(0) {
int quad_pair = (lane_id >> 3);
int quad_quad = (lane_id >> 4);
int lane_in_quad = (lane_id & 3);
int lane_in_quad_pair = (lane_id & 7);
int lane_in_quad_quad = (lane_id & 15);
CUTLASS_PRAGMA_UNROLL
for (int i = 0; i < kPointerCount; ++i) {
int partition_contiguous_idx = -1;
int access_contiguous_idx = -1;
int access_strided_idx = -1;
if (Policy::LdsmShape::kContiguous == 4) {
// Matrix multiply 1688 A/B
// Q0 Q1 Q2 Q3 (Q stands for 1 8x128bit block).
// Four blocks are next to each other in the contiguous dimension.
partition_contiguous_idx = ((lane_in_quad_pair >> 2) ^ i);
access_contiguous_idx = (quad_pair ^ lane_in_quad);
access_strided_idx = lane_in_quad_pair;
}
else if (Policy::LdsmShape::kContiguous == 2 &&
kOperand == Operand::kA) {
// Matrix multiply 16816 A
// Q0 Q2
// Q1 Q3
partition_contiguous_idx = ((lane_in_quad_pair >> 2) ^ (i >> 1));
access_contiguous_idx =
(((quad_pair & 1) + ((i & 1) << 1)) ^ lane_in_quad);
access_strided_idx = lane_in_quad_pair + (lane_id >> 4 << 3);
} else if (Policy::LdsmShape::kContiguous == 2 &&
kOperand == Operand::kB) {
// Matrix multiply 16816 B
// Q0 Q1
// Q2 Q3
partition_contiguous_idx = ((lane_in_quad_pair >> 2) ^ (i >> 1));
access_contiguous_idx = ((quad_quad + ((i & 1) << 1)) ^ lane_in_quad);
access_strided_idx = lane_in_quad_quad;
} else if (Policy::LdsmShape::kContiguous == 1) {
// Matrix multiply 16832.SP B
// Q0
// Q1
// Q2
// Q3
partition_contiguous_idx = ((lane_in_quad_pair >> 2) ^ (i >> 2));
access_contiguous_idx = ((i & 3) ^ lane_in_quad);
access_strided_idx = lane_id;
}
int access_contiguous =
partition_contiguous_idx * Layout::PartitionShape::kContiguous +
access_contiguous_idx;
int access_strided = access_strided_idx;
pointer_[i] = reinterpret_cast<AccessType const *>(ref.data()) +
access_contiguous + access_strided * stride_;
}
}
/// Adds a pointer offset to internal pointer(s) to advance through memory
CUTLASS_DEVICE
MmaTensorOpMultiplicandTileIterator &add_pointer_offset(LongIndex offset) {
byte_offset_ += offset * sizeof(Element);
return *this;
}
/// Advances an iterator along logical dimensions of matrix in units of whole tiles
CUTLASS_HOST_DEVICE
MmaTensorOpMultiplicandTileIterator &add_tile_offset(TensorCoord const &tile_offset) {
int contiguous_offset = tile_offset.contiguous();
if (Shape::kContiguous ==
Layout::PartitionShape::kContiguous * Layout::kElementsPerAccess) {
if (tile_offset.contiguous() % 2) {
CUTLASS_PRAGMA_UNROLL
for (int i = 0; i < kPointerCount / 2; ++i) {
AccessType const *tmp_pointer = pointer_[i];
pointer_[i] = pointer_[i + kPointerCount / 2];
pointer_[i + kPointerCount / 2] = tmp_pointer;
}
}
contiguous_offset = (tile_offset.contiguous() >> 1) << 1;
}
int offset = (tile_offset.strided() * InstructionShape::kStrided) *
stride_ * Layout::kElementsPerAccess +
contiguous_offset * Shape::kContiguous;
add_pointer_offset(offset);
return *this;
}
/// Advances the iterator along the advance dimension
CUTLASS_DEVICE
MmaTensorOpMultiplicandTileIterator & operator++() {
add_tile_offset({0, 1});
if (kPartitionsK > 1) {
++k_group_idx_;
// Jump to next stage
if (k_group_idx_ == Policy::kGroupsPerTile) {
k_group_idx_ = 0;
add_tile_offset(
{0, ((kPartitionsK - 1) * Policy::kGroupsPerTile)});
}
}
return *this;
}
/// Advances the iterator along the opposite of the advance dimension
CUTLASS_HOST_DEVICE
MmaTensorOpMultiplicandTileIterator & operator--() {
byte_offset_ -= stride_ * InstructionShape::kStrided * sizeof(Element) *
Layout::kElementsPerAccess;
return *this;
}
///< advances in units of whole tiles along the logical coordinate space of the tensor
CUTLASS_DEVICE
MmaTensorOpMultiplicandTileIterator & operator+=(TensorCoord const &tile_offset) {
add_tile_offset(tile_offset);
return *this;
}
///< advances in units of whole tiles along the logical coordinate space of the tensor
CUTLASS_DEVICE
MmaTensorOpMultiplicandTileIterator & operator-=(TensorCoord const &tile_offset) {
add_tile_offset(-tile_offset);
return *this;
}
/// Loads a fragment from memory at the location pointed to by the iterator.
CUTLASS_HOST_DEVICE
void load(Fragment &frag) const {
load_with_byte_offset(frag, 0);
}
/// Loads a fragment from memory with additional logical offset
CUTLASS_DEVICE
void load_with_byte_offset(
/// fragment to load from the tensor
Fragment &frag,
/// loads a tile with a linear offset in units of bytes
Index byte_offset) const {
Array<unsigned, Policy::LdsmShape::kCount> *fetch_ptr =
reinterpret_cast<Array<unsigned, Policy::LdsmShape::kCount> *>(&frag);
CUTLASS_PRAGMA_UNROLL
for (int s = 0; s < Policy::LdsmIterations::kStrided; ++s) {
CUTLASS_PRAGMA_UNROLL
for (int c = 0; c < Policy::LdsmIterations::kContiguous; ++c) {
int access_idx = c + s * Policy::LdsmIterations::kContiguous;
AccessType const *source_ptr =
pointer_[c % kPointerCount] +
Layout::TileShape::kContiguous * (c / kPointerCount) +
Policy::LdsmShape::kStrided * s * stride_;
char const *source_byte_ptr = reinterpret_cast<char const *>(source_ptr) + byte_offset + byte_offset_;
cutlass::arch::ldsm<layout::ColumnMajor, Policy::LdsmShape::kCount>(
fetch_ptr[access_idx],
source_byte_ptr
);
}
}
}
/// Loads a fragment from memory with additional logical offset
CUTLASS_DEVICE
void load_with_pointer_offset(
/// fragment to load from the tensor
Fragment &frag,
/// loads a tile with a linear offset
Index pointer_offset) const {
load_with_byte_offset(frag, pointer_offset * sizeof(Element));
}
/// Loads a fragment from memory with logical offset in units of whole tiles.
CUTLASS_DEVICE
void load(
/// fragment to load from the tensor
Fragment &frag,
/// loads a tile with a logical offset in units of whole tiles
TensorCoord const &tile_offset) const {
load_with_byte_offset(frag, tile_offset, 0);
}
/// Loads a fragment from memory with logical offset in units of whole tiles.
CUTLASS_DEVICE
void load(
/// fragment to load from the tensor
Fragment &frag,
/// loads a tile with a logical offset in units of whole tiles
TensorCoord const &tile_offset,
/// loads a tile with a logical offset AND a pointer offset
Index pointer_offset) const {
load_with_byte_offset(frag, tile_offset, pointer_offset * sizeof(Element));
}
/// Loads a fragment from memory with logical offset in units of whole tiles.
CUTLASS_DEVICE
void load_with_byte_offset(
/// fragment to load from the tensor
Fragment &frag,
/// loads a tile with a logical offset in units of whole tiles
TensorCoord const &tile_offset,
/// loads a tile with a logical offset AND a pointer offset
Index byte_offset) const {
Index pointer_offset =
tile_offset.contiguous() * Shape::kContiguous / Layout::kElementsPerAccess +
tile_offset.strided() * InstructionShape::kStrided * stride_;
byte_offset += sizeof(AccessType) * pointer_offset;
load_with_byte_offset(frag, byte_offset);
}
/// Notify the iterator which k-group it is currently pointing to.
///
/// This does not advance the iterator. Rather, it overrides its internal
/// tracking with constant-valued k-group index to enable the compiler to
/// fold constants and achieve more efficient code.
///
/// This is used by some nontrivial permuted layouts.
CUTLASS_DEVICE
void set_kgroup_index(int k_group) {
// no op
}
};
////////////////////////////////////////////////////////////////////////////////
/// This tile iterator is specialized for 32-thread MMA.TF32 NT TensorOps. It
/// uses LDS.32 to load from shared memory and therefore must be initialized
/// with a TensorRef to shared memory.
///
/// Satisfies:
/// ReadableRandomAccessContiguousTileIteratorConcept
///
template <
/// Size of the matrix to load (concept: PitchLinearShape)
typename Shape_,
/// Identifies A or B multiplicand
Operand Operand_,
/// Data type of elements
typename Element_,
/// Shape of one matrix product operation (concept: PitchLinearShape)
typename InstructionShape_,
/// Interval between adjacent *MMA instructions (in units of MMA
/// instructions)
int OpDelta_,
/// Number of partitions along K dimension
int PartitionsK_>
class MmaTensorOpMultiplicandTileIterator<
Shape_, Operand_, Element_,
cutlass::layout::TensorOpMultiplicandCongruous<32, 32>, InstructionShape_,
OpDelta_, 32, PartitionsK_> {
public:
/// Shape of tile to load (concept: PitchLinearShape)
using Shape = Shape_;
/// Operand tag
static Operand const kOperand = Operand_;
static_assert(kOperand == Operand::kA || kOperand == Operand::kB,
"MmaTensorOpMultiplicandIterator may only be instantiated for "
"A or B operands to warp-level Mma.");
/// Element type
using Element = Element_;
/// Layout of source tile
using Layout = cutlass::layout::TensorOpMultiplicandCongruous<32, 32>;
/// Shape of one matrix product operation (concept: GemmShape)
using InstructionShape = InstructionShape_;
/// Delta between *MMA operations (in units of *MMA operations, concept:
/// MatrixShape)
static int const kOpDelta = OpDelta_;
/// Number of participating threads
static int const kThreads = 32;
/// Number of partitions along K dimension
static int const kPartitionsK = PartitionsK_;
/// TensorRef type for loading element from a tensor
using TensorRef = TensorRef<Element, Layout>;
/// Index type
using Index = typename TensorRef::Index;
/// Long Index type
using LongIndex = typename TensorRef::LongIndex;
/// Coordinate for an element in the tensor
using TensorCoord = typename TensorRef::TensorCoord;
/// Internal structure of iterator - made public to enable introspection
struct Policy {
static_assert(
!(Shape::kContiguous % InstructionShape::kContiguous),
"Shape of warp-level Mma must be divisible by operator shape.");
// Determine number of elements along outer dimension per individual 32bit
// shared memory load op. Every one warp of 32bit shared memory load loads
// 8x4 elements
static int const kLdsOpInner = Layout::TileShape::kStrided;
static int const kLdsOpOuter = kThreads / kLdsOpInner;
static_assert(!(Shape::kContiguous % kLdsOpOuter),
"Shape of warp-level mma must be divisible by 32bit "
"fundamental tile size.");
static_assert(!(Shape::kStrided % kLdsOpInner),
"Shape of warp-level mma must be divisible by 32bit "
"fundamental tile size.");
/// Number of 32 bit shared memory load instructions needed by one MMA instruction
/// 1688 A 2x2
/// 1688 B 1x2
/// 16816 B 1x4
static int const LdsShapeContiguous =
InstructionShape::kContiguous / kLdsOpOuter;
static int const LdsShapeStrided = InstructionShape::kStrided / kLdsOpInner;
using LdsShape =
layout::PitchLinearShape<LdsShapeContiguous, LdsShapeStrided>;
/// Number and arrangement of LDS instructions
using LdsIterations = layout::PitchLinearShape<
Shape::kContiguous / LdsShapeContiguous / kLdsOpOuter, 1>;
/// Number of groups for each tile
static int const kGroupsPerTile =
Shape::kStrided / InstructionShape::kStrided;
};
private:
/// Not working on this feature at the moment.
static_assert(kOpDelta == 1,
"Alternative arrangements not supported at present.");
/// Number of internal pointers needed to reference shared memory
static int const kPointerCount = Layout::TileShape::kContiguous *
Layout::kElementsPerAccess /
Policy::kLdsOpOuter;
/// Vectorized access is not used
static int const kElementsPerAccess = 1;
/// Pointer type used for accesses
using AccessType = Element;
/// Internal counter used to jump to next K partition
int k_group_idx_;
public:
//
// Derived quantities
//
/// Fragment object holding a thread's part of a tile
using Fragment =
Array<Element, Shape::kContiguous * InstructionShape::kStrided / kThreads>;
private:
/// Layout object storing stride values
Index stride_;
/// Shared memory base pointers - not advanced
AccessType const *pointer_[kPointerCount];
/// Byte offset incremented as iterator advances
Index byte_offset_;
public:
/// Default ctor constructs null iterator
CUTLASS_HOST_DEVICE
MmaTensorOpMultiplicandTileIterator() : stride_(0), byte_offset_(0) {}
/// Constructor from TensorRef
CUTLASS_DEVICE
MmaTensorOpMultiplicandTileIterator(TensorRef const &ref, int lane_id)
: stride_(ref.stride(0)), byte_offset_(0), k_group_idx_(0) {
CUTLASS_PRAGMA_UNROLL
for (int i = 0; i < kPointerCount; ++i) {
int access_strided = lane_id % Policy::kLdsOpInner;
int access_contiguous = (lane_id / Policy::kLdsOpInner) +
(access_strided ^ i) * Policy::kLdsOpOuter;
pointer_[i] = reinterpret_cast<AccessType const *>(ref.data()) +
access_contiguous + access_strided * stride_;
}
}
/// Adds a pointer offset to internal pointer(s) to advance through memory
CUTLASS_DEVICE
MmaTensorOpMultiplicandTileIterator &add_pointer_offset(LongIndex offset) {
byte_offset_ += offset * sizeof(Element);
return *this;
}
/// Advances an iterator along logical dimensions of matrix in units of whole
/// tiles
CUTLASS_HOST_DEVICE
MmaTensorOpMultiplicandTileIterator &add_tile_offset(
TensorCoord const &tile_offset) {
int contiguous_offset = tile_offset.contiguous();
if (Shape::kContiguous ==
Layout::TileShape::kContiguous * Layout::kElementsPerAccess / 2) {
if (tile_offset.contiguous() % 2) {
// Matrix multiply 1688 pointer_[0] <=> pointer_[4] pointer_[1] <=> pointer_[5]
// pointer_[2] <=> pointer_[6] pointer_[3] <=> pointer_[7]
CUTLASS_PRAGMA_UNROLL
for (int i = 0; i < kPointerCount / 2; ++i) {
AccessType const *tmp_pointer = pointer_[i];
pointer_[i] = pointer_[i + kPointerCount / 2];
pointer_[i + kPointerCount / 2] = tmp_pointer;
}
}
contiguous_offset = (tile_offset.contiguous() >> 1) << 1;
}
int offset = (tile_offset.strided() * InstructionShape::kStrided) * stride_ +
contiguous_offset * Shape::kContiguous;
add_pointer_offset(offset);
return *this;
}
/// Advances the iterator along the advance dimension
CUTLASS_DEVICE
MmaTensorOpMultiplicandTileIterator &operator++() {
add_tile_offset({0, 1});
if (kPartitionsK > 1) {
++k_group_idx_;
// Jump to next stage
if (k_group_idx_ == Policy::kGroupsPerTile) {
k_group_idx_ = 0;
add_tile_offset(
{0, ((kPartitionsK - 1) * Policy::kGroupsPerTile)});
}
}
return *this;
}
/// Advances the iterator along the opposite of the advance dimension
CUTLASS_HOST_DEVICE
MmaTensorOpMultiplicandTileIterator &operator--() {
byte_offset_ -= stride_ * InstructionShape::kStrided * sizeof(Element) *
kElementsPerAccess;
return *this;
}
///< advances in units of whole tiles along the logical coordinate space of
///< the tensor
CUTLASS_DEVICE
MmaTensorOpMultiplicandTileIterator &operator+=(
TensorCoord const &tile_offset) {
add_tile_offset(tile_offset);
return *this;
}
///< advances in units of whole tiles along the logical coordinate space of
///< the tensor
CUTLASS_DEVICE
MmaTensorOpMultiplicandTileIterator &operator-=(
TensorCoord const &tile_offset) {
add_tile_offset(-tile_offset);
return *this;
}
/// Loads a fragment from memory at the location pointed to by the iterator.
CUTLASS_HOST_DEVICE
void load(Fragment &frag) const { load_with_byte_offset(frag, 0); }
/// Loads a fragment from memory with additional logical offset
CUTLASS_DEVICE
void load_with_byte_offset(
/// fragment to load from the tensor
Fragment &frag,
/// loads a tile with a linear offset in units of bytes
Index byte_offset) const {
Element *fetch_ptr = reinterpret_cast<Element *>(&frag);
CUTLASS_PRAGMA_UNROLL
for (int s = 0; s < Policy::LdsIterations::kStrided; ++s) {
CUTLASS_PRAGMA_UNROLL
for (int c = 0; c < Policy::LdsIterations::kContiguous; ++c) {
CUTLASS_PRAGMA_UNROLL
for (int ss = 0; ss < Policy::LdsShape::kStrided; ++ss) {
CUTLASS_PRAGMA_UNROLL
for (int cc = 0; cc < Policy::LdsShape::kContiguous; ++cc) {
int access_idx =
cc + (ss + (c + s * Policy::LdsIterations::kContiguous) *
Policy::LdsShape::kStrided) *
Policy::LdsShape::kContiguous;
int access_idx_contiguous = cc + c * Policy::LdsShape::kContiguous;
int access_idx_strided =
(ss + s * Policy::LdsShape::kStrided) * Policy::kLdsOpInner;
AccessType const *source_ptr =
pointer_[access_idx_contiguous % kPointerCount] +
Layout::TileShape::kContiguous * Layout::kElementsPerAccess *
(access_idx_contiguous / kPointerCount) +
access_idx_strided * stride_;
char const *source_byte_ptr =
reinterpret_cast<char const *>(source_ptr) + byte_offset +
byte_offset_;
fetch_ptr[access_idx] =
*reinterpret_cast<Element const *>(source_byte_ptr);
}
}
}
}
}
/// Loads a fragment from memory with additional logical offset
CUTLASS_DEVICE
void load_with_pointer_offset(
/// fragment to load from the tensor
Fragment &frag,
/// loads a tile with a linear offset
Index pointer_offset) const {
load_with_byte_offset(frag, pointer_offset * sizeof(Element));
}
/// Loads a fragment from memory with logical offset in units of whole tiles.
CUTLASS_DEVICE
void load(
/// fragment to load from the tensor
Fragment &frag,
/// loads a tile with a logical offset in units of whole tiles
TensorCoord const &tile_offset) const {
load_with_byte_offset(frag, tile_offset, 0);
}
/// Loads a fragment from memory with logical offset in units of whole tiles.
CUTLASS_DEVICE
void load(
/// fragment to load from the tensor
Fragment &frag,
/// loads a tile with a logical offset in units of whole tiles
TensorCoord const &tile_offset,
/// loads a tile with a logical offset AND a pointer offset
Index pointer_offset) const {
load_with_byte_offset(frag, tile_offset, pointer_offset * sizeof(Element));
}
/// Loads a fragment from memory with logical offset in units of whole tiles.
CUTLASS_DEVICE
void load_with_byte_offset(
/// fragment to load from the tensor
Fragment &frag,
/// loads a tile with a logical offset in units of whole tiles
TensorCoord const &tile_offset,
/// loads a tile with a logical offset AND a pointer offset
Index byte_offset) const {
Index pointer_offset =
tile_offset.contiguous() * Shape::kContiguous /
Layout::kElementsPerAccess +
tile_offset.strided() * InstructionShape::kStrided * stride_;
byte_offset += sizeof(AccessType) * pointer_offset;
load_with_byte_offset(frag, byte_offset);
}
/// Notify the iterator which k-group it is currently pointing to.
///
/// This does not advance the iterator. Rather, it overrides its internal
/// tracking with constant-valued k-group index to enable the compiler to
/// fold constants and achieve more efficient code.
///
/// This is used by some nontrivial permuted layouts.
CUTLASS_DEVICE
void set_kgroup_index(int k_group) {
// no op
}
};
////////////////////////////////////////////////////////////////////////////////
/// This tile iterator is specialized for 32-thread TensorOps. It uses LDSM to load from shared
/// memory and therefore must be initialized with a TensorRef to shared memory.
///
/// Satisfies:
/// ReadableRandomAccessContiguousTileIteratorConcept
///
template <
/// Size of the matrix to load (concept: MatrixShape)
typename Shape_,
/// Identifies A or B multiplicand
Operand Operand_,
/// Data type of elements
typename Element_,
/// Shape of one matrix product operation (concept: MatrixShape)
typename InstructionShape_,
/// Interval between adjacent *MMA instructions (in units of MMA
/// instructions)
int OpDelta_,
/// Number of partitions along K dimension
int PartitionsK_>
class MmaTensorOpMultiplicandTileIterator<
Shape_, Operand_, Element_,
cutlass::layout::ColumnMajorTensorOpMultiplicandCongruous<
sizeof_bits<Element_>::value, int(128 / sizeof(Element_))>,
InstructionShape_, OpDelta_, 32, PartitionsK_> {
public:
/// Shape of tile to load (concept: PitchLinearShape)
using Shape = Shape_;
/// Operand tag
static Operand const kOperand = Operand_;
static_assert(kOperand == Operand::kA,
"MmaTensorOpMultiplicandIterator for ColumnMajor Congruous may "
"only be instantiated for A operand to warp-level Mma.");
/// Element type
using Element = Element_;
/// Layout of source tile
using Layout = cutlass::layout::ColumnMajorTensorOpMultiplicandCongruous<
sizeof_bits<Element_>::value, int(128 / sizeof(Element_))>;
/// Shape of one matrix product operation (concept: MatrixShape)
using InstructionShape = InstructionShape_;
/// Delta between *MMA operations (in units of *MMA operations, concept: MatrixShape)
static int const kOpDelta = OpDelta_;
/// Number of participating threads
static int const kThreads = 32;
/// TensorRef type for loading element from a tensor
using TensorRef = TensorRef<Element, Layout>;
/// Index type
using Index = typename TensorRef::Index;
/// Long Index type
using LongIndex = typename TensorRef::LongIndex;
/// Coordinate for an element in the tensor
using TensorCoord = typename TensorRef::TensorCoord;
/// Underlying tile iterator implementation
using Base = MmaTensorOpMultiplicandTileIterator<
layout::PitchLinearShape<Shape::kRow, Shape::kColumn>, kOperand, Element,
layout::TensorOpMultiplicandCongruous<sizeof_bits<Element_>::value,
int(128 / sizeof(Element_))>,
layout::PitchLinearShape<InstructionShape::kRow,
InstructionShape::kColumn>,
kOpDelta, kThreads, PartitionsK_>;
public:
//
// Derived quantities
//
/// Fragment object holding a thread's part of a tile
using Fragment = typename Base::Fragment;
private:
/// Underlying tile iterator
Base iterator_;
public:
/// Default ctor constructs null iterator
CUTLASS_HOST_DEVICE
MmaTensorOpMultiplicandTileIterator() { }
/// Constructor from TensorRef
CUTLASS_HOST_DEVICE
MmaTensorOpMultiplicandTileIterator(
TensorRef const &ref,
int lane_id
): iterator_({ref.data(), ref.stride()}, lane_id) {
}
/// Adds a pointer offset to internal pointer(s) to advance through memory
CUTLASS_HOST_DEVICE
MmaTensorOpMultiplicandTileIterator &add_pointer_offset(LongIndex offset) {
iterator_.add_pointer_offset(offset);
return *this;
}
/// Advances an iterator along logical dimensions of matrix in units of whole tiles
CUTLASS_HOST_DEVICE
MmaTensorOpMultiplicandTileIterator &add_tile_offset(TensorCoord const &tile_offset) {
iterator_.add_tile_offset({tile_offset.row(), tile_offset.column()});
return *this;
}
/// Advances the iterator along the advance dimension
CUTLASS_HOST_DEVICE
MmaTensorOpMultiplicandTileIterator & operator++() {
++iterator_;
return *this;
}
/// Advances the iterator along the advance dimension
CUTLASS_HOST_DEVICE
MmaTensorOpMultiplicandTileIterator & operator--() {
--iterator_;
return *this;
}
///< advances in units of whole tiles along the logical coordinate space of the tensor
CUTLASS_DEVICE
MmaTensorOpMultiplicandTileIterator & operator+=(TensorCoord const &tile_offset) {
add_tile_offset(PitchLinearCoord(tile_offset.row(), tile_offset.column()));
return *this;
}
///< advances in units of whole tiles along the logical coordinate space of the tensor
CUTLASS_DEVICE
MmaTensorOpMultiplicandTileIterator & operator-=(TensorCoord const &tile_offset) {
add_tile_offset(-PitchLinearCoord(tile_offset.row(), tile_offset.column()));
return *this;
}
/// Loads a fragment from memory at the location pointed to by the iterator.
CUTLASS_HOST_DEVICE
void load(Fragment &frag) const {
iterator_.load(frag);
}
/// Loads a fragment from memory with additional logical offset
CUTLASS_DEVICE
void load_with_pointer_offset(
/// fragment to load from the tensor
Fragment &frag,
/// loads a tile with a linear offset
Index pointer_offset) const {
iterator_.load_with_pointer_offset(frag, pointer_offset);
}
/// Loads a fragment from memory with additional logical offset
CUTLASS_DEVICE
void load_with_byte_offset(
/// fragment to load from the tensor
Fragment &frag,
/// loads a tile with a linear offset
Index byte_offset) const {
iterator_.load_with_byte_offset(frag, byte_offset);
}
/// Loads a fragment from memory with logical offset in units of whole tiles.
CUTLASS_DEVICE
void load(
/// fragment to load from the tensor
Fragment &frag,
/// loads a tile with a logical offset in units of whole tiles
TensorCoord const &tile_offset) const {
// TODO
}
/// Loads a fragment from memory with logical offset in units of whole tiles.
CUTLASS_DEVICE
void load(
/// fragment to load from the tensor
Fragment &frag,
/// loads a tile with a logical offset in units of whole tiles
TensorCoord const &tile_offset,
/// loads a tile with a logical offset AND a pointer offset
Index pointer_offset) const {
// TODO
}
/// Loads a fragment from memory with logical offset in units of whole tiles.
CUTLASS_DEVICE
void load_with_byte_offset(
/// fragment to load from the tensor
Fragment &frag,
/// loads a tile with a logical offset in units of whole tiles
TensorCoord const &tile_offset,
/// loads a tile with a logical offset AND a pointer offset
Index byte_offset) const {
iterator_.load_with_byte_offset(
frag,
{tile_offset.contiguous(), tile_offset.strided()},
byte_offset);
}
/// Notify the iterator which k-group it is currently pointing to.
///
/// This does not advance the iterator. Rather, it overrides its internal
/// tracking with constant-valued k-group index to enable the compiler to
/// fold constants and achieve more efficient code.
///
/// This is used by some nontrivial permuted layouts.
CUTLASS_DEVICE
void set_kgroup_index(int k_group) {
iterator_.set_kgroup_index(k_group);
}
};
////////////////////////////////////////////////////////////////////////////////
/// This tile iterator is specialized for 32-thread TensorOps. It uses LDSM to load from shared
/// memory and therefore must be initialized with a TensorRef to shared memory.
///
/// Satisfies:
/// ReadableRandomAccessContiguousTileIteratorConcept
///
template <
/// Size of the matrix to load (concept: MatrixShape)
typename Shape_,
/// Identifies A or B multiplicand
Operand Operand_,
/// Data type of elements
typename Element_,
/// Shape of one matrix product operation (concept: MatrixShape)
typename InstructionShape_,
/// Interval between adjacent *MMA instructions (in units of MMA
/// instructions)
int OpDelta_,
/// Number of partitions along K dimension
int PartitionsK_>
class MmaTensorOpMultiplicandTileIterator<
Shape_, Operand_, Element_,
cutlass::layout::RowMajorTensorOpMultiplicandCongruous<
sizeof_bits<Element_>::value, int(128 / sizeof(Element_))>,
InstructionShape_, OpDelta_, 32, PartitionsK_> {
public:
/// Shape of tile to load (concept: PitchLinearShape)
using Shape = Shape_;
/// Operand tag
static Operand const kOperand = Operand_;
static_assert(kOperand == Operand::kB,
"MmaTensorOpMultiplicandIterator for RowMajor Congruous may "
"only be instantiated for B operand to warp-level Mma.");
/// Element type
using Element = Element_;
/// Layout of source tile
using Layout = cutlass::layout::RowMajorTensorOpMultiplicandCongruous<
sizeof_bits<Element_>::value, int(128 / sizeof(Element_))>;
/// Shape of one matrix product operation (concept: MatrixShape)
using InstructionShape = InstructionShape_;
/// Delta between *MMA operations (in units of *MMA operations, concept: MatrixShape)
static int const kOpDelta = OpDelta_;
/// Number of participating threads
static int const kThreads = 32;
/// TensorRef type for loading element from a tensor
using TensorRef = TensorRef<Element, Layout>;
/// Index type
using Index = typename TensorRef::Index;
/// Long Index type
using LongIndex = typename TensorRef::LongIndex;
/// Coordinate for an element in the tensor
using TensorCoord = typename TensorRef::TensorCoord;
/// Underlying tile iterator implementation
using Base = MmaTensorOpMultiplicandTileIterator<
layout::PitchLinearShape<Shape::kColumn, Shape::kRow>, kOperand, Element,
layout::TensorOpMultiplicandCongruous<sizeof_bits<Element_>::value,
int(128 / sizeof(Element_))>,
layout::PitchLinearShape<InstructionShape::kColumn,
InstructionShape::kRow>,
kOpDelta, kThreads, PartitionsK_>;
public:
//
// Derived quantities
//
/// Fragment object holding a thread's part of a tile
using Fragment = typename Base::Fragment;
private:
/// Underlying tile iterator
Base iterator_;
public:
/// Default ctor constructs null iterator
CUTLASS_HOST_DEVICE
MmaTensorOpMultiplicandTileIterator() { }
/// Constructor from TensorRef
CUTLASS_HOST_DEVICE
MmaTensorOpMultiplicandTileIterator(
TensorRef const &ref,
int lane_id
): iterator_({ref.data(), ref.stride()}, lane_id) {
}
/// Adds a pointer offset to internal pointer(s) to advance through memory
CUTLASS_HOST_DEVICE
MmaTensorOpMultiplicandTileIterator &add_pointer_offset(LongIndex offset) {
iterator_.add_pointer_offset(offset);
return *this;
}
/// Advances an iterator along logical dimensions of matrix in units of whole tiles
CUTLASS_HOST_DEVICE
MmaTensorOpMultiplicandTileIterator &add_tile_offset(TensorCoord const &tile_offset) {
iterator_.add_tile_offset({tile_offset.column(), tile_offset.row()});
return *this;
}
/// Advances the iterator along the advance dimension
CUTLASS_HOST_DEVICE
MmaTensorOpMultiplicandTileIterator & operator++() {
++iterator_;
return *this;
}
/// Advances the iterator along the advance dimension
CUTLASS_HOST_DEVICE
MmaTensorOpMultiplicandTileIterator & operator--() {
--iterator_;
return *this;
}
///< advances in units of whole tiles along the logical coordinate space of the tensor
CUTLASS_DEVICE
MmaTensorOpMultiplicandTileIterator & operator+=(TensorCoord const &tile_offset) {
add_tile_offset(PitchLinearCoord(tile_offset.column(), tile_offset.row()));
return *this;
}
///< advances in units of whole tiles along the logical coordinate space of the tensor
CUTLASS_DEVICE
MmaTensorOpMultiplicandTileIterator & operator-=(TensorCoord const &tile_offset) {
add_tile_offset(-PitchLinearCoord(tile_offset.column(), tile_offset.row()));
return *this;
}
/// Loads a fragment from memory at the location pointed to by the iterator.
CUTLASS_HOST_DEVICE
void load(Fragment &frag) const {
iterator_.load(frag);
}
/// Loads a fragment from memory with additional logical offset
CUTLASS_DEVICE
void load_with_pointer_offset(
/// fragment to load from the tensor
Fragment &frag,
/// loads a tile with a linear offset
Index pointer_offset) const {
iterator_.load_with_pointer_offset(frag, pointer_offset);
}
/// Loads a fragment from memory with additional logical offset
CUTLASS_DEVICE
void load_with_byte_offset(
/// fragment to load from the tensor
Fragment &frag,
/// loads a tile with a linear offset
Index byte_offset) const {
iterator_.load_with_byte_offset(frag, byte_offset);
}
/// Loads a fragment from memory with logical offset in units of whole tiles.
CUTLASS_DEVICE
void load(
/// fragment to load from the tensor
Fragment &frag,
/// loads a tile with a logical offset in units of whole tiles
TensorCoord const &tile_offset) const {
// TODO
}
/// Loads a fragment from memory with logical offset in units of whole tiles.
CUTLASS_DEVICE
void load(
/// fragment to load from the tensor
Fragment &frag,
/// loads a tile with a logical offset in units of whole tiles
TensorCoord const &tile_offset,
/// loads a tile with a logical offset AND a pointer offset
Index pointer_offset) const {
// TODO
}
/// Loads a fragment from memory with logical offset in units of whole tiles.
CUTLASS_DEVICE
void load_with_byte_offset(
/// fragment to load from the tensor
Fragment &frag,
/// loads a tile with a logical offset in units of whole tiles
TensorCoord const &tile_offset,
/// loads a tile with a logical offset AND a pointer offset
Index byte_offset) const {
iterator_.load_with_byte_offset(
frag,
{tile_offset.strided(), tile_offset.contiguous()},
byte_offset);
}
/// Notify the iterator which k-group it is currently pointing to.
///
/// This does not advance the iterator. Rather, it overrides its internal
/// tracking with constant-valued k-group index to enable the compiler to
/// fold constants and achieve more efficient code.
///
/// This is used by some nontrivial permuted layouts.
CUTLASS_DEVICE
void set_kgroup_index(int k_group) {
iterator_.set_kgroup_index(k_group);
}
};
////////////////////////////////////////////////////////////////////////////////
/// This tile iterator is specialized for 32-thread TensorOps. It uses LDSM to
/// load from shared memory and therefore must be initialized with a TensorRef
/// to shared memory.
///
/// Satisfies:
/// ReadableRandomAccessContiguousTileIteratorConcept
///
template <
/// Size of the matrix to load (concept: PitchLinearShape)
typename Shape_,
/// Identifies A or B multiplicand
Operand Operand_,
/// Data type of elements
typename Element_,
/// Shape of one matrix product operation (concept: PitchLinearShape)
typename InstructionShape_,
/// Interval between adjacent *MMA instructions (in units of MMA
/// instructions)
int OpDelta_,
/// Element number when the layout crosses (in units of elements)
int Crosswise,
/// Number of partitions along K dimension
int PartitionsK_>
class MmaTensorOpMultiplicandTileIterator<
Shape_, Operand_, Element_,
cutlass::layout::TensorOpMultiplicandCrosswise<sizeof_bits<Element_>::value,
Crosswise>,
InstructionShape_, OpDelta_, 32, PartitionsK_> {
public:
/// Shape of tile to load (concept: PitchLinearShape)
using Shape = Shape_;
/// Operand tag
static Operand const kOperand = Operand_;
static_assert(kOperand == Operand::kA || kOperand == Operand::kB,
"MmaTensorOpMultiplicandIterator may only be instantiated for "
"A or B operands to warp-level Mma.");
/// Element type
using Element = Element_;
/// Element number when the layout crosses
static int const kCrosswise = Crosswise;
/// Layout of source tile
using Layout = cutlass::layout::TensorOpMultiplicandCrosswise<
sizeof_bits<Element_>::value, kCrosswise>;
/// Shape of one matrix product operation (concept: GemmShape)
using InstructionShape = InstructionShape_;
/// Delta between *MMA operations (in units of *MMA operations, concept:
/// MatrixShape)
static int const kOpDelta = OpDelta_;
/// Number of participating threads
static int const kThreads = 32;
/// Number of partitions along K dimension
static int const kPartitionsK = PartitionsK_;
/// TensorRef type for loading element from a tensor
using TensorRef = TensorRef<Element, Layout>;
/// Index type
using Index = typename TensorRef::Index;
/// Long Index type
using LongIndex = typename TensorRef::LongIndex;
/// Coordinate for an element in the tensor
using TensorCoord = typename TensorRef::TensorCoord;
/// Internal structure of iterator - made public to enable introspection
struct Policy {
static_assert(
!(Shape::kContiguous % InstructionShape::kContiguous),
"Shape of warp-level Mma must be divisible by operator shape.");
// Determine number of elements along outer dimension per individual LDSM op
static int const kLdsmOpOuter = Layout::kElementsPerAccess;
static int const kLdsmOpInner = 8;
static_assert(!(Shape::kContiguous % kLdsmOpOuter),
"Shape of warp-level mma must be divisible by LDSM's "
"fundamental tile size.");
static_assert(!(Shape::kStrided % kLdsmOpInner),
"Shape of warp-level mma must be divisible by LDSM's "
"fundamental tile size.");
/// Shape of one individual LDSM instruction
static int const LdsmShapeContiguous =
InstructionShape::kContiguous / kLdsmOpOuter;
static int const LdsmShapeStrided =
((4 / LdsmShapeContiguous * kLdsmOpInner) > Shape::kStrided)
? (Shape::kStrided / kLdsmOpInner)
: (4 / LdsmShapeContiguous);
using LdsmShape =
layout::PitchLinearShape<LdsmShapeContiguous, LdsmShapeStrided>;
/// Number and arrangement of LDSM instructions
using LdsmIterations =
layout::PitchLinearShape<1, Shape::kStrided / kLdsmOpInner /
LdsmShape::kStrided>;
///
static int const kGroupsPerTile = Layout::TileShape::kContiguous /
Layout::kFactor / LdsmShape::kContiguous;
};
private:
/// Not working on this feature at the moment.
static_assert(kOpDelta == 1,
"Alternative arrangements not supported at present.");
/// Pointer type used for accesses
using AccessType = Array<Element, Layout::kElementsPerAccess>;
public:
//
// Derived quantities
//
/// Fragment object holding a thread's part of a tile
using Fragment = Array<Element, Shape::kStrided *
InstructionShape::kContiguous / kThreads>;
private:
/// Total number of sections. The memory is divided into stages. One stage
/// can store one tile. Stage is divided into sections. Interleaved layout
/// can have multiple sections in a stage. The rest layout only has one section
/// in a stage.
int sections_;
/// Layout object storing stride values
Index stride_;
/// Shared memory base pointers - not advanced
AccessType const *pointer_;
/// Byte offset incremented as iterator advances
Index byte_offset_;
/// Internal counter used to determine when to increment byte offset and when
/// to XOR it
int k_group_idx_;
public:
/// Default ctor constructs null iterator
CUTLASS_HOST_DEVICE
MmaTensorOpMultiplicandTileIterator()
: pointer_(nullptr),
sections_(0),
stride_(0),
byte_offset_(0),
k_group_idx_(0) {}
/// Constructor from TensorRef
CUTLASS_DEVICE
MmaTensorOpMultiplicandTileIterator(TensorRef const &ref, int lane_id)
: pointer_(reinterpret_cast<AccessType const *>(ref.data())),
sections_(ref.stride(0) / kCrosswise),
// stride_ = kCrosswise x sections_ x kFactor
stride_(ref.stride(0) * Layout::kFactor / Layout::kElementsPerAccess),
byte_offset_(0),
k_group_idx_(0) {
// Warp level iterator at most use double buffer to hide latency. If there
// are more than 2 sections, every stage should have more than 1 section.
// Turing silicon requires all 32 threads in a warp provide valid addresses
// even for LDSM.1 and LDSM.2
#if (defined(__CUDA_ARCH__) && (__CUDA_ARCH__ == 750))
lane_id = lane_id % (Policy::LdsmShape::kCount * Policy::kLdsmOpInner);
#endif
int quad_quad = (lane_id >> 4);
int quad_pair = (lane_id >> 3);
int lane_in_pair = (lane_id & 1);
int lane_in_quad = (lane_id & 3);
int lane_in_quad_pair = (lane_id & 7);
int lane_in_quad_quad = (lane_id & 15);
int partition_contiguous_idx = -1;
int access_contiguous_idx = -1;
int access_strided_idx = -1;
if (Layout::kFactor == 4) {
// Super Integer matrix multiply Interleaved-32
int factor_in_partition =
(Layout::PartitionShape::kContiguous * Layout::kFactor /
Layout::TileShape::kContiguous);
if (Policy::LdsmShape::kStrided == Policy::LdsmShape::kCount) {
// Integer matrix multiply 8816 A/B
partition_contiguous_idx = lane_in_quad / factor_in_partition;
access_contiguous_idx = ((lane_in_pair * factor_in_partition) ^
(lane_in_quad_quad / Layout::kFactor));
access_strided_idx = lane_id / Layout::kFactor;
}
else if (Policy::LdsmShape::kStrided ==
(Policy::LdsmShape::kCount / 2) &&
kOperand == Operand::kA) {
// Integer matrix multiply 16832 A
partition_contiguous_idx = lane_in_quad / factor_in_partition;
access_strided_idx = lane_in_quad_quad / Layout::kFactor;
access_contiguous_idx =
((lane_in_pair * factor_in_partition + quad_quad) ^
access_strided_idx);
}
else if (Policy::LdsmShape::kStrided ==
(Policy::LdsmShape::kCount / 2) &&
kOperand == Operand::kB) {
// Integer matrix multiply 16832 B
partition_contiguous_idx = lane_in_quad / factor_in_partition;
access_strided_idx = lane_in_quad_pair / Layout::kFactor + quad_quad * 2;
access_contiguous_idx =
((lane_in_pair * factor_in_partition + ((lane_id & 8) >> 3)) ^
access_strided_idx);
}
} else if (Layout::kFactor == 2) {
// Super Matrix multiply kBlock = 32
if (Policy::LdsmShape::kStrided == Policy::LdsmShape::kCount) {
// Matrix multiply 1688 A/B
// (Q stands for 1 8x128bit block).
// Q0
// Q1
// Q2
// Q3
// Four blocks are next to each other in the strided dimension.
partition_contiguous_idx = (lane_id % Layout::kFactor);
access_contiguous_idx = (lane_in_quad_pair / Layout::kFactor);
access_strided_idx = lane_id / Layout::kFactor;
}
else if (Policy::LdsmShape::kStrided ==
(Policy::LdsmShape::kCount / 2) &&
kOperand == Operand::kA) {
// Matrix multiply 16816|1688.TF32 A
// Q0 Q2
// Q1 Q3
partition_contiguous_idx = (lane_id % Layout::kFactor);
access_contiguous_idx =
(quad_quad ^ (lane_in_quad_pair / Layout::kFactor));
access_strided_idx = (lane_in_quad_quad / Layout::kFactor);
} else if (Policy::LdsmShape::kStrided ==
(Policy::LdsmShape::kCount / 2) &&
kOperand == Operand::kB) {
// Matrix multiply 16816|1688.TF32 B
// Q0 Q1
// Q2 Q3
partition_contiguous_idx = (lane_id % Layout::kFactor);
access_contiguous_idx =
((quad_pair & 1) ^ (lane_in_quad_pair / Layout::kFactor));
access_strided_idx =
(lane_in_quad_pair + (lane_id >> 4 << 3)) / Layout::kFactor;
}
else if (Policy::LdsmShape::kContiguous == Policy::LdsmShape::kCount) {
// Matrix multiply 16832.SP B
// Q0 Q1 Q2 Q3
partition_contiguous_idx = (lane_id % Layout::kFactor);
access_contiguous_idx =
(quad_pair ^ (lane_in_quad_pair / Layout::kFactor));
access_strided_idx = lane_in_quad_pair / Layout::kFactor;
}
} else if (Layout::kFactor == 1) {
// Super Matrix multiply kBlock = 64
if (Policy::LdsmShape::kStrided == Policy::LdsmShape::kCount) {
// Q0
// Q1
// Q2
// Q3
partition_contiguous_idx = (lane_in_quad_pair >> 2);
access_contiguous_idx = lane_in_quad;
access_strided_idx = lane_id;
}
else if (Policy::LdsmShape::kStrided ==
(Policy::LdsmShape::kCount / 2) &&
kOperand == Operand::kA) {
// Matrix multiply 16816|1688.TF32 A
// Q0 Q2
// Q1 Q3
partition_contiguous_idx = (lane_in_quad_pair >> 2);
access_contiguous_idx = (quad_quad ^ lane_in_quad);
access_strided_idx = lane_in_quad_quad;
} else if (Policy::LdsmShape::kStrided ==
(Policy::LdsmShape::kCount / 2) &&
kOperand == Operand::kB) {
// Matrix multiply 16816|1688.TF32 B
// Q0 Q1
// Q2 Q3
partition_contiguous_idx = (lane_in_quad_pair >> 2);
access_contiguous_idx = ((quad_pair & 1) ^ lane_in_quad);
access_strided_idx = lane_in_quad_pair + (lane_id >> 4 << 3);
}
else if (Policy::LdsmShape::kContiguous == Policy::LdsmShape::kCount) {
// Matrix multiply 16832.SP B
// Q0 Q1 Q2 Q3
partition_contiguous_idx = (lane_in_quad_pair >> 2);
access_contiguous_idx = (quad_pair ^ lane_in_quad);
access_strided_idx = lane_in_quad_pair;
}
}
int access_contiguous =
partition_contiguous_idx * Layout::PartitionShape::kContiguous +
access_contiguous_idx;
int access_strided = access_strided_idx;
byte_offset_ = (access_contiguous + access_strided * stride_) *
sizeof_bits<Element>::value * Layout::kElementsPerAccess / 8;
}
/// Adds a pointer offset to internal pointer(s) to advance through memory
CUTLASS_DEVICE
MmaTensorOpMultiplicandTileIterator &add_pointer_offset(LongIndex offset) {
byte_offset_ += offset * sizeof_bits<Element>::value / 8;
return *this;
}
/// Advances an iterator along logical dimensions of matrix in units of whole
/// tiles
CUTLASS_DEVICE
MmaTensorOpMultiplicandTileIterator &add_tile_offset(
TensorCoord const &tile_offset) {
int whole_tiles = tile_offset.contiguous() / Policy::kGroupsPerTile;
int k_groups_delta = tile_offset.contiguous() % Policy::kGroupsPerTile;
byte_offset_ ^= k_groups_delta * sizeof_bits<Element>::value *
Layout::kElementsPerAccess *
Policy::LdsmShape::kContiguous / 8;
pointer_ +=
tile_offset.strided() * stride_ * Shape::kStrided / Layout::kFactor +
whole_tiles * stride_ / sections_;
return *this;
}
/// Advances an iterator along logical dimensions of matrix in units of whole
/// tiles
CUTLASS_DEVICE
MmaTensorOpMultiplicandTileIterator &add_tile_offset_negative(
TensorCoord const &tile_offset) {
int whole_tiles = tile_offset.contiguous() / Policy::kGroupsPerTile;
int k_groups_delta = tile_offset.contiguous() % Policy::kGroupsPerTile;
if (k_groups_delta < 0) {
whole_tiles -= 1;
k_groups_delta += Policy::kGroupsPerTile;
}
if ((Policy::kGroupsPerTile / kPartitionsK) >= 2) {
byte_offset_ ^= (k_groups_delta & 1) * Policy::LdsmShape::kContiguous *
sizeof_bits<Element>::value *
Layout::kElementsPerAccess / 8;
}
if ((Policy::kGroupsPerTile / kPartitionsK) >= 4) {
byte_offset_ ^= ((k_groups_delta + (k_group_idx_ & 1)) & 2) *
Policy::LdsmShape::kContiguous *
sizeof_bits<Element>::value *
Layout::kElementsPerAccess / 8;
}
if ((Policy::kGroupsPerTile / kPartitionsK) == 8) {
byte_offset_ ^= ((k_groups_delta + (k_group_idx_ & 3)) & 4) *
Policy::LdsmShape::kContiguous *
sizeof_bits<Element>::value *
Layout::kElementsPerAccess / 8;
}
k_group_idx_ += k_groups_delta;
whole_tiles += k_group_idx_ / (Policy::kGroupsPerTile / kPartitionsK);
k_group_idx_ = k_group_idx_ % (Policy::kGroupsPerTile / kPartitionsK);
pointer_ +=
tile_offset.strided() * stride_ * Shape::kStrided / Layout::kFactor +
whole_tiles * stride_ / sections_;
return *this;
}
/// Advances the iterator along the advance dimension
CUTLASS_DEVICE
MmaTensorOpMultiplicandTileIterator &operator++() {
// Integer matrix multiply 16832 Interleaved-32
// NONE
// Integer matrix multiply 16816 Interleaved-32 || Integer matrix multiply 16816 kblock=32
// Integer matrix multiply 8816 Interleaved-32
// ^1 ^1
// Matrix multiply 1684.TF32 kblock=16 || Integer matrix multiply 16816 kblock=64
// Matrix multiply 1688 kblock=32 || Integer matrix multiply 8816 kblock=64
// ^1 ^3 ^1 ^3
// Matrix multiply 1688 kblock=64
// ^1 ^3 ^1 ^7 ^1 ^3 ^1 ^7
// Matrix multiply 16816 kblock=32 | 1688.TF32 kblock=16 || Integer matrix multiply 16832 kblock=64
// ^2 ^2
// Matrix multiply 16816 kblock=64 | 1688.TF32 kblock=32 || Integer matrix multiply 16832 kblock=128
// ^2 ^6 ^2 ^6
if ((Policy::kGroupsPerTile / kPartitionsK) > 1) {
int mask = ((Policy::kGroupsPerTile / kPartitionsK) == 8)
? 3
: (((Policy::kGroupsPerTile / kPartitionsK) == 4) ? 1 : 0);
if (((k_group_idx_ & mask) % 2) == 0)
byte_offset_ ^= 1 * Policy::LdsmShape::kContiguous *
sizeof_bits<Element>::value *
Layout::kElementsPerAccess / 8;
else if ((k_group_idx_ & mask) == 1)
byte_offset_ ^= 3 * Policy::LdsmShape::kContiguous *
sizeof_bits<Element>::value *
Layout::kElementsPerAccess / 8;
else if ((k_group_idx_ & mask) == 3)
byte_offset_ ^= 7 * Policy::LdsmShape::kContiguous *
sizeof_bits<Element>::value *
Layout::kElementsPerAccess / 8;
}
k_group_idx_++;
if (k_group_idx_ == (Policy::kGroupsPerTile / kPartitionsK)) {
k_group_idx_ = 0;
add_tile_offset({Policy::kGroupsPerTile, 0});
}
return *this;
}
/// Advances the iterator along the advance dimension
CUTLASS_HOST_DEVICE
MmaTensorOpMultiplicandTileIterator &operator--() { assert(0); }
///< advances in units of whole tiles along the logical coordinate space of
///< the tensor
CUTLASS_DEVICE
MmaTensorOpMultiplicandTileIterator &operator+=(
TensorCoord const &tile_offset) {
add_tile_offset(tile_offset);
return *this;
}
///< advances in units of whole tiles along the logical coordinate space of
///< the tensor
CUTLASS_DEVICE
MmaTensorOpMultiplicandTileIterator &operator-=(
TensorCoord const &tile_offset) {
add_tile_offset(-tile_offset);
return *this;
}
/// Loads a fragment from memory at the location pointed to by the iterator.
CUTLASS_HOST_DEVICE
void load(Fragment &frag) const { load_with_byte_offset(frag, 0); }
/// Loads a fragment from memory with additional logical offset
CUTLASS_DEVICE
void load_with_byte_offset(
/// fragment to load from the tensor
Fragment &frag,
/// loads a tile with a linear offset in units of bytes
Index byte_offset) const {
Array<unsigned, Policy::LdsmShape::kCount> *fetch_ptr =
reinterpret_cast<Array<unsigned, Policy::LdsmShape::kCount> *>(&frag);
CUTLASS_PRAGMA_UNROLL
for (int s = 0; s < Policy::LdsmIterations::kStrided; ++s) {
CUTLASS_PRAGMA_UNROLL
for (int c = 0; c < Policy::LdsmIterations::kContiguous; ++c) {
int access_idx = c + s * Policy::LdsmIterations::kContiguous;
AccessType const *source_ptr =
pointer_ + Policy::LdsmShape::kContiguous * c +
Policy::kLdsmOpInner / Layout::kFactor *
Policy::LdsmShape::kStrided * s * stride_;
char const *source_byte_ptr =
reinterpret_cast<char const *>(source_ptr) + byte_offset +
byte_offset_;
cutlass::arch::ldsm<layout::RowMajor, Policy::LdsmShape::kCount>(
fetch_ptr[access_idx], source_byte_ptr);
}
}
}
/// Loads a fragment from memory with additional logical offset
CUTLASS_DEVICE
void load_with_pointer_offset(
/// fragment to load from the tensor
Fragment &frag,
/// loads a tile with a linear offset
Index pointer_offset) const {
load_with_byte_offset(frag, pointer_offset * sizeof(Element));
}
/// Loads a fragment from memory with logical offset in units of whole tiles.
CUTLASS_DEVICE
void load(
/// fragment to load from the tensor
Fragment &frag,
/// loads a tile with a logical offset in units of whole tiles
TensorCoord const &tile_offset) const {
load_with_byte_offset(frag, tile_offset, 0);
}
/// Loads a fragment from memory with logical offset in units of whole tiles.
CUTLASS_DEVICE
void load(
/// fragment to load from the tensor
Fragment &frag,
/// loads a tile with a logical offset in units of whole tiles
TensorCoord const &tile_offset,
/// loads a tile with a logical offset AND a pointer offset
Index pointer_offset) const {
load_with_byte_offset(frag, tile_offset, pointer_offset * sizeof(Element));
}
/// Loads a fragment from memory with logical offset in units of whole tiles.
CUTLASS_DEVICE
void load_with_byte_offset(
/// fragment to load from the tensor
Fragment &frag,
/// loads a tile with a logical offset in units of whole tiles
TensorCoord const &tile_offset,
/// loads a tile with a logical offset AND a pointer offset
Index byte_offset) const {
Index pointer_offset = tile_offset.contiguous() *
InstructionShape::kContiguous /
Layout::kElementsPerAccess +
tile_offset.strided() * Shape::kStrided * stride_;
byte_offset += sizeof_bits<AccessType>::value * pointer_offset / 8;
load_with_byte_offset(frag, byte_offset);
}
/// Notify the iterator which k-group it is currently pointing to.
///
/// This does not advance the iterator. Rather, it overrides its internal
/// tracking with constant-valued k-group index to enable the compiler to
/// fold constants and achieve more efficient code.
///
/// This is used by some nontrivial permuted layouts.
CUTLASS_DEVICE
void set_kgroup_index(int k_group) {
k_group_idx_ = k_group % (Policy::kGroupsPerTile / kPartitionsK);
}
};
////////////////////////////////////////////////////////////////////////////////
/// This tile iterator is specialized for 32-thread TensorOps. It uses LDSM to
/// load from shared memory and therefore must be initialized with a TensorRef
/// to shared memory.
///
/// Satisfies:
/// ReadableRandomAccessContiguousTileIteratorConcept
///
template <
/// Size of the matrix to load (concept: MatrixShape)
typename Shape_,
/// Identifies A or B multiplicand
Operand Operand_,
/// Data type of elements
typename Element_,
/// Shape of one matrix product operation (concept: MatrixShape)
typename InstructionShape_,
/// Interval between adjacent *MMA instructions (in units of MMA
/// instructions)
int OpDelta_,
/// Element number when the layout crosses (in units of elements)
int Crosswise,
/// Number of partitions along K dimension
int PartitionsK_>
class MmaTensorOpMultiplicandTileIterator<
Shape_, Operand_, Element_,
cutlass::layout::ColumnMajorTensorOpMultiplicandCrosswise<
sizeof_bits<Element_>::value, Crosswise>,
InstructionShape_, OpDelta_, 32, PartitionsK_> {
public:
/// Shape of tile to load (concept: PitchLinearShape)
using Shape = Shape_;
/// Operand tag
static Operand const kOperand = Operand_;
static_assert(kOperand == Operand::kB,
"MmaTensorOpMultiplicandIterator for ColumnMajor Crosswise may "
"only be instantiated for B operand to warp-level Mma.");
/// Element type
using Element = Element_;
/// KBlock size
static int const kCrosswise = Crosswise;
/// Layout of source tile
using Layout = cutlass::layout::ColumnMajorTensorOpMultiplicandCrosswise<
sizeof_bits<Element_>::value, kCrosswise>;
/// Shape of one matrix product operation (concept: MatrixShape)
using InstructionShape = InstructionShape_;
/// Delta between *MMA operations (in units of *MMA operations, concept:
/// MatrixShape)
static int const kOpDelta = OpDelta_;
/// Number of participating threads
static int const kThreads = 32;
/// TensorRef type for loading element from a tensor
using TensorRef = TensorRef<Element, Layout>;
/// Index type
using Index = typename TensorRef::Index;
/// Long Index type
using LongIndex = typename TensorRef::LongIndex;
/// Coordinate for an element in the tensor
using TensorCoord = typename TensorRef::TensorCoord;
/// Underlying tile iterator implementation
using Base = MmaTensorOpMultiplicandTileIterator<
layout::PitchLinearShape<Shape::kRow, Shape::kColumn>, kOperand, Element,
layout::TensorOpMultiplicandCrosswise<sizeof_bits<Element_>::value,
kCrosswise>,
layout::PitchLinearShape<InstructionShape::kRow,
InstructionShape::kColumn>,
kOpDelta, kThreads, PartitionsK_>;
public:
//
// Derived quantities
//
/// Fragment object holding a thread's part of a tile
using Fragment = typename Base::Fragment;
private:
/// Underlying tile iterator
Base iterator_;
public:
/// Default ctor constructs null iterator
CUTLASS_HOST_DEVICE
MmaTensorOpMultiplicandTileIterator() {}
/// Constructor from TensorRef
CUTLASS_HOST_DEVICE
MmaTensorOpMultiplicandTileIterator(TensorRef const &ref, int lane_id)
: iterator_({ref.data(), ref.stride()}, lane_id) {}
/// Adds a pointer offset to internal pointer(s) to advance through memory
CUTLASS_HOST_DEVICE
MmaTensorOpMultiplicandTileIterator &add_pointer_offset(LongIndex offset) {
iterator_.add_pointer_offset(offset);
return *this;
}
/// Advances an iterator along logical dimensions of matrix in units of whole
/// tiles
CUTLASS_HOST_DEVICE
MmaTensorOpMultiplicandTileIterator &add_tile_offset(
TensorCoord const &tile_offset) {
iterator_.add_tile_offset({tile_offset.row(), tile_offset.column()});
return *this;
}
/// Advances an iterator along logical dimensions of matrix in units of whole
/// tiles
CUTLASS_DEVICE
MmaTensorOpMultiplicandTileIterator &add_tile_offset_negative(
TensorCoord const &tile_offset) {
iterator_.add_tile_offset_negative({tile_offset.row(), tile_offset.column()});
return *this;
}
/// Advances the iterator along the advance dimension
CUTLASS_HOST_DEVICE
MmaTensorOpMultiplicandTileIterator &operator++() {
++iterator_;
return *this;
}
/// Advances the iterator along the advance dimension
CUTLASS_HOST_DEVICE
MmaTensorOpMultiplicandTileIterator &operator--() {
--iterator_;
return *this;
}
///< advances in units of whole tiles along the logical coordinate space of
///< the tensor
CUTLASS_DEVICE
MmaTensorOpMultiplicandTileIterator &operator+=(
TensorCoord const &tile_offset) {
add_tile_offset(PitchLinearCoord(tile_offset.row(), tile_offset.column()));
return *this;
}
///< advances in units of whole tiles along the logical coordinate space of
///< the tensor
CUTLASS_DEVICE
MmaTensorOpMultiplicandTileIterator &operator-=(
TensorCoord const &tile_offset) {
add_tile_offset(-PitchLinearCoord(tile_offset.row(), tile_offset.column()));
return *this;
}
/// Loads a fragment from memory at the location pointed to by the iterator.
CUTLASS_HOST_DEVICE
void load(Fragment &frag) const { iterator_.load(frag); }
/// Loads a fragment from memory with additional logical offset
CUTLASS_DEVICE
void load_with_pointer_offset(
/// fragment to load from the tensor
Fragment &frag,
/// loads a tile with a linear offset
Index pointer_offset) const {
iterator_.load_with_pointer_offset(frag, pointer_offset);
}
/// Loads a fragment from memory with additional logical offset
CUTLASS_DEVICE
void load_with_byte_offset(
/// fragment to load from the tensor
Fragment &frag,
/// loads a tile with a linear offset
Index byte_offset) const {
iterator_.load_with_byte_offset(frag, byte_offset);
}
/// Loads a fragment from memory with logical offset in units of whole tiles.
CUTLASS_DEVICE
void load(
/// fragment to load from the tensor
Fragment &frag,
/// loads a tile with a logical offset in units of whole tiles
TensorCoord const &tile_offset) const {
// TODO
assert(0);
}
/// Loads a fragment from memory with logical offset in units of whole tiles.
CUTLASS_DEVICE
void load(
/// fragment to load from the tensor
Fragment &frag,
/// loads a tile with a logical offset in units of whole tiles
TensorCoord const &tile_offset,
/// loads a tile with a logical offset AND a pointer offset
Index pointer_offset) const {
// TODO
assert(0);
}
/// Loads a fragment from memory with logical offset in units of whole tiles.
CUTLASS_DEVICE
void load_with_byte_offset(
/// fragment to load from the tensor
Fragment &frag,
/// loads a tile with a logical offset in units of whole tiles
TensorCoord const &tile_offset,
/// loads a tile with a logical offset AND a pointer offset
Index byte_offset) const {
iterator_.load_with_byte_offset(
frag, {tile_offset.contiguous(), tile_offset.strided()}, byte_offset);
}
/// Notify the iterator which k-group it is currently pointing to.
///
/// This does not advance the iterator. Rather, it overrides its internal
/// tracking with constant-valued k-group index to enable the compiler to
/// fold constants and achieve more efficient code.
///
/// This is used by some nontrivial permuted layouts.
CUTLASS_DEVICE
void set_kgroup_index(int k_group) {
iterator_.set_kgroup_index(k_group);
}
};
////////////////////////////////////////////////////////////////////////////////
/// This tile iterator is specialized for 32-thread TensorOps. It uses LDSM to
/// load from shared memory and therefore must be initialized with a TensorRef
/// to shared memory.
///
/// Satisfies:
/// ReadableRandomAccessContiguousTileIteratorConcept
///
template <
/// Size of the matrix to load (concept: MatrixShape)
typename Shape_,
/// Identifies A or B multiplicand
Operand Operand_,
/// Data type of elements
typename Element_,
/// Shape of one matrix product operation (concept: MatrixShape)
typename InstructionShape_,
/// Interval between adjacent *MMA instructions (in units of MMA
/// instructions)
int OpDelta_,
/// Element number when the layout crosses (in units of elements)
int Crosswise,
/// Number of partitions along K dimension
int PartitionsK_>
class MmaTensorOpMultiplicandTileIterator<
Shape_, Operand_, Element_,
cutlass::layout::RowMajorTensorOpMultiplicandCrosswise<
sizeof_bits<Element_>::value, Crosswise>,
InstructionShape_, OpDelta_, 32, PartitionsK_> {
public:
/// Shape of tile to load (concept: PitchLinearShape)
using Shape = Shape_;
/// Operand tag
static Operand const kOperand = Operand_;
static_assert(kOperand == Operand::kA,
"MmaTensorOpMultiplicandIterator for RowMajor Crosswise may "
"only be instantiated for A operand to warp-level Mma.");
/// Element type
using Element = Element_;
/// Element number when the layout crosses
static int const kCrosswise = Crosswise;
/// Layout of source tile
using Layout = cutlass::layout::RowMajorTensorOpMultiplicandCrosswise<
sizeof_bits<Element_>::value, kCrosswise>;
/// Shape of one matrix product operation (concept: MatrixShape)
using InstructionShape = InstructionShape_;
/// Delta between *MMA operations (in units of *MMA operations, concept:
/// MatrixShape)
static int const kOpDelta = OpDelta_;
/// Number of participating threads
static int const kThreads = 32;
/// TensorRef type for loading element from a tensor
using TensorRef = TensorRef<Element, Layout>;
/// Index type
using Index = typename TensorRef::Index;
/// Long Index type
using LongIndex = typename TensorRef::LongIndex;
/// Coordinate for an element in the tensor
using TensorCoord = typename TensorRef::TensorCoord;
/// Underlying tile iterator implementation
using Base = MmaTensorOpMultiplicandTileIterator<
layout::PitchLinearShape<Shape::kColumn, Shape::kRow>, kOperand, Element,
layout::TensorOpMultiplicandCrosswise<sizeof_bits<Element_>::value,
kCrosswise>,
layout::PitchLinearShape<InstructionShape::kColumn,
InstructionShape::kRow>,
kOpDelta, kThreads, PartitionsK_>;
public:
//
// Derived quantities
//
/// Fragment object holding a thread's part of a tile
using Fragment = typename Base::Fragment;
private:
/// Underlying tile iterator
Base iterator_;
public:
/// Default ctor constructs null iterator
CUTLASS_HOST_DEVICE
MmaTensorOpMultiplicandTileIterator() {}
/// Constructor from TensorRef
CUTLASS_HOST_DEVICE
MmaTensorOpMultiplicandTileIterator(TensorRef const &ref, int lane_id)
: iterator_({ref.data(), ref.stride()}, lane_id) {}
/// Adds a pointer offset to internal pointer(s) to advance through memory
CUTLASS_HOST_DEVICE
MmaTensorOpMultiplicandTileIterator &add_pointer_offset(LongIndex offset) {
iterator_.add_pointer_offset(offset);
return *this;
}
/// Advances an iterator along logical dimensions of matrix in units of whole
/// tiles
CUTLASS_HOST_DEVICE
MmaTensorOpMultiplicandTileIterator &add_tile_offset(
TensorCoord const &tile_offset) {
iterator_.add_tile_offset({tile_offset.column(), tile_offset.row()});
return *this;
}
/// Advances an iterator along logical dimensions of matrix in units of whole
/// tiles
CUTLASS_DEVICE
MmaTensorOpMultiplicandTileIterator &add_tile_offset_negative(
TensorCoord const &tile_offset) {
iterator_.add_tile_offset_negative({tile_offset.column(), tile_offset.row()});
return *this;
}
/// Advances the iterator along the advance dimension
CUTLASS_HOST_DEVICE
MmaTensorOpMultiplicandTileIterator &operator++() {
++iterator_;
return *this;
}
/// Advances the iterator along the advance dimension
CUTLASS_HOST_DEVICE
MmaTensorOpMultiplicandTileIterator &operator--() {
--iterator_;
return *this;
}
///< advances in units of whole tiles along the logical coordinate space of
///< the tensor
CUTLASS_DEVICE
MmaTensorOpMultiplicandTileIterator &operator+=(
TensorCoord const &tile_offset) {
add_tile_offset(PitchLinearCoord(tile_offset.column(), tile_offset.row()));
return *this;
}
///< advances in units of whole tiles along the logical coordinate space of
///< the tensor
CUTLASS_DEVICE
MmaTensorOpMultiplicandTileIterator &operator-=(
TensorCoord const &tile_offset) {
add_tile_offset(-PitchLinearCoord(tile_offset.column(), tile_offset.row()));
return *this;
}
/// Loads a fragment from memory at the location pointed to by the iterator.
CUTLASS_HOST_DEVICE
void load(Fragment &frag) const { iterator_.load(frag); }
/// Loads a fragment from memory with additional logical offset
CUTLASS_DEVICE
void load_with_pointer_offset(
/// fragment to load from the tensor
Fragment &frag,
/// loads a tile with a linear offset
Index pointer_offset) const {
iterator_.load_with_pointer_offset(frag, pointer_offset);
}
/// Loads a fragment from memory with additional logical offset
CUTLASS_DEVICE
void load_with_byte_offset(
/// fragment to load from the tensor
Fragment &frag,
/// loads a tile with a linear offset
Index byte_offset) const {
iterator_.load_with_byte_offset(frag, byte_offset);
}
/// Loads a fragment from memory with logical offset in units of whole tiles.
CUTLASS_DEVICE
void load(
/// fragment to load from the tensor
Fragment &frag,
/// loads a tile with a logical offset in units of whole tiles
TensorCoord const &tile_offset) const {
// TODO
assert(0);
}
/// Loads a fragment from memory with logical offset in units of whole tiles.
CUTLASS_DEVICE
void load(
/// fragment to load from the tensor
Fragment &frag,
/// loads a tile with a logical offset in units of whole tiles
TensorCoord const &tile_offset,
/// loads a tile with a logical offset AND a pointer offset
Index pointer_offset) const {
// TODO
assert(0);
}
/// Loads a fragment from memory with logical offset in units of whole tiles.
CUTLASS_DEVICE
void load_with_byte_offset(
/// fragment to load from the tensor
Fragment &frag,
/// loads a tile with a logical offset in units of whole tiles
TensorCoord const &tile_offset,
/// loads a tile with a logical offset AND a pointer offset
Index byte_offset) const {
iterator_.load_with_byte_offset(
frag, {tile_offset.strided(), tile_offset.contiguous()}, byte_offset);
}
/// Notify the iterator which k-group it is currently pointing to.
///
/// This does not advance the iterator. Rather, it overrides its internal
/// tracking with constant-valued k-group index to enable the compiler to
/// fold constants and achieve more efficient code.
///
/// This is used by some nontrivial permuted layouts.
CUTLASS_DEVICE
void set_kgroup_index(int k_group) {
iterator_.set_kgroup_index(k_group);
}
};
////////////////////////////////////////////////////////////////////////////////
template <
/// Size of the matrix to load (concept: MatrixShape)
typename Shape_,
/// Element type
typename Element_,
/// Layout of operand in memory
typename Layout_,
/// Shape of one matrix product operation (concept: MatrixShape)
typename InstructionShape_,
/// Interval between adjacent *MMA instructions (in units of MMA
/// instructions, concept: MatrixShape)
typename OpDelta_>
class MmaTensorOpAccumulatorTileIterator;
////////////////////////////////////////////////////////////////////////////////
/// This tile iterator is specialized for 32-thread TensorOps. It is used to load or store
/// accumulators from memory and is agnostic to layout. It could be faster if it assumed row-major
/// accumulator layout.
///
/// Satisfies:
/// ReadableRandomAccessContiguousTileIteratorConcept |
/// WriteableRandomAccessContiguousTileIteratorConcept
///
template <
/// Size of the matrix to load (concept: MatrixShape)
typename Shape_,
/// Element type
typename Element_,
/// Shape of one matrix product operation (concept: MatrixShape)
typename InstructionShape_,
/// Interval between adjacent *MMA instructions (in units of MMA
/// instructions, concept: MatrixShape)
typename OpDelta_>
class MmaTensorOpAccumulatorTileIterator<
Shape_, Element_, cutlass::layout::RowMajor, InstructionShape_, OpDelta_> {
public:
/// Shape of tile to load (concept: MatrixShape)
using Shape = Shape_;
/// Operand tag
static Operand const kOperand = Operand::kC;
/// Element type
using Element = Element_;
/// Layout of source tile
using Layout = cutlass::layout::RowMajor;
/// Shape of one matrix product operation (concept: MatrixShape)
using InstructionShape = InstructionShape_;
/// Delta between *MMA operations (in units of *MMA operations, concept: MatrixShape)
using OpDelta = OpDelta_;
/// Number of participating threads
static int const kThreads = 32;
/// TensorRef type for loading element from a tensor
using TensorRef = TensorRef<Element, Layout>;
/// Index type
using Index = typename TensorRef::Index;
/// Long Index type
using LongIndex = typename TensorRef::LongIndex;
/// Coordinate for an element in the tensor
using TensorCoord = typename TensorRef::TensorCoord;
/// Internal structure of iterator - made public to enable introspection
struct Policy {
static bool const kDivisible =
!(Shape::kRow % InstructionShape::kM) &&
!(Shape::kColumn % InstructionShape::kN);
static_assert(platform::is_same<TensorCoord, MatrixCoord>::value,
"Layouts must be defined for logical MatrixCoord coordinate space.");
/// Number of mma operations performed
using MmaIterations = MatrixShape<
(Shape::kRow + InstructionShape::kM - 1) / InstructionShape::kM,
(Shape::kColumn + InstructionShape::kN - 1) / InstructionShape::kN
>;
};
private:
// Assume accumulator tile is an arrangement of 8-by-8 tiles replicated over the entire
// shape, with each quad mapped to one row and each thread mapped to 1/4 of the elements
// of that row. The accumulators within one row are assumed to be consecutive.
static int const kElementsPerAccess = InstructionShape::kN / 4;
static int const kRowsPerTile = 8;
static int const kAccumulatorRows = InstructionShape::kM / kRowsPerTile;
public:
//
// Derived quantities
//
/// Fragment object holding a thread's part of a tile
using Fragment = Array<
Element,
Policy::MmaIterations::kCount * InstructionShape::kMN / kThreads>;
private:
/// Reference to output tensor
TensorRef ref_;
public:
/// Default ctor constructs null iterator
CUTLASS_HOST_DEVICE
MmaTensorOpAccumulatorTileIterator() { }
/// Constructor from TensorRef
CUTLASS_HOST_DEVICE
MmaTensorOpAccumulatorTileIterator(
TensorRef const &ref,
int lane_id
):
ref_(ref) {
int quad = (lane_id >> 2);
int lane_in_quad = (lane_id & 3);
MatrixCoord lane_offset(quad, lane_in_quad * kElementsPerAccess);
ref_.add_coord_offset(lane_offset);
}
/// Adds a pointer offset to internal pointer(s) to advance through memory
CUTLASS_HOST_DEVICE
MmaTensorOpAccumulatorTileIterator &add_pointer_offset(LongIndex offset) {
ref_.add_pointer_offset(offset);
return *this;
}
/// Advances an iterator along logical dimensions of matrix in units of whole tiles
CUTLASS_HOST_DEVICE
MmaTensorOpAccumulatorTileIterator &add_tile_offset(TensorCoord const &tile_offset) {
ref_.add_coord_offset(tile_offset * make_Coord(Shape::kRow, Shape::kColumn));
return *this;
}
/// Advances the iterator along the advance dimension
CUTLASS_HOST_DEVICE
MmaTensorOpAccumulatorTileIterator & operator++() {
// deliberate no-op
return *this;
}
/// Advances the iterator along the advance dimension
CUTLASS_HOST_DEVICE
MmaTensorOpAccumulatorTileIterator & operator--() {
// deliberate no-op
return *this;
}
///< advances in units of whole tiles along the logical coordinate space of the tensor
CUTLASS_DEVICE
MmaTensorOpAccumulatorTileIterator & operator+=(TensorCoord const &tile_offset) {
add_tile_offset(tile_offset);
return *this;
}
///< advances in units of whole tiles along the logical coordinate space of the tensor
CUTLASS_DEVICE
MmaTensorOpAccumulatorTileIterator & operator-=(TensorCoord const &tile_offset) {
add_tile_offset(-tile_offset);
return *this;
}
/// Loads a fragment from memory at the location pointed to by the iterator.
CUTLASS_HOST_DEVICE
void load(Fragment &frag) const {
load_with_pointer_offset(frag, 0);
}
/// Loads a fragment from memory with additional logical offset
CUTLASS_DEVICE
void load_with_pointer_offset(
Fragment &frag, ///< fragment to load from the tensor
Index pointer_offset) const { ///< loads a tile with a linear offset
TensorRef offset_ref(ref_);
offset_ref.add_pointer_offset(pointer_offset);
CUTLASS_PRAGMA_UNROLL
for (int mma_n = 0; mma_n < Policy::MmaIterations::kColumn; ++mma_n) {
CUTLASS_PRAGMA_UNROLL
for (int mma_m = 0; mma_m < Policy::MmaIterations::kRow; ++mma_m) {
int mma_accum_start = kAccumulatorRows * kElementsPerAccess *
(mma_n * Policy::MmaIterations::kRow + mma_m);
CUTLASS_PRAGMA_UNROLL
for (int row = 0; row < kAccumulatorRows; ++row) {
CUTLASS_PRAGMA_UNROLL
for (int col = 0; col < kElementsPerAccess; ++col) {
int accum_m = mma_m * InstructionShape::kM * OpDelta::kRow +
row * kRowsPerTile;
int accum_n = mma_n * InstructionShape::kN * OpDelta::kColumn + col;
frag[mma_accum_start + row * kElementsPerAccess + col] = offset_ref.at({accum_m, accum_n});
}
}
}
}
}
/// Loads a fragment from memory with additional logical offset
CUTLASS_DEVICE
void load_with_byte_offset(
Fragment &frag, ///< fragment to load from the tensor
Index byte_offset) const { ///< loads a tile with a linear offset
load_with_pointer_offset(byte_offset / sizeof(Element));
}
/// Loads a fragment from memory with logical offset in units of whole tiles.
CUTLASS_DEVICE
void load(
Fragment &frag, ///< fragment to load from the tensor
TensorCoord const &tile_offset) const { ///< loads a tile with a logical offset in units of whole tiles
load(frag, tile_offset, 0);
}
/// Loads a fragment from memory with logical offset in units of whole tiles.
CUTLASS_DEVICE
void load(
Fragment &frag, ///< fragment to load from the tensor
TensorCoord const &tile_offset, ///< loads a tile with a logical offset in units of whole tiles
Index pointer_offset) const { ///< loads a tile with a logical offset AND a pointer offset
load_with_pointer_offset(frag, ref_.offset(tile_offset) + pointer_offset);
}
/// Stores a fragment to memory
CUTLASS_HOST_DEVICE
void store(Fragment const &frag) const {
store_with_pointer_offset(frag, 0);
}
/// Stores a fragment to memory with additional pointer offset
CUTLASS_DEVICE
void store_with_pointer_offset(
Fragment const &frag, ///< fragment to store from the tensor
Index pointer_offset) const { ///< store a tile with a linear offset
TensorRef offset_ref(ref_);
offset_ref.add_pointer_offset(pointer_offset);
CUTLASS_PRAGMA_UNROLL
for (int mma_n = 0; mma_n < Policy::MmaIterations::kColumn; ++mma_n) {
CUTLASS_PRAGMA_UNROLL
for (int mma_m = 0; mma_m < Policy::MmaIterations::kRow; ++mma_m) {
int mma_accum_start = kAccumulatorRows * kElementsPerAccess *
(mma_n * Policy::MmaIterations::kRow + mma_m);
CUTLASS_PRAGMA_UNROLL
for (int row = 0; row < kAccumulatorRows; ++row) {
CUTLASS_PRAGMA_UNROLL
for (int col = 0; col < kElementsPerAccess; ++col) {
int accum_m = mma_m * InstructionShape::kM * OpDelta::kRow +
row * kRowsPerTile;
int accum_n = mma_n * InstructionShape::kN * OpDelta::kColumn + col;
int idx = mma_accum_start + row * kElementsPerAccess + col;
offset_ref.at({accum_m, accum_n}) = frag[idx];
}
}
}
}
}
/// Stores a fragment to memory with additional pointer offset
CUTLASS_DEVICE
void store_with_byte_offset(
Fragment const &frag, ///< fragment to store from the tensor
Index byte_offset) const { ///< store a tile with a linear offset
store_with_pointer_offset(byte_offset / sizeof(Element));
}
/// Stores a fragment to memory with logical offset in units of whole tiles.
CUTLASS_DEVICE
void store(
Fragment &frag, ///< fragment to store to the tensor
TensorCoord const &tile_offset) const { ///< stores a tile with a logical offset in units of whole tiles
store(frag, tile_offset, 0);
}
/// Stores a fragment from memory with logical offset in units of whole tiles.
CUTLASS_DEVICE
void store(
/// fragment to store to the tensor
Fragment const &frag,
/// stores a tile with a logical offset in units of whole tiles
TensorCoord const &tile_offset,
/// stores a tile with a logical offset AND a pointer offset
Index pointer_offset) const {
store_with_pointer_offset(frag, ref_.offset(tile_offset) + pointer_offset);
}
};
////////////////////////////////////////////////////////////////////////////////
/// This tile iterator is specialized for 32-thread TensorOps. It is used to load or store
/// accumulators from memory and is agnostic to layout. It could be faster if it assumed row-major
/// accumulator layout.
///
/// Satisfies:
/// ReadableRandomAccessContiguousTileIteratorConcept |
/// WriteableRandomAccessContiguousTileIteratorConcept
///
template <
/// Size of the matrix to load (concept: MatrixShape)
typename Shape_,
/// Element type
typename Element_,
/// Shape of one matrix product operation (concept: MatrixShape)
typename InstructionShape_,
/// Interval between adjacent *MMA instructions (in units of MMA
/// instructions, concept: MatrixShape)
typename OpDelta_>
class MmaTensorOpAccumulatorTileIterator<Shape_, Element_,
cutlass::layout::ColumnMajor,
InstructionShape_, OpDelta_> {
public:
/// Shape of tile to load (concept: MatrixShape)
using Shape = Shape_;
/// Operand tag
static Operand const kOperand = Operand::kC;
/// Element type
using Element = Element_;
/// Layout of source tile
using Layout = cutlass::layout::ColumnMajor;
/// Shape of one matrix product operation (concept: MatrixShape)
using InstructionShape = InstructionShape_;
/// Delta between *MMA operations (in units of *MMA operations, concept: MatrixShape)
using OpDelta = OpDelta_;
/// Number of participating threads
static int const kThreads = 32;
/// TensorRef type for loading element from a tensor
using TensorRef = TensorRef<Element, Layout>;
/// Index type
using Index = typename TensorRef::Index;
/// Long Index type
using LongIndex = typename TensorRef::LongIndex;
/// Coordinate for an element in the tensor
using TensorCoord = typename TensorRef::TensorCoord;
/// Internal structure of iterator - made public to enable introspection
struct Policy {
static bool const kDivisible =
!(Shape::kRow % InstructionShape::kM) &&
!(Shape::kColumn % InstructionShape::kN);
static_assert(platform::is_same<TensorCoord, MatrixCoord>::value,
"Layouts must be defined for logical MatrixCoord coordinate space.");
/// Number of mma operations performed
using MmaIterations = MatrixShape<
(Shape::kRow + InstructionShape::kM - 1) / InstructionShape::kM,
(Shape::kColumn + InstructionShape::kN - 1) / InstructionShape::kN
>;
};
private:
// Assume accumulator tile is an arrangement of 8-by-8 tiles replicated over the entire
// shape, with each quad mapped to one row and each thread mapped to 1/4 of the elements
// of that row. The accumulators within one row are assumed to be consecutive.
static int const kElementsPerAccess = InstructionShape::kN / 4;
static int const kRowsPerTile = 8;
static int const kAccumulatorRows = InstructionShape::kM / kRowsPerTile;
public:
//
// Derived quantities
//
/// Fragment object holding a thread's part of a tile
using Fragment = Array<Element,
Policy::MmaIterations::kCount * InstructionShape::kMN / kThreads>;
private:
/// Reference to output tensor
TensorRef ref_;
public:
/// Default ctor constructs null iterator
CUTLASS_HOST_DEVICE
MmaTensorOpAccumulatorTileIterator() { }
/// Constructor from TensorRef
CUTLASS_HOST_DEVICE
MmaTensorOpAccumulatorTileIterator(
TensorRef const &ref,
int lane_id
):
ref_(ref) {
int quad = (lane_id >> 2);
int lane_in_quad = (lane_id & 3);
MatrixCoord lane_offset(quad, lane_in_quad * kElementsPerAccess);
ref_.add_coord_offset(lane_offset);
}
/// Adds a pointer offset to internal pointer(s) to advance through memory
CUTLASS_HOST_DEVICE
MmaTensorOpAccumulatorTileIterator &add_pointer_offset(LongIndex offset) {
ref_.add_pointer_offset(offset);
return *this;
}
/// Advances an iterator along logical dimensions of matrix in units of whole tiles
CUTLASS_HOST_DEVICE
MmaTensorOpAccumulatorTileIterator &add_tile_offset(TensorCoord const &tile_offset) {
ref_.add_coord_offset(tile_offset * make_Coord(Shape::kRow, Shape::kColumn));
return *this;
}
/// Advances the iterator along the advance dimension
CUTLASS_HOST_DEVICE
MmaTensorOpAccumulatorTileIterator & operator++() {
// deliberate no-op
return *this;
}
/// Advances the iterator along the advance dimension
CUTLASS_HOST_DEVICE
MmaTensorOpAccumulatorTileIterator & operator--() {
// deliberate no-op
return *this;
}
///< advances in units of whole tiles along the logical coordinate space of the tensor
CUTLASS_DEVICE
MmaTensorOpAccumulatorTileIterator & operator+=(TensorCoord const &tile_offset) {
add_tile_offset(tile_offset);
return *this;
}
///< advances in units of whole tiles along the logical coordinate space of the tensor
CUTLASS_DEVICE
MmaTensorOpAccumulatorTileIterator & operator-=(TensorCoord const &tile_offset) {
add_tile_offset(-tile_offset);
return *this;
}
/// Loads a fragment from memory at the location pointed to by the iterator.
CUTLASS_HOST_DEVICE
void load(Fragment &frag) const {
load_with_pointer_offset(frag, 0);
}
/// Loads a fragment from memory with additional logical offset
CUTLASS_DEVICE
void load_with_pointer_offset(
Fragment &frag, ///< fragment to load from the tensor
Index pointer_offset) const { ///< loads a tile with a linear offset
TensorRef offset_ref(ref_);
offset_ref.add_pointer_offset(pointer_offset);
CUTLASS_PRAGMA_UNROLL
for (int mma_n = 0; mma_n < Policy::MmaIterations::kColumn; ++mma_n) {
CUTLASS_PRAGMA_UNROLL
for (int mma_m = 0; mma_m < Policy::MmaIterations::kRow; ++mma_m) {
int mma_accum_start = kAccumulatorRows * kElementsPerAccess *
(mma_n * Policy::MmaIterations::kRow + mma_m);
CUTLASS_PRAGMA_UNROLL
for (int row = 0; row < kAccumulatorRows; ++row) {
CUTLASS_PRAGMA_UNROLL
for (int col = 0; col < kElementsPerAccess; ++col) {
int accum_m = mma_m * InstructionShape::kM * OpDelta::kRow +
row * kRowsPerTile;
int accum_n = mma_n * InstructionShape::kN * OpDelta::kColumn + col;
int idx = mma_accum_start + row * kElementsPerAccess + col;
frag[idx] = offset_ref.at({accum_m, accum_n});
}
}
}
}
}
/// Loads a fragment from memory with additional logical offset
CUTLASS_DEVICE
void load_with_byte_offset(
Fragment &frag, ///< fragment to load from the tensor
Index byte_offset) const { ///< loads a tile with a linear offset
load_with_pointer_offset(byte_offset / sizeof(Element));
}
/// Loads a fragment from memory with logical offset in units of whole tiles.
CUTLASS_DEVICE
void load(
Fragment &frag, ///< fragment to load from the tensor
TensorCoord const &tile_offset) const { ///< loads a tile with a logical offset in units of whole tiles
load(frag, tile_offset, 0);
}
/// Loads a fragment from memory with logical offset in units of whole tiles.
CUTLASS_DEVICE
void load(
Fragment &frag, ///< fragment to load from the tensor
TensorCoord const &tile_offset, ///< loads a tile with a logical offset in units of whole tiles
Index pointer_offset) const { ///< loads a tile with a logical offset AND a pointer offset
load_with_pointer_offset(frag, ref_.offset(tile_offset) + pointer_offset);
}
/// Stores a fragment to memory
CUTLASS_HOST_DEVICE
void store(Fragment const &frag) const {
store_with_pointer_offset(frag, 0);
}
/// Stores a fragment to memory with additional pointer offset
CUTLASS_DEVICE
void store_with_pointer_offset(
Fragment const &frag, ///< fragment to store from the tensor
Index pointer_offset) const { ///< store a tile with a linear offset
TensorRef offset_ref(ref_);
offset_ref.add_pointer_offset(pointer_offset);
CUTLASS_PRAGMA_UNROLL
for (int mma_n = 0; mma_n < Policy::MmaIterations::kColumn; ++mma_n) {
CUTLASS_PRAGMA_UNROLL
for (int mma_m = 0; mma_m < Policy::MmaIterations::kRow; ++mma_m) {
int mma_accum_start = kAccumulatorRows * kElementsPerAccess *
(mma_n * Policy::MmaIterations::kRow + mma_m);
CUTLASS_PRAGMA_UNROLL
for (int row = 0; row < kAccumulatorRows; ++row) {
CUTLASS_PRAGMA_UNROLL
for (int col = 0; col < kElementsPerAccess; ++col) {
int accum_m = mma_m * InstructionShape::kM * OpDelta::kRow +
row * kRowsPerTile;
int accum_n = mma_n * InstructionShape::kN * OpDelta::kColumn + col;
int idx = mma_accum_start + row * kElementsPerAccess + col;
offset_ref.at({accum_m, accum_n}) = frag[idx];
}
}
}
}
}
/// Stores a fragment to memory with additional pointer offset
CUTLASS_DEVICE
void store_with_byte_offset(
Fragment const &frag, ///< fragment to store from the tensor
Index byte_offset) const { ///< store a tile with a linear offset
store_with_pointer_offset(byte_offset / sizeof(Element));
}
/// Stores a fragment to memory with logical offset in units of whole tiles.
CUTLASS_DEVICE
void store(
Fragment &frag, ///< fragment to store to the tensor
TensorCoord const &tile_offset) const { ///< stores a tile with a logical offset in units of whole tiles
store(frag, tile_offset, 0);
}
/// Stores a fragment from memory with logical offset in units of whole tiles.
CUTLASS_DEVICE
void store(
/// fragment to store to the tensor
Fragment const &frag,
/// stores a tile with a logical offset in units of whole tiles
TensorCoord const &tile_offset,
/// stores a tile with a logical offset AND a pointer offset
Index pointer_offset) const {
store_with_pointer_offset(frag, ref_.offset(tile_offset) + pointer_offset);
}
};
////////////////////////////////////////////////////////////////////////////////
/// This tile iterator is specialized for 32-thread TensorOps. It is used to load or store
/// accumulators from memory and is agnostic to layout. It could be faster if it assumed row-major
/// accumulator layout.
///
/// Satisfies:
/// ReadableRandomAccessContiguousTileIteratorConcept |
/// WriteableRandomAccessContiguousTileIteratorConcept
///
template <
/// Size of the matrix to load (concept: MatrixShape)
typename Shape_,
/// Element typ
typename Element_,
/// Shape of one matrix product operation (concept: MatrixShape)
typename InstructionShape_,
/// Interval between adjacent *MMA instructions (in units of MMA
/// instructions, concept: MatrixShape)
typename OpDelta_,
/// Interleaved N
int InterleavedN>
class MmaTensorOpAccumulatorTileIterator<
Shape_, Element_, cutlass::layout::ColumnMajorInterleaved<InterleavedN>,
InstructionShape_, OpDelta_> {
public:
/// Shape of tile to load (concept: MatrixShape)
using Shape = Shape_;
/// Operand tag
static Operand const kOperand = Operand::kC;
/// Element type
using Element = Element_;
/// Layout of source tile
using Layout = cutlass::layout::ColumnMajorInterleaved<InterleavedN>;
/// Shape of one matrix product operation (concept: MatrixShape)
using InstructionShape = InstructionShape_;
/// Delta between *MMA operations (in units of *MMA operations, concept: MatrixShape)
using OpDelta = OpDelta_;
/// Number of participating threads
static int const kThreads = 32;
/// TensorRef type for loading element from a tensor
using TensorRef = TensorRef<Element, Layout>;
/// Index type
using Index = typename TensorRef::Index;
/// Long Index type
using LongIndex = typename TensorRef::LongIndex;
/// Coordinate for an element in the tensor
using TensorCoord = typename TensorRef::TensorCoord;
/// Internal structure of iterator - made public to enable introspection
struct Policy {
static_assert(
!(Shape::kRow % InstructionShape::kM) &&
!(Shape::kColumn % InstructionShape::kN),
"Shape of warp-level Mma must be divisible by operator shape.");
static_assert(platform::is_same<TensorCoord, MatrixCoord>::value,
"Layouts must be defined for logical MatrixCoord coordinate space.");
/// Number of mma operations performed
using MmaIterations = MatrixShape<Shape::kRow / InstructionShape::kM,
Shape::kColumn / InstructionShape::kN>;
};
private:
static int const kElementsPerAccess = 2;
public:
//
// Derived quantities
//
using AccessType = Array<Element, kElementsPerAccess>;
/// Fragment object holding a thread's part of a tile
using Fragment = Array<Element, Shape::kCount / kThreads>;
private:
/// Reference to output tensor
TensorRef ref_;
public:
/// Default ctor constructs null iterator
CUTLASS_HOST_DEVICE
MmaTensorOpAccumulatorTileIterator() { }
/// Constructor from TensorRef
CUTLASS_HOST_DEVICE
MmaTensorOpAccumulatorTileIterator(
TensorRef const &ref,
int lane_id
):
ref_(ref) {
int quad = (lane_id >> 2);
int lane_in_quad = (lane_id & 3);
MatrixCoord lane_offset(quad, lane_in_quad * kElementsPerAccess);
ref_.add_coord_offset(lane_offset);
}
/// Adds a pointer offset to internal pointer(s) to advance through memory
CUTLASS_HOST_DEVICE
MmaTensorOpAccumulatorTileIterator &add_pointer_offset(LongIndex offset) {
ref_.add_pointer_offset(offset);
return *this;
}
/// Advances an iterator along logical dimensions of matrix in units of whole tiles
CUTLASS_HOST_DEVICE
MmaTensorOpAccumulatorTileIterator &add_tile_offset(TensorCoord const &tile_offset) {
ref_.add_coord_offset(tile_offset * make_Coord(Shape::kRow, Shape::kColumn));
return *this;
}
/// Advances the iterator along the advance dimension
CUTLASS_HOST_DEVICE
MmaTensorOpAccumulatorTileIterator & operator++() {
// deliberate no-op
return *this;
}
/// Advances the iterator along the advance dimension
CUTLASS_HOST_DEVICE
MmaTensorOpAccumulatorTileIterator & operator--() {
// deliberate no-op
return *this;
}
///< advances in units of whole tiles along the logical coordinate space of the tensor
CUTLASS_DEVICE
MmaTensorOpAccumulatorTileIterator & operator+=(TensorCoord const &tile_offset) {
add_tile_offset(tile_offset);
return *this;
}
///< advances in units of whole tiles along the logical coordinate space of the tensor
CUTLASS_DEVICE
MmaTensorOpAccumulatorTileIterator & operator-=(TensorCoord const &tile_offset) {
add_tile_offset(-tile_offset);
return *this;
}
/// Loads a fragment from memory at the location pointed to by the iterator.
CUTLASS_HOST_DEVICE
void load(Fragment &frag) const {
load_with_pointer_offset(frag, 0);
}
/// Loads a fragment from memory with additional logical offset
CUTLASS_DEVICE
void load_with_pointer_offset(
Fragment &frag, ///< fragment to load from the tensor
Index pointer_offset) const { ///< loads a tile with a linear offset
TensorRef offset_ref(ref_);
offset_ref.add_pointer_offset(pointer_offset);
AccessType* frag_ptr = reinterpret_cast<AccessType *>(&frag);
CUTLASS_PRAGMA_UNROLL
for (int mma_n = 0; mma_n < Policy::MmaIterations::kColumn; ++mma_n) {
CUTLASS_PRAGMA_UNROLL
for (int mma_m = 0; mma_m < Policy::MmaIterations::kRow; ++mma_m) {
int accum_m = mma_m * InstructionShape::kM;
int accum_n = mma_n * InstructionShape::kN;
int idx = mma_m + mma_n * Policy::MmaIterations::kRow;
AccessType* access_ptr = reinterpret_cast<AccessType *>(offset_ref.data() +
offset_ref.offset(TensorCoord(accum_m, accum_n)));
frag_ptr[idx] = access_ptr[0];
}
}
}
/// Loads a fragment from memory with additional logical offset
CUTLASS_DEVICE
void load_with_byte_offset(
Fragment &frag, ///< fragment to load from the tensor
Index byte_offset) const { ///< loads a tile with a linear offset
load_with_pointer_offset(byte_offset / sizeof(Element));
}
/// Loads a fragment from memory with logical offset in units of whole tiles.
CUTLASS_DEVICE
void load(
Fragment &frag, ///< fragment to load from the tensor
TensorCoord const &tile_offset) const { ///< loads a tile with a logical offset in units of whole tiles
load(frag, tile_offset, 0);
}
/// Loads a fragment from memory with logical offset in units of whole tiles.
CUTLASS_DEVICE
void load(
Fragment &frag, ///< fragment to load from the tensor
TensorCoord const &tile_offset, ///< loads a tile with a logical offset in units of whole tiles
Index pointer_offset) const { ///< loads a tile with a logical offset AND a pointer offset
load_with_pointer_offset(frag, ref_.offset(tile_offset) + pointer_offset);
}
/// Stores a fragment to memory
CUTLASS_HOST_DEVICE
void store(Fragment const &frag) const {
store_with_pointer_offset(frag, 0);
}
/// Stores a fragment to memory with additional pointer offset
CUTLASS_DEVICE
void store_with_pointer_offset(
Fragment const &frag, ///< fragment to store from the tensor
Index pointer_offset) const { ///< store a tile with a linear offset
TensorRef offset_ref(ref_);
offset_ref.add_pointer_offset(pointer_offset);
AccessType const *frag_ptr = reinterpret_cast<AccessType const*>(&frag);
CUTLASS_PRAGMA_UNROLL
for (int mma_n = 0; mma_n < Policy::MmaIterations::kColumn; ++mma_n) {
CUTLASS_PRAGMA_UNROLL
for (int mma_m = 0; mma_m < Policy::MmaIterations::kRow; ++mma_m) {
int accum_m = mma_m * InstructionShape::kM;
int accum_n = mma_n * InstructionShape::kN;
int idx = mma_m + mma_n * Policy::MmaIterations::kRow;
AccessType* access_ptr = reinterpret_cast<AccessType *>(offset_ref.data() +
offset_ref.offset(TensorCoord(accum_m, accum_n)));
access_ptr[0] = frag_ptr[idx];
}
}
}
/// Stores a fragment to memory with additional pointer offset
CUTLASS_DEVICE
void store_with_byte_offset(
Fragment const &frag, ///< fragment to store from the tensor
Index byte_offset) const { ///< store a tile with a linear offset
store_with_pointer_offset(byte_offset / sizeof(Element));
}
/// Stores a fragment to memory with logical offset in units of whole tiles.
CUTLASS_DEVICE
void store(
Fragment &frag, ///< fragment to store to the tensor
TensorCoord const &tile_offset) const { ///< stores a tile with a logical offset in units of whole tiles
store(frag, tile_offset, 0);
}
/// Stores a fragment from memory with logical offset in units of whole tiles.
CUTLASS_DEVICE
void store(
/// fragment to store to the tensor
Fragment const &frag,
/// stores a tile with a logical offset in units of whole tiles
TensorCoord const &tile_offset,
/// stores a tile with a logical offset AND a pointer offset
Index pointer_offset) const {
store_with_pointer_offset(frag, ref_.offset(tile_offset) + pointer_offset);
}
};
////////////////////////////////////////////////////////////////////////////////
/// This tile iterator is specialized for 32-thread TensorOps. It is used to load or store
/// accumulators from memory and is agnostic to layout. It could be faster if it assumed row-major
/// accumulator layout.
///
/// Satisfies:
/// ReadableRandomAccessContiguousTileIteratorConcept |
/// WriteableRandomAccessContiguousTileIteratorConcept
///
template <
/// Size of the matrix to load (concept: MatrixShape)
typename Shape_,
/// Element typ
typename Element_,
/// Shape of one matrix product operation (concept: MatrixShape)
typename InstructionShape_,
/// Interval between adjacent *MMA instructions (in units of MMA
/// instructions, concept: MatrixShape)
typename OpDelta_,
/// Interleaved N
int InterleavedN>
class MmaTensorOpAccumulatorTileIterator<
Shape_, Element_, cutlass::layout::TensorNCxHWx<InterleavedN>,
InstructionShape_, OpDelta_> {
public:
/// Shape of tile to load (concept: MatrixShape)
using Shape = Shape_;
/// Operand tag
static Operand const kOperand = Operand::kC;
/// Element type
using Element = int8_t;
/// Layout of source tile
using Layout = cutlass::layout::TensorNCxHWx<InterleavedN>;
/// Shape of one matrix product operation (concept: MatrixShape)
using InstructionShape = InstructionShape_;
/// Delta between *MMA operations (in units of *MMA operations, concept: MatrixShape)
using OpDelta = OpDelta_;
/// Number of participating threads
static int const kThreads = 32;
/// TensorRef type for loading element from a tensor
using TensorRef = TensorRef<Element, Layout>;
/// Index type
using Index = typename TensorRef::Index;
/// Long Index type
using LongIndex = typename TensorRef::LongIndex;
/// Coordinate for an element in the tensor
using TensorCoord = typename TensorRef::TensorCoord;
/// Internal structure of iterator - made public to enable introspection
struct Policy {
static_assert(
!(Shape::kRow % InstructionShape::kM) &&
!(Shape::kColumn % InstructionShape::kN),
"Shape of warp-level Mma must be divisible by operator shape.");
/// Number of elements in strided dimension that each STG writes
static int const kStridedPerSTG = 8;
/// Factor to calculate reorder index to pack accumulator.
static int const kPackedFactor = Shape::kColumn / 32;
/// Number of mma operations performed
using MmaIterations = MatrixShape<Shape::kRow / kStridedPerSTG,
Shape::kColumn / InterleavedN>;
};
private:
static int const kElementsPerAccess = InterleavedN / 4;
public:
//
// Derived quantities
//
struct alignas((kElementsPerAccess * sizeof_bits<Element>::value / 8)) AccessType {
Array<Element, kElementsPerAccess> storage;
};
/// Fragment object holding a thread's part of a tile
using Fragment = Array<int32_t, Shape::kCount / kThreads>;
private:
/// Reference to output tensor
TensorRef ref_;
/// Row offset index globally
LongIndex global_offset_row_;
/// Column offset index globally
LongIndex global_offset_col_;
/// Output tensor size
TensorCoord extent_;
/// Alpha
float alpha_;
/// Beta
float beta_;
public:
/// Default ctor constructs null iterator
CUTLASS_HOST_DEVICE
MmaTensorOpAccumulatorTileIterator() { }
/// Constructor from TensorRef
CUTLASS_HOST_DEVICE
MmaTensorOpAccumulatorTileIterator(
TensorRef const &ref,
int const lane_id,
TensorCoord extent,
float alpha = 1.0f,
float beta = 0.0f
):
ref_(ref),
extent_(extent),
alpha_(alpha),
beta_(beta) {
int quad = (lane_id >> 2);
int lane_in_quad = (lane_id & 3);
global_offset_row_ = quad;
global_offset_col_ = lane_in_quad * kElementsPerAccess;
}
/// Adds a pointer offset to internal pointer(s) to advance through memory
CUTLASS_HOST_DEVICE
MmaTensorOpAccumulatorTileIterator &add_pointer_offset(LongIndex offset) {
ref_.add_pointer_offset(offset);
return *this;
}
/// Advances an iterator along logical dimensions of matrix in units of whole tiles
CUTLASS_HOST_DEVICE
MmaTensorOpAccumulatorTileIterator &add_tile_offset(MatrixCoord const &tile_offset) {
global_offset_row_ += tile_offset.row() * Shape::kRow;
global_offset_col_ += tile_offset.column() * Shape::kColumn;
return *this;
}
/// Advances the iterator along the advance dimension
CUTLASS_HOST_DEVICE
MmaTensorOpAccumulatorTileIterator & operator++() {
// deliberate no-op
return *this;
}
/// Advances the iterator along the advance dimension
CUTLASS_HOST_DEVICE
MmaTensorOpAccumulatorTileIterator & operator--() {
// deliberate no-op
return *this;
}
///< advances in units of whole tiles along the logical coordinate space of the tensor
CUTLASS_DEVICE
MmaTensorOpAccumulatorTileIterator & operator+=(TensorCoord const &tile_offset) {
add_tile_offset(tile_offset);
return *this;
}
///< advances in units of whole tiles along the logical coordinate space of the tensor
CUTLASS_DEVICE
MmaTensorOpAccumulatorTileIterator & operator-=(TensorCoord const &tile_offset) {
add_tile_offset(-tile_offset);
return *this;
}
/// Loads a fragment from memory at the location pointed to by the iterator.
CUTLASS_HOST_DEVICE
void load(Fragment &frag) const {
load_with_pointer_offset(frag);
}
/// Loads a fragment from memory with additional logical offset
CUTLASS_DEVICE
void load_with_pointer_offset(
Fragment &frag, ///< fragment to load from the tensor
Index pointer_offset) const { ///< loads a tile with a linear offset
TensorRef offset_ref(ref_);
offset_ref.add_pointer_offset(pointer_offset);
AccessType* frag_ptr = reinterpret_cast<AccessType *>(&frag);
CUTLASS_PRAGMA_UNROLL
for (int mma_n = 0; mma_n < Policy::MmaIterations::kN; ++mma_n) {
CUTLASS_PRAGMA_UNROLL
for (int mma_m = 0; mma_m < Policy::MmaIterations::kM; ++mma_m) {
int accum_m = mma_m * InstructionShape::kM;
int accum_n = mma_n * InstructionShape::kN;
int idx = mma_m + mma_n * Policy::MmaIterations::kM;
AccessType* access_ptr = reinterpret_cast<AccessType *>(offset_ref.data() +
accum_m * offset_ref.stride(0) + accum_n);
frag_ptr[idx] = access_ptr[0];
}
}
}
/// Loads a fragment from memory with additional logical offset
CUTLASS_DEVICE
void load_with_byte_offset(
Fragment &frag, ///< fragment to load from the tensor
Index byte_offset) const { ///< loads a tile with a linear offset
load_with_pointer_offset(byte_offset / sizeof(Element));
}
/// Loads a fragment from memory with logical offset in units of whole tiles.
CUTLASS_DEVICE
void load(
Fragment &frag, ///< fragment to load from the tensor
TensorCoord const &tile_offset) const { ///< loads a tile with a logical offset in units of whole tiles
load(frag, tile_offset, 0);
}
/// Loads a fragment from memory with logical offset in units of whole tiles.
CUTLASS_DEVICE
void load(
Fragment &frag, ///< fragment to load from the tensor
TensorCoord const &tile_offset, ///< loads a tile with a logical offset in units of whole tiles
Index pointer_offset) const { ///< loads a tile with a logical offset AND a pointer offset
load_with_pointer_offset(frag, ref_.offset(tile_offset) + pointer_offset);
}
/// Stores a fragment to memory
CUTLASS_HOST_DEVICE
void store(Fragment const &frag) const {
store_with_pointer_offset(frag, 0);
}
/// Stores a fragment to memory with additional pointer offset
CUTLASS_DEVICE
void store_with_pointer_offset(
Fragment const &frag, ///< fragment to store from the tensor
Index pointer_offset) const { ///< store a tile with a linear offset
TensorRef offset_ref(ref_);
offset_ref.add_pointer_offset(pointer_offset);
Array<float, Shape::kCount / kThreads> output_frag_f;
Array<Element, Shape::kCount / kThreads> output_frag;
LongIndex pq = extent_.h() * extent_.w();
LongIndex extent_row = extent_.n() * pq;
LongIndex extent_col = extent_.c();
LongIndex k_major = (global_offset_col_ / InterleavedN) * pq;
Index k_minor = global_offset_col_ % InterleavedN;
LongIndex k_offset = k_major * InterleavedN + k_minor;
LongIndex k_offset_delta = pq * InterleavedN;
LongIndex stride_n = pq * extent_.c();
Index n;
LongIndex pq_rem;
unsigned int pq_mul, pq_shr;
find_divisor(pq_mul, pq_shr, pq);
if(beta_ == 0.0f) {
CUTLASS_PRAGMA_UNROLL
for(int i = 0; i < frag.size(); ++i) {
output_frag_f[i] = frag[i];
}
if(InstructionShape::kM == Policy::kStridedPerSTG) {
CUTLASS_PRAGMA_UNROLL
for(int i = 0; i < frag.size(); ++i) {
output_frag[i] = (Element)(output_frag_f[i] * alpha_);
}
} else {
CUTLASS_PRAGMA_UNROLL
for(int i = 0; i < frag.size(); ++i) {
int map_i = (i / (16 * Policy::kPackedFactor)) * (16 * Policy::kPackedFactor)
+ (i % (8 * Policy::kPackedFactor)) / 2 * 4
+ (i % (8 * Policy::kPackedFactor)) % 2
+ (i / (8 * Policy::kPackedFactor)) % 2 * 2;
output_frag[i] = (Element)(output_frag_f[map_i] * alpha_);
}
}
AccessType const *frag_ptr = reinterpret_cast<AccessType const*>(&output_frag);
CUTLASS_PRAGMA_UNROLL
for (int mma_m = 0; mma_m < Policy::MmaIterations::kRow; ++mma_m) {
int accum_m = mma_m * Policy::kStridedPerSTG;
fast_divmod(n, pq_rem, global_offset_row_ + accum_m, pq, pq_mul, pq_shr);
LongIndex offset_m = n * stride_n + k_offset + pq_rem * InterleavedN;
CUTLASS_PRAGMA_UNROLL
for (int mma_n = 0; mma_n < Policy::MmaIterations::kColumn; ++mma_n) {
int accum_n = mma_n * InterleavedN;
int idx = mma_n + mma_m * Policy::MmaIterations::kColumn;
if((global_offset_row_ + accum_m < extent_row) && (global_offset_col_ + accum_n < extent_col)) {
AccessType* access_ptr = reinterpret_cast<AccessType *>(offset_ref.data() +
offset_m + mma_n * k_offset_delta);
access_ptr[0] = frag_ptr[idx];
}
}
}
} else {
if(InstructionShape::kM == Policy::kStridedPerSTG) {
CUTLASS_PRAGMA_UNROLL
for(int i = 0; i < frag.size(); ++i) {
output_frag_f[i] = frag[i];
}
} else {
CUTLASS_PRAGMA_UNROLL
for(int i = 0; i < frag.size(); ++i) {
int map_i = (i / (16 * Policy::kPackedFactor)) * (16 * Policy::kPackedFactor)
+ (i % (8 * Policy::kPackedFactor)) / 2 * 4
+ (i % (8 * Policy::kPackedFactor)) % 2
+ (i / (8 * Policy::kPackedFactor)) % 2 * 2;
output_frag_f[i] = frag[map_i];
}
}
AccessType const *frag_ptr = reinterpret_cast<AccessType const*>(&output_frag);
Array<Element, kElementsPerAccess> ref_frag;
AccessType *ref_frag_ptr = reinterpret_cast<AccessType *>(&ref_frag);
CUTLASS_PRAGMA_UNROLL
for (int mma_m = 0; mma_m < Policy::MmaIterations::kRow; ++mma_m) {
int accum_m = mma_m * Policy::kStridedPerSTG;
fast_divmod(n, pq_rem, global_offset_row_ + accum_m, pq, pq_mul, pq_shr);
LongIndex offset_m = n * stride_n + k_offset + pq_rem * InterleavedN;
CUTLASS_PRAGMA_UNROLL
for (int mma_n = 0; mma_n < Policy::MmaIterations::kColumn; ++mma_n) {
int accum_n = mma_n * InterleavedN;
int idx = mma_n + mma_m * Policy::MmaIterations::kColumn;
if((global_offset_row_ + accum_m < extent_row) && (global_offset_col_ + accum_n < extent_col)) {
AccessType* access_ptr = reinterpret_cast<AccessType *>(offset_ref.data() +
offset_m + mma_n * k_offset_delta);
ref_frag_ptr[0] = access_ptr[0];
CUTLASS_PRAGMA_UNROLL
for(int i = 0; i < kElementsPerAccess; ++i) {
output_frag[idx * kElementsPerAccess + i] = Element(alpha_ * output_frag_f[idx * kElementsPerAccess + i]
+ beta_ * ref_frag[i]);
}
access_ptr[0] = frag_ptr[idx];
}
}
}
}
}
/// Stores a fragment to memory with additional pointer offset
CUTLASS_DEVICE
void store_with_byte_offset(
Fragment const &frag, ///< fragment to store from the tensor
Index byte_offset) const { ///< store a tile with a linear offset
store_with_pointer_offset(byte_offset / sizeof(Element));
}
/// Stores a fragment to memory with logical offset in units of whole tiles.
CUTLASS_DEVICE
void store(
Fragment &frag, ///< fragment to store to the tensor
TensorCoord const &tile_offset) const { ///< stores a tile with a logical offset in units of whole tiles
store(frag, tile_offset, 0);
}
/// Stores a fragment from memory with logical offset in units of whole tiles.
CUTLASS_DEVICE
void store(
/// fragment to store to the tensor
Fragment const &frag,
/// stores a tile with a logical offset in units of whole tiles
TensorCoord const &tile_offset,
/// stores a tile with a logical offset AND a pointer offset
Index pointer_offset) const {
store_with_pointer_offset(frag, ref_.offset(tile_offset) + pointer_offset);
}
};
////////////////////////////////////////////////////////////////////////////////
} // namespace warp
} // namespace gemm
} // namespace cutlass
////////////////////////////////////////////////////////////////////////////////
|
[
"hungryhe@tencent.com"
] |
hungryhe@tencent.com
|
ad862cfe25d168bf5d4962bdf6f2d638b1e14185
|
e0cc82d04bfc8d58ac5419456c8c04879bd1bc81
|
/deps/WFA/WFA/gap_affine/affine_wavefront_penalties.cpp
|
f9ed5bf048feec98eb3dfc545e67ea72a436daeb
|
[
"MIT"
] |
permissive
|
urbanslug/wflign
|
6500511a474c6b42607801c07c66ff677ac3c15c
|
4e2d5b607b762973f3d6efe8b547a56f041bc87a
|
refs/heads/main
| 2023-04-22T04:51:58.716692
| 2021-05-13T11:48:07
| 2021-05-13T11:48:07
| null | 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 5,239
|
cpp
|
/*
* The MIT License
*
* Wavefront Alignments Algorithms
* Copyright (c) 2017 by Santiago Marco-Sola <santiagomsola@gmail.com>
*
* This file is part of Wavefront Alignments Algorithms.
*
* 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.
*
* PROJECT: Wavefront Alignments Algorithms
* AUTHOR(S): Santiago Marco-Sola <santiagomsola@gmail.com>
* DESCRIPTION: WFA support functions for handling penalties scores
*/
#include "WFA/gap_affine/affine_wavefront_penalties.hpp"
namespace wfa {
/*
* Setup
*/
void affine_wavefronts_penalties_init(
affine_wavefronts_penalties_t* const wavefronts_penalties,
affine_penalties_t* const penalties,
const wavefronts_penalties_strategy penalties_strategy) {
wavefronts_penalties->base_penalties = *penalties;
wavefronts_penalties->penalties_strategy =
(penalties->match==0) ? wavefronts_penalties_match_zero : penalties_strategy;
switch (wavefronts_penalties->penalties_strategy) {
case wavefronts_penalties_match_zero:
case wavefronts_penalties_force_zero_match:
affine_penalties_mzero(penalties,&(wavefronts_penalties->wavefront_penalties));
break;
case wavefronts_penalties_shifted_penalties:
affine_penalties_shift(penalties,&(wavefronts_penalties->wavefront_penalties),false);
break;
case wavefronts_penalties_odd_pair_penalties:
affine_penalties_shift(penalties,&(wavefronts_penalties->wavefront_penalties),true);
break;
default:
break;
}
}
/*
* Score Adjustment
*/
void affine_penalties_mzero(
affine_penalties_t* const base_penalties,
affine_penalties_t* const shifted_penalties) {
// Check base penalties
if (base_penalties->match > 0) {
fprintf(stderr,"Match score must be negative or zero (M=%d)\n",base_penalties->match);
exit(1);
}
if (base_penalties->mismatch <= 0 ||
base_penalties->gap_opening <= 0 ||
base_penalties->gap_extension <= 0) {
fprintf(stderr,"Mismatch/Gap scores must be strictly positive (X=%d,O=%d,E=%d)\n",
base_penalties->mismatch,base_penalties->gap_opening,base_penalties->gap_extension);
exit(1);
}
// Copy base penalties
*shifted_penalties = *base_penalties;
// Zero match score
shifted_penalties->match = 0;
}
void affine_penalties_shift(
affine_penalties_t* const base_penalties,
affine_penalties_t* const shifted_penalties,
const bool pair_odd_heuristic) {
// Check base penalties
if (base_penalties->match > 0) {
fprintf(stderr,"Match score must be negative (M=%d)\n",base_penalties->match);
exit(1);
}
if (base_penalties->mismatch <= 0 ||
base_penalties->gap_opening <= 0 ||
base_penalties->gap_extension <= 0) {
fprintf(stderr,"Mismatch/Gap scores must be strictly positive (X=%d,O=%d,E=%d)\n",
base_penalties->mismatch,base_penalties->gap_opening,base_penalties->gap_extension);
exit(1);
}
// Copy base penalties
*shifted_penalties = *base_penalties;
// Shift to zero match score
shifted_penalties->match = 0;
shifted_penalties->mismatch -= base_penalties->match;
shifted_penalties->gap_opening -= base_penalties->match;
shifted_penalties->gap_extension -= base_penalties->match;
// Odd/Pair shift heuristic
if (pair_odd_heuristic) {
const bool is_mismatch_pair = ((shifted_penalties->mismatch%2)==0);
const bool is_gap_opening_pair = ((shifted_penalties->gap_opening%2)==0);
const bool is_gap_extension_pair = ((shifted_penalties->gap_extension%2)==0);
const int total_odd = !is_mismatch_pair + !is_gap_opening_pair + !is_gap_extension_pair;
const int total_pair = is_mismatch_pair + is_gap_opening_pair + is_gap_extension_pair;
if (total_odd > total_pair) {
// Shift all to odd
if (is_mismatch_pair) ++(shifted_penalties->mismatch);
if (is_gap_opening_pair) ++(shifted_penalties->gap_opening);
if (is_gap_extension_pair) ++(shifted_penalties->gap_extension);
} else {
// Shift all to pair
if (!is_mismatch_pair) ++(shifted_penalties->mismatch);
if (!is_gap_opening_pair) ++(shifted_penalties->gap_opening);
if (!is_gap_extension_pair) ++(shifted_penalties->gap_extension);
}
}
}
}
|
[
"erik.garrison@gmail.com"
] |
erik.garrison@gmail.com
|
252b67c4a8e5b39e679b5c700de05da8d1e60538
|
413152f28183be8116b665e58b048495e2cbb564
|
/Programs/C++/CodeChef/COG1801.cpp
|
0d3d76257a08885bd7174c1694c96f2aec5e819d
|
[] |
no_license
|
avii-ahuja/Competitive-Programmming
|
a5340a7e3b0f46e6643b7251208557ed6453d80f
|
e2b9b1efa1ee60bf5375e84c5778af81e05daf28
|
refs/heads/master
| 2021-10-22T13:41:56.933137
| 2018-12-09T17:29:33
| 2018-12-09T17:29:33
| 162,143,800
| 1
| 0
| null | 2018-12-17T14:35:45
| 2018-12-17T14:35:44
| null |
UTF-8
|
C++
| false
| false
| 455
|
cpp
|
#include<bits/stdc++.h>
using namespace std;
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t;
cin >> t;
while(t--)
{
int n,p,k;
cin >> n >> p >> k;
int arr[n];
for(int i = 0; i<n; i++)
{
cin >> arr[i];
}
sort(arr, arr+n);
int ans = 0;
for(int i = 0; i<n-k; i++)
{
for(int j = i+k-1; j<n; j++)
{
if(arr[j] > arr[i]*p)
{
ans+= j-(i+k);
}
}
}
cout << ans << "\n";
}
}
|
[
"salilgokhale03@gmail.com"
] |
salilgokhale03@gmail.com
|
699ac4a6c787baadd097598408626a4a1fa0275b
|
11e97f87deb25babb4a32c80941e7ff4e476c92a
|
/TRS/HRI_530v/Motion/Sort.~h
|
0b56d548c5403c037c304f3c6e0d65d0ac4aa7e1
|
[] |
no_license
|
xhyangxianjun/Builder6-program
|
b9d03d98658db5a5a8cf1586210a373bc391dc48
|
a12d811d7a5fa3dba6d3e8c05989a41cb89783de
|
refs/heads/master
| 2022-04-03T00:25:47.274355
| 2019-09-19T08:26:56
| 2019-09-19T08:26:56
| null | 0
| 0
| null | null | null | null |
UHC
|
C++
| false
| false
| 8,916
|
//---------------------------------------------------------------------------
#ifndef SortH
#define SortH
//---------------------------------------------------------------------------
#include "PartInterface.h"
#include "Timer.h"
#include "DataMan.h"
enum EN_VAC_ERR_STAT { //현재 랏 런 하고 있는 상태.
vsNomal = 0 , //에러났던 곳을 다시 픽하고 안찝히면 다시 에러.
vsErrSkipPick = 1 , //픽했던데 다시 픽하고 없으면 그냥 다음 픽으로 넘어감 -> vsNomal.
vsErrSkipRow = 2 , //픽했던데 다시 픽하고 해당 에러열에서는 에러 스킵 -> vsNomal.
vsErrSkipTray = 3 , //픽했던데 다시 픽하고 해당 트레이에서는 에러 스킵 -> vsNomal.
vsErrSkipRowOut = 4 , //픽했던열 스킵으로 확인 하고 트레이 아웃.
vsErrSkipRowOutLE = 5 , //픽했던열 스킵으로 확인하고 트레이 아웃후 랏엔드요청.
//이것은 클릭시에 바로 처리 되서 필요 없다. vsTrayOut = 6 , //현재 트레이 모두 Empty 시키기.
//이것은 클릭시에 바로 처리 되서 필요 없다. vsTrayOutLE = 7 , //트레이 아웃 시키고 랏앤드 요청.
};
//---------------------------------------------------------------------------
class CSort : public CPartInterface
{
public: //초기화 등등.
//Constructor
CSort ();
~CSort ();
void Init();
void Close();
public:
//Vars.
struct SStat {
bool bWorkEnd ;
bool bReqStop ;
}; //sun Clear When LOT Open. and every 30Sec in autorun()
enum EN_SEQ_CYCLE {
scIdle = 0 ,
scPickSTG = 1 ,
scPlceRJT = 2 ,
scPlceULD = 3 ,
scPickZIG = 4 ,
scPlceSTG = 5 ,
scPickLDR = 6 ,
scPlceZIG = 7 ,
MAX_SEQ_CYCLE
};
AnsiString m_sCycleName[MAX_SEQ_CYCLE] ;
int m_iCycleTime[MAX_SEQ_CYCLE] ; //마지막 사이클 시간. ms
void InitCycleName(){
m_sCycleName[scIdle ]="Idle ";
m_sCycleName[scPickSTG]="PickSTG";
m_sCycleName[scPlceRJT]="PlceRJT";
m_sCycleName[scPlceULD]="PlceULD";
m_sCycleName[scPickZIG]="PickZIG";
m_sCycleName[scPlceSTG]="PlceSTG";
m_sCycleName[scPickLDR]="PickLDR";
m_sCycleName[scPlceZIG]="PlceZIG";
}
void InitCycleTime(){
memset(&m_iCycleTime , 0 , sizeof(int )*MAX_SEQ_CYCLE);
}
struct SStep {
int iHome ;
int iToStart ;
EN_SEQ_CYCLE iSeq ;
int iCycle ;
int iToStop ;
};
protected:
AnsiString m_sPartName ;
//Timer.
CDelayTimer m_tmMain ;
CDelayTimer m_tmCycle ;
CDelayTimer m_tmHome ;
CDelayTimer m_tmToStop ;
CDelayTimer m_tmToStart ;
CDelayTimer m_tmDelay ;
SStat Stat ;
SStep Step , PreStep ;
SStat GetStat(){return Stat;}
void ResetTimer();
bool FindChip (EN_ARAY_ID _iArray , EN_CHIP_STAT _iStat , int &r , int &c );
double GetMotrPos (EN_MOTR_ID _iMotr , EN_PSTN_ID _iPstnId );
public: //인터페이스 상속.==================================================
void Reset (); //리셑 버튼 눌렀을때 타는 함수.
//Running Functions.
bool ToStopCon (); //스탑을 하기 위한 조건을 보는 함수.
bool ToStartCon(); //스타트를 하기 위한 조건을 보는 함수.
bool ToStart (); //스타트를 하기 위한 함수.
bool ToStop (); //스탑을 하기 위한 함수.
int GetHomeStep (){return Step.iHome ;} int GetPreHomeStep (){return PreStep.iHome ;}void InitHomeStep (){ Step.iHome = 10 ; PreStep.iHome = 0 ;}
int GetToStartStep (){return Step.iToStart ;} int GetPreToStartStep(){return PreStep.iToStart ;}
int GetSeqStep (){return (int)Step.iSeq;} int GetPreSeqStep (){return (int)PreStep.iSeq;}
int GetCycleStep (){return Step.iCycle ;} int GetPreCycleStep (){return PreStep.iCycle ;}void InitCycleStep(){ Step.iCycle = 10 ; PreStep.iCycle = 0 ;}
int GetToStopStep (){return Step.iToStop ;} int GetPreToStopStep (){return PreStep.iToStop ;}
AnsiString GetCycleName (int _iSeq){return m_sCycleName[_iSeq];}
int GetCycleTime (int _iSeq){return m_iCycleTime[_iSeq];}
AnsiString GetPartName (){return m_sPartName ;}
int GetCycleMaxCnt (){return MAX_SEQ_CYCLE ;}
bool Autorun (); //오토런닝시에 계속 타는 함수.
//======================================================================
public:
//HomeCycle
bool CycleHome(); //파트 홈을 잡을때 쓰는 함수.
//One Cycle.
bool CyclePickSTG();
bool CyclePlceRJT();
bool CyclePlceULD();
bool CyclePickZIG();
bool CyclePlceSTG();
bool CyclePickLDR();
bool CyclePlceZIG();
bool CheckSafe (EN_MOTR_ID _iMotr , EN_PSTN_ID _iPstnId );
bool CheckSafe (EN_ACTR_ID _iActr , bool _bFwd );
bool GetWorkEnd (){return Stat.bWorkEnd ;}
bool GetReqStop (){return Stat.bReqStop ;}
void SetStat(SStat _sStat) { Stat = _sStat ; }
//Motor.
bool MoveMotr (EN_MOTR_ID _iMotr , EN_PSTN_ID _iPstnId); // 모터를 움직일때 쓰는 함수.
void MoveIncMotr (EN_MOTR_ID _iMotr , double _iPstn); // 모터를 움직일때 쓰는 함수.
//Actuator.
bool MoveActr (EN_ACTR_ID _iActr , bool _bFwd); //실린더를 움직일때 쓰는 함수.
//For Start Stop Checking.
void SetLastCmd (); //장비 정지시에 마지막 커맨드를 기억 하고 있다가.
bool CheckMoved (); //이 함수를 이용해 움직였는지 확인 하고 장비 스타트 시에 그냥 작업 할 껀지 아니면 ToStart를 하고 할 건지 결정.
bool CheckStop (); //장비 정지시에 모든 모터 와 실린더 가 정지 되었는지 확인 하는 함수.
//Loading Para.
void Load(bool _bLoad);
//소팅 인포=============================================================
struct TSortInfo{
bool bFindOk ; //작업가능여부.
bool isPick ; //픽용인지 플레이스 용인지.
int iCol ; //iARAY의 작업할 영역의 왼쪽
int iRow ; //iARAY의 작업할 영역의 제일위쪽.
EN_CHIP_STAT iTargetStat ; //목적 칩 상태.
EN_ARAY_ID iAray ; //작업할 어레이
EN_ARAY_ID iTool ; //피커툴 어레이.
int iToolShft ; //툴의 첫번째 컬럼 부터 작업이 안될경우 쉬프트 된다.
int iDnCnt ; //찝거나 내려놓는 칩 갯수.
bool bDn[MAX_TOOL_SOCK_COL] ;
};
TSortInfo SortInfo ;
//트레이에서 찝거나 트레이에 놓을때 사용 하는 함수.
bool GetTraySortInfo (bool _bPick , EN_ARAY_ID _iTool , EN_ARAY_ID _iAray , TSortInfo & _tInfo);
bool ShiftTraySortInfo(TSortInfo & _tInfo , bool _bVacErr1 = false , bool _bVacErr2 = false ,bool _bVacErr3 = false ,bool _bVacErr4 = false );
//지그나 소켓에서 찝거나 놓을때 사용 하는 함수.
bool GetSockSortInfo (bool _bPick , EN_ARAY_ID _iTool , EN_ARAY_ID _iAray , TSortInfo & _tInfo);
bool ShiftSockSortInfo(TSortInfo & _tInfo , bool _bVacErr1 = false , bool _bVacErr2 = false ,bool _bVacErr3 = false ,bool _bVacErr4 = false );
//========================================================================
//베큠에러
EN_VAC_ERR_STAT m_iVacErrStat ;
bool m_bVacErr[MAX_TOOL_SOCK_COL] ;
bool CheckRetryStgPick();
bool CheckRetryZigPick();
bool m_bRetryZigPick ; //픽 미스 에러 났을때 리트라이 선택시..
bool m_bRetryStgPick ;
bool m_bLdrPickErrDisp ; //로더에서 픽 미스 났을때 선택창 디스플레이
bool m_bZigPickErrDisp ; //지그에서 픽 미스 났을때 선택창 디스플레이
bool m_bStgPickErrDisp ; //스테이지에서 픽 미스 났을때 선택창 디스플레이
double m_dTickTime;
};
//---------------------------------------------------------------------------
extern CSort SRT;
//---------------------------------------------------------------------------
#endif
|
[
"sheepdw@gmail.com"
] |
sheepdw@gmail.com
|
|
620bc3c5e9b62a813cab8e15994e01d0d6303ad8
|
ec0b9f8281874dcfd725193388ab4a36a410a92a
|
/PA-1/PA-1.1/Stress_ball_test.cpp
|
8e788db3a8fe27eb96a1b6d8aecead5c5e0498ba
|
[] |
no_license
|
coraenglish/CSCE-221
|
c3bcf25b8f9a1166d0a769afe358c2c71784842a
|
b4cdcef2e7b214a7123b2b6714d6fcfad78de7bc
|
refs/heads/master
| 2022-11-28T08:56:43.258690
| 2020-08-05T00:00:34
| 2020-08-05T00:00:34
| 285,126,749
| 1
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 930
|
cpp
|
#include <iostream>
#include <cstdlib>
#include "Stress_ball.h"
using namespace std;
int main(){
srand(time(NULL));
cout << "Default constructor test:\n";
Stress_ball arr_test[15];
for(int i = 0; i < 15; i++){
arr_test[i] = Stress_ball();
cout << i << ": " << arr_test[i] << endl;
}
cout << "\nTwo arg constructor test:\n";
Stress_ball test2(Stress_ball_colors::red, Stress_ball_sizes::small);
cout << test2 << endl;
Stress_ball test3(Stress_ball_colors::green, Stress_ball_sizes::large);
cout << test3 << endl;
cout << "\nCompare stress balls:\n";
for (int i = 0; i < 5; i++) {
if (arr_test[i] == test2) {
cout << "arr_test[" << i << "] equal test2\n";
} else if (arr_test[i] == test3) {
cout << "arr_test[" << i << "] equal test3\n";
} else {
cout << "arr_test[" << i << "] not equal test2 nor test3\n";
}
}
}
|
[
"noreply@github.com"
] |
coraenglish.noreply@github.com
|
30955d8b5929aa611245dc1a374c8361bf3e8eb7
|
f12e53b806ba418a58f814ebc87c4446a422b2f5
|
/solutions/uri/1097/1097.cpp
|
7c6a3a45e582521d62052f1a775a29aa58fa537b
|
[
"MIT"
] |
permissive
|
biadelmont/playground
|
f775cd86109e30ed464d4d6eff13f9ded40627cb
|
93c6248ec6cd25d75f0efbda1d50e0705bbd1e5a
|
refs/heads/master
| 2021-05-06T15:49:43.253788
| 2017-11-07T13:00:31
| 2017-11-07T13:00:31
| null | 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 249
|
cpp
|
#include <cstdio>
int main() {
int i = 1, j = 7;
while (i <= 9) {
printf("I=%d J=%d\n", i, j--);
printf("I=%d J=%d\n", i, j--);
printf("I=%d J=%d\n", i, j--);
i += 2;
j += 5;
}
return 0;
}
|
[
"deniscostadsc@gmail.com"
] |
deniscostadsc@gmail.com
|
efe56b4329c6230391ddf66bc861eeb8b332fc4f
|
56825fcc0d7c55dbffcb325b254996340863b894
|
/generic/uva11547.cpp
|
7247cd0c029761cca326dbee12f0ebe947c1a5c1
|
[] |
no_license
|
matheusrotta7/uva_onlinejudge_files
|
49589a356062d493ee2c8b71c268d0ad39072931
|
69ef715daf08b6145111621c5e544127cabb1a9b
|
refs/heads/master
| 2020-05-27T13:22:40.327968
| 2019-05-26T04:00:53
| 2019-05-26T04:00:53
| 188,637,773
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 296
|
cpp
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
for (int i = 0; i < t; i++) {
int n;
cin >> n;
n = (n*63 + 7492)*5 - 498;
n = abs(n);
n = n/10;
n = n%10;
cout << n << '\n';
}
return 0;
}
|
[
"matheusrotta7@gmail.com"
] |
matheusrotta7@gmail.com
|
75c4901a417198cb1ee9d990896c7b4fe464bed4
|
cee83e8f6585c20d4444ddc12492e42a6b3412d5
|
/dep/gme/src/Ym2413_Emu.cpp
|
14d2d6ffdcd120a785d1de553e9a24c991bca23e
|
[] |
no_license
|
fgenesis/tyrsound
|
95b93afb71fa80a6d95b8c6771f29aea6333afd2
|
a032eaf8a3a8212a764bf6c801325e67ab02473e
|
refs/heads/master
| 2021-01-22T10:08:35.576908
| 2014-08-31T01:54:17
| 2014-08-31T01:54:17
| 10,146,874
| 4
| 0
| null | 2014-02-02T02:42:25
| 2013-05-18T20:40:23
|
C
|
UTF-8
|
C++
| false
| false
| 1,229
|
cpp
|
// Game_Music_Emu 0.5.5. http://www.slack.net/~ant/
#include "Ym2413_Emu.h"
#include "ym2413.h"
Ym2413_Emu::Ym2413_Emu() { opll = 0; }
Ym2413_Emu::~Ym2413_Emu()
{
if ( opll ) ym2413_shutdown( opll );
}
int Ym2413_Emu::set_rate( double sample_rate, double clock_rate )
{
if ( opll )
{
ym2413_shutdown( opll );
opll = 0;
}
opll = ym2413_init( clock_rate, sample_rate, 0 );
if ( !opll )
return 1;
reset();
return 0;
}
void Ym2413_Emu::reset()
{
ym2413_reset_chip( opll );
ym2413_set_mask( opll, 0 );
}
void Ym2413_Emu::write( int addr, int data )
{
ym2413_write( opll, 0, addr );
ym2413_write( opll, 1, data );
}
void Ym2413_Emu::mute_voices( int mask )
{
ym2413_set_mask( opll, mask );
}
void Ym2413_Emu::run( int pair_count, sample_t* out )
{
SAMP bufMO[ 1024 ];
SAMP bufRO[ 1024 ];
SAMP * buffers[2] = { bufMO, bufRO };
while (pair_count > 0)
{
int todo = pair_count;
if (todo > 1024) todo = 1024;
ym2413_update_one( opll, buffers, todo );
for (int i = 0; i < todo; i++)
{
int output = bufMO [i];
output += bufRO [i];
if ( (short)output != output ) output = 0x7FFF ^ ( output >> 31 );
out [0] = output;
out [1] = output;
out += 2;
}
pair_count -= todo;
}
}
|
[
"false.genesis@googlemail.com"
] |
false.genesis@googlemail.com
|
5958763f1f4baab3ae8cf4eec0698e3020346736
|
a07e8ce8748e1c11dcb2fb4f1d8438759a791c0d
|
/year1/trashcollector/garbage_collector (copy)/main.cpp
|
305978a9da03356c6e05f9aefc5c46a842123598
|
[] |
no_license
|
celidos/programming-mipt-2015-2017
|
7aef789009cf63dfe415070e6907c634a0b89c7a
|
cd27a7798f2f50164228b3ab0b7c3015a9c7c049
|
refs/heads/master
| 2021-06-16T14:22:29.455077
| 2017-05-13T15:33:58
| 2017-05-13T15:33:58
| 91,165,940
| 1
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 192
|
cpp
|
#include <iostream>
#include <test.h>
int main()
{
//GarbageCollector::Instance();
//test1();
//test2();
test3();
//GarbageCollector::DeleteInstance();
}
|
[
"chloroformorganic@gmail.com"
] |
chloroformorganic@gmail.com
|
14159129a9eeb420c500b2ca235ad95489cfaa4d
|
6426fde30c1112041cad5e94af0418a51d87e267
|
/recursive_house_robber.cpp
|
9abaffcf0af67a674e75e34ea4199204a498324e
|
[] |
no_license
|
verycoolgirl/test
|
19ea73481fb323974a7649bbe10ba9f686101b1a
|
b337e9495cb36b32904e7842001cd1b8e7c11bd4
|
refs/heads/master
| 2021-01-10T02:00:17.169396
| 2015-10-18T22:05:58
| 2015-10-18T22:05:58
| 44,063,918
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 398
|
cpp
|
int rob(int* nums, int numsSize) {
int rob_first;
int not_rob_first;
if (numsSize <= 0) {
return 0;
}
if (numsSize == 1) {
return nums[0];
}
rob_first = nums[0] + rob(&nums[2], numsSize - 2);
not_rob_first = rob(&nums[1], numsSize - 1);
if (rob_first > not_rob_first) {
return rob_first;
} else {
return not_rob_first;
}
}
|
[
"chrisleann@gmail.com"
] |
chrisleann@gmail.com
|
799e568101fa7d6017ab9cbd238dc43dec67f30b
|
0e885d0f082f978a84f2efc47aba29e74e608b74
|
/world/game_debug.cpp
|
ce606d893a41de4a50bcb4a48c41c930e04d58f0
|
[] |
no_license
|
Jim-Holmstroem/Hax---The-Game
|
79200fb7c9cc28d8630313e72c4bd2d8080d9720
|
44ff59fe9ae597da19923e5661c21dfe5d997322
|
refs/heads/master
| 2016-09-06T06:50:58.948468
| 2012-11-16T19:30:37
| 2012-11-16T19:31:36
| 3,327,626
| 1
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 3,057
|
cpp
|
#include "game_debug.h"
#include "level.h"
#include "../area/indoor.h"
#include "../area/outdoor.h"
#include "../ch/human.h"
#include "../ch/undead.h"
#include "../obj/container.h"
#include "../obj/obstacle.h"
#include "../area/road.h"
int main(int argc, const char* argv[]){
srand(time(NULL)); //initialize random seed to a value based on the time the program is executed
std::ofstream dbg;
dbg.open("parse_debug.dat", std::ios::out | std::ios::trunc); //if file existed before it will be overwritten
dbg << "**New game**\n";
dbg.close();
hax::Level* test = hax::initNewGame();
std::cout << "Type help for a list of available commands." << std::endl;
std::cout << "Pay attention to case sensitivity!" << std::endl;
std::string input = "";
while(input != "quit"){
getline(std::cin, input);
if(input != ""){
test->parse( hax::split(input,' ') );
std::ofstream dbg;
dbg.open("parse_debug.dat", std::ios::out | std::ios::app); //append to EOF
dbg << input << "\n"; //write to parse_debug.dat
dbg.close();
}
}
delete test;
return 0;
};
//http://stackoverflow.com/questions/236129/how-to-split-a-string-in-c
std::vector<std::string>& hax::split(const std::string& s, char delim, std::vector<std::string>& elems){
std::stringstream ss(s);
std::string item;
while(std::getline(ss, item, delim)){
elems.push_back(item);
}
return elems;
};
std::vector<std::string> hax::split(const std::string s, char delim){
std::vector<std::string> elems;
return split(s, delim, elems);
};
hax::Level* hax::initNewGame(){
//create objects
Level* test = new Level();
Area* borg = new Castle("Hogwarts");
Area* kth = new School("KTH");
Area* skog = new Forest("FoReSt Of DoOm");
Area* tysk = new Shop("IKEA");
Character* albus = new Wizard("Albus");
Character* voldy = new Wizard("Voldy");
Character* conan = new Barbarian("Conan");
Character* snape = new Wizard("Snape");
Character* necro = new Necromancer("Sauron");
Key* nyckel = new Key();
Container* sack = new Backpack();
//build level
test->add(borg);
test->add(kth);
test->add(skog);
test->add(tysk);
test->add(albus);
test->add(voldy);
test->add(conan);
test->add(necro);
borg->addRoute(new Road("north", borg, kth));
borg->addRoute(new Road("west", borg, skog));
kth->addRoute(new Road("south", kth, borg));
kth->addRoute(new Door("southwest", kth, skog, nyckel));
kth->addRoute(new Door("in", kth, tysk));
skog->addRoute(new Road("east", skog, borg, new Tree()));
skog->addRoute(new Road("northeast", skog, kth, snape));
tysk->addRoute(new Door("out", tysk, kth));
//add Character to Area
borg->enter(albus);
borg->enter(necro);
kth->enter(conan);
kth->enter(voldy);
//add Object to Area
kth->pick_up(nyckel);
borg->pick_up(sack);
//add Object to Character
return test;
};
|
[
"jim.holmstroem@gmail.com"
] |
jim.holmstroem@gmail.com
|
22e1a32bb131cc31127e3018bc36f6f141f5aa41
|
154dfd2a2130a3a7731a9a9b431e8295fbf82cd2
|
/TIOJ/TIOJ1210.cpp
|
37bd78fed45f37dba002474541e87d81a2396f0c
|
[] |
no_license
|
ltf0501/Competitive-Programming
|
1f898318eaecae14b6e040ffc7e36a9497ee288c
|
9660b28d979721f2befcb590182975f10c9b6ac8
|
refs/heads/master
| 2022-11-20T21:08:45.651706
| 2020-07-23T11:55:05
| 2020-07-23T11:55:05
| 245,600,907
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 604
|
cpp
|
//Haval
#include<cstdio>
#include<iostream>
#include<algorithm>
#include<cstring>
using namespace std;
#define maxn 10000+5
int n;
int a[maxn];
bool solve()
{
for(int i=0;i<n;i++)
{
sort(a+i,a+n,greater<int>());
for(int j=i+1;j<n && a[i]>0;j++)
{
a[i]--;a[j]--;
if(a[j]<0)return 0;
}
if(a[i]>0)return 0;
}
return 1;
}
main()
{
while(~scanf("%d",&n) && n)
{
for(int i=0;i<n;i++)scanf("%d",&a[i]);
if(solve())puts("Yes");
else puts("No");
}
return 0;
}
|
[
"0110420@stu.nknush.kh.edu.tw"
] |
0110420@stu.nknush.kh.edu.tw
|
1fc6a33b828bc8a026820add1b00af24e739e716
|
6dcc896b27c8e425f30ebaf891fdd5270647cb14
|
/src/vsg/vk/Image.cpp
|
8a8f1c13c6ca9586b881580ba57dde5841e370f8
|
[
"MIT"
] |
permissive
|
kallr/VulkanSceneGraph
|
60f8f3e3b734f019e2449d7434eb44cabf0139a7
|
1f64f315f4148210604a4282e643a260bb4127c9
|
refs/heads/master
| 2022-06-17T21:55:16.569172
| 2020-05-07T13:53:01
| 2020-05-07T13:53:01
| 262,469,895
| 1
| 0
| null | 2020-05-09T02:15:04
| 2020-05-09T02:15:04
| null |
UTF-8
|
C++
| false
| false
| 2,131
|
cpp
|
/* <editor-fold desc="MIT License">
Copyright(c) 2018 Robert Osfield
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.
</editor-fold> */
#include <vsg/core/Exception.h>
#include <vsg/vk/Image.h>
using namespace vsg;
Image::Image(VkImage image, Device* device, AllocationCallbacks* allocator) :
_image(image),
_device(device),
_allocator(allocator)
{
}
Image::Image(Device* device, const VkImageCreateInfo& createImageInfo, AllocationCallbacks* allocator) :
_device(device),
_allocator(allocator)
{
if (VkResult result = vkCreateImage(*device, &createImageInfo, allocator, &_image); result != VK_SUCCESS)
{
throw Exception{"Error: Failed to create vkImage.", result};
}
}
Image::~Image()
{
if (_deviceMemory)
{
_deviceMemory->release(_memoryOffset, 0); // TODO, we don't locally have a size allocated
}
if (_image)
{
vkDestroyImage(*_device, _image, _allocator);
}
}
VkMemoryRequirements Image::getMemoryRequirements() const
{
VkMemoryRequirements memRequirements;
vkGetImageMemoryRequirements(*_device, _image, &memRequirements);
return memRequirements;
}
|
[
"robert@openscenegraph.com"
] |
robert@openscenegraph.com
|
99ebfb64b7f23cdb66d53ea9c4ca4d34d5150af7
|
8aab36ad37ee4b62be4027595c254d2b39956220
|
/third_parties/soci-3.2.2/core/connection-pool.h
|
a97dabbd5dbcffddd3603dac3837b9fb97a65378
|
[] |
no_license
|
vladimir-rangelov/ubreader-ios
|
20698665f57123d6fb86341df211002759c72a4d
|
c2aadc6ae2cbaac3630427ce263095dfa9ef820d
|
refs/heads/master
| 2022-05-27T20:42:41.530431
| 2022-05-20T10:29:59
| 2022-05-20T10:29:59
| 36,655,378
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 833
|
h
|
//
// Copyright (C) 2008 Maciej Sobczak
// 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_CONNECTION_POOL_H_INCLUDED
#define SOCI_CONNECTION_POOL_H_INCLUDED
#include "soci-config.h"
// std
#include <cstddef>
namespace soci
{
class session;
class SOCI_DECL connection_pool
{
public:
explicit connection_pool(std::size_t size);
~connection_pool();
session & at(std::size_t pos);
std::size_t lease(const bool exclusive_for_writing = false);
bool try_lease(std::size_t & pos, int timeout, const bool exclusive_for_writing);
void give_back(std::size_t pos);
private:
struct connection_pool_impl;
connection_pool_impl * pimpl_;
};
}
#endif // SOCI_CONNECTION_POOL_H_INCLUDED
|
[
"vladorangelov@vladimir-rangelov.local"
] |
vladorangelov@vladimir-rangelov.local
|
96c7d4c85b30b9d00f14ea0a738dce554c549e16
|
b961139f628cbda2221df78599f919847e9962b6
|
/[2020][modulo][Processamento_Linguagem_Natural]/codigos/venv/lib/python3.7/site-packages/spacy/syntax/arc_eager.cpp
|
f583620482007c003aec3ef91f2058468e144ad8
|
[] |
no_license
|
rafaelstojoao/pos-unip
|
167fe60e752b1660172c71cd5a3607101b8b3d49
|
50d9711e313fdcac59fa89498b0a3ea5d004ac49
|
refs/heads/master
| 2022-12-21T14:20:36.790476
| 2020-10-25T11:52:41
| 2020-10-25T11:52:41
| 246,832,526
| 4
| 1
| null | 2022-12-19T10:12:14
| 2020-03-12T12:47:17
|
Python
|
UTF-8
|
C++
| false
| true
| 1,907,843
|
cpp
|
/* Generated by Cython 0.29.21 */
#define PY_SSIZE_T_CLEAN
#include "Python.h"
#ifndef Py_PYTHON_H
#error Python headers needed to compile C extensions, please install development version of Python.
#elif PY_VERSION_HEX < 0x02060000 || (0x03000000 <= PY_VERSION_HEX && PY_VERSION_HEX < 0x03030000)
#error Cython requires Python 2.6+ or Python 3.3+.
#else
#define CYTHON_ABI "0_29_21"
#define CYTHON_HEX_VERSION 0x001D15F0
#define CYTHON_FUTURE_DIVISION 0
#include <stddef.h>
#ifndef offsetof
#define offsetof(type, member) ( (size_t) & ((type*)0) -> member )
#endif
#if !defined(WIN32) && !defined(MS_WINDOWS)
#ifndef __stdcall
#define __stdcall
#endif
#ifndef __cdecl
#define __cdecl
#endif
#ifndef __fastcall
#define __fastcall
#endif
#endif
#ifndef DL_IMPORT
#define DL_IMPORT(t) t
#endif
#ifndef DL_EXPORT
#define DL_EXPORT(t) t
#endif
#define __PYX_COMMA ,
#ifndef HAVE_LONG_LONG
#if PY_VERSION_HEX >= 0x02070000
#define HAVE_LONG_LONG
#endif
#endif
#ifndef PY_LONG_LONG
#define PY_LONG_LONG LONG_LONG
#endif
#ifndef Py_HUGE_VAL
#define Py_HUGE_VAL HUGE_VAL
#endif
#ifdef PYPY_VERSION
#define CYTHON_COMPILING_IN_PYPY 1
#define CYTHON_COMPILING_IN_PYSTON 0
#define CYTHON_COMPILING_IN_CPYTHON 0
#undef CYTHON_USE_TYPE_SLOTS
#define CYTHON_USE_TYPE_SLOTS 0
#undef CYTHON_USE_PYTYPE_LOOKUP
#define CYTHON_USE_PYTYPE_LOOKUP 0
#if PY_VERSION_HEX < 0x03050000
#undef CYTHON_USE_ASYNC_SLOTS
#define CYTHON_USE_ASYNC_SLOTS 0
#elif !defined(CYTHON_USE_ASYNC_SLOTS)
#define CYTHON_USE_ASYNC_SLOTS 1
#endif
#undef CYTHON_USE_PYLIST_INTERNALS
#define CYTHON_USE_PYLIST_INTERNALS 0
#undef CYTHON_USE_UNICODE_INTERNALS
#define CYTHON_USE_UNICODE_INTERNALS 0
#undef CYTHON_USE_UNICODE_WRITER
#define CYTHON_USE_UNICODE_WRITER 0
#undef CYTHON_USE_PYLONG_INTERNALS
#define CYTHON_USE_PYLONG_INTERNALS 0
#undef CYTHON_AVOID_BORROWED_REFS
#define CYTHON_AVOID_BORROWED_REFS 1
#undef CYTHON_ASSUME_SAFE_MACROS
#define CYTHON_ASSUME_SAFE_MACROS 0
#undef CYTHON_UNPACK_METHODS
#define CYTHON_UNPACK_METHODS 0
#undef CYTHON_FAST_THREAD_STATE
#define CYTHON_FAST_THREAD_STATE 0
#undef CYTHON_FAST_PYCALL
#define CYTHON_FAST_PYCALL 0
#undef CYTHON_PEP489_MULTI_PHASE_INIT
#define CYTHON_PEP489_MULTI_PHASE_INIT 0
#undef CYTHON_USE_TP_FINALIZE
#define CYTHON_USE_TP_FINALIZE 0
#undef CYTHON_USE_DICT_VERSIONS
#define CYTHON_USE_DICT_VERSIONS 0
#undef CYTHON_USE_EXC_INFO_STACK
#define CYTHON_USE_EXC_INFO_STACK 0
#elif defined(PYSTON_VERSION)
#define CYTHON_COMPILING_IN_PYPY 0
#define CYTHON_COMPILING_IN_PYSTON 1
#define CYTHON_COMPILING_IN_CPYTHON 0
#ifndef CYTHON_USE_TYPE_SLOTS
#define CYTHON_USE_TYPE_SLOTS 1
#endif
#undef CYTHON_USE_PYTYPE_LOOKUP
#define CYTHON_USE_PYTYPE_LOOKUP 0
#undef CYTHON_USE_ASYNC_SLOTS
#define CYTHON_USE_ASYNC_SLOTS 0
#undef CYTHON_USE_PYLIST_INTERNALS
#define CYTHON_USE_PYLIST_INTERNALS 0
#ifndef CYTHON_USE_UNICODE_INTERNALS
#define CYTHON_USE_UNICODE_INTERNALS 1
#endif
#undef CYTHON_USE_UNICODE_WRITER
#define CYTHON_USE_UNICODE_WRITER 0
#undef CYTHON_USE_PYLONG_INTERNALS
#define CYTHON_USE_PYLONG_INTERNALS 0
#ifndef CYTHON_AVOID_BORROWED_REFS
#define CYTHON_AVOID_BORROWED_REFS 0
#endif
#ifndef CYTHON_ASSUME_SAFE_MACROS
#define CYTHON_ASSUME_SAFE_MACROS 1
#endif
#ifndef CYTHON_UNPACK_METHODS
#define CYTHON_UNPACK_METHODS 1
#endif
#undef CYTHON_FAST_THREAD_STATE
#define CYTHON_FAST_THREAD_STATE 0
#undef CYTHON_FAST_PYCALL
#define CYTHON_FAST_PYCALL 0
#undef CYTHON_PEP489_MULTI_PHASE_INIT
#define CYTHON_PEP489_MULTI_PHASE_INIT 0
#undef CYTHON_USE_TP_FINALIZE
#define CYTHON_USE_TP_FINALIZE 0
#undef CYTHON_USE_DICT_VERSIONS
#define CYTHON_USE_DICT_VERSIONS 0
#undef CYTHON_USE_EXC_INFO_STACK
#define CYTHON_USE_EXC_INFO_STACK 0
#else
#define CYTHON_COMPILING_IN_PYPY 0
#define CYTHON_COMPILING_IN_PYSTON 0
#define CYTHON_COMPILING_IN_CPYTHON 1
#ifndef CYTHON_USE_TYPE_SLOTS
#define CYTHON_USE_TYPE_SLOTS 1
#endif
#if PY_VERSION_HEX < 0x02070000
#undef CYTHON_USE_PYTYPE_LOOKUP
#define CYTHON_USE_PYTYPE_LOOKUP 0
#elif !defined(CYTHON_USE_PYTYPE_LOOKUP)
#define CYTHON_USE_PYTYPE_LOOKUP 1
#endif
#if PY_MAJOR_VERSION < 3
#undef CYTHON_USE_ASYNC_SLOTS
#define CYTHON_USE_ASYNC_SLOTS 0
#elif !defined(CYTHON_USE_ASYNC_SLOTS)
#define CYTHON_USE_ASYNC_SLOTS 1
#endif
#if PY_VERSION_HEX < 0x02070000
#undef CYTHON_USE_PYLONG_INTERNALS
#define CYTHON_USE_PYLONG_INTERNALS 0
#elif !defined(CYTHON_USE_PYLONG_INTERNALS)
#define CYTHON_USE_PYLONG_INTERNALS 1
#endif
#ifndef CYTHON_USE_PYLIST_INTERNALS
#define CYTHON_USE_PYLIST_INTERNALS 1
#endif
#ifndef CYTHON_USE_UNICODE_INTERNALS
#define CYTHON_USE_UNICODE_INTERNALS 1
#endif
#if PY_VERSION_HEX < 0x030300F0
#undef CYTHON_USE_UNICODE_WRITER
#define CYTHON_USE_UNICODE_WRITER 0
#elif !defined(CYTHON_USE_UNICODE_WRITER)
#define CYTHON_USE_UNICODE_WRITER 1
#endif
#ifndef CYTHON_AVOID_BORROWED_REFS
#define CYTHON_AVOID_BORROWED_REFS 0
#endif
#ifndef CYTHON_ASSUME_SAFE_MACROS
#define CYTHON_ASSUME_SAFE_MACROS 1
#endif
#ifndef CYTHON_UNPACK_METHODS
#define CYTHON_UNPACK_METHODS 1
#endif
#ifndef CYTHON_FAST_THREAD_STATE
#define CYTHON_FAST_THREAD_STATE 1
#endif
#ifndef CYTHON_FAST_PYCALL
#define CYTHON_FAST_PYCALL 1
#endif
#ifndef CYTHON_PEP489_MULTI_PHASE_INIT
#define CYTHON_PEP489_MULTI_PHASE_INIT (PY_VERSION_HEX >= 0x03050000)
#endif
#ifndef CYTHON_USE_TP_FINALIZE
#define CYTHON_USE_TP_FINALIZE (PY_VERSION_HEX >= 0x030400a1)
#endif
#ifndef CYTHON_USE_DICT_VERSIONS
#define CYTHON_USE_DICT_VERSIONS (PY_VERSION_HEX >= 0x030600B1)
#endif
#ifndef CYTHON_USE_EXC_INFO_STACK
#define CYTHON_USE_EXC_INFO_STACK (PY_VERSION_HEX >= 0x030700A3)
#endif
#endif
#if !defined(CYTHON_FAST_PYCCALL)
#define CYTHON_FAST_PYCCALL (CYTHON_FAST_PYCALL && PY_VERSION_HEX >= 0x030600B1)
#endif
#if CYTHON_USE_PYLONG_INTERNALS
#include "longintrepr.h"
#undef SHIFT
#undef BASE
#undef MASK
#ifdef SIZEOF_VOID_P
enum { __pyx_check_sizeof_voidp = 1 / (int)(SIZEOF_VOID_P == sizeof(void*)) };
#endif
#endif
#ifndef __has_attribute
#define __has_attribute(x) 0
#endif
#ifndef __has_cpp_attribute
#define __has_cpp_attribute(x) 0
#endif
#ifndef CYTHON_RESTRICT
#if defined(__GNUC__)
#define CYTHON_RESTRICT __restrict__
#elif defined(_MSC_VER) && _MSC_VER >= 1400
#define CYTHON_RESTRICT __restrict
#elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
#define CYTHON_RESTRICT restrict
#else
#define CYTHON_RESTRICT
#endif
#endif
#ifndef CYTHON_UNUSED
# if defined(__GNUC__)
# if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
# define CYTHON_UNUSED __attribute__ ((__unused__))
# else
# define CYTHON_UNUSED
# endif
# elif defined(__ICC) || (defined(__INTEL_COMPILER) && !defined(_MSC_VER))
# define CYTHON_UNUSED __attribute__ ((__unused__))
# else
# define CYTHON_UNUSED
# endif
#endif
#ifndef CYTHON_MAYBE_UNUSED_VAR
# if defined(__cplusplus)
template<class T> void CYTHON_MAYBE_UNUSED_VAR( const T& ) { }
# else
# define CYTHON_MAYBE_UNUSED_VAR(x) (void)(x)
# endif
#endif
#ifndef CYTHON_NCP_UNUSED
# if CYTHON_COMPILING_IN_CPYTHON
# define CYTHON_NCP_UNUSED
# else
# define CYTHON_NCP_UNUSED CYTHON_UNUSED
# endif
#endif
#define __Pyx_void_to_None(void_result) ((void)(void_result), Py_INCREF(Py_None), Py_None)
#ifdef _MSC_VER
#ifndef _MSC_STDINT_H_
#if _MSC_VER < 1300
typedef unsigned char uint8_t;
typedef unsigned int uint32_t;
#else
typedef unsigned __int8 uint8_t;
typedef unsigned __int32 uint32_t;
#endif
#endif
#else
#include <stdint.h>
#endif
#ifndef CYTHON_FALLTHROUGH
#if defined(__cplusplus) && __cplusplus >= 201103L
#if __has_cpp_attribute(fallthrough)
#define CYTHON_FALLTHROUGH [[fallthrough]]
#elif __has_cpp_attribute(clang::fallthrough)
#define CYTHON_FALLTHROUGH [[clang::fallthrough]]
#elif __has_cpp_attribute(gnu::fallthrough)
#define CYTHON_FALLTHROUGH [[gnu::fallthrough]]
#endif
#endif
#ifndef CYTHON_FALLTHROUGH
#if __has_attribute(fallthrough)
#define CYTHON_FALLTHROUGH __attribute__((fallthrough))
#else
#define CYTHON_FALLTHROUGH
#endif
#endif
#if defined(__clang__ ) && defined(__apple_build_version__)
#if __apple_build_version__ < 7000000
#undef CYTHON_FALLTHROUGH
#define CYTHON_FALLTHROUGH
#endif
#endif
#endif
#ifndef __cplusplus
#error "Cython files generated with the C++ option must be compiled with a C++ compiler."
#endif
#ifndef CYTHON_INLINE
#if defined(__clang__)
#define CYTHON_INLINE __inline__ __attribute__ ((__unused__))
#else
#define CYTHON_INLINE inline
#endif
#endif
template<typename T>
void __Pyx_call_destructor(T& x) {
x.~T();
}
template<typename T>
class __Pyx_FakeReference {
public:
__Pyx_FakeReference() : ptr(NULL) { }
__Pyx_FakeReference(const T& ref) : ptr(const_cast<T*>(&ref)) { }
T *operator->() { return ptr; }
T *operator&() { return ptr; }
operator T&() { return *ptr; }
template<typename U> bool operator ==(U other) { return *ptr == other; }
template<typename U> bool operator !=(U other) { return *ptr != other; }
private:
T *ptr;
};
#if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX < 0x02070600 && !defined(Py_OptimizeFlag)
#define Py_OptimizeFlag 0
#endif
#define __PYX_BUILD_PY_SSIZE_T "n"
#define CYTHON_FORMAT_SSIZE_T "z"
#if PY_MAJOR_VERSION < 3
#define __Pyx_BUILTIN_MODULE_NAME "__builtin__"
#define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\
PyCode_New(a+k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)
#define __Pyx_DefaultClassType PyClass_Type
#else
#define __Pyx_BUILTIN_MODULE_NAME "builtins"
#if PY_VERSION_HEX >= 0x030800A4 && PY_VERSION_HEX < 0x030800B2
#define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\
PyCode_New(a, 0, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)
#else
#define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\
PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)
#endif
#define __Pyx_DefaultClassType PyType_Type
#endif
#ifndef Py_TPFLAGS_CHECKTYPES
#define Py_TPFLAGS_CHECKTYPES 0
#endif
#ifndef Py_TPFLAGS_HAVE_INDEX
#define Py_TPFLAGS_HAVE_INDEX 0
#endif
#ifndef Py_TPFLAGS_HAVE_NEWBUFFER
#define Py_TPFLAGS_HAVE_NEWBUFFER 0
#endif
#ifndef Py_TPFLAGS_HAVE_FINALIZE
#define Py_TPFLAGS_HAVE_FINALIZE 0
#endif
#ifndef METH_STACKLESS
#define METH_STACKLESS 0
#endif
#if PY_VERSION_HEX <= 0x030700A3 || !defined(METH_FASTCALL)
#ifndef METH_FASTCALL
#define METH_FASTCALL 0x80
#endif
typedef PyObject *(*__Pyx_PyCFunctionFast) (PyObject *self, PyObject *const *args, Py_ssize_t nargs);
typedef PyObject *(*__Pyx_PyCFunctionFastWithKeywords) (PyObject *self, PyObject *const *args,
Py_ssize_t nargs, PyObject *kwnames);
#else
#define __Pyx_PyCFunctionFast _PyCFunctionFast
#define __Pyx_PyCFunctionFastWithKeywords _PyCFunctionFastWithKeywords
#endif
#if CYTHON_FAST_PYCCALL
#define __Pyx_PyFastCFunction_Check(func)\
((PyCFunction_Check(func) && (METH_FASTCALL == (PyCFunction_GET_FLAGS(func) & ~(METH_CLASS | METH_STATIC | METH_COEXIST | METH_KEYWORDS | METH_STACKLESS)))))
#else
#define __Pyx_PyFastCFunction_Check(func) 0
#endif
#if CYTHON_COMPILING_IN_PYPY && !defined(PyObject_Malloc)
#define PyObject_Malloc(s) PyMem_Malloc(s)
#define PyObject_Free(p) PyMem_Free(p)
#define PyObject_Realloc(p) PyMem_Realloc(p)
#endif
#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030400A1
#define PyMem_RawMalloc(n) PyMem_Malloc(n)
#define PyMem_RawRealloc(p, n) PyMem_Realloc(p, n)
#define PyMem_RawFree(p) PyMem_Free(p)
#endif
#if CYTHON_COMPILING_IN_PYSTON
#define __Pyx_PyCode_HasFreeVars(co) PyCode_HasFreeVars(co)
#define __Pyx_PyFrame_SetLineNumber(frame, lineno) PyFrame_SetLineNumber(frame, lineno)
#else
#define __Pyx_PyCode_HasFreeVars(co) (PyCode_GetNumFree(co) > 0)
#define __Pyx_PyFrame_SetLineNumber(frame, lineno) (frame)->f_lineno = (lineno)
#endif
#if !CYTHON_FAST_THREAD_STATE || PY_VERSION_HEX < 0x02070000
#define __Pyx_PyThreadState_Current PyThreadState_GET()
#elif PY_VERSION_HEX >= 0x03060000
#define __Pyx_PyThreadState_Current _PyThreadState_UncheckedGet()
#elif PY_VERSION_HEX >= 0x03000000
#define __Pyx_PyThreadState_Current PyThreadState_GET()
#else
#define __Pyx_PyThreadState_Current _PyThreadState_Current
#endif
#if PY_VERSION_HEX < 0x030700A2 && !defined(PyThread_tss_create) && !defined(Py_tss_NEEDS_INIT)
#include "pythread.h"
#define Py_tss_NEEDS_INIT 0
typedef int Py_tss_t;
static CYTHON_INLINE int PyThread_tss_create(Py_tss_t *key) {
*key = PyThread_create_key();
return 0;
}
static CYTHON_INLINE Py_tss_t * PyThread_tss_alloc(void) {
Py_tss_t *key = (Py_tss_t *)PyObject_Malloc(sizeof(Py_tss_t));
*key = Py_tss_NEEDS_INIT;
return key;
}
static CYTHON_INLINE void PyThread_tss_free(Py_tss_t *key) {
PyObject_Free(key);
}
static CYTHON_INLINE int PyThread_tss_is_created(Py_tss_t *key) {
return *key != Py_tss_NEEDS_INIT;
}
static CYTHON_INLINE void PyThread_tss_delete(Py_tss_t *key) {
PyThread_delete_key(*key);
*key = Py_tss_NEEDS_INIT;
}
static CYTHON_INLINE int PyThread_tss_set(Py_tss_t *key, void *value) {
return PyThread_set_key_value(*key, value);
}
static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) {
return PyThread_get_key_value(*key);
}
#endif
#if CYTHON_COMPILING_IN_CPYTHON || defined(_PyDict_NewPresized)
#define __Pyx_PyDict_NewPresized(n) ((n <= 8) ? PyDict_New() : _PyDict_NewPresized(n))
#else
#define __Pyx_PyDict_NewPresized(n) PyDict_New()
#endif
#if PY_MAJOR_VERSION >= 3 || CYTHON_FUTURE_DIVISION
#define __Pyx_PyNumber_Divide(x,y) PyNumber_TrueDivide(x,y)
#define __Pyx_PyNumber_InPlaceDivide(x,y) PyNumber_InPlaceTrueDivide(x,y)
#else
#define __Pyx_PyNumber_Divide(x,y) PyNumber_Divide(x,y)
#define __Pyx_PyNumber_InPlaceDivide(x,y) PyNumber_InPlaceDivide(x,y)
#endif
#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030500A1 && CYTHON_USE_UNICODE_INTERNALS
#define __Pyx_PyDict_GetItemStr(dict, name) _PyDict_GetItem_KnownHash(dict, name, ((PyASCIIObject *) name)->hash)
#else
#define __Pyx_PyDict_GetItemStr(dict, name) PyDict_GetItem(dict, name)
#endif
#if PY_VERSION_HEX > 0x03030000 && defined(PyUnicode_KIND)
#define CYTHON_PEP393_ENABLED 1
#define __Pyx_PyUnicode_READY(op) (likely(PyUnicode_IS_READY(op)) ?\
0 : _PyUnicode_Ready((PyObject *)(op)))
#define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GET_LENGTH(u)
#define __Pyx_PyUnicode_READ_CHAR(u, i) PyUnicode_READ_CHAR(u, i)
#define __Pyx_PyUnicode_MAX_CHAR_VALUE(u) PyUnicode_MAX_CHAR_VALUE(u)
#define __Pyx_PyUnicode_KIND(u) PyUnicode_KIND(u)
#define __Pyx_PyUnicode_DATA(u) PyUnicode_DATA(u)
#define __Pyx_PyUnicode_READ(k, d, i) PyUnicode_READ(k, d, i)
#define __Pyx_PyUnicode_WRITE(k, d, i, ch) PyUnicode_WRITE(k, d, i, ch)
#if defined(PyUnicode_IS_READY) && defined(PyUnicode_GET_SIZE)
#define __Pyx_PyUnicode_IS_TRUE(u) (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : PyUnicode_GET_SIZE(u)))
#else
#define __Pyx_PyUnicode_IS_TRUE(u) (0 != PyUnicode_GET_LENGTH(u))
#endif
#else
#define CYTHON_PEP393_ENABLED 0
#define PyUnicode_1BYTE_KIND 1
#define PyUnicode_2BYTE_KIND 2
#define PyUnicode_4BYTE_KIND 4
#define __Pyx_PyUnicode_READY(op) (0)
#define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GET_SIZE(u)
#define __Pyx_PyUnicode_READ_CHAR(u, i) ((Py_UCS4)(PyUnicode_AS_UNICODE(u)[i]))
#define __Pyx_PyUnicode_MAX_CHAR_VALUE(u) ((sizeof(Py_UNICODE) == 2) ? 65535 : 1114111)
#define __Pyx_PyUnicode_KIND(u) (sizeof(Py_UNICODE))
#define __Pyx_PyUnicode_DATA(u) ((void*)PyUnicode_AS_UNICODE(u))
#define __Pyx_PyUnicode_READ(k, d, i) ((void)(k), (Py_UCS4)(((Py_UNICODE*)d)[i]))
#define __Pyx_PyUnicode_WRITE(k, d, i, ch) (((void)(k)), ((Py_UNICODE*)d)[i] = ch)
#define __Pyx_PyUnicode_IS_TRUE(u) (0 != PyUnicode_GET_SIZE(u))
#endif
#if CYTHON_COMPILING_IN_PYPY
#define __Pyx_PyUnicode_Concat(a, b) PyNumber_Add(a, b)
#define __Pyx_PyUnicode_ConcatSafe(a, b) PyNumber_Add(a, b)
#else
#define __Pyx_PyUnicode_Concat(a, b) PyUnicode_Concat(a, b)
#define __Pyx_PyUnicode_ConcatSafe(a, b) ((unlikely((a) == Py_None) || unlikely((b) == Py_None)) ?\
PyNumber_Add(a, b) : __Pyx_PyUnicode_Concat(a, b))
#endif
#if CYTHON_COMPILING_IN_PYPY && !defined(PyUnicode_Contains)
#define PyUnicode_Contains(u, s) PySequence_Contains(u, s)
#endif
#if CYTHON_COMPILING_IN_PYPY && !defined(PyByteArray_Check)
#define PyByteArray_Check(obj) PyObject_TypeCheck(obj, &PyByteArray_Type)
#endif
#if CYTHON_COMPILING_IN_PYPY && !defined(PyObject_Format)
#define PyObject_Format(obj, fmt) PyObject_CallMethod(obj, "__format__", "O", fmt)
#endif
#define __Pyx_PyString_FormatSafe(a, b) ((unlikely((a) == Py_None || (PyString_Check(b) && !PyString_CheckExact(b)))) ? PyNumber_Remainder(a, b) : __Pyx_PyString_Format(a, b))
#define __Pyx_PyUnicode_FormatSafe(a, b) ((unlikely((a) == Py_None || (PyUnicode_Check(b) && !PyUnicode_CheckExact(b)))) ? PyNumber_Remainder(a, b) : PyUnicode_Format(a, b))
#if PY_MAJOR_VERSION >= 3
#define __Pyx_PyString_Format(a, b) PyUnicode_Format(a, b)
#else
#define __Pyx_PyString_Format(a, b) PyString_Format(a, b)
#endif
#if PY_MAJOR_VERSION < 3 && !defined(PyObject_ASCII)
#define PyObject_ASCII(o) PyObject_Repr(o)
#endif
#if PY_MAJOR_VERSION >= 3
#define PyBaseString_Type PyUnicode_Type
#define PyStringObject PyUnicodeObject
#define PyString_Type PyUnicode_Type
#define PyString_Check PyUnicode_Check
#define PyString_CheckExact PyUnicode_CheckExact
#ifndef PyObject_Unicode
#define PyObject_Unicode PyObject_Str
#endif
#endif
#if PY_MAJOR_VERSION >= 3
#define __Pyx_PyBaseString_Check(obj) PyUnicode_Check(obj)
#define __Pyx_PyBaseString_CheckExact(obj) PyUnicode_CheckExact(obj)
#else
#define __Pyx_PyBaseString_Check(obj) (PyString_Check(obj) || PyUnicode_Check(obj))
#define __Pyx_PyBaseString_CheckExact(obj) (PyString_CheckExact(obj) || PyUnicode_CheckExact(obj))
#endif
#ifndef PySet_CheckExact
#define PySet_CheckExact(obj) (Py_TYPE(obj) == &PySet_Type)
#endif
#if PY_VERSION_HEX >= 0x030900A4
#define __Pyx_SET_REFCNT(obj, refcnt) Py_SET_REFCNT(obj, refcnt)
#define __Pyx_SET_SIZE(obj, size) Py_SET_SIZE(obj, size)
#else
#define __Pyx_SET_REFCNT(obj, refcnt) Py_REFCNT(obj) = (refcnt)
#define __Pyx_SET_SIZE(obj, size) Py_SIZE(obj) = (size)
#endif
#if CYTHON_ASSUME_SAFE_MACROS
#define __Pyx_PySequence_SIZE(seq) Py_SIZE(seq)
#else
#define __Pyx_PySequence_SIZE(seq) PySequence_Size(seq)
#endif
#if PY_MAJOR_VERSION >= 3
#define PyIntObject PyLongObject
#define PyInt_Type PyLong_Type
#define PyInt_Check(op) PyLong_Check(op)
#define PyInt_CheckExact(op) PyLong_CheckExact(op)
#define PyInt_FromString PyLong_FromString
#define PyInt_FromUnicode PyLong_FromUnicode
#define PyInt_FromLong PyLong_FromLong
#define PyInt_FromSize_t PyLong_FromSize_t
#define PyInt_FromSsize_t PyLong_FromSsize_t
#define PyInt_AsLong PyLong_AsLong
#define PyInt_AS_LONG PyLong_AS_LONG
#define PyInt_AsSsize_t PyLong_AsSsize_t
#define PyInt_AsUnsignedLongMask PyLong_AsUnsignedLongMask
#define PyInt_AsUnsignedLongLongMask PyLong_AsUnsignedLongLongMask
#define PyNumber_Int PyNumber_Long
#endif
#if PY_MAJOR_VERSION >= 3
#define PyBoolObject PyLongObject
#endif
#if PY_MAJOR_VERSION >= 3 && CYTHON_COMPILING_IN_PYPY
#ifndef PyUnicode_InternFromString
#define PyUnicode_InternFromString(s) PyUnicode_FromString(s)
#endif
#endif
#if PY_VERSION_HEX < 0x030200A4
typedef long Py_hash_t;
#define __Pyx_PyInt_FromHash_t PyInt_FromLong
#define __Pyx_PyInt_AsHash_t PyInt_AsLong
#else
#define __Pyx_PyInt_FromHash_t PyInt_FromSsize_t
#define __Pyx_PyInt_AsHash_t PyInt_AsSsize_t
#endif
#if PY_MAJOR_VERSION >= 3
#define __Pyx_PyMethod_New(func, self, klass) ((self) ? ((void)(klass), PyMethod_New(func, self)) : __Pyx_NewRef(func))
#else
#define __Pyx_PyMethod_New(func, self, klass) PyMethod_New(func, self, klass)
#endif
#if CYTHON_USE_ASYNC_SLOTS
#if PY_VERSION_HEX >= 0x030500B1
#define __Pyx_PyAsyncMethodsStruct PyAsyncMethods
#define __Pyx_PyType_AsAsync(obj) (Py_TYPE(obj)->tp_as_async)
#else
#define __Pyx_PyType_AsAsync(obj) ((__Pyx_PyAsyncMethodsStruct*) (Py_TYPE(obj)->tp_reserved))
#endif
#else
#define __Pyx_PyType_AsAsync(obj) NULL
#endif
#ifndef __Pyx_PyAsyncMethodsStruct
typedef struct {
unaryfunc am_await;
unaryfunc am_aiter;
unaryfunc am_anext;
} __Pyx_PyAsyncMethodsStruct;
#endif
#if defined(WIN32) || defined(MS_WINDOWS)
#define _USE_MATH_DEFINES
#endif
#include <math.h>
#ifdef NAN
#define __PYX_NAN() ((float) NAN)
#else
static CYTHON_INLINE float __PYX_NAN() {
float value;
memset(&value, 0xFF, sizeof(value));
return value;
}
#endif
#if defined(__CYGWIN__) && defined(_LDBL_EQ_DBL)
#define __Pyx_truncl trunc
#else
#define __Pyx_truncl truncl
#endif
#define __PYX_MARK_ERR_POS(f_index, lineno) \
{ __pyx_filename = __pyx_f[f_index]; (void)__pyx_filename; __pyx_lineno = lineno; (void)__pyx_lineno; __pyx_clineno = __LINE__; (void)__pyx_clineno; }
#define __PYX_ERR(f_index, lineno, Ln_error) \
{ __PYX_MARK_ERR_POS(f_index, lineno) goto Ln_error; }
#ifndef __PYX_EXTERN_C
#ifdef __cplusplus
#define __PYX_EXTERN_C extern "C"
#else
#define __PYX_EXTERN_C extern
#endif
#endif
#define __PYX_HAVE__spacy__syntax__arc_eager
#define __PYX_HAVE_API__spacy__syntax__arc_eager
/* Early includes */
#include <stdint.h>
#include <string.h>
#include "ios"
#include "new"
#include "stdexcept"
#include "typeinfo"
#include <vector>
#include <utility>
#if __cplusplus > 199711L
#include <type_traits>
namespace cython_std {
template <typename T> typename std::remove_reference<T>::type&& move(T& t) noexcept { return std::move(t); }
template <typename T> typename std::remove_reference<T>::type&& move(T&& t) noexcept { return std::move(t); }
}
#endif
#include <set>
#include <stdlib.h>
#include <stdio.h>
#include "numpy/arrayobject.h"
#include "numpy/ufuncobject.h"
/* NumPy API declarations from "numpy/__init__.pxd" */
#include <queue>
#include "pythread.h"
#include "pystate.h"
#ifdef _OPENMP
#include <omp.h>
#endif /* _OPENMP */
#if defined(PYREX_WITHOUT_ASSERTIONS) && !defined(CYTHON_WITHOUT_ASSERTIONS)
#define CYTHON_WITHOUT_ASSERTIONS
#endif
typedef struct {PyObject **p; const char *s; const Py_ssize_t n; const char* encoding;
const char is_unicode; const char is_str; const char intern; } __Pyx_StringTabEntry;
#define __PYX_DEFAULT_STRING_ENCODING_IS_ASCII 0
#define __PYX_DEFAULT_STRING_ENCODING_IS_UTF8 0
#define __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT (PY_MAJOR_VERSION >= 3 && __PYX_DEFAULT_STRING_ENCODING_IS_UTF8)
#define __PYX_DEFAULT_STRING_ENCODING ""
#define __Pyx_PyObject_FromString __Pyx_PyBytes_FromString
#define __Pyx_PyObject_FromStringAndSize __Pyx_PyBytes_FromStringAndSize
#define __Pyx_uchar_cast(c) ((unsigned char)c)
#define __Pyx_long_cast(x) ((long)x)
#define __Pyx_fits_Py_ssize_t(v, type, is_signed) (\
(sizeof(type) < sizeof(Py_ssize_t)) ||\
(sizeof(type) > sizeof(Py_ssize_t) &&\
likely(v < (type)PY_SSIZE_T_MAX ||\
v == (type)PY_SSIZE_T_MAX) &&\
(!is_signed || likely(v > (type)PY_SSIZE_T_MIN ||\
v == (type)PY_SSIZE_T_MIN))) ||\
(sizeof(type) == sizeof(Py_ssize_t) &&\
(is_signed || likely(v < (type)PY_SSIZE_T_MAX ||\
v == (type)PY_SSIZE_T_MAX))) )
static CYTHON_INLINE int __Pyx_is_valid_index(Py_ssize_t i, Py_ssize_t limit) {
return (size_t) i < (size_t) limit;
}
#if defined (__cplusplus) && __cplusplus >= 201103L
#include <cstdlib>
#define __Pyx_sst_abs(value) std::abs(value)
#elif SIZEOF_INT >= SIZEOF_SIZE_T
#define __Pyx_sst_abs(value) abs(value)
#elif SIZEOF_LONG >= SIZEOF_SIZE_T
#define __Pyx_sst_abs(value) labs(value)
#elif defined (_MSC_VER)
#define __Pyx_sst_abs(value) ((Py_ssize_t)_abs64(value))
#elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
#define __Pyx_sst_abs(value) llabs(value)
#elif defined (__GNUC__)
#define __Pyx_sst_abs(value) __builtin_llabs(value)
#else
#define __Pyx_sst_abs(value) ((value<0) ? -value : value)
#endif
static CYTHON_INLINE const char* __Pyx_PyObject_AsString(PyObject*);
static CYTHON_INLINE const char* __Pyx_PyObject_AsStringAndSize(PyObject*, Py_ssize_t* length);
#define __Pyx_PyByteArray_FromString(s) PyByteArray_FromStringAndSize((const char*)s, strlen((const char*)s))
#define __Pyx_PyByteArray_FromStringAndSize(s, l) PyByteArray_FromStringAndSize((const char*)s, l)
#define __Pyx_PyBytes_FromString PyBytes_FromString
#define __Pyx_PyBytes_FromStringAndSize PyBytes_FromStringAndSize
static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char*);
#if PY_MAJOR_VERSION < 3
#define __Pyx_PyStr_FromString __Pyx_PyBytes_FromString
#define __Pyx_PyStr_FromStringAndSize __Pyx_PyBytes_FromStringAndSize
#else
#define __Pyx_PyStr_FromString __Pyx_PyUnicode_FromString
#define __Pyx_PyStr_FromStringAndSize __Pyx_PyUnicode_FromStringAndSize
#endif
#define __Pyx_PyBytes_AsWritableString(s) ((char*) PyBytes_AS_STRING(s))
#define __Pyx_PyBytes_AsWritableSString(s) ((signed char*) PyBytes_AS_STRING(s))
#define __Pyx_PyBytes_AsWritableUString(s) ((unsigned char*) PyBytes_AS_STRING(s))
#define __Pyx_PyBytes_AsString(s) ((const char*) PyBytes_AS_STRING(s))
#define __Pyx_PyBytes_AsSString(s) ((const signed char*) PyBytes_AS_STRING(s))
#define __Pyx_PyBytes_AsUString(s) ((const unsigned char*) PyBytes_AS_STRING(s))
#define __Pyx_PyObject_AsWritableString(s) ((char*) __Pyx_PyObject_AsString(s))
#define __Pyx_PyObject_AsWritableSString(s) ((signed char*) __Pyx_PyObject_AsString(s))
#define __Pyx_PyObject_AsWritableUString(s) ((unsigned char*) __Pyx_PyObject_AsString(s))
#define __Pyx_PyObject_AsSString(s) ((const signed char*) __Pyx_PyObject_AsString(s))
#define __Pyx_PyObject_AsUString(s) ((const unsigned char*) __Pyx_PyObject_AsString(s))
#define __Pyx_PyObject_FromCString(s) __Pyx_PyObject_FromString((const char*)s)
#define __Pyx_PyBytes_FromCString(s) __Pyx_PyBytes_FromString((const char*)s)
#define __Pyx_PyByteArray_FromCString(s) __Pyx_PyByteArray_FromString((const char*)s)
#define __Pyx_PyStr_FromCString(s) __Pyx_PyStr_FromString((const char*)s)
#define __Pyx_PyUnicode_FromCString(s) __Pyx_PyUnicode_FromString((const char*)s)
static CYTHON_INLINE size_t __Pyx_Py_UNICODE_strlen(const Py_UNICODE *u) {
const Py_UNICODE *u_end = u;
while (*u_end++) ;
return (size_t)(u_end - u - 1);
}
#define __Pyx_PyUnicode_FromUnicode(u) PyUnicode_FromUnicode(u, __Pyx_Py_UNICODE_strlen(u))
#define __Pyx_PyUnicode_FromUnicodeAndLength PyUnicode_FromUnicode
#define __Pyx_PyUnicode_AsUnicode PyUnicode_AsUnicode
#define __Pyx_NewRef(obj) (Py_INCREF(obj), obj)
#define __Pyx_Owned_Py_None(b) __Pyx_NewRef(Py_None)
static CYTHON_INLINE PyObject * __Pyx_PyBool_FromLong(long b);
static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject*);
static CYTHON_INLINE int __Pyx_PyObject_IsTrueAndDecref(PyObject*);
static CYTHON_INLINE PyObject* __Pyx_PyNumber_IntOrLong(PyObject* x);
#define __Pyx_PySequence_Tuple(obj)\
(likely(PyTuple_CheckExact(obj)) ? __Pyx_NewRef(obj) : PySequence_Tuple(obj))
static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject*);
static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t);
#if CYTHON_ASSUME_SAFE_MACROS
#define __pyx_PyFloat_AsDouble(x) (PyFloat_CheckExact(x) ? PyFloat_AS_DOUBLE(x) : PyFloat_AsDouble(x))
#else
#define __pyx_PyFloat_AsDouble(x) PyFloat_AsDouble(x)
#endif
#define __pyx_PyFloat_AsFloat(x) ((float) __pyx_PyFloat_AsDouble(x))
#if PY_MAJOR_VERSION >= 3
#define __Pyx_PyNumber_Int(x) (PyLong_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Long(x))
#else
#define __Pyx_PyNumber_Int(x) (PyInt_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Int(x))
#endif
#define __Pyx_PyNumber_Float(x) (PyFloat_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Float(x))
#if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII
static int __Pyx_sys_getdefaultencoding_not_ascii;
static int __Pyx_init_sys_getdefaultencoding_params(void) {
PyObject* sys;
PyObject* default_encoding = NULL;
PyObject* ascii_chars_u = NULL;
PyObject* ascii_chars_b = NULL;
const char* default_encoding_c;
sys = PyImport_ImportModule("sys");
if (!sys) goto bad;
default_encoding = PyObject_CallMethod(sys, (char*) "getdefaultencoding", NULL);
Py_DECREF(sys);
if (!default_encoding) goto bad;
default_encoding_c = PyBytes_AsString(default_encoding);
if (!default_encoding_c) goto bad;
if (strcmp(default_encoding_c, "ascii") == 0) {
__Pyx_sys_getdefaultencoding_not_ascii = 0;
} else {
char ascii_chars[128];
int c;
for (c = 0; c < 128; c++) {
ascii_chars[c] = c;
}
__Pyx_sys_getdefaultencoding_not_ascii = 1;
ascii_chars_u = PyUnicode_DecodeASCII(ascii_chars, 128, NULL);
if (!ascii_chars_u) goto bad;
ascii_chars_b = PyUnicode_AsEncodedString(ascii_chars_u, default_encoding_c, NULL);
if (!ascii_chars_b || !PyBytes_Check(ascii_chars_b) || memcmp(ascii_chars, PyBytes_AS_STRING(ascii_chars_b), 128) != 0) {
PyErr_Format(
PyExc_ValueError,
"This module compiled with c_string_encoding=ascii, but default encoding '%.200s' is not a superset of ascii.",
default_encoding_c);
goto bad;
}
Py_DECREF(ascii_chars_u);
Py_DECREF(ascii_chars_b);
}
Py_DECREF(default_encoding);
return 0;
bad:
Py_XDECREF(default_encoding);
Py_XDECREF(ascii_chars_u);
Py_XDECREF(ascii_chars_b);
return -1;
}
#endif
#if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT && PY_MAJOR_VERSION >= 3
#define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_DecodeUTF8(c_str, size, NULL)
#else
#define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_Decode(c_str, size, __PYX_DEFAULT_STRING_ENCODING, NULL)
#if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT
static char* __PYX_DEFAULT_STRING_ENCODING;
static int __Pyx_init_sys_getdefaultencoding_params(void) {
PyObject* sys;
PyObject* default_encoding = NULL;
char* default_encoding_c;
sys = PyImport_ImportModule("sys");
if (!sys) goto bad;
default_encoding = PyObject_CallMethod(sys, (char*) (const char*) "getdefaultencoding", NULL);
Py_DECREF(sys);
if (!default_encoding) goto bad;
default_encoding_c = PyBytes_AsString(default_encoding);
if (!default_encoding_c) goto bad;
__PYX_DEFAULT_STRING_ENCODING = (char*) malloc(strlen(default_encoding_c) + 1);
if (!__PYX_DEFAULT_STRING_ENCODING) goto bad;
strcpy(__PYX_DEFAULT_STRING_ENCODING, default_encoding_c);
Py_DECREF(default_encoding);
return 0;
bad:
Py_XDECREF(default_encoding);
return -1;
}
#endif
#endif
/* Test for GCC > 2.95 */
#if defined(__GNUC__) && (__GNUC__ > 2 || (__GNUC__ == 2 && (__GNUC_MINOR__ > 95)))
#define likely(x) __builtin_expect(!!(x), 1)
#define unlikely(x) __builtin_expect(!!(x), 0)
#else /* !__GNUC__ or GCC < 2.95 */
#define likely(x) (x)
#define unlikely(x) (x)
#endif /* __GNUC__ */
static CYTHON_INLINE void __Pyx_pretend_to_initialize(void* ptr) { (void)ptr; }
static PyObject *__pyx_m = NULL;
static PyObject *__pyx_d;
static PyObject *__pyx_b;
static PyObject *__pyx_cython_runtime = NULL;
static PyObject *__pyx_empty_tuple;
static PyObject *__pyx_empty_bytes;
static PyObject *__pyx_empty_unicode;
static int __pyx_lineno;
static int __pyx_clineno = 0;
static const char * __pyx_cfilenm= __FILE__;
static const char *__pyx_filename;
/* Header.proto */
#if !defined(CYTHON_CCOMPLEX)
#if defined(__cplusplus)
#define CYTHON_CCOMPLEX 1
#elif defined(_Complex_I)
#define CYTHON_CCOMPLEX 1
#else
#define CYTHON_CCOMPLEX 0
#endif
#endif
#if CYTHON_CCOMPLEX
#ifdef __cplusplus
#include <complex>
#else
#include <complex.h>
#endif
#endif
#if CYTHON_CCOMPLEX && !defined(__cplusplus) && defined(__sun__) && defined(__GNUC__)
#undef _Complex_I
#define _Complex_I 1.0fj
#endif
static const char *__pyx_f[] = {
"arc_eager.pyx",
"stringsource",
"__init__.pxd",
"lexeme.pxd",
"_state.pxd",
"stateclass.pxd",
"search.pxd",
"cymem.pxd",
"maps.pxd",
"strings.pxd",
"morphology.pxd",
"vocab.pxd",
"type.pxd",
"gold.pxd",
"doc.pxd",
};
/* ForceInitThreads.proto */
#ifndef __PYX_FORCE_INIT_THREADS
#define __PYX_FORCE_INIT_THREADS 0
#endif
/* NoFastGil.proto */
#define __Pyx_PyGILState_Ensure PyGILState_Ensure
#define __Pyx_PyGILState_Release PyGILState_Release
#define __Pyx_FastGIL_Remember()
#define __Pyx_FastGIL_Forget()
#define __Pyx_FastGilFuncInit()
/* BufferFormatStructs.proto */
#define IS_UNSIGNED(type) (((type) -1) > 0)
struct __Pyx_StructField_;
#define __PYX_BUF_FLAGS_PACKED_STRUCT (1 << 0)
typedef struct {
const char* name;
struct __Pyx_StructField_* fields;
size_t size;
size_t arraysize[8];
int ndim;
char typegroup;
char is_unsigned;
int flags;
} __Pyx_TypeInfo;
typedef struct __Pyx_StructField_ {
__Pyx_TypeInfo* type;
const char* name;
size_t offset;
} __Pyx_StructField;
typedef struct {
__Pyx_StructField* field;
size_t parent_offset;
} __Pyx_BufFmt_StackElem;
typedef struct {
__Pyx_StructField root;
__Pyx_BufFmt_StackElem* head;
size_t fmt_offset;
size_t new_count, enc_count;
size_t struct_alignment;
int is_complex;
char enc_type;
char new_packmode;
char enc_packmode;
char is_valid_array;
} __Pyx_BufFmt_Context;
/* Atomics.proto */
#include <pythread.h>
#ifndef CYTHON_ATOMICS
#define CYTHON_ATOMICS 1
#endif
#define __pyx_atomic_int_type int
#if CYTHON_ATOMICS && __GNUC__ >= 4 && (__GNUC_MINOR__ > 1 ||\
(__GNUC_MINOR__ == 1 && __GNUC_PATCHLEVEL >= 2)) &&\
!defined(__i386__)
#define __pyx_atomic_incr_aligned(value, lock) __sync_fetch_and_add(value, 1)
#define __pyx_atomic_decr_aligned(value, lock) __sync_fetch_and_sub(value, 1)
#ifdef __PYX_DEBUG_ATOMICS
#warning "Using GNU atomics"
#endif
#elif CYTHON_ATOMICS && defined(_MSC_VER) && 0
#include <Windows.h>
#undef __pyx_atomic_int_type
#define __pyx_atomic_int_type LONG
#define __pyx_atomic_incr_aligned(value, lock) InterlockedIncrement(value)
#define __pyx_atomic_decr_aligned(value, lock) InterlockedDecrement(value)
#ifdef __PYX_DEBUG_ATOMICS
#pragma message ("Using MSVC atomics")
#endif
#elif CYTHON_ATOMICS && (defined(__ICC) || defined(__INTEL_COMPILER)) && 0
#define __pyx_atomic_incr_aligned(value, lock) _InterlockedIncrement(value)
#define __pyx_atomic_decr_aligned(value, lock) _InterlockedDecrement(value)
#ifdef __PYX_DEBUG_ATOMICS
#warning "Using Intel atomics"
#endif
#else
#undef CYTHON_ATOMICS
#define CYTHON_ATOMICS 0
#ifdef __PYX_DEBUG_ATOMICS
#warning "Not using atomics"
#endif
#endif
typedef volatile __pyx_atomic_int_type __pyx_atomic_int;
#if CYTHON_ATOMICS
#define __pyx_add_acquisition_count(memview)\
__pyx_atomic_incr_aligned(__pyx_get_slice_count_pointer(memview), memview->lock)
#define __pyx_sub_acquisition_count(memview)\
__pyx_atomic_decr_aligned(__pyx_get_slice_count_pointer(memview), memview->lock)
#else
#define __pyx_add_acquisition_count(memview)\
__pyx_add_acquisition_count_locked(__pyx_get_slice_count_pointer(memview), memview->lock)
#define __pyx_sub_acquisition_count(memview)\
__pyx_sub_acquisition_count_locked(__pyx_get_slice_count_pointer(memview), memview->lock)
#endif
/* MemviewSliceStruct.proto */
struct __pyx_memoryview_obj;
typedef struct {
struct __pyx_memoryview_obj *memview;
char *data;
Py_ssize_t shape[8];
Py_ssize_t strides[8];
Py_ssize_t suboffsets[8];
} __Pyx_memviewslice;
#define __Pyx_MemoryView_Len(m) (m.shape[0])
/* "thinc/typedefs.pxd":7
*
*
* ctypedef float weight_t # <<<<<<<<<<<<<<
* ctypedef uint64_t atom_t
* ctypedef uint64_t feat_t
*/
typedef float __pyx_t_5thinc_8typedefs_weight_t;
/* "thinc/typedefs.pxd":8
*
* ctypedef float weight_t
* ctypedef uint64_t atom_t # <<<<<<<<<<<<<<
* ctypedef uint64_t feat_t
* ctypedef uint64_t hash_t
*/
typedef uint64_t __pyx_t_5thinc_8typedefs_atom_t;
/* "thinc/typedefs.pxd":9
* ctypedef float weight_t
* ctypedef uint64_t atom_t
* ctypedef uint64_t feat_t # <<<<<<<<<<<<<<
* ctypedef uint64_t hash_t
* ctypedef int32_t class_t
*/
typedef uint64_t __pyx_t_5thinc_8typedefs_feat_t;
/* "thinc/typedefs.pxd":10
* ctypedef uint64_t atom_t
* ctypedef uint64_t feat_t
* ctypedef uint64_t hash_t # <<<<<<<<<<<<<<
* ctypedef int32_t class_t
* ctypedef uint32_t count_t
*/
typedef uint64_t __pyx_t_5thinc_8typedefs_hash_t;
/* "thinc/typedefs.pxd":11
* ctypedef uint64_t feat_t
* ctypedef uint64_t hash_t
* ctypedef int32_t class_t # <<<<<<<<<<<<<<
* ctypedef uint32_t count_t
* ctypedef uint32_t time_t
*/
typedef int32_t __pyx_t_5thinc_8typedefs_class_t;
/* "thinc/typedefs.pxd":12
* ctypedef uint64_t hash_t
* ctypedef int32_t class_t
* ctypedef uint32_t count_t # <<<<<<<<<<<<<<
* ctypedef uint32_t time_t
* ctypedef int32_t len_t
*/
typedef uint32_t __pyx_t_5thinc_8typedefs_count_t;
/* "thinc/typedefs.pxd":13
* ctypedef int32_t class_t
* ctypedef uint32_t count_t
* ctypedef uint32_t time_t # <<<<<<<<<<<<<<
* ctypedef int32_t len_t
* ctypedef int32_t idx_t
*/
typedef uint32_t __pyx_t_5thinc_8typedefs_time_t;
/* "thinc/typedefs.pxd":14
* ctypedef uint32_t count_t
* ctypedef uint32_t time_t
* ctypedef int32_t len_t # <<<<<<<<<<<<<<
* ctypedef int32_t idx_t
*
*/
typedef int32_t __pyx_t_5thinc_8typedefs_len_t;
/* "thinc/typedefs.pxd":15
* ctypedef uint32_t time_t
* ctypedef int32_t len_t
* ctypedef int32_t idx_t # <<<<<<<<<<<<<<
*
*
*/
typedef int32_t __pyx_t_5thinc_8typedefs_idx_t;
/* "typedefs.pxd":5
*
*
* ctypedef uint64_t hash_t # <<<<<<<<<<<<<<
* ctypedef char* utf8_t
* ctypedef uint64_t attr_t
*/
typedef uint64_t __pyx_t_5spacy_8typedefs_hash_t;
/* "typedefs.pxd":7
* ctypedef uint64_t hash_t
* ctypedef char* utf8_t
* ctypedef uint64_t attr_t # <<<<<<<<<<<<<<
* ctypedef uint64_t flags_t
* ctypedef uint16_t len_t
*/
typedef uint64_t __pyx_t_5spacy_8typedefs_attr_t;
/* "typedefs.pxd":8
* ctypedef char* utf8_t
* ctypedef uint64_t attr_t
* ctypedef uint64_t flags_t # <<<<<<<<<<<<<<
* ctypedef uint16_t len_t
* ctypedef uint16_t tag_t
*/
typedef uint64_t __pyx_t_5spacy_8typedefs_flags_t;
/* "typedefs.pxd":9
* ctypedef uint64_t attr_t
* ctypedef uint64_t flags_t
* ctypedef uint16_t len_t # <<<<<<<<<<<<<<
* ctypedef uint16_t tag_t
*/
typedef uint16_t __pyx_t_5spacy_8typedefs_len_t;
/* "typedefs.pxd":10
* ctypedef uint64_t flags_t
* ctypedef uint16_t len_t
* ctypedef uint16_t tag_t # <<<<<<<<<<<<<<
*/
typedef uint16_t __pyx_t_5spacy_8typedefs_tag_t;
/* "preshed/maps.pxd":5
*
*
* ctypedef uint64_t key_t # <<<<<<<<<<<<<<
*
*
*/
typedef uint64_t __pyx_t_7preshed_4maps_key_t;
/* "../../../../opt/python/cp37-cp37m/lib/python3.7/site-packages/numpy/__init__.pxd":697
* # in Cython to enable them only on the right systems.
*
* ctypedef npy_int8 int8_t # <<<<<<<<<<<<<<
* ctypedef npy_int16 int16_t
* ctypedef npy_int32 int32_t
*/
typedef npy_int8 __pyx_t_5numpy_int8_t;
/* "../../../../opt/python/cp37-cp37m/lib/python3.7/site-packages/numpy/__init__.pxd":698
*
* ctypedef npy_int8 int8_t
* ctypedef npy_int16 int16_t # <<<<<<<<<<<<<<
* ctypedef npy_int32 int32_t
* ctypedef npy_int64 int64_t
*/
typedef npy_int16 __pyx_t_5numpy_int16_t;
/* "../../../../opt/python/cp37-cp37m/lib/python3.7/site-packages/numpy/__init__.pxd":699
* ctypedef npy_int8 int8_t
* ctypedef npy_int16 int16_t
* ctypedef npy_int32 int32_t # <<<<<<<<<<<<<<
* ctypedef npy_int64 int64_t
* #ctypedef npy_int96 int96_t
*/
typedef npy_int32 __pyx_t_5numpy_int32_t;
/* "../../../../opt/python/cp37-cp37m/lib/python3.7/site-packages/numpy/__init__.pxd":700
* ctypedef npy_int16 int16_t
* ctypedef npy_int32 int32_t
* ctypedef npy_int64 int64_t # <<<<<<<<<<<<<<
* #ctypedef npy_int96 int96_t
* #ctypedef npy_int128 int128_t
*/
typedef npy_int64 __pyx_t_5numpy_int64_t;
/* "../../../../opt/python/cp37-cp37m/lib/python3.7/site-packages/numpy/__init__.pxd":704
* #ctypedef npy_int128 int128_t
*
* ctypedef npy_uint8 uint8_t # <<<<<<<<<<<<<<
* ctypedef npy_uint16 uint16_t
* ctypedef npy_uint32 uint32_t
*/
typedef npy_uint8 __pyx_t_5numpy_uint8_t;
/* "../../../../opt/python/cp37-cp37m/lib/python3.7/site-packages/numpy/__init__.pxd":705
*
* ctypedef npy_uint8 uint8_t
* ctypedef npy_uint16 uint16_t # <<<<<<<<<<<<<<
* ctypedef npy_uint32 uint32_t
* ctypedef npy_uint64 uint64_t
*/
typedef npy_uint16 __pyx_t_5numpy_uint16_t;
/* "../../../../opt/python/cp37-cp37m/lib/python3.7/site-packages/numpy/__init__.pxd":706
* ctypedef npy_uint8 uint8_t
* ctypedef npy_uint16 uint16_t
* ctypedef npy_uint32 uint32_t # <<<<<<<<<<<<<<
* ctypedef npy_uint64 uint64_t
* #ctypedef npy_uint96 uint96_t
*/
typedef npy_uint32 __pyx_t_5numpy_uint32_t;
/* "../../../../opt/python/cp37-cp37m/lib/python3.7/site-packages/numpy/__init__.pxd":707
* ctypedef npy_uint16 uint16_t
* ctypedef npy_uint32 uint32_t
* ctypedef npy_uint64 uint64_t # <<<<<<<<<<<<<<
* #ctypedef npy_uint96 uint96_t
* #ctypedef npy_uint128 uint128_t
*/
typedef npy_uint64 __pyx_t_5numpy_uint64_t;
/* "../../../../opt/python/cp37-cp37m/lib/python3.7/site-packages/numpy/__init__.pxd":711
* #ctypedef npy_uint128 uint128_t
*
* ctypedef npy_float32 float32_t # <<<<<<<<<<<<<<
* ctypedef npy_float64 float64_t
* #ctypedef npy_float80 float80_t
*/
typedef npy_float32 __pyx_t_5numpy_float32_t;
/* "../../../../opt/python/cp37-cp37m/lib/python3.7/site-packages/numpy/__init__.pxd":712
*
* ctypedef npy_float32 float32_t
* ctypedef npy_float64 float64_t # <<<<<<<<<<<<<<
* #ctypedef npy_float80 float80_t
* #ctypedef npy_float128 float128_t
*/
typedef npy_float64 __pyx_t_5numpy_float64_t;
/* "../../../../opt/python/cp37-cp37m/lib/python3.7/site-packages/numpy/__init__.pxd":721
* # The int types are mapped a bit surprising --
* # numpy.int corresponds to 'l' and numpy.long to 'q'
* ctypedef npy_long int_t # <<<<<<<<<<<<<<
* ctypedef npy_longlong long_t
* ctypedef npy_longlong longlong_t
*/
typedef npy_long __pyx_t_5numpy_int_t;
/* "../../../../opt/python/cp37-cp37m/lib/python3.7/site-packages/numpy/__init__.pxd":722
* # numpy.int corresponds to 'l' and numpy.long to 'q'
* ctypedef npy_long int_t
* ctypedef npy_longlong long_t # <<<<<<<<<<<<<<
* ctypedef npy_longlong longlong_t
*
*/
typedef npy_longlong __pyx_t_5numpy_long_t;
/* "../../../../opt/python/cp37-cp37m/lib/python3.7/site-packages/numpy/__init__.pxd":723
* ctypedef npy_long int_t
* ctypedef npy_longlong long_t
* ctypedef npy_longlong longlong_t # <<<<<<<<<<<<<<
*
* ctypedef npy_ulong uint_t
*/
typedef npy_longlong __pyx_t_5numpy_longlong_t;
/* "../../../../opt/python/cp37-cp37m/lib/python3.7/site-packages/numpy/__init__.pxd":725
* ctypedef npy_longlong longlong_t
*
* ctypedef npy_ulong uint_t # <<<<<<<<<<<<<<
* ctypedef npy_ulonglong ulong_t
* ctypedef npy_ulonglong ulonglong_t
*/
typedef npy_ulong __pyx_t_5numpy_uint_t;
/* "../../../../opt/python/cp37-cp37m/lib/python3.7/site-packages/numpy/__init__.pxd":726
*
* ctypedef npy_ulong uint_t
* ctypedef npy_ulonglong ulong_t # <<<<<<<<<<<<<<
* ctypedef npy_ulonglong ulonglong_t
*
*/
typedef npy_ulonglong __pyx_t_5numpy_ulong_t;
/* "../../../../opt/python/cp37-cp37m/lib/python3.7/site-packages/numpy/__init__.pxd":727
* ctypedef npy_ulong uint_t
* ctypedef npy_ulonglong ulong_t
* ctypedef npy_ulonglong ulonglong_t # <<<<<<<<<<<<<<
*
* ctypedef npy_intp intp_t
*/
typedef npy_ulonglong __pyx_t_5numpy_ulonglong_t;
/* "../../../../opt/python/cp37-cp37m/lib/python3.7/site-packages/numpy/__init__.pxd":729
* ctypedef npy_ulonglong ulonglong_t
*
* ctypedef npy_intp intp_t # <<<<<<<<<<<<<<
* ctypedef npy_uintp uintp_t
*
*/
typedef npy_intp __pyx_t_5numpy_intp_t;
/* "../../../../opt/python/cp37-cp37m/lib/python3.7/site-packages/numpy/__init__.pxd":730
*
* ctypedef npy_intp intp_t
* ctypedef npy_uintp uintp_t # <<<<<<<<<<<<<<
*
* ctypedef npy_double float_t
*/
typedef npy_uintp __pyx_t_5numpy_uintp_t;
/* "../../../../opt/python/cp37-cp37m/lib/python3.7/site-packages/numpy/__init__.pxd":732
* ctypedef npy_uintp uintp_t
*
* ctypedef npy_double float_t # <<<<<<<<<<<<<<
* ctypedef npy_double double_t
* ctypedef npy_longdouble longdouble_t
*/
typedef npy_double __pyx_t_5numpy_float_t;
/* "../../../../opt/python/cp37-cp37m/lib/python3.7/site-packages/numpy/__init__.pxd":733
*
* ctypedef npy_double float_t
* ctypedef npy_double double_t # <<<<<<<<<<<<<<
* ctypedef npy_longdouble longdouble_t
*
*/
typedef npy_double __pyx_t_5numpy_double_t;
/* "../../../../opt/python/cp37-cp37m/lib/python3.7/site-packages/numpy/__init__.pxd":734
* ctypedef npy_double float_t
* ctypedef npy_double double_t
* ctypedef npy_longdouble longdouble_t # <<<<<<<<<<<<<<
*
* ctypedef npy_cfloat cfloat_t
*/
typedef npy_longdouble __pyx_t_5numpy_longdouble_t;
/* Declarations.proto */
#if CYTHON_CCOMPLEX
#ifdef __cplusplus
typedef ::std::complex< float > __pyx_t_float_complex;
#else
typedef float _Complex __pyx_t_float_complex;
#endif
#else
typedef struct { float real, imag; } __pyx_t_float_complex;
#endif
static CYTHON_INLINE __pyx_t_float_complex __pyx_t_float_complex_from_parts(float, float);
/* Declarations.proto */
#if CYTHON_CCOMPLEX
#ifdef __cplusplus
typedef ::std::complex< double > __pyx_t_double_complex;
#else
typedef double _Complex __pyx_t_double_complex;
#endif
#else
typedef struct { double real, imag; } __pyx_t_double_complex;
#endif
static CYTHON_INLINE __pyx_t_double_complex __pyx_t_double_complex_from_parts(double, double);
/*--- Type declarations ---*/
struct __pyx_obj_5cymem_5cymem_PyMalloc;
struct __pyx_obj_5cymem_5cymem_PyFree;
struct __pyx_obj_5cymem_5cymem_Pool;
struct __pyx_obj_5cymem_5cymem_Address;
struct __pyx_obj_7preshed_4maps_PreshMap;
struct __pyx_obj_7preshed_4maps_PreshMapArray;
struct __pyx_obj_5spacy_7strings_StringStore;
struct __pyx_obj_5spacy_10morphology_Morphology;
struct __pyx_obj_5spacy_5vocab_Vocab;
struct __pyx_obj_5spacy_6lexeme_Lexeme;
struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass;
struct __pyx_obj_5spacy_4gold_GoldParse;
struct __pyx_obj_5spacy_6syntax_17transition_system_TransitionSystem;
struct __pyx_obj_5thinc_5extra_6search_Beam;
struct __pyx_obj_5thinc_5extra_6search_MaxViolation;
struct __pyx_obj_5spacy_6tokens_3doc_Doc;
struct __pyx_obj_5spacy_6syntax_9arc_eager_ArcEager;
struct __pyx_obj_5spacy_6syntax_9arc_eager_Shift;
struct __pyx_obj_5spacy_6syntax_9arc_eager_Reduce;
struct __pyx_obj_5spacy_6syntax_9arc_eager_LeftArc;
struct __pyx_obj_5spacy_6syntax_9arc_eager_RightArc;
struct __pyx_obj_5spacy_6syntax_9arc_eager_Break;
struct __pyx_array_obj;
struct __pyx_MemviewEnum_obj;
struct __pyx_memoryview_obj;
struct __pyx_memoryviewslice_obj;
/* "cymem/cymem.pxd":1
* ctypedef void* (*malloc_t)(size_t n) # <<<<<<<<<<<<<<
* ctypedef void (*free_t)(void *p)
*
*/
typedef void *(*__pyx_t_5cymem_5cymem_malloc_t)(size_t);
/* "cymem/cymem.pxd":2
* ctypedef void* (*malloc_t)(size_t n)
* ctypedef void (*free_t)(void *p) # <<<<<<<<<<<<<<
*
* cdef class PyMalloc:
*/
typedef void (*__pyx_t_5cymem_5cymem_free_t)(void *);
/* "typedefs.pxd":6
*
* ctypedef uint64_t hash_t
* ctypedef char* utf8_t # <<<<<<<<<<<<<<
* ctypedef uint64_t attr_t
* ctypedef uint64_t flags_t
*/
typedef char *__pyx_t_5spacy_8typedefs_utf8_t;
/* "symbols.pxd":1
* cdef enum symbol_t: # <<<<<<<<<<<<<<
* NIL
* IS_ALPHA
*/
enum __pyx_t_5spacy_7symbols_symbol_t {
__pyx_e_5spacy_7symbols_NIL,
__pyx_e_5spacy_7symbols_IS_ALPHA,
__pyx_e_5spacy_7symbols_IS_ASCII,
__pyx_e_5spacy_7symbols_IS_DIGIT,
__pyx_e_5spacy_7symbols_IS_LOWER,
__pyx_e_5spacy_7symbols_IS_PUNCT,
__pyx_e_5spacy_7symbols_IS_SPACE,
__pyx_e_5spacy_7symbols_IS_TITLE,
__pyx_e_5spacy_7symbols_IS_UPPER,
__pyx_e_5spacy_7symbols_LIKE_URL,
__pyx_e_5spacy_7symbols_LIKE_NUM,
__pyx_e_5spacy_7symbols_LIKE_EMAIL,
__pyx_e_5spacy_7symbols_IS_STOP,
__pyx_e_5spacy_7symbols_IS_OOV_DEPRECATED,
__pyx_e_5spacy_7symbols_IS_BRACKET,
__pyx_e_5spacy_7symbols_IS_QUOTE,
__pyx_e_5spacy_7symbols_IS_LEFT_PUNCT,
__pyx_e_5spacy_7symbols_IS_RIGHT_PUNCT,
__pyx_e_5spacy_7symbols_IS_CURRENCY,
__pyx_e_5spacy_7symbols_FLAG19 = 19,
__pyx_e_5spacy_7symbols_FLAG20,
__pyx_e_5spacy_7symbols_FLAG21,
__pyx_e_5spacy_7symbols_FLAG22,
__pyx_e_5spacy_7symbols_FLAG23,
__pyx_e_5spacy_7symbols_FLAG24,
__pyx_e_5spacy_7symbols_FLAG25,
__pyx_e_5spacy_7symbols_FLAG26,
__pyx_e_5spacy_7symbols_FLAG27,
__pyx_e_5spacy_7symbols_FLAG28,
__pyx_e_5spacy_7symbols_FLAG29,
__pyx_e_5spacy_7symbols_FLAG30,
__pyx_e_5spacy_7symbols_FLAG31,
__pyx_e_5spacy_7symbols_FLAG32,
__pyx_e_5spacy_7symbols_FLAG33,
__pyx_e_5spacy_7symbols_FLAG34,
__pyx_e_5spacy_7symbols_FLAG35,
__pyx_e_5spacy_7symbols_FLAG36,
__pyx_e_5spacy_7symbols_FLAG37,
__pyx_e_5spacy_7symbols_FLAG38,
__pyx_e_5spacy_7symbols_FLAG39,
__pyx_e_5spacy_7symbols_FLAG40,
__pyx_e_5spacy_7symbols_FLAG41,
__pyx_e_5spacy_7symbols_FLAG42,
__pyx_e_5spacy_7symbols_FLAG43,
__pyx_e_5spacy_7symbols_FLAG44,
__pyx_e_5spacy_7symbols_FLAG45,
__pyx_e_5spacy_7symbols_FLAG46,
__pyx_e_5spacy_7symbols_FLAG47,
__pyx_e_5spacy_7symbols_FLAG48,
__pyx_e_5spacy_7symbols_FLAG49,
__pyx_e_5spacy_7symbols_FLAG50,
__pyx_e_5spacy_7symbols_FLAG51,
__pyx_e_5spacy_7symbols_FLAG52,
__pyx_e_5spacy_7symbols_FLAG53,
__pyx_e_5spacy_7symbols_FLAG54,
__pyx_e_5spacy_7symbols_FLAG55,
__pyx_e_5spacy_7symbols_FLAG56,
__pyx_e_5spacy_7symbols_FLAG57,
__pyx_e_5spacy_7symbols_FLAG58,
__pyx_e_5spacy_7symbols_FLAG59,
__pyx_e_5spacy_7symbols_FLAG60,
__pyx_e_5spacy_7symbols_FLAG61,
__pyx_e_5spacy_7symbols_FLAG62,
__pyx_e_5spacy_7symbols_FLAG63,
__pyx_e_5spacy_7symbols_ID,
__pyx_e_5spacy_7symbols_ORTH,
__pyx_e_5spacy_7symbols_LOWER,
__pyx_e_5spacy_7symbols_NORM,
__pyx_e_5spacy_7symbols_SHAPE,
__pyx_e_5spacy_7symbols_PREFIX,
__pyx_e_5spacy_7symbols_SUFFIX,
__pyx_e_5spacy_7symbols_LENGTH,
__pyx_e_5spacy_7symbols_CLUSTER,
__pyx_e_5spacy_7symbols_LEMMA,
__pyx_e_5spacy_7symbols_POS,
__pyx_e_5spacy_7symbols_TAG,
__pyx_e_5spacy_7symbols_DEP,
__pyx_e_5spacy_7symbols_ENT_IOB,
__pyx_e_5spacy_7symbols_ENT_TYPE,
__pyx_e_5spacy_7symbols_HEAD,
__pyx_e_5spacy_7symbols_SENT_START,
__pyx_e_5spacy_7symbols_SPACY,
__pyx_e_5spacy_7symbols_PROB,
__pyx_e_5spacy_7symbols_LANG,
__pyx_e_5spacy_7symbols_ADJ,
__pyx_e_5spacy_7symbols_ADP,
__pyx_e_5spacy_7symbols_ADV,
__pyx_e_5spacy_7symbols_AUX,
__pyx_e_5spacy_7symbols_CONJ,
__pyx_e_5spacy_7symbols_CCONJ,
__pyx_e_5spacy_7symbols_DET,
__pyx_e_5spacy_7symbols_INTJ,
__pyx_e_5spacy_7symbols_NOUN,
__pyx_e_5spacy_7symbols_NUM,
__pyx_e_5spacy_7symbols_PART,
__pyx_e_5spacy_7symbols_PRON,
__pyx_e_5spacy_7symbols_PROPN,
__pyx_e_5spacy_7symbols_PUNCT,
__pyx_e_5spacy_7symbols_SCONJ,
__pyx_e_5spacy_7symbols_SYM,
__pyx_e_5spacy_7symbols_VERB,
__pyx_e_5spacy_7symbols_X,
__pyx_e_5spacy_7symbols_EOL,
__pyx_e_5spacy_7symbols_SPACE,
__pyx_e_5spacy_7symbols_Animacy_anim,
__pyx_e_5spacy_7symbols_Animacy_inan,
__pyx_e_5spacy_7symbols_Animacy_hum,
__pyx_e_5spacy_7symbols_Animacy_nhum,
__pyx_e_5spacy_7symbols_Aspect_freq,
__pyx_e_5spacy_7symbols_Aspect_imp,
__pyx_e_5spacy_7symbols_Aspect_mod,
__pyx_e_5spacy_7symbols_Aspect_none,
__pyx_e_5spacy_7symbols_Aspect_perf,
__pyx_e_5spacy_7symbols_Aspect_iter,
__pyx_e_5spacy_7symbols_Aspect_hab,
__pyx_e_5spacy_7symbols_Case_abe,
__pyx_e_5spacy_7symbols_Case_abl,
__pyx_e_5spacy_7symbols_Case_abs,
__pyx_e_5spacy_7symbols_Case_acc,
__pyx_e_5spacy_7symbols_Case_ade,
__pyx_e_5spacy_7symbols_Case_all,
__pyx_e_5spacy_7symbols_Case_cau,
__pyx_e_5spacy_7symbols_Case_com,
__pyx_e_5spacy_7symbols_Case_cmp,
__pyx_e_5spacy_7symbols_Case_dat,
__pyx_e_5spacy_7symbols_Case_del,
__pyx_e_5spacy_7symbols_Case_dis,
__pyx_e_5spacy_7symbols_Case_ela,
__pyx_e_5spacy_7symbols_Case_equ,
__pyx_e_5spacy_7symbols_Case_ess,
__pyx_e_5spacy_7symbols_Case_gen,
__pyx_e_5spacy_7symbols_Case_ill,
__pyx_e_5spacy_7symbols_Case_ine,
__pyx_e_5spacy_7symbols_Case_ins,
__pyx_e_5spacy_7symbols_Case_loc,
__pyx_e_5spacy_7symbols_Case_lat,
__pyx_e_5spacy_7symbols_Case_nom,
__pyx_e_5spacy_7symbols_Case_par,
__pyx_e_5spacy_7symbols_Case_sub,
__pyx_e_5spacy_7symbols_Case_sup,
__pyx_e_5spacy_7symbols_Case_tem,
__pyx_e_5spacy_7symbols_Case_ter,
__pyx_e_5spacy_7symbols_Case_tra,
__pyx_e_5spacy_7symbols_Case_voc,
__pyx_e_5spacy_7symbols_Definite_two,
__pyx_e_5spacy_7symbols_Definite_def,
__pyx_e_5spacy_7symbols_Definite_red,
__pyx_e_5spacy_7symbols_Definite_cons,
__pyx_e_5spacy_7symbols_Definite_ind,
__pyx_e_5spacy_7symbols_Definite_spec,
__pyx_e_5spacy_7symbols_Degree_cmp,
__pyx_e_5spacy_7symbols_Degree_comp,
__pyx_e_5spacy_7symbols_Degree_none,
__pyx_e_5spacy_7symbols_Degree_pos,
__pyx_e_5spacy_7symbols_Degree_sup,
__pyx_e_5spacy_7symbols_Degree_abs,
__pyx_e_5spacy_7symbols_Degree_com,
__pyx_e_5spacy_7symbols_Degree_dim,
__pyx_e_5spacy_7symbols_Degree_equ,
__pyx_e_5spacy_7symbols_Evident_nfh,
__pyx_e_5spacy_7symbols_Gender_com,
__pyx_e_5spacy_7symbols_Gender_fem,
__pyx_e_5spacy_7symbols_Gender_masc,
__pyx_e_5spacy_7symbols_Gender_neut,
__pyx_e_5spacy_7symbols_Mood_cnd,
__pyx_e_5spacy_7symbols_Mood_imp,
__pyx_e_5spacy_7symbols_Mood_ind,
__pyx_e_5spacy_7symbols_Mood_n,
__pyx_e_5spacy_7symbols_Mood_pot,
__pyx_e_5spacy_7symbols_Mood_sub,
__pyx_e_5spacy_7symbols_Mood_opt,
__pyx_e_5spacy_7symbols_Mood_prp,
__pyx_e_5spacy_7symbols_Mood_adm,
__pyx_e_5spacy_7symbols_Negative_neg,
__pyx_e_5spacy_7symbols_Negative_pos,
__pyx_e_5spacy_7symbols_Negative_yes,
__pyx_e_5spacy_7symbols_Polarity_neg,
__pyx_e_5spacy_7symbols_Polarity_pos,
__pyx_e_5spacy_7symbols_Number_com,
__pyx_e_5spacy_7symbols_Number_dual,
__pyx_e_5spacy_7symbols_Number_none,
__pyx_e_5spacy_7symbols_Number_plur,
__pyx_e_5spacy_7symbols_Number_sing,
__pyx_e_5spacy_7symbols_Number_ptan,
__pyx_e_5spacy_7symbols_Number_count,
__pyx_e_5spacy_7symbols_Number_tri,
__pyx_e_5spacy_7symbols_NumType_card,
__pyx_e_5spacy_7symbols_NumType_dist,
__pyx_e_5spacy_7symbols_NumType_frac,
__pyx_e_5spacy_7symbols_NumType_gen,
__pyx_e_5spacy_7symbols_NumType_mult,
__pyx_e_5spacy_7symbols_NumType_none,
__pyx_e_5spacy_7symbols_NumType_ord,
__pyx_e_5spacy_7symbols_NumType_sets,
__pyx_e_5spacy_7symbols_Person_one,
__pyx_e_5spacy_7symbols_Person_two,
__pyx_e_5spacy_7symbols_Person_three,
__pyx_e_5spacy_7symbols_Person_none,
__pyx_e_5spacy_7symbols_Poss_yes,
__pyx_e_5spacy_7symbols_PronType_advPart,
__pyx_e_5spacy_7symbols_PronType_art,
__pyx_e_5spacy_7symbols_PronType_default,
__pyx_e_5spacy_7symbols_PronType_dem,
__pyx_e_5spacy_7symbols_PronType_ind,
__pyx_e_5spacy_7symbols_PronType_int,
__pyx_e_5spacy_7symbols_PronType_neg,
__pyx_e_5spacy_7symbols_PronType_prs,
__pyx_e_5spacy_7symbols_PronType_rcp,
__pyx_e_5spacy_7symbols_PronType_rel,
__pyx_e_5spacy_7symbols_PronType_tot,
__pyx_e_5spacy_7symbols_PronType_clit,
__pyx_e_5spacy_7symbols_PronType_exc,
__pyx_e_5spacy_7symbols_PronType_emp,
__pyx_e_5spacy_7symbols_Reflex_yes,
__pyx_e_5spacy_7symbols_Tense_fut,
__pyx_e_5spacy_7symbols_Tense_imp,
__pyx_e_5spacy_7symbols_Tense_past,
__pyx_e_5spacy_7symbols_Tense_pres,
__pyx_e_5spacy_7symbols_VerbForm_fin,
__pyx_e_5spacy_7symbols_VerbForm_ger,
__pyx_e_5spacy_7symbols_VerbForm_inf,
__pyx_e_5spacy_7symbols_VerbForm_none,
__pyx_e_5spacy_7symbols_VerbForm_part,
__pyx_e_5spacy_7symbols_VerbForm_partFut,
__pyx_e_5spacy_7symbols_VerbForm_partPast,
__pyx_e_5spacy_7symbols_VerbForm_partPres,
__pyx_e_5spacy_7symbols_VerbForm_sup,
__pyx_e_5spacy_7symbols_VerbForm_trans,
__pyx_e_5spacy_7symbols_VerbForm_conv,
__pyx_e_5spacy_7symbols_VerbForm_gdv,
__pyx_e_5spacy_7symbols_VerbForm_vnoun,
__pyx_e_5spacy_7symbols_Voice_act,
__pyx_e_5spacy_7symbols_Voice_cau,
__pyx_e_5spacy_7symbols_Voice_pass,
__pyx_e_5spacy_7symbols_Voice_mid,
__pyx_e_5spacy_7symbols_Voice_int,
__pyx_e_5spacy_7symbols_Voice_antip,
__pyx_e_5spacy_7symbols_Voice_dir,
__pyx_e_5spacy_7symbols_Voice_inv,
__pyx_e_5spacy_7symbols_Abbr_yes,
__pyx_e_5spacy_7symbols_AdpType_prep,
__pyx_e_5spacy_7symbols_AdpType_post,
__pyx_e_5spacy_7symbols_AdpType_voc,
__pyx_e_5spacy_7symbols_AdpType_comprep,
__pyx_e_5spacy_7symbols_AdpType_circ,
__pyx_e_5spacy_7symbols_AdvType_man,
__pyx_e_5spacy_7symbols_AdvType_loc,
__pyx_e_5spacy_7symbols_AdvType_tim,
__pyx_e_5spacy_7symbols_AdvType_deg,
__pyx_e_5spacy_7symbols_AdvType_cau,
__pyx_e_5spacy_7symbols_AdvType_mod,
__pyx_e_5spacy_7symbols_AdvType_sta,
__pyx_e_5spacy_7symbols_AdvType_ex,
__pyx_e_5spacy_7symbols_AdvType_adadj,
__pyx_e_5spacy_7symbols_ConjType_oper,
__pyx_e_5spacy_7symbols_ConjType_comp,
__pyx_e_5spacy_7symbols_Connegative_yes,
__pyx_e_5spacy_7symbols_Derivation_minen,
__pyx_e_5spacy_7symbols_Derivation_sti,
__pyx_e_5spacy_7symbols_Derivation_inen,
__pyx_e_5spacy_7symbols_Derivation_lainen,
__pyx_e_5spacy_7symbols_Derivation_ja,
__pyx_e_5spacy_7symbols_Derivation_ton,
__pyx_e_5spacy_7symbols_Derivation_vs,
__pyx_e_5spacy_7symbols_Derivation_ttain,
__pyx_e_5spacy_7symbols_Derivation_ttaa,
__pyx_e_5spacy_7symbols_Echo_rdp,
__pyx_e_5spacy_7symbols_Echo_ech,
__pyx_e_5spacy_7symbols_Foreign_foreign,
__pyx_e_5spacy_7symbols_Foreign_fscript,
__pyx_e_5spacy_7symbols_Foreign_tscript,
__pyx_e_5spacy_7symbols_Foreign_yes,
__pyx_e_5spacy_7symbols_Gender_dat_masc,
__pyx_e_5spacy_7symbols_Gender_dat_fem,
__pyx_e_5spacy_7symbols_Gender_erg_masc,
__pyx_e_5spacy_7symbols_Gender_erg_fem,
__pyx_e_5spacy_7symbols_Gender_psor_masc,
__pyx_e_5spacy_7symbols_Gender_psor_fem,
__pyx_e_5spacy_7symbols_Gender_psor_neut,
__pyx_e_5spacy_7symbols_Hyph_yes,
__pyx_e_5spacy_7symbols_InfForm_one,
__pyx_e_5spacy_7symbols_InfForm_two,
__pyx_e_5spacy_7symbols_InfForm_three,
__pyx_e_5spacy_7symbols_NameType_geo,
__pyx_e_5spacy_7symbols_NameType_prs,
__pyx_e_5spacy_7symbols_NameType_giv,
__pyx_e_5spacy_7symbols_NameType_sur,
__pyx_e_5spacy_7symbols_NameType_nat,
__pyx_e_5spacy_7symbols_NameType_com,
__pyx_e_5spacy_7symbols_NameType_pro,
__pyx_e_5spacy_7symbols_NameType_oth,
__pyx_e_5spacy_7symbols_NounType_com,
__pyx_e_5spacy_7symbols_NounType_prop,
__pyx_e_5spacy_7symbols_NounType_class,
__pyx_e_5spacy_7symbols_Number_abs_sing,
__pyx_e_5spacy_7symbols_Number_abs_plur,
__pyx_e_5spacy_7symbols_Number_dat_sing,
__pyx_e_5spacy_7symbols_Number_dat_plur,
__pyx_e_5spacy_7symbols_Number_erg_sing,
__pyx_e_5spacy_7symbols_Number_erg_plur,
__pyx_e_5spacy_7symbols_Number_psee_sing,
__pyx_e_5spacy_7symbols_Number_psee_plur,
__pyx_e_5spacy_7symbols_Number_psor_sing,
__pyx_e_5spacy_7symbols_Number_psor_plur,
__pyx_e_5spacy_7symbols_Number_pauc,
__pyx_e_5spacy_7symbols_Number_grpa,
__pyx_e_5spacy_7symbols_Number_grpl,
__pyx_e_5spacy_7symbols_Number_inv,
__pyx_e_5spacy_7symbols_NumForm_digit,
__pyx_e_5spacy_7symbols_NumForm_roman,
__pyx_e_5spacy_7symbols_NumForm_word,
__pyx_e_5spacy_7symbols_NumValue_one,
__pyx_e_5spacy_7symbols_NumValue_two,
__pyx_e_5spacy_7symbols_NumValue_three,
__pyx_e_5spacy_7symbols_PartForm_pres,
__pyx_e_5spacy_7symbols_PartForm_past,
__pyx_e_5spacy_7symbols_PartForm_agt,
__pyx_e_5spacy_7symbols_PartForm_neg,
__pyx_e_5spacy_7symbols_PartType_mod,
__pyx_e_5spacy_7symbols_PartType_emp,
__pyx_e_5spacy_7symbols_PartType_res,
__pyx_e_5spacy_7symbols_PartType_inf,
__pyx_e_5spacy_7symbols_PartType_vbp,
__pyx_e_5spacy_7symbols_Person_abs_one,
__pyx_e_5spacy_7symbols_Person_abs_two,
__pyx_e_5spacy_7symbols_Person_abs_three,
__pyx_e_5spacy_7symbols_Person_dat_one,
__pyx_e_5spacy_7symbols_Person_dat_two,
__pyx_e_5spacy_7symbols_Person_dat_three,
__pyx_e_5spacy_7symbols_Person_erg_one,
__pyx_e_5spacy_7symbols_Person_erg_two,
__pyx_e_5spacy_7symbols_Person_erg_three,
__pyx_e_5spacy_7symbols_Person_psor_one,
__pyx_e_5spacy_7symbols_Person_psor_two,
__pyx_e_5spacy_7symbols_Person_psor_three,
__pyx_e_5spacy_7symbols_Person_zero,
__pyx_e_5spacy_7symbols_Person_four,
__pyx_e_5spacy_7symbols_Polite_inf,
__pyx_e_5spacy_7symbols_Polite_pol,
__pyx_e_5spacy_7symbols_Polite_abs_inf,
__pyx_e_5spacy_7symbols_Polite_abs_pol,
__pyx_e_5spacy_7symbols_Polite_erg_inf,
__pyx_e_5spacy_7symbols_Polite_erg_pol,
__pyx_e_5spacy_7symbols_Polite_dat_inf,
__pyx_e_5spacy_7symbols_Polite_dat_pol,
__pyx_e_5spacy_7symbols_Polite_infm,
__pyx_e_5spacy_7symbols_Polite_form,
__pyx_e_5spacy_7symbols_Polite_form_elev,
__pyx_e_5spacy_7symbols_Polite_form_humb,
__pyx_e_5spacy_7symbols_Prefix_yes,
__pyx_e_5spacy_7symbols_PrepCase_npr,
__pyx_e_5spacy_7symbols_PrepCase_pre,
__pyx_e_5spacy_7symbols_PunctSide_ini,
__pyx_e_5spacy_7symbols_PunctSide_fin,
__pyx_e_5spacy_7symbols_PunctType_peri,
__pyx_e_5spacy_7symbols_PunctType_qest,
__pyx_e_5spacy_7symbols_PunctType_excl,
__pyx_e_5spacy_7symbols_PunctType_quot,
__pyx_e_5spacy_7symbols_PunctType_brck,
__pyx_e_5spacy_7symbols_PunctType_comm,
__pyx_e_5spacy_7symbols_PunctType_colo,
__pyx_e_5spacy_7symbols_PunctType_semi,
__pyx_e_5spacy_7symbols_PunctType_dash,
__pyx_e_5spacy_7symbols_Style_arch,
__pyx_e_5spacy_7symbols_Style_rare,
__pyx_e_5spacy_7symbols_Style_poet,
__pyx_e_5spacy_7symbols_Style_norm,
__pyx_e_5spacy_7symbols_Style_coll,
__pyx_e_5spacy_7symbols_Style_vrnc,
__pyx_e_5spacy_7symbols_Style_sing,
__pyx_e_5spacy_7symbols_Style_expr,
__pyx_e_5spacy_7symbols_Style_derg,
__pyx_e_5spacy_7symbols_Style_vulg,
__pyx_e_5spacy_7symbols_Style_yes,
__pyx_e_5spacy_7symbols_StyleVariant_styleShort,
__pyx_e_5spacy_7symbols_StyleVariant_styleBound,
__pyx_e_5spacy_7symbols_VerbType_aux,
__pyx_e_5spacy_7symbols_VerbType_cop,
__pyx_e_5spacy_7symbols_VerbType_mod,
__pyx_e_5spacy_7symbols_VerbType_light,
__pyx_e_5spacy_7symbols_PERSON,
__pyx_e_5spacy_7symbols_NORP,
__pyx_e_5spacy_7symbols_FACILITY,
__pyx_e_5spacy_7symbols_ORG,
__pyx_e_5spacy_7symbols_GPE,
__pyx_e_5spacy_7symbols_LOC,
__pyx_e_5spacy_7symbols_PRODUCT,
__pyx_e_5spacy_7symbols_EVENT,
__pyx_e_5spacy_7symbols_WORK_OF_ART,
__pyx_e_5spacy_7symbols_LANGUAGE,
__pyx_e_5spacy_7symbols_LAW,
__pyx_e_5spacy_7symbols_DATE,
__pyx_e_5spacy_7symbols_TIME,
__pyx_e_5spacy_7symbols_PERCENT,
__pyx_e_5spacy_7symbols_MONEY,
__pyx_e_5spacy_7symbols_QUANTITY,
__pyx_e_5spacy_7symbols_ORDINAL,
__pyx_e_5spacy_7symbols_CARDINAL,
__pyx_e_5spacy_7symbols_acomp,
__pyx_e_5spacy_7symbols_advcl,
__pyx_e_5spacy_7symbols_advmod,
__pyx_e_5spacy_7symbols_agent,
__pyx_e_5spacy_7symbols_amod,
__pyx_e_5spacy_7symbols_appos,
__pyx_e_5spacy_7symbols_attr,
__pyx_e_5spacy_7symbols_aux,
__pyx_e_5spacy_7symbols_auxpass,
__pyx_e_5spacy_7symbols_cc,
__pyx_e_5spacy_7symbols_ccomp,
__pyx_e_5spacy_7symbols_complm,
__pyx_e_5spacy_7symbols_conj,
__pyx_e_5spacy_7symbols_cop,
__pyx_e_5spacy_7symbols_csubj,
__pyx_e_5spacy_7symbols_csubjpass,
__pyx_e_5spacy_7symbols_dep,
__pyx_e_5spacy_7symbols_det,
__pyx_e_5spacy_7symbols_dobj,
__pyx_e_5spacy_7symbols_expl,
__pyx_e_5spacy_7symbols_hmod,
__pyx_e_5spacy_7symbols_hyph,
__pyx_e_5spacy_7symbols_infmod,
__pyx_e_5spacy_7symbols_intj,
__pyx_e_5spacy_7symbols_iobj,
__pyx_e_5spacy_7symbols_mark,
__pyx_e_5spacy_7symbols_meta,
__pyx_e_5spacy_7symbols_neg,
__pyx_e_5spacy_7symbols_nmod,
__pyx_e_5spacy_7symbols_nn,
__pyx_e_5spacy_7symbols_npadvmod,
__pyx_e_5spacy_7symbols_nsubj,
__pyx_e_5spacy_7symbols_nsubjpass,
__pyx_e_5spacy_7symbols_num,
__pyx_e_5spacy_7symbols_number,
__pyx_e_5spacy_7symbols_oprd,
__pyx_e_5spacy_7symbols_obj,
__pyx_e_5spacy_7symbols_obl,
__pyx_e_5spacy_7symbols_parataxis,
__pyx_e_5spacy_7symbols_partmod,
__pyx_e_5spacy_7symbols_pcomp,
__pyx_e_5spacy_7symbols_pobj,
__pyx_e_5spacy_7symbols_poss,
__pyx_e_5spacy_7symbols_possessive,
__pyx_e_5spacy_7symbols_preconj,
__pyx_e_5spacy_7symbols_prep,
__pyx_e_5spacy_7symbols_prt,
__pyx_e_5spacy_7symbols_punct,
__pyx_e_5spacy_7symbols_quantmod,
__pyx_e_5spacy_7symbols_relcl,
__pyx_e_5spacy_7symbols_rcmod,
__pyx_e_5spacy_7symbols_root,
__pyx_e_5spacy_7symbols_xcomp,
__pyx_e_5spacy_7symbols_acl,
__pyx_e_5spacy_7symbols_ENT_KB_ID,
__pyx_e_5spacy_7symbols_ENT_ID,
__pyx_e_5spacy_7symbols_IDX
};
/* "parts_of_speech.pxd":3
* from . cimport symbols
*
* cpdef enum univ_pos_t: # <<<<<<<<<<<<<<
* NO_TAG = 0
* ADJ = symbols.ADJ
*/
enum __pyx_t_5spacy_15parts_of_speech_univ_pos_t {
/* "parts_of_speech.pxd":5
* cpdef enum univ_pos_t:
* NO_TAG = 0
* ADJ = symbols.ADJ # <<<<<<<<<<<<<<
* ADP
* ADV
*/
__pyx_e_5spacy_15parts_of_speech_NO_TAG = 0,
__pyx_e_5spacy_15parts_of_speech_ADJ = __pyx_e_5spacy_7symbols_ADJ,
__pyx_e_5spacy_15parts_of_speech_ADP,
__pyx_e_5spacy_15parts_of_speech_ADV,
__pyx_e_5spacy_15parts_of_speech_AUX,
__pyx_e_5spacy_15parts_of_speech_CONJ,
__pyx_e_5spacy_15parts_of_speech_CCONJ,
__pyx_e_5spacy_15parts_of_speech_DET,
__pyx_e_5spacy_15parts_of_speech_INTJ,
__pyx_e_5spacy_15parts_of_speech_NOUN,
__pyx_e_5spacy_15parts_of_speech_NUM,
__pyx_e_5spacy_15parts_of_speech_PART,
__pyx_e_5spacy_15parts_of_speech_PRON,
__pyx_e_5spacy_15parts_of_speech_PROPN,
__pyx_e_5spacy_15parts_of_speech_PUNCT,
__pyx_e_5spacy_15parts_of_speech_SCONJ,
__pyx_e_5spacy_15parts_of_speech_SYM,
__pyx_e_5spacy_15parts_of_speech_VERB,
__pyx_e_5spacy_15parts_of_speech_X,
__pyx_e_5spacy_15parts_of_speech_EOL,
__pyx_e_5spacy_15parts_of_speech_SPACE
};
struct __pyx_t_5spacy_7structs_LexemeC;
struct __pyx_t_5spacy_7structs_SpanC;
struct __pyx_t_5spacy_7structs_TokenC;
struct __pyx_t_5spacy_7structs_MorphAnalysisC;
struct __pyx_t_5spacy_7structs_KBEntryC;
struct __pyx_t_5spacy_7structs_AliasC;
/* "structs.pxd":11
*
*
* cdef struct LexemeC: # <<<<<<<<<<<<<<
* flags_t flags
*
*/
struct __pyx_t_5spacy_7structs_LexemeC {
__pyx_t_5spacy_8typedefs_flags_t flags;
__pyx_t_5spacy_8typedefs_attr_t lang;
__pyx_t_5spacy_8typedefs_attr_t id;
__pyx_t_5spacy_8typedefs_attr_t length;
__pyx_t_5spacy_8typedefs_attr_t orth;
__pyx_t_5spacy_8typedefs_attr_t lower;
__pyx_t_5spacy_8typedefs_attr_t norm;
__pyx_t_5spacy_8typedefs_attr_t shape;
__pyx_t_5spacy_8typedefs_attr_t prefix;
__pyx_t_5spacy_8typedefs_attr_t suffix;
};
/* "structs.pxd":27
*
*
* cdef struct SpanC: # <<<<<<<<<<<<<<
* hash_t id
* int start
*/
struct __pyx_t_5spacy_7structs_SpanC {
__pyx_t_5spacy_8typedefs_hash_t id;
int start;
int end;
int start_char;
int end_char;
__pyx_t_5spacy_8typedefs_attr_t label;
__pyx_t_5spacy_8typedefs_attr_t kb_id;
};
/* "structs.pxd":37
*
*
* cdef struct TokenC: # <<<<<<<<<<<<<<
* const LexemeC* lex
* uint64_t morph
*/
struct __pyx_t_5spacy_7structs_TokenC {
struct __pyx_t_5spacy_7structs_LexemeC const *lex;
uint64_t morph;
enum __pyx_t_5spacy_15parts_of_speech_univ_pos_t pos;
int spacy;
__pyx_t_5spacy_8typedefs_attr_t tag;
int idx;
__pyx_t_5spacy_8typedefs_attr_t lemma;
__pyx_t_5spacy_8typedefs_attr_t norm;
int head;
__pyx_t_5spacy_8typedefs_attr_t dep;
uint32_t l_kids;
uint32_t r_kids;
uint32_t l_edge;
uint32_t r_edge;
int sent_start;
int ent_iob;
__pyx_t_5spacy_8typedefs_attr_t ent_type;
__pyx_t_5spacy_8typedefs_attr_t ent_kb_id;
__pyx_t_5spacy_8typedefs_hash_t ent_id;
};
/* "structs.pxd":61
*
*
* cdef struct MorphAnalysisC: # <<<<<<<<<<<<<<
* univ_pos_t pos
* int length
*/
struct __pyx_t_5spacy_7structs_MorphAnalysisC {
enum __pyx_t_5spacy_15parts_of_speech_univ_pos_t pos;
int length;
__pyx_t_5spacy_8typedefs_attr_t abbr;
__pyx_t_5spacy_8typedefs_attr_t adp_type;
__pyx_t_5spacy_8typedefs_attr_t adv_type;
__pyx_t_5spacy_8typedefs_attr_t animacy;
__pyx_t_5spacy_8typedefs_attr_t aspect;
__pyx_t_5spacy_8typedefs_attr_t __pyx_case;
__pyx_t_5spacy_8typedefs_attr_t conj_type;
__pyx_t_5spacy_8typedefs_attr_t connegative;
__pyx_t_5spacy_8typedefs_attr_t definite;
__pyx_t_5spacy_8typedefs_attr_t degree;
__pyx_t_5spacy_8typedefs_attr_t derivation;
__pyx_t_5spacy_8typedefs_attr_t echo;
__pyx_t_5spacy_8typedefs_attr_t foreign;
__pyx_t_5spacy_8typedefs_attr_t gender;
__pyx_t_5spacy_8typedefs_attr_t hyph;
__pyx_t_5spacy_8typedefs_attr_t inf_form;
__pyx_t_5spacy_8typedefs_attr_t mood;
__pyx_t_5spacy_8typedefs_attr_t negative;
__pyx_t_5spacy_8typedefs_attr_t number;
__pyx_t_5spacy_8typedefs_attr_t name_type;
__pyx_t_5spacy_8typedefs_attr_t noun_type;
__pyx_t_5spacy_8typedefs_attr_t num_form;
__pyx_t_5spacy_8typedefs_attr_t num_type;
__pyx_t_5spacy_8typedefs_attr_t num_value;
__pyx_t_5spacy_8typedefs_attr_t part_form;
__pyx_t_5spacy_8typedefs_attr_t part_type;
__pyx_t_5spacy_8typedefs_attr_t person;
__pyx_t_5spacy_8typedefs_attr_t polite;
__pyx_t_5spacy_8typedefs_attr_t polarity;
__pyx_t_5spacy_8typedefs_attr_t poss;
__pyx_t_5spacy_8typedefs_attr_t prefix;
__pyx_t_5spacy_8typedefs_attr_t prep_case;
__pyx_t_5spacy_8typedefs_attr_t pron_type;
__pyx_t_5spacy_8typedefs_attr_t punct_side;
__pyx_t_5spacy_8typedefs_attr_t punct_type;
__pyx_t_5spacy_8typedefs_attr_t reflex;
__pyx_t_5spacy_8typedefs_attr_t style;
__pyx_t_5spacy_8typedefs_attr_t style_variant;
__pyx_t_5spacy_8typedefs_attr_t tense;
__pyx_t_5spacy_8typedefs_attr_t typo;
__pyx_t_5spacy_8typedefs_attr_t verb_form;
__pyx_t_5spacy_8typedefs_attr_t voice;
__pyx_t_5spacy_8typedefs_attr_t verb_type;
};
/* "structs.pxd":110
*
* # Internal struct, for storage and disambiguation of entities.
* cdef struct KBEntryC: # <<<<<<<<<<<<<<
*
* # The hash of this entry's unique ID/name in the kB
*/
struct __pyx_t_5spacy_7structs_KBEntryC {
__pyx_t_5spacy_8typedefs_hash_t entity_hash;
int32_t vector_index;
int32_t feats_row;
float freq;
};
/* "structs.pxd":129
* # Each alias struct stores a list of Entry pointers with their prior probabilities
* # for this specific mention/alias.
* cdef struct AliasC: # <<<<<<<<<<<<<<
*
* # All entry candidates for this alias
*/
struct __pyx_t_5spacy_7structs_AliasC {
std::vector<int64_t> entry_indices;
std::vector<float> probs;
};
struct __pyx_t_7preshed_4maps_Cell;
struct __pyx_t_7preshed_4maps_Result;
struct __pyx_t_7preshed_4maps_MapStruct;
/* "preshed/maps.pxd":8
*
*
* cdef struct Cell: # <<<<<<<<<<<<<<
* key_t key
* void* value
*/
struct __pyx_t_7preshed_4maps_Cell {
__pyx_t_7preshed_4maps_key_t key;
void *value;
};
/* "preshed/maps.pxd":13
*
*
* cdef struct Result: # <<<<<<<<<<<<<<
* int found
* void* value
*/
struct __pyx_t_7preshed_4maps_Result {
int found;
void *value;
};
/* "preshed/maps.pxd":18
*
*
* cdef struct MapStruct: # <<<<<<<<<<<<<<
* Cell* cells
* void* value_for_empty_key
*/
struct __pyx_t_7preshed_4maps_MapStruct {
struct __pyx_t_7preshed_4maps_Cell *cells;
void *value_for_empty_key;
void *value_for_del_key;
__pyx_t_7preshed_4maps_key_t length;
__pyx_t_7preshed_4maps_key_t filled;
int is_empty_key_set;
int is_del_key_set;
};
union __pyx_t_5spacy_7strings_Utf8Str;
typedef union __pyx_t_5spacy_7strings_Utf8Str __pyx_t_5spacy_7strings_Utf8Str;
/* "strings.pxd":18
*
*
* ctypedef union Utf8Str: # <<<<<<<<<<<<<<
* unsigned char[8] s
* unsigned char* p
*/
union __pyx_t_5spacy_7strings_Utf8Str {
unsigned char s[8];
unsigned char *p;
};
union __pyx_t_5spacy_5vocab_LexemesOrTokens;
struct __pyx_t_5spacy_5vocab__Cached;
/* "vocab.pxd":16
*
*
* cdef union LexemesOrTokens: # <<<<<<<<<<<<<<
* const LexemeC* const* lexemes
* const TokenC* tokens
*/
union __pyx_t_5spacy_5vocab_LexemesOrTokens {
struct __pyx_t_5spacy_7structs_LexemeC const *const *lexemes;
struct __pyx_t_5spacy_7structs_TokenC const *tokens;
};
/* "vocab.pxd":21
*
*
* cdef struct _Cached: # <<<<<<<<<<<<<<
* LexemesOrTokens data
* bint is_lex
*/
struct __pyx_t_5spacy_5vocab__Cached {
union __pyx_t_5spacy_5vocab_LexemesOrTokens data;
int is_lex;
int length;
};
/* "attrs.pxd":4
* from . cimport symbols
*
* cdef enum attr_id_t: # <<<<<<<<<<<<<<
* NULL_ATTR
* IS_ALPHA
*/
enum __pyx_t_5spacy_5attrs_attr_id_t {
/* "attrs.pxd":94
* LANG
* ENT_KB_ID = symbols.ENT_KB_ID
* ENT_ID = symbols.ENT_ID # <<<<<<<<<<<<<<
*
* IDX
*/
__pyx_e_5spacy_5attrs_NULL_ATTR,
__pyx_e_5spacy_5attrs_IS_ALPHA,
__pyx_e_5spacy_5attrs_IS_ASCII,
__pyx_e_5spacy_5attrs_IS_DIGIT,
__pyx_e_5spacy_5attrs_IS_LOWER,
__pyx_e_5spacy_5attrs_IS_PUNCT,
__pyx_e_5spacy_5attrs_IS_SPACE,
__pyx_e_5spacy_5attrs_IS_TITLE,
__pyx_e_5spacy_5attrs_IS_UPPER,
__pyx_e_5spacy_5attrs_LIKE_URL,
__pyx_e_5spacy_5attrs_LIKE_NUM,
__pyx_e_5spacy_5attrs_LIKE_EMAIL,
__pyx_e_5spacy_5attrs_IS_STOP,
__pyx_e_5spacy_5attrs_IS_OOV_DEPRECATED,
__pyx_e_5spacy_5attrs_IS_BRACKET,
__pyx_e_5spacy_5attrs_IS_QUOTE,
__pyx_e_5spacy_5attrs_IS_LEFT_PUNCT,
__pyx_e_5spacy_5attrs_IS_RIGHT_PUNCT,
__pyx_e_5spacy_5attrs_IS_CURRENCY,
__pyx_e_5spacy_5attrs_FLAG19 = 19,
__pyx_e_5spacy_5attrs_FLAG20,
__pyx_e_5spacy_5attrs_FLAG21,
__pyx_e_5spacy_5attrs_FLAG22,
__pyx_e_5spacy_5attrs_FLAG23,
__pyx_e_5spacy_5attrs_FLAG24,
__pyx_e_5spacy_5attrs_FLAG25,
__pyx_e_5spacy_5attrs_FLAG26,
__pyx_e_5spacy_5attrs_FLAG27,
__pyx_e_5spacy_5attrs_FLAG28,
__pyx_e_5spacy_5attrs_FLAG29,
__pyx_e_5spacy_5attrs_FLAG30,
__pyx_e_5spacy_5attrs_FLAG31,
__pyx_e_5spacy_5attrs_FLAG32,
__pyx_e_5spacy_5attrs_FLAG33,
__pyx_e_5spacy_5attrs_FLAG34,
__pyx_e_5spacy_5attrs_FLAG35,
__pyx_e_5spacy_5attrs_FLAG36,
__pyx_e_5spacy_5attrs_FLAG37,
__pyx_e_5spacy_5attrs_FLAG38,
__pyx_e_5spacy_5attrs_FLAG39,
__pyx_e_5spacy_5attrs_FLAG40,
__pyx_e_5spacy_5attrs_FLAG41,
__pyx_e_5spacy_5attrs_FLAG42,
__pyx_e_5spacy_5attrs_FLAG43,
__pyx_e_5spacy_5attrs_FLAG44,
__pyx_e_5spacy_5attrs_FLAG45,
__pyx_e_5spacy_5attrs_FLAG46,
__pyx_e_5spacy_5attrs_FLAG47,
__pyx_e_5spacy_5attrs_FLAG48,
__pyx_e_5spacy_5attrs_FLAG49,
__pyx_e_5spacy_5attrs_FLAG50,
__pyx_e_5spacy_5attrs_FLAG51,
__pyx_e_5spacy_5attrs_FLAG52,
__pyx_e_5spacy_5attrs_FLAG53,
__pyx_e_5spacy_5attrs_FLAG54,
__pyx_e_5spacy_5attrs_FLAG55,
__pyx_e_5spacy_5attrs_FLAG56,
__pyx_e_5spacy_5attrs_FLAG57,
__pyx_e_5spacy_5attrs_FLAG58,
__pyx_e_5spacy_5attrs_FLAG59,
__pyx_e_5spacy_5attrs_FLAG60,
__pyx_e_5spacy_5attrs_FLAG61,
__pyx_e_5spacy_5attrs_FLAG62,
__pyx_e_5spacy_5attrs_FLAG63,
__pyx_e_5spacy_5attrs_ID,
__pyx_e_5spacy_5attrs_ORTH,
__pyx_e_5spacy_5attrs_LOWER,
__pyx_e_5spacy_5attrs_NORM,
__pyx_e_5spacy_5attrs_SHAPE,
__pyx_e_5spacy_5attrs_PREFIX,
__pyx_e_5spacy_5attrs_SUFFIX,
__pyx_e_5spacy_5attrs_LENGTH,
__pyx_e_5spacy_5attrs_CLUSTER,
__pyx_e_5spacy_5attrs_LEMMA,
__pyx_e_5spacy_5attrs_POS,
__pyx_e_5spacy_5attrs_TAG,
__pyx_e_5spacy_5attrs_DEP,
__pyx_e_5spacy_5attrs_ENT_IOB,
__pyx_e_5spacy_5attrs_ENT_TYPE,
__pyx_e_5spacy_5attrs_HEAD,
__pyx_e_5spacy_5attrs_SENT_START,
__pyx_e_5spacy_5attrs_SPACY,
__pyx_e_5spacy_5attrs_PROB,
__pyx_e_5spacy_5attrs_LANG,
__pyx_e_5spacy_5attrs_ENT_KB_ID = __pyx_e_5spacy_7symbols_ENT_KB_ID,
__pyx_e_5spacy_5attrs_ENT_ID = __pyx_e_5spacy_7symbols_ENT_ID,
__pyx_e_5spacy_5attrs_IDX,
__pyx_e_5spacy_5attrs_SENT_END
};
/* "../../../../opt/python/cp37-cp37m/lib/python3.7/site-packages/numpy/__init__.pxd":736
* ctypedef npy_longdouble longdouble_t
*
* ctypedef npy_cfloat cfloat_t # <<<<<<<<<<<<<<
* ctypedef npy_cdouble cdouble_t
* ctypedef npy_clongdouble clongdouble_t
*/
typedef npy_cfloat __pyx_t_5numpy_cfloat_t;
/* "../../../../opt/python/cp37-cp37m/lib/python3.7/site-packages/numpy/__init__.pxd":737
*
* ctypedef npy_cfloat cfloat_t
* ctypedef npy_cdouble cdouble_t # <<<<<<<<<<<<<<
* ctypedef npy_clongdouble clongdouble_t
*
*/
typedef npy_cdouble __pyx_t_5numpy_cdouble_t;
/* "../../../../opt/python/cp37-cp37m/lib/python3.7/site-packages/numpy/__init__.pxd":738
* ctypedef npy_cfloat cfloat_t
* ctypedef npy_cdouble cdouble_t
* ctypedef npy_clongdouble clongdouble_t # <<<<<<<<<<<<<<
*
* ctypedef npy_cdouble complex_t
*/
typedef npy_clongdouble __pyx_t_5numpy_clongdouble_t;
/* "../../../../opt/python/cp37-cp37m/lib/python3.7/site-packages/numpy/__init__.pxd":740
* ctypedef npy_clongdouble clongdouble_t
*
* ctypedef npy_cdouble complex_t # <<<<<<<<<<<<<<
*
* cdef inline object PyArray_MultiIterNew1(a):
*/
typedef npy_cdouble __pyx_t_5numpy_complex_t;
struct __pyx_t_5spacy_6syntax_6_state_RingBufferC;
struct __pyx_t_5spacy_6syntax_6_state_StateC;
/* "_state.pxd":20
* return Lexeme.c_check_flag(token.lex, IS_SPACE)
*
* cdef struct RingBufferC: # <<<<<<<<<<<<<<
* int[8] data
* int i
*/
struct __pyx_t_5spacy_6syntax_6_state_RingBufferC {
int data[8];
int i;
int __pyx_default;
};
struct __pyx_t_5spacy_6syntax_6_state_StateC {
/* "_state.pxd":38
*
*
* cdef cppclass StateC: # <<<<<<<<<<<<<<
* int* _stack
* int* _buffer
*/
int *_stack;
int *_buffer;
int *shifted;
struct __pyx_t_5spacy_7structs_TokenC *_sent;
struct __pyx_t_5spacy_7structs_SpanC *_ents;
struct __pyx_t_5spacy_7structs_TokenC _empty_token;
struct __pyx_t_5spacy_6syntax_6_state_RingBufferC _hist;
int length;
int offset;
int _s_i;
int _b_i;
int _e_i;
int _break;
void __pyx_f___init__StateC(struct __pyx_t_5spacy_7structs_TokenC const *, int);
void __pyx_f___dealloc__StateC(void);
virtual void set_context_tokens(int *, int);
virtual int S(int) const;
virtual int B(int) const;
virtual struct __pyx_t_5spacy_7structs_TokenC const *S_(int) const;
virtual struct __pyx_t_5spacy_7structs_TokenC const *B_(int) const;
virtual struct __pyx_t_5spacy_7structs_TokenC const *H_(int) const;
virtual struct __pyx_t_5spacy_7structs_TokenC const *E_(int) const;
virtual struct __pyx_t_5spacy_7structs_TokenC const *L_(int, int) const;
virtual struct __pyx_t_5spacy_7structs_TokenC const *R_(int, int) const;
virtual struct __pyx_t_5spacy_7structs_TokenC const *safe_get(int) const;
virtual int H(int) const;
virtual int E(int) const;
virtual int L(int, int) const;
virtual int R(int, int) const;
virtual int empty(void) const;
virtual int eol(void) const;
virtual int at_break(void) const;
virtual int is_final(void) const;
virtual int has_head(int) const;
virtual int n_L(int) const;
virtual int n_R(int) const;
virtual int stack_is_connected(void) const;
virtual int entity_is_open(void) const;
virtual int stack_depth(void) const;
virtual int buffer_length(void) const;
virtual uint64_t hash(void) const;
virtual void push_hist(int);
virtual int get_hist(int);
virtual void push(void);
virtual void pop(void);
virtual void force_final(void);
virtual void unshift(void);
virtual void add_arc(int, int, __pyx_t_5spacy_8typedefs_attr_t);
virtual void del_arc(int, int);
virtual void open_ent(__pyx_t_5spacy_8typedefs_attr_t);
virtual void close_ent(void);
virtual void set_ent_tag(int, int, __pyx_t_5spacy_8typedefs_attr_t);
virtual void set_break(int);
virtual void clone(__pyx_t_5spacy_6syntax_6_state_StateC const *);
virtual void fast_forward(void);
__pyx_t_5spacy_6syntax_6_state_StateC(struct __pyx_t_5spacy_7structs_TokenC const *__pyx_v_sent, int __pyx_v_length) {
__pyx_f___init__StateC(__pyx_v_sent, __pyx_v_length);
}
virtual ~__pyx_t_5spacy_6syntax_6_state_StateC() {
__pyx_f___dealloc__StateC();
}
};
struct __pyx_t_5spacy_4gold_GoldParseC;
/* "gold.pxd":8
*
*
* cdef struct GoldParseC: # <<<<<<<<<<<<<<
* int* tags
* int* heads
*/
struct __pyx_t_5spacy_4gold_GoldParseC {
int *tags;
int *heads;
int *has_dep;
int *sent_start;
__pyx_t_5spacy_8typedefs_attr_t *labels;
int **brackets;
struct __pyx_t_5spacy_6syntax_17transition_system_Transition *ner;
};
struct __pyx_t_5spacy_6syntax_17transition_system_Transition;
/* "transition_system.pxd":14
*
*
* cdef struct Transition: # <<<<<<<<<<<<<<
* int clas
* int move
*/
struct __pyx_t_5spacy_6syntax_17transition_system_Transition {
int clas;
int move;
__pyx_t_5spacy_8typedefs_attr_t label;
__pyx_t_5thinc_8typedefs_weight_t score;
int (*is_valid)(__pyx_t_5spacy_6syntax_6_state_StateC const *, __pyx_t_5spacy_8typedefs_attr_t);
__pyx_t_5thinc_8typedefs_weight_t (*get_cost)(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *, struct __pyx_t_5spacy_4gold_GoldParseC const *, __pyx_t_5spacy_8typedefs_attr_t);
int (*__pyx_do)(__pyx_t_5spacy_6syntax_6_state_StateC *, __pyx_t_5spacy_8typedefs_attr_t);
};
/* "transition_system.pxd":26
*
*
* ctypedef weight_t (*get_cost_func_t)(StateClass state, const GoldParseC* gold, # <<<<<<<<<<<<<<
* attr_tlabel) nogil
* ctypedef weight_t (*move_cost_func_t)(StateClass state, const GoldParseC* gold) nogil
*/
typedef __pyx_t_5thinc_8typedefs_weight_t (*__pyx_t_5spacy_6syntax_17transition_system_get_cost_func_t)(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *, struct __pyx_t_5spacy_4gold_GoldParseC const *, PyObject *);
/* "transition_system.pxd":28
* ctypedef weight_t (*get_cost_func_t)(StateClass state, const GoldParseC* gold,
* attr_tlabel) nogil
* ctypedef weight_t (*move_cost_func_t)(StateClass state, const GoldParseC* gold) nogil # <<<<<<<<<<<<<<
* ctypedef weight_t (*label_cost_func_t)(StateClass state, const GoldParseC*
* gold, attr_t label) nogil
*/
typedef __pyx_t_5thinc_8typedefs_weight_t (*__pyx_t_5spacy_6syntax_17transition_system_move_cost_func_t)(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *, struct __pyx_t_5spacy_4gold_GoldParseC const *);
/* "transition_system.pxd":29
* attr_tlabel) nogil
* ctypedef weight_t (*move_cost_func_t)(StateClass state, const GoldParseC* gold) nogil
* ctypedef weight_t (*label_cost_func_t)(StateClass state, const GoldParseC* # <<<<<<<<<<<<<<
* gold, attr_t label) nogil
*
*/
typedef __pyx_t_5thinc_8typedefs_weight_t (*__pyx_t_5spacy_6syntax_17transition_system_label_cost_func_t)(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *, struct __pyx_t_5spacy_4gold_GoldParseC const *, __pyx_t_5spacy_8typedefs_attr_t);
/* "transition_system.pxd":32
* gold, attr_t label) nogil
*
* ctypedef int (*do_func_t)(StateC* state, attr_t label) nogil # <<<<<<<<<<<<<<
*
* ctypedef void* (*init_state_t)(Pool mem, int length, void* tokens) except NULL
*/
typedef int (*__pyx_t_5spacy_6syntax_17transition_system_do_func_t)(__pyx_t_5spacy_6syntax_6_state_StateC *, __pyx_t_5spacy_8typedefs_attr_t);
/* "transition_system.pxd":34
* ctypedef int (*do_func_t)(StateC* state, attr_t label) nogil
*
* ctypedef void* (*init_state_t)(Pool mem, int length, void* tokens) except NULL # <<<<<<<<<<<<<<
*
* ctypedef int (*del_state_t)(Pool mem, void* state, void* extra_args) except -1
*/
typedef void *(*__pyx_t_5spacy_6syntax_17transition_system_init_state_t)(struct __pyx_obj_5cymem_5cymem_Pool *, int, void *);
/* "transition_system.pxd":36
* ctypedef void* (*init_state_t)(Pool mem, int length, void* tokens) except NULL
*
* ctypedef int (*del_state_t)(Pool mem, void* state, void* extra_args) except -1 # <<<<<<<<<<<<<<
*
* cdef class TransitionSystem:
*/
typedef int (*__pyx_t_5spacy_6syntax_17transition_system_del_state_t)(struct __pyx_obj_5cymem_5cymem_Pool *, void *, void *);
struct __pyx_t_5thinc_5extra_6search__State;
/* "thinc/extra/search.pxd":12
*
*
* ctypedef pair[weight_t, size_t] Entry # <<<<<<<<<<<<<<
* ctypedef priority_queue[Entry] Queue
*
*/
typedef std::pair<__pyx_t_5thinc_8typedefs_weight_t,size_t> __pyx_t_5thinc_5extra_6search_Entry;
/* "thinc/extra/search.pxd":13
*
* ctypedef pair[weight_t, size_t] Entry
* ctypedef priority_queue[Entry] Queue # <<<<<<<<<<<<<<
*
*
*/
typedef std::priority_queue<__pyx_t_5thinc_5extra_6search_Entry> __pyx_t_5thinc_5extra_6search_Queue;
/* "thinc/extra/search.pxd":16
*
*
* ctypedef int (*trans_func_t)(void* dest, void* src, class_t clas, void* x) except -1 # <<<<<<<<<<<<<<
*
* ctypedef void* (*init_func_t)(Pool mem, int n, void* extra_args) except NULL
*/
typedef int (*__pyx_t_5thinc_5extra_6search_trans_func_t)(void *, void *, __pyx_t_5thinc_8typedefs_class_t, void *);
/* "thinc/extra/search.pxd":18
* ctypedef int (*trans_func_t)(void* dest, void* src, class_t clas, void* x) except -1
*
* ctypedef void* (*init_func_t)(Pool mem, int n, void* extra_args) except NULL # <<<<<<<<<<<<<<
*
* ctypedef int (*del_func_t)(Pool mem, void* state, void* extra_args) except -1
*/
typedef void *(*__pyx_t_5thinc_5extra_6search_init_func_t)(struct __pyx_obj_5cymem_5cymem_Pool *, int, void *);
/* "thinc/extra/search.pxd":20
* ctypedef void* (*init_func_t)(Pool mem, int n, void* extra_args) except NULL
*
* ctypedef int (*del_func_t)(Pool mem, void* state, void* extra_args) except -1 # <<<<<<<<<<<<<<
*
* ctypedef int (*finish_func_t)(void* state, void* extra_args) except -1
*/
typedef int (*__pyx_t_5thinc_5extra_6search_del_func_t)(struct __pyx_obj_5cymem_5cymem_Pool *, void *, void *);
/* "thinc/extra/search.pxd":22
* ctypedef int (*del_func_t)(Pool mem, void* state, void* extra_args) except -1
*
* ctypedef int (*finish_func_t)(void* state, void* extra_args) except -1 # <<<<<<<<<<<<<<
*
* ctypedef hash_t (*hash_func_t)(void* state, void* x) except 0
*/
typedef int (*__pyx_t_5thinc_5extra_6search_finish_func_t)(void *, void *);
/* "thinc/extra/search.pxd":24
* ctypedef int (*finish_func_t)(void* state, void* extra_args) except -1
*
* ctypedef hash_t (*hash_func_t)(void* state, void* x) except 0 # <<<<<<<<<<<<<<
*
*
*/
typedef __pyx_t_5thinc_8typedefs_hash_t (*__pyx_t_5thinc_5extra_6search_hash_func_t)(void *, void *);
/* "thinc/extra/search.pxd":27
*
*
* cdef struct _State: # <<<<<<<<<<<<<<
* void* content
* class_t* hist
*/
struct __pyx_t_5thinc_5extra_6search__State {
void *content;
__pyx_t_5thinc_8typedefs_class_t *hist;
__pyx_t_5thinc_8typedefs_weight_t score;
__pyx_t_5thinc_8typedefs_weight_t loss;
int i;
int t;
int is_done;
};
/* "tokens/doc.pxd":14
*
*
* ctypedef const LexemeC* const_Lexeme_ptr # <<<<<<<<<<<<<<
* ctypedef const TokenC* const_TokenC_ptr
*
*/
typedef struct __pyx_t_5spacy_7structs_LexemeC const *__pyx_t_5spacy_6tokens_3doc_const_Lexeme_ptr;
/* "tokens/doc.pxd":15
*
* ctypedef const LexemeC* const_Lexeme_ptr
* ctypedef const TokenC* const_TokenC_ptr # <<<<<<<<<<<<<<
*
* ctypedef fused LexemeOrToken:
*/
typedef struct __pyx_t_5spacy_7structs_TokenC const *__pyx_t_5spacy_6tokens_3doc_const_TokenC_ptr;
/* "spacy/syntax/arc_eager.pyx":35
* # Break transition from here
* # http://www.aclweb.org/anthology/P13-1074
* cdef enum: # <<<<<<<<<<<<<<
* SHIFT
* REDUCE
*/
enum {
__pyx_e_5spacy_6syntax_9arc_eager_SHIFT,
__pyx_e_5spacy_6syntax_9arc_eager_REDUCE,
__pyx_e_5spacy_6syntax_9arc_eager_LEFT,
__pyx_e_5spacy_6syntax_9arc_eager_RIGHT,
__pyx_e_5spacy_6syntax_9arc_eager_BREAK,
__pyx_e_5spacy_6syntax_9arc_eager_N_MOVES
};
/* "cymem/cymem.pxd":4
* ctypedef void (*free_t)(void *p)
*
* cdef class PyMalloc: # <<<<<<<<<<<<<<
* cdef malloc_t malloc
* cdef void _set(self, malloc_t malloc)
*/
struct __pyx_obj_5cymem_5cymem_PyMalloc {
PyObject_HEAD
struct __pyx_vtabstruct_5cymem_5cymem_PyMalloc *__pyx_vtab;
__pyx_t_5cymem_5cymem_malloc_t malloc;
};
/* "cymem/cymem.pxd":10
* cdef PyMalloc WrapMalloc(malloc_t malloc)
*
* cdef class PyFree: # <<<<<<<<<<<<<<
* cdef free_t free
* cdef void _set(self, free_t free)
*/
struct __pyx_obj_5cymem_5cymem_PyFree {
PyObject_HEAD
struct __pyx_vtabstruct_5cymem_5cymem_PyFree *__pyx_vtab;
__pyx_t_5cymem_5cymem_free_t free;
};
/* "cymem/cymem.pxd":16
* cdef PyFree WrapFree(free_t free)
*
* cdef class Pool: # <<<<<<<<<<<<<<
* cdef readonly size_t size
* cdef readonly dict addresses
*/
struct __pyx_obj_5cymem_5cymem_Pool {
PyObject_HEAD
struct __pyx_vtabstruct_5cymem_5cymem_Pool *__pyx_vtab;
size_t size;
PyObject *addresses;
PyObject *refs;
struct __pyx_obj_5cymem_5cymem_PyMalloc *pymalloc;
struct __pyx_obj_5cymem_5cymem_PyFree *pyfree;
};
/* "cymem/cymem.pxd":28
*
*
* cdef class Address: # <<<<<<<<<<<<<<
* cdef void* ptr
* cdef readonly PyMalloc pymalloc
*/
struct __pyx_obj_5cymem_5cymem_Address {
PyObject_HEAD
void *ptr;
struct __pyx_obj_5cymem_5cymem_PyMalloc *pymalloc;
struct __pyx_obj_5cymem_5cymem_PyFree *pyfree;
};
/* "preshed/maps.pxd":45
*
*
* cdef class PreshMap: # <<<<<<<<<<<<<<
* cdef MapStruct* c_map
* cdef Pool mem
*/
struct __pyx_obj_7preshed_4maps_PreshMap {
PyObject_HEAD
struct __pyx_vtabstruct_7preshed_4maps_PreshMap *__pyx_vtab;
struct __pyx_t_7preshed_4maps_MapStruct *c_map;
struct __pyx_obj_5cymem_5cymem_Pool *mem;
};
/* "preshed/maps.pxd":53
*
*
* cdef class PreshMapArray: # <<<<<<<<<<<<<<
* cdef Pool mem
* cdef MapStruct* maps
*/
struct __pyx_obj_7preshed_4maps_PreshMapArray {
PyObject_HEAD
struct __pyx_vtabstruct_7preshed_4maps_PreshMapArray *__pyx_vtab;
struct __pyx_obj_5cymem_5cymem_Pool *mem;
struct __pyx_t_7preshed_4maps_MapStruct *maps;
size_t length;
};
/* "strings.pxd":23
*
*
* cdef class StringStore: # <<<<<<<<<<<<<<
* cdef Pool mem
*
*/
struct __pyx_obj_5spacy_7strings_StringStore {
PyObject_HEAD
struct __pyx_vtabstruct_5spacy_7strings_StringStore *__pyx_vtab;
struct __pyx_obj_5cymem_5cymem_Pool *mem;
std::vector<__pyx_t_5spacy_8typedefs_hash_t> keys;
std::set<__pyx_t_5spacy_8typedefs_hash_t> hits;
struct __pyx_obj_7preshed_4maps_PreshMap *_map;
};
/* "morphology.pxd":13
* from . cimport symbols
*
* cdef class Morphology: # <<<<<<<<<<<<<<
* cdef readonly Pool mem
* cdef readonly StringStore strings
*/
struct __pyx_obj_5spacy_10morphology_Morphology {
PyObject_HEAD
struct __pyx_vtabstruct_5spacy_10morphology_Morphology *__pyx_vtab;
struct __pyx_obj_5cymem_5cymem_Pool *mem;
struct __pyx_obj_5spacy_7strings_StringStore *strings;
struct __pyx_obj_7preshed_4maps_PreshMap *tags;
PyObject *lemmatizer;
PyObject *tag_map;
PyObject *tag_names;
PyObject *reverse_index;
PyObject *exc;
PyObject *_feat_map;
struct __pyx_obj_7preshed_4maps_PreshMapArray *_cache;
int n_tags;
};
/* "vocab.pxd":27
*
*
* cdef class Vocab: # <<<<<<<<<<<<<<
* cdef Pool mem
* cpdef readonly StringStore strings
*/
struct __pyx_obj_5spacy_5vocab_Vocab {
PyObject_HEAD
struct __pyx_vtabstruct_5spacy_5vocab_Vocab *__pyx_vtab;
struct __pyx_obj_5cymem_5cymem_Pool *mem;
struct __pyx_obj_5spacy_7strings_StringStore *strings;
struct __pyx_obj_5spacy_10morphology_Morphology *morphology;
PyObject *vectors;
PyObject *lookups;
PyObject *lookups_extra;
int length;
PyObject *data_dir;
PyObject *lex_attr_getters;
PyObject *cfg;
struct __pyx_obj_7preshed_4maps_PreshMap *_by_orth;
};
/* "lexeme.pxd":15
* cdef attr_t OOV_RANK
*
* cdef class Lexeme: # <<<<<<<<<<<<<<
* cdef LexemeC* c
* cdef readonly Vocab vocab
*/
struct __pyx_obj_5spacy_6lexeme_Lexeme {
PyObject_HEAD
struct __pyx_vtabstruct_5spacy_6lexeme_Lexeme *__pyx_vtab;
struct __pyx_t_5spacy_7structs_LexemeC *c;
struct __pyx_obj_5spacy_5vocab_Vocab *vocab;
__pyx_t_5spacy_8typedefs_attr_t orth;
};
/* "stateclass.pxd":13
*
*
* cdef class StateClass: # <<<<<<<<<<<<<<
* cdef Pool mem
* cdef StateC* c
*/
struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass {
PyObject_HEAD
struct __pyx_vtabstruct_5spacy_6syntax_10stateclass_StateClass *__pyx_vtab;
struct __pyx_obj_5cymem_5cymem_Pool *mem;
__pyx_t_5spacy_6syntax_6_state_StateC *c;
int _borrowed;
};
/* "gold.pxd":18
*
*
* cdef class GoldParse: # <<<<<<<<<<<<<<
* cdef Pool mem
*
*/
struct __pyx_obj_5spacy_4gold_GoldParse {
PyObject_HEAD
struct __pyx_obj_5cymem_5cymem_Pool *mem;
struct __pyx_t_5spacy_4gold_GoldParseC c;
int length;
int loss;
PyObject *words;
PyObject *tags;
PyObject *morphology;
PyObject *heads;
PyObject *labels;
PyObject *orths;
PyObject *ner;
PyObject *ents;
PyObject *brackets;
PyObject *cats;
PyObject *links;
PyObject *cand_to_gold;
PyObject *gold_to_cand;
PyObject *orig_annot;
};
/* "transition_system.pxd":38
* ctypedef int (*del_state_t)(Pool mem, void* state, void* extra_args) except -1
*
* cdef class TransitionSystem: # <<<<<<<<<<<<<<
* cdef Pool mem
* cdef StringStore strings
*/
struct __pyx_obj_5spacy_6syntax_17transition_system_TransitionSystem {
PyObject_HEAD
struct __pyx_vtabstruct_5spacy_6syntax_17transition_system_TransitionSystem *__pyx_vtab;
struct __pyx_obj_5cymem_5cymem_Pool *mem;
struct __pyx_obj_5spacy_7strings_StringStore *strings;
struct __pyx_t_5spacy_6syntax_17transition_system_Transition *c;
int n_moves;
int _size;
__pyx_t_5spacy_8typedefs_attr_t root_label;
PyObject *freqs;
__pyx_t_5spacy_6syntax_17transition_system_init_state_t init_beam_state;
__pyx_t_5spacy_6syntax_17transition_system_del_state_t del_beam_state;
PyObject *labels;
};
/* "thinc/extra/search.pxd":37
*
*
* cdef class Beam: # <<<<<<<<<<<<<<
* cdef Pool mem
* cdef class_t nr_class
*/
struct __pyx_obj_5thinc_5extra_6search_Beam {
PyObject_HEAD
struct __pyx_vtabstruct_5thinc_5extra_6search_Beam *__pyx_vtab;
struct __pyx_obj_5cymem_5cymem_Pool *mem;
__pyx_t_5thinc_8typedefs_class_t nr_class;
__pyx_t_5thinc_8typedefs_class_t width;
__pyx_t_5thinc_8typedefs_class_t size;
__pyx_t_5thinc_8typedefs_weight_t min_density;
int t;
int is_done;
PyObject *histories;
PyObject *_parent_histories;
__pyx_t_5thinc_8typedefs_weight_t **scores;
int **is_valid;
__pyx_t_5thinc_8typedefs_weight_t **costs;
struct __pyx_t_5thinc_5extra_6search__State *_parents;
struct __pyx_t_5thinc_5extra_6search__State *_states;
__pyx_t_5thinc_5extra_6search_del_func_t del_func;
};
/* "thinc/extra/search.pxd":75
*
*
* cdef class MaxViolation: # <<<<<<<<<<<<<<
* cdef Pool mem
* cdef weight_t cost
*/
struct __pyx_obj_5thinc_5extra_6search_MaxViolation {
PyObject_HEAD
struct __pyx_vtabstruct_5thinc_5extra_6search_MaxViolation *__pyx_vtab;
struct __pyx_obj_5cymem_5cymem_Pool *mem;
__pyx_t_5thinc_8typedefs_weight_t cost;
__pyx_t_5thinc_8typedefs_weight_t delta;
__pyx_t_5thinc_8typedefs_weight_t p_score;
__pyx_t_5thinc_8typedefs_weight_t g_score;
double Z;
double gZ;
__pyx_t_5thinc_8typedefs_class_t n;
PyObject *p_hist;
PyObject *g_hist;
PyObject *p_probs;
PyObject *g_probs;
};
/* "tokens/doc.pxd":39
* cdef int [:,:] _get_lca_matrix(Doc, int start, int end)
*
* cdef class Doc: # <<<<<<<<<<<<<<
* cdef readonly Pool mem
* cdef readonly Vocab vocab
*/
struct __pyx_obj_5spacy_6tokens_3doc_Doc {
PyObject_HEAD
struct __pyx_vtabstruct_5spacy_6tokens_3doc_Doc *__pyx_vtab;
struct __pyx_obj_5cymem_5cymem_Pool *mem;
struct __pyx_obj_5spacy_5vocab_Vocab *vocab;
PyObject *_vector;
PyObject *_vector_norm;
PyObject *tensor;
PyObject *cats;
PyObject *user_data;
struct __pyx_t_5spacy_7structs_TokenC *c;
int is_tagged;
int is_parsed;
float sentiment;
PyObject *user_hooks;
PyObject *user_token_hooks;
PyObject *user_span_hooks;
PyObject *_py_tokens;
int length;
int max_length;
PyObject *noun_chunks_iterator;
PyObject *__weakref__;
};
/* "spacy/syntax/arc_eager.pxd":12
*
*
* cdef class ArcEager(TransitionSystem): # <<<<<<<<<<<<<<
* pass
*
*/
struct __pyx_obj_5spacy_6syntax_9arc_eager_ArcEager {
struct __pyx_obj_5spacy_6syntax_17transition_system_TransitionSystem __pyx_base;
};
/* "spacy/syntax/arc_eager.pyx":122
* return gold.heads[word] == word or not gold.has_dep[word]
*
* cdef class Shift: # <<<<<<<<<<<<<<
* @staticmethod
* cdef bint is_valid(const StateC* st, attr_t label) nogil:
*/
struct __pyx_obj_5spacy_6syntax_9arc_eager_Shift {
PyObject_HEAD
struct __pyx_vtabstruct_5spacy_6syntax_9arc_eager_Shift *__pyx_vtab;
};
/* "spacy/syntax/arc_eager.pyx":146
*
*
* cdef class Reduce: # <<<<<<<<<<<<<<
* @staticmethod
* cdef bint is_valid(const StateC* st, attr_t label) nogil:
*/
struct __pyx_obj_5spacy_6syntax_9arc_eager_Reduce {
PyObject_HEAD
struct __pyx_vtabstruct_5spacy_6syntax_9arc_eager_Reduce *__pyx_vtab;
};
/* "spacy/syntax/arc_eager.pyx":183
*
*
* cdef class LeftArc: # <<<<<<<<<<<<<<
* @staticmethod
* cdef bint is_valid(const StateC* st, attr_t label) nogil:
*/
struct __pyx_obj_5spacy_6syntax_9arc_eager_LeftArc {
PyObject_HEAD
struct __pyx_vtabstruct_5spacy_6syntax_9arc_eager_LeftArc *__pyx_vtab;
};
/* "spacy/syntax/arc_eager.pyx":220
*
*
* cdef class RightArc: # <<<<<<<<<<<<<<
* @staticmethod
* cdef bint is_valid(const StateC* st, attr_t label) nogil:
*/
struct __pyx_obj_5spacy_6syntax_9arc_eager_RightArc {
PyObject_HEAD
struct __pyx_vtabstruct_5spacy_6syntax_9arc_eager_RightArc *__pyx_vtab;
};
/* "spacy/syntax/arc_eager.pyx":253
*
*
* cdef class Break: # <<<<<<<<<<<<<<
* @staticmethod
* cdef bint is_valid(const StateC* st, attr_t label) nogil:
*/
struct __pyx_obj_5spacy_6syntax_9arc_eager_Break {
PyObject_HEAD
struct __pyx_vtabstruct_5spacy_6syntax_9arc_eager_Break *__pyx_vtab;
};
/* "View.MemoryView":105
*
* @cname("__pyx_array")
* cdef class array: # <<<<<<<<<<<<<<
*
* cdef:
*/
struct __pyx_array_obj {
PyObject_HEAD
struct __pyx_vtabstruct_array *__pyx_vtab;
char *data;
Py_ssize_t len;
char *format;
int ndim;
Py_ssize_t *_shape;
Py_ssize_t *_strides;
Py_ssize_t itemsize;
PyObject *mode;
PyObject *_format;
void (*callback_free_data)(void *);
int free_data;
int dtype_is_object;
};
/* "View.MemoryView":279
*
* @cname('__pyx_MemviewEnum')
* cdef class Enum(object): # <<<<<<<<<<<<<<
* cdef object name
* def __init__(self, name):
*/
struct __pyx_MemviewEnum_obj {
PyObject_HEAD
PyObject *name;
};
/* "View.MemoryView":330
*
* @cname('__pyx_memoryview')
* cdef class memoryview(object): # <<<<<<<<<<<<<<
*
* cdef object obj
*/
struct __pyx_memoryview_obj {
PyObject_HEAD
struct __pyx_vtabstruct_memoryview *__pyx_vtab;
PyObject *obj;
PyObject *_size;
PyObject *_array_interface;
PyThread_type_lock lock;
__pyx_atomic_int acquisition_count[2];
__pyx_atomic_int *acquisition_count_aligned_p;
Py_buffer view;
int flags;
int dtype_is_object;
__Pyx_TypeInfo *typeinfo;
};
/* "View.MemoryView":965
*
* @cname('__pyx_memoryviewslice')
* cdef class _memoryviewslice(memoryview): # <<<<<<<<<<<<<<
* "Internal class for passing memoryview slices to Python"
*
*/
struct __pyx_memoryviewslice_obj {
struct __pyx_memoryview_obj __pyx_base;
__Pyx_memviewslice from_slice;
PyObject *from_object;
PyObject *(*to_object_func)(char *);
int (*to_dtype_func)(char *, PyObject *);
};
/* "cymem/cymem.pxd":4
* ctypedef void (*free_t)(void *p)
*
* cdef class PyMalloc: # <<<<<<<<<<<<<<
* cdef malloc_t malloc
* cdef void _set(self, malloc_t malloc)
*/
struct __pyx_vtabstruct_5cymem_5cymem_PyMalloc {
void (*_set)(struct __pyx_obj_5cymem_5cymem_PyMalloc *, __pyx_t_5cymem_5cymem_malloc_t);
};
static struct __pyx_vtabstruct_5cymem_5cymem_PyMalloc *__pyx_vtabptr_5cymem_5cymem_PyMalloc;
/* "cymem/cymem.pxd":10
* cdef PyMalloc WrapMalloc(malloc_t malloc)
*
* cdef class PyFree: # <<<<<<<<<<<<<<
* cdef free_t free
* cdef void _set(self, free_t free)
*/
struct __pyx_vtabstruct_5cymem_5cymem_PyFree {
void (*_set)(struct __pyx_obj_5cymem_5cymem_PyFree *, __pyx_t_5cymem_5cymem_free_t);
};
static struct __pyx_vtabstruct_5cymem_5cymem_PyFree *__pyx_vtabptr_5cymem_5cymem_PyFree;
/* "cymem/cymem.pxd":16
* cdef PyFree WrapFree(free_t free)
*
* cdef class Pool: # <<<<<<<<<<<<<<
* cdef readonly size_t size
* cdef readonly dict addresses
*/
struct __pyx_vtabstruct_5cymem_5cymem_Pool {
void *(*alloc)(struct __pyx_obj_5cymem_5cymem_Pool *, size_t, size_t);
void (*free)(struct __pyx_obj_5cymem_5cymem_Pool *, void *);
void *(*realloc)(struct __pyx_obj_5cymem_5cymem_Pool *, void *, size_t);
};
static struct __pyx_vtabstruct_5cymem_5cymem_Pool *__pyx_vtabptr_5cymem_5cymem_Pool;
/* "preshed/maps.pxd":45
*
*
* cdef class PreshMap: # <<<<<<<<<<<<<<
* cdef MapStruct* c_map
* cdef Pool mem
*/
struct __pyx_vtabstruct_7preshed_4maps_PreshMap {
void *(*get)(struct __pyx_obj_7preshed_4maps_PreshMap *, __pyx_t_7preshed_4maps_key_t);
void (*set)(struct __pyx_obj_7preshed_4maps_PreshMap *, __pyx_t_7preshed_4maps_key_t, void *);
};
static struct __pyx_vtabstruct_7preshed_4maps_PreshMap *__pyx_vtabptr_7preshed_4maps_PreshMap;
/* "preshed/maps.pxd":53
*
*
* cdef class PreshMapArray: # <<<<<<<<<<<<<<
* cdef Pool mem
* cdef MapStruct* maps
*/
struct __pyx_vtabstruct_7preshed_4maps_PreshMapArray {
void *(*get)(struct __pyx_obj_7preshed_4maps_PreshMapArray *, size_t, __pyx_t_7preshed_4maps_key_t);
void (*set)(struct __pyx_obj_7preshed_4maps_PreshMapArray *, size_t, __pyx_t_7preshed_4maps_key_t, void *);
};
static struct __pyx_vtabstruct_7preshed_4maps_PreshMapArray *__pyx_vtabptr_7preshed_4maps_PreshMapArray;
/* "strings.pxd":23
*
*
* cdef class StringStore: # <<<<<<<<<<<<<<
* cdef Pool mem
*
*/
struct __pyx_vtabstruct_5spacy_7strings_StringStore {
__pyx_t_5spacy_7strings_Utf8Str const *(*intern_unicode)(struct __pyx_obj_5spacy_7strings_StringStore *, PyObject *);
__pyx_t_5spacy_7strings_Utf8Str const *(*_intern_utf8)(struct __pyx_obj_5spacy_7strings_StringStore *, char *, int);
};
static struct __pyx_vtabstruct_5spacy_7strings_StringStore *__pyx_vtabptr_5spacy_7strings_StringStore;
/* "morphology.pxd":13
* from . cimport symbols
*
* cdef class Morphology: # <<<<<<<<<<<<<<
* cdef readonly Pool mem
* cdef readonly StringStore strings
*/
struct __pyx_vtabstruct_5spacy_10morphology_Morphology {
PyObject *(*update)(struct __pyx_obj_5spacy_10morphology_Morphology *, __pyx_t_5spacy_8typedefs_hash_t, PyObject *, int __pyx_skip_dispatch);
__pyx_t_5spacy_8typedefs_hash_t (*insert)(struct __pyx_obj_5spacy_10morphology_Morphology *, struct __pyx_t_5spacy_7structs_MorphAnalysisC);
int (*assign_untagged)(struct __pyx_obj_5spacy_10morphology_Morphology *, struct __pyx_t_5spacy_7structs_TokenC *);
int (*assign_tag)(struct __pyx_obj_5spacy_10morphology_Morphology *, struct __pyx_t_5spacy_7structs_TokenC *, PyObject *);
int (*assign_tag_id)(struct __pyx_obj_5spacy_10morphology_Morphology *, struct __pyx_t_5spacy_7structs_TokenC *, int);
int (*_assign_tag_from_exceptions)(struct __pyx_obj_5spacy_10morphology_Morphology *, struct __pyx_t_5spacy_7structs_TokenC *, int);
};
static struct __pyx_vtabstruct_5spacy_10morphology_Morphology *__pyx_vtabptr_5spacy_10morphology_Morphology;
/* "vocab.pxd":27
*
*
* cdef class Vocab: # <<<<<<<<<<<<<<
* cdef Pool mem
* cpdef readonly StringStore strings
*/
struct __pyx_vtabstruct_5spacy_5vocab_Vocab {
struct __pyx_t_5spacy_7structs_LexemeC const *(*get)(struct __pyx_obj_5spacy_5vocab_Vocab *, struct __pyx_obj_5cymem_5cymem_Pool *, PyObject *);
struct __pyx_t_5spacy_7structs_LexemeC const *(*get_by_orth)(struct __pyx_obj_5spacy_5vocab_Vocab *, struct __pyx_obj_5cymem_5cymem_Pool *, __pyx_t_5spacy_8typedefs_attr_t);
struct __pyx_t_5spacy_7structs_TokenC const *(*make_fused_token)(struct __pyx_obj_5spacy_5vocab_Vocab *, PyObject *);
struct __pyx_t_5spacy_7structs_LexemeC const *(*_new_lexeme)(struct __pyx_obj_5spacy_5vocab_Vocab *, struct __pyx_obj_5cymem_5cymem_Pool *, PyObject *);
int (*_add_lex_to_vocab)(struct __pyx_obj_5spacy_5vocab_Vocab *, __pyx_t_5spacy_8typedefs_hash_t, struct __pyx_t_5spacy_7structs_LexemeC const *);
};
static struct __pyx_vtabstruct_5spacy_5vocab_Vocab *__pyx_vtabptr_5spacy_5vocab_Vocab;
/* "lexeme.pxd":15
* cdef attr_t OOV_RANK
*
* cdef class Lexeme: # <<<<<<<<<<<<<<
* cdef LexemeC* c
* cdef readonly Vocab vocab
*/
struct __pyx_vtabstruct_5spacy_6lexeme_Lexeme {
struct __pyx_obj_5spacy_6lexeme_Lexeme *(*from_ptr)(struct __pyx_t_5spacy_7structs_LexemeC *, struct __pyx_obj_5spacy_5vocab_Vocab *, int);
void (*set_struct_attr)(struct __pyx_t_5spacy_7structs_LexemeC *, enum __pyx_t_5spacy_5attrs_attr_id_t, __pyx_t_5spacy_8typedefs_attr_t);
__pyx_t_5spacy_8typedefs_attr_t (*get_struct_attr)(struct __pyx_t_5spacy_7structs_LexemeC const *, enum __pyx_t_5spacy_5attrs_attr_id_t);
int (*c_check_flag)(struct __pyx_t_5spacy_7structs_LexemeC const *, enum __pyx_t_5spacy_5attrs_attr_id_t);
int (*c_set_flag)(struct __pyx_t_5spacy_7structs_LexemeC *, enum __pyx_t_5spacy_5attrs_attr_id_t, int);
};
static struct __pyx_vtabstruct_5spacy_6lexeme_Lexeme *__pyx_vtabptr_5spacy_6lexeme_Lexeme;
static CYTHON_INLINE struct __pyx_obj_5spacy_6lexeme_Lexeme *__pyx_f_5spacy_6lexeme_6Lexeme_from_ptr(struct __pyx_t_5spacy_7structs_LexemeC *, struct __pyx_obj_5spacy_5vocab_Vocab *, int);
static CYTHON_INLINE void __pyx_f_5spacy_6lexeme_6Lexeme_set_struct_attr(struct __pyx_t_5spacy_7structs_LexemeC *, enum __pyx_t_5spacy_5attrs_attr_id_t, __pyx_t_5spacy_8typedefs_attr_t);
static CYTHON_INLINE __pyx_t_5spacy_8typedefs_attr_t __pyx_f_5spacy_6lexeme_6Lexeme_get_struct_attr(struct __pyx_t_5spacy_7structs_LexemeC const *, enum __pyx_t_5spacy_5attrs_attr_id_t);
static CYTHON_INLINE int __pyx_f_5spacy_6lexeme_6Lexeme_c_check_flag(struct __pyx_t_5spacy_7structs_LexemeC const *, enum __pyx_t_5spacy_5attrs_attr_id_t);
static CYTHON_INLINE int __pyx_f_5spacy_6lexeme_6Lexeme_c_set_flag(struct __pyx_t_5spacy_7structs_LexemeC *, enum __pyx_t_5spacy_5attrs_attr_id_t, int);
/* "stateclass.pxd":13
*
*
* cdef class StateClass: # <<<<<<<<<<<<<<
* cdef Pool mem
* cdef StateC* c
*/
struct __pyx_vtabstruct_5spacy_6syntax_10stateclass_StateClass {
struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *(*init)(struct __pyx_t_5spacy_7structs_TokenC const *, int);
struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *(*borrow)(__pyx_t_5spacy_6syntax_6_state_StateC *);
struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *(*init_offset)(struct __pyx_t_5spacy_7structs_TokenC const *, int, int);
int (*S)(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *, int);
int (*B)(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *, int);
struct __pyx_t_5spacy_7structs_TokenC const *(*S_)(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *, int);
struct __pyx_t_5spacy_7structs_TokenC const *(*B_)(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *, int);
struct __pyx_t_5spacy_7structs_TokenC const *(*H_)(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *, int);
struct __pyx_t_5spacy_7structs_TokenC const *(*E_)(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *, int);
struct __pyx_t_5spacy_7structs_TokenC const *(*L_)(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *, int, int);
struct __pyx_t_5spacy_7structs_TokenC const *(*R_)(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *, int, int);
struct __pyx_t_5spacy_7structs_TokenC const *(*safe_get)(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *, int);
int (*H)(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *, int);
int (*E)(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *, int);
int (*L)(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *, int, int);
int (*R)(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *, int, int);
int (*empty)(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *);
int (*eol)(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *);
int (*at_break)(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *);
int (*has_head)(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *, int);
int (*n_L)(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *, int);
int (*n_R)(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *, int);
int (*stack_is_connected)(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *);
int (*entity_is_open)(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *);
int (*stack_depth)(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *);
int (*buffer_length)(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *);
void (*push)(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *);
void (*pop)(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *);
void (*unshift)(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *);
void (*add_arc)(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *, int, int, __pyx_t_5spacy_8typedefs_attr_t);
void (*del_arc)(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *, int, int);
void (*open_ent)(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *, __pyx_t_5spacy_8typedefs_attr_t);
void (*close_ent)(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *);
void (*set_ent_tag)(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *, int, int, __pyx_t_5spacy_8typedefs_attr_t);
void (*set_break)(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *, int);
void (*clone)(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *, struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *);
void (*fast_forward)(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *);
};
static struct __pyx_vtabstruct_5spacy_6syntax_10stateclass_StateClass *__pyx_vtabptr_5spacy_6syntax_10stateclass_StateClass;
static CYTHON_INLINE struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *__pyx_f_5spacy_6syntax_10stateclass_10StateClass_init(struct __pyx_t_5spacy_7structs_TokenC const *, int);
static CYTHON_INLINE struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *__pyx_f_5spacy_6syntax_10stateclass_10StateClass_borrow(__pyx_t_5spacy_6syntax_6_state_StateC *);
static CYTHON_INLINE struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *__pyx_f_5spacy_6syntax_10stateclass_10StateClass_init_offset(struct __pyx_t_5spacy_7structs_TokenC const *, int, int);
static CYTHON_INLINE int __pyx_f_5spacy_6syntax_10stateclass_10StateClass_S(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *, int);
static CYTHON_INLINE int __pyx_f_5spacy_6syntax_10stateclass_10StateClass_B(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *, int);
static CYTHON_INLINE struct __pyx_t_5spacy_7structs_TokenC const *__pyx_f_5spacy_6syntax_10stateclass_10StateClass_S_(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *, int);
static CYTHON_INLINE struct __pyx_t_5spacy_7structs_TokenC const *__pyx_f_5spacy_6syntax_10stateclass_10StateClass_B_(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *, int);
static CYTHON_INLINE struct __pyx_t_5spacy_7structs_TokenC const *__pyx_f_5spacy_6syntax_10stateclass_10StateClass_H_(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *, int);
static CYTHON_INLINE struct __pyx_t_5spacy_7structs_TokenC const *__pyx_f_5spacy_6syntax_10stateclass_10StateClass_E_(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *, int);
static CYTHON_INLINE struct __pyx_t_5spacy_7structs_TokenC const *__pyx_f_5spacy_6syntax_10stateclass_10StateClass_L_(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *, int, int);
static CYTHON_INLINE struct __pyx_t_5spacy_7structs_TokenC const *__pyx_f_5spacy_6syntax_10stateclass_10StateClass_R_(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *, int, int);
static CYTHON_INLINE struct __pyx_t_5spacy_7structs_TokenC const *__pyx_f_5spacy_6syntax_10stateclass_10StateClass_safe_get(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *, int);
static CYTHON_INLINE int __pyx_f_5spacy_6syntax_10stateclass_10StateClass_H(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *, int);
static CYTHON_INLINE int __pyx_f_5spacy_6syntax_10stateclass_10StateClass_E(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *, int);
static CYTHON_INLINE int __pyx_f_5spacy_6syntax_10stateclass_10StateClass_L(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *, int, int);
static CYTHON_INLINE int __pyx_f_5spacy_6syntax_10stateclass_10StateClass_R(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *, int, int);
static CYTHON_INLINE int __pyx_f_5spacy_6syntax_10stateclass_10StateClass_empty(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *);
static CYTHON_INLINE int __pyx_f_5spacy_6syntax_10stateclass_10StateClass_eol(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *);
static CYTHON_INLINE int __pyx_f_5spacy_6syntax_10stateclass_10StateClass_at_break(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *);
static CYTHON_INLINE int __pyx_f_5spacy_6syntax_10stateclass_10StateClass_has_head(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *, int);
static CYTHON_INLINE int __pyx_f_5spacy_6syntax_10stateclass_10StateClass_n_L(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *, int);
static CYTHON_INLINE int __pyx_f_5spacy_6syntax_10stateclass_10StateClass_n_R(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *, int);
static CYTHON_INLINE int __pyx_f_5spacy_6syntax_10stateclass_10StateClass_stack_is_connected(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *);
static CYTHON_INLINE int __pyx_f_5spacy_6syntax_10stateclass_10StateClass_entity_is_open(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *);
static CYTHON_INLINE int __pyx_f_5spacy_6syntax_10stateclass_10StateClass_stack_depth(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *);
static CYTHON_INLINE int __pyx_f_5spacy_6syntax_10stateclass_10StateClass_buffer_length(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *);
static CYTHON_INLINE void __pyx_f_5spacy_6syntax_10stateclass_10StateClass_push(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *);
static CYTHON_INLINE void __pyx_f_5spacy_6syntax_10stateclass_10StateClass_pop(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *);
static CYTHON_INLINE void __pyx_f_5spacy_6syntax_10stateclass_10StateClass_unshift(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *);
static CYTHON_INLINE void __pyx_f_5spacy_6syntax_10stateclass_10StateClass_add_arc(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *, int, int, __pyx_t_5spacy_8typedefs_attr_t);
static CYTHON_INLINE void __pyx_f_5spacy_6syntax_10stateclass_10StateClass_del_arc(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *, int, int);
static CYTHON_INLINE void __pyx_f_5spacy_6syntax_10stateclass_10StateClass_open_ent(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *, __pyx_t_5spacy_8typedefs_attr_t);
static CYTHON_INLINE void __pyx_f_5spacy_6syntax_10stateclass_10StateClass_close_ent(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *);
static CYTHON_INLINE void __pyx_f_5spacy_6syntax_10stateclass_10StateClass_set_ent_tag(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *, int, int, __pyx_t_5spacy_8typedefs_attr_t);
static CYTHON_INLINE void __pyx_f_5spacy_6syntax_10stateclass_10StateClass_set_break(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *, int);
static CYTHON_INLINE void __pyx_f_5spacy_6syntax_10stateclass_10StateClass_clone(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *, struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *);
static CYTHON_INLINE void __pyx_f_5spacy_6syntax_10stateclass_10StateClass_fast_forward(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *);
/* "transition_system.pxd":38
* ctypedef int (*del_state_t)(Pool mem, void* state, void* extra_args) except -1
*
* cdef class TransitionSystem: # <<<<<<<<<<<<<<
* cdef Pool mem
* cdef StringStore strings
*/
struct __pyx_vtabstruct_5spacy_6syntax_17transition_system_TransitionSystem {
int (*initialize_state)(struct __pyx_obj_5spacy_6syntax_17transition_system_TransitionSystem *, __pyx_t_5spacy_6syntax_6_state_StateC *);
int (*finalize_state)(struct __pyx_obj_5spacy_6syntax_17transition_system_TransitionSystem *, __pyx_t_5spacy_6syntax_6_state_StateC *);
struct __pyx_t_5spacy_6syntax_17transition_system_Transition (*lookup_transition)(struct __pyx_obj_5spacy_6syntax_17transition_system_TransitionSystem *, PyObject *);
struct __pyx_t_5spacy_6syntax_17transition_system_Transition (*init_transition)(struct __pyx_obj_5spacy_6syntax_17transition_system_TransitionSystem *, int, int, __pyx_t_5spacy_8typedefs_attr_t);
int (*set_valid)(struct __pyx_obj_5spacy_6syntax_17transition_system_TransitionSystem *, int *, __pyx_t_5spacy_6syntax_6_state_StateC const *);
int (*set_costs)(struct __pyx_obj_5spacy_6syntax_17transition_system_TransitionSystem *, int *, __pyx_t_5thinc_8typedefs_weight_t *, struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *, struct __pyx_obj_5spacy_4gold_GoldParse *);
};
static struct __pyx_vtabstruct_5spacy_6syntax_17transition_system_TransitionSystem *__pyx_vtabptr_5spacy_6syntax_17transition_system_TransitionSystem;
/* "thinc/extra/search.pxd":37
*
*
* cdef class Beam: # <<<<<<<<<<<<<<
* cdef Pool mem
* cdef class_t nr_class
*/
struct __pyx_vtabstruct_5thinc_5extra_6search_Beam {
int (*_fill)(struct __pyx_obj_5thinc_5extra_6search_Beam *, __pyx_t_5thinc_5extra_6search_Queue *, __pyx_t_5thinc_8typedefs_weight_t **, int **);
void *(*at)(struct __pyx_obj_5thinc_5extra_6search_Beam *, int);
int (*initialize)(struct __pyx_obj_5thinc_5extra_6search_Beam *, __pyx_t_5thinc_5extra_6search_init_func_t, __pyx_t_5thinc_5extra_6search_del_func_t, int, void *);
int (*advance)(struct __pyx_obj_5thinc_5extra_6search_Beam *, __pyx_t_5thinc_5extra_6search_trans_func_t, __pyx_t_5thinc_5extra_6search_hash_func_t, void *);
int (*check_done)(struct __pyx_obj_5thinc_5extra_6search_Beam *, __pyx_t_5thinc_5extra_6search_finish_func_t, void *);
void (*set_cell)(struct __pyx_obj_5thinc_5extra_6search_Beam *, int, int, __pyx_t_5thinc_8typedefs_weight_t, int, __pyx_t_5thinc_8typedefs_weight_t);
int (*set_row)(struct __pyx_obj_5thinc_5extra_6search_Beam *, int, __pyx_t_5thinc_8typedefs_weight_t const *, int const *, __pyx_t_5thinc_8typedefs_weight_t const *);
int (*set_table)(struct __pyx_obj_5thinc_5extra_6search_Beam *, __pyx_t_5thinc_8typedefs_weight_t **, int **, __pyx_t_5thinc_8typedefs_weight_t **);
};
static struct __pyx_vtabstruct_5thinc_5extra_6search_Beam *__pyx_vtabptr_5thinc_5extra_6search_Beam;
static CYTHON_INLINE void *__pyx_f_5thinc_5extra_6search_4Beam_at(struct __pyx_obj_5thinc_5extra_6search_Beam *, int);
static CYTHON_INLINE void __pyx_f_5thinc_5extra_6search_4Beam_set_cell(struct __pyx_obj_5thinc_5extra_6search_Beam *, int, int, __pyx_t_5thinc_8typedefs_weight_t, int, __pyx_t_5thinc_8typedefs_weight_t);
/* "thinc/extra/search.pxd":75
*
*
* cdef class MaxViolation: # <<<<<<<<<<<<<<
* cdef Pool mem
* cdef weight_t cost
*/
struct __pyx_vtabstruct_5thinc_5extra_6search_MaxViolation {
int (*check)(struct __pyx_obj_5thinc_5extra_6search_MaxViolation *, struct __pyx_obj_5thinc_5extra_6search_Beam *, struct __pyx_obj_5thinc_5extra_6search_Beam *, int __pyx_skip_dispatch);
int (*check_crf)(struct __pyx_obj_5thinc_5extra_6search_MaxViolation *, struct __pyx_obj_5thinc_5extra_6search_Beam *, struct __pyx_obj_5thinc_5extra_6search_Beam *, int __pyx_skip_dispatch);
};
static struct __pyx_vtabstruct_5thinc_5extra_6search_MaxViolation *__pyx_vtabptr_5thinc_5extra_6search_MaxViolation;
/* "tokens/doc.pxd":39
* cdef int [:,:] _get_lca_matrix(Doc, int start, int end)
*
* cdef class Doc: # <<<<<<<<<<<<<<
* cdef readonly Pool mem
* cdef readonly Vocab vocab
*/
struct __pyx_vtabstruct_5spacy_6tokens_3doc_Doc {
PyArrayObject *(*to_array)(struct __pyx_obj_5spacy_6tokens_3doc_Doc *, PyObject *, int __pyx_skip_dispatch);
void (*set_parse)(struct __pyx_obj_5spacy_6tokens_3doc_Doc *, struct __pyx_t_5spacy_7structs_TokenC const *);
int (*__pyx_fuse_0push_back)(struct __pyx_obj_5spacy_6tokens_3doc_Doc *, __pyx_t_5spacy_6tokens_3doc_const_Lexeme_ptr, int);
int (*__pyx_fuse_1push_back)(struct __pyx_obj_5spacy_6tokens_3doc_Doc *, __pyx_t_5spacy_6tokens_3doc_const_TokenC_ptr, int);
};
static struct __pyx_vtabstruct_5spacy_6tokens_3doc_Doc *__pyx_vtabptr_5spacy_6tokens_3doc_Doc;
/* "spacy/syntax/arc_eager.pyx":332
*
*
* cdef class ArcEager(TransitionSystem): # <<<<<<<<<<<<<<
* def __init__(self, *args, **kwargs):
* TransitionSystem.__init__(self, *args, **kwargs)
*/
struct __pyx_vtabstruct_5spacy_6syntax_9arc_eager_ArcEager {
struct __pyx_vtabstruct_5spacy_6syntax_17transition_system_TransitionSystem __pyx_base;
};
static struct __pyx_vtabstruct_5spacy_6syntax_9arc_eager_ArcEager *__pyx_vtabptr_5spacy_6syntax_9arc_eager_ArcEager;
/* "spacy/syntax/arc_eager.pyx":122
* return gold.heads[word] == word or not gold.has_dep[word]
*
* cdef class Shift: # <<<<<<<<<<<<<<
* @staticmethod
* cdef bint is_valid(const StateC* st, attr_t label) nogil:
*/
struct __pyx_vtabstruct_5spacy_6syntax_9arc_eager_Shift {
int (*is_valid)(__pyx_t_5spacy_6syntax_6_state_StateC const *, __pyx_t_5spacy_8typedefs_attr_t);
int (*transition)(__pyx_t_5spacy_6syntax_6_state_StateC *, __pyx_t_5spacy_8typedefs_attr_t);
__pyx_t_5thinc_8typedefs_weight_t (*cost)(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *, struct __pyx_t_5spacy_4gold_GoldParseC const *, __pyx_t_5spacy_8typedefs_attr_t);
__pyx_t_5thinc_8typedefs_weight_t (*move_cost)(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *, struct __pyx_t_5spacy_4gold_GoldParseC const *);
__pyx_t_5thinc_8typedefs_weight_t (*label_cost)(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *, struct __pyx_t_5spacy_4gold_GoldParseC const *, __pyx_t_5spacy_8typedefs_attr_t);
};
static struct __pyx_vtabstruct_5spacy_6syntax_9arc_eager_Shift *__pyx_vtabptr_5spacy_6syntax_9arc_eager_Shift;
static CYTHON_INLINE __pyx_t_5thinc_8typedefs_weight_t __pyx_f_5spacy_6syntax_9arc_eager_5Shift_move_cost(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *, struct __pyx_t_5spacy_4gold_GoldParseC const *);
static CYTHON_INLINE __pyx_t_5thinc_8typedefs_weight_t __pyx_f_5spacy_6syntax_9arc_eager_5Shift_label_cost(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *, struct __pyx_t_5spacy_4gold_GoldParseC const *, __pyx_t_5spacy_8typedefs_attr_t);
/* "spacy/syntax/arc_eager.pyx":146
*
*
* cdef class Reduce: # <<<<<<<<<<<<<<
* @staticmethod
* cdef bint is_valid(const StateC* st, attr_t label) nogil:
*/
struct __pyx_vtabstruct_5spacy_6syntax_9arc_eager_Reduce {
int (*is_valid)(__pyx_t_5spacy_6syntax_6_state_StateC const *, __pyx_t_5spacy_8typedefs_attr_t);
int (*transition)(__pyx_t_5spacy_6syntax_6_state_StateC *, __pyx_t_5spacy_8typedefs_attr_t);
__pyx_t_5thinc_8typedefs_weight_t (*cost)(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *, struct __pyx_t_5spacy_4gold_GoldParseC const *, __pyx_t_5spacy_8typedefs_attr_t);
__pyx_t_5thinc_8typedefs_weight_t (*move_cost)(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *, struct __pyx_t_5spacy_4gold_GoldParseC const *);
__pyx_t_5thinc_8typedefs_weight_t (*label_cost)(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *, struct __pyx_t_5spacy_4gold_GoldParseC const *, __pyx_t_5spacy_8typedefs_attr_t);
};
static struct __pyx_vtabstruct_5spacy_6syntax_9arc_eager_Reduce *__pyx_vtabptr_5spacy_6syntax_9arc_eager_Reduce;
static CYTHON_INLINE __pyx_t_5thinc_8typedefs_weight_t __pyx_f_5spacy_6syntax_9arc_eager_6Reduce_move_cost(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *, struct __pyx_t_5spacy_4gold_GoldParseC const *);
static CYTHON_INLINE __pyx_t_5thinc_8typedefs_weight_t __pyx_f_5spacy_6syntax_9arc_eager_6Reduce_label_cost(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *, struct __pyx_t_5spacy_4gold_GoldParseC const *, __pyx_t_5spacy_8typedefs_attr_t);
/* "spacy/syntax/arc_eager.pyx":183
*
*
* cdef class LeftArc: # <<<<<<<<<<<<<<
* @staticmethod
* cdef bint is_valid(const StateC* st, attr_t label) nogil:
*/
struct __pyx_vtabstruct_5spacy_6syntax_9arc_eager_LeftArc {
int (*is_valid)(__pyx_t_5spacy_6syntax_6_state_StateC const *, __pyx_t_5spacy_8typedefs_attr_t);
int (*transition)(__pyx_t_5spacy_6syntax_6_state_StateC *, __pyx_t_5spacy_8typedefs_attr_t);
__pyx_t_5thinc_8typedefs_weight_t (*cost)(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *, struct __pyx_t_5spacy_4gold_GoldParseC const *, __pyx_t_5spacy_8typedefs_attr_t);
__pyx_t_5thinc_8typedefs_weight_t (*move_cost)(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *, struct __pyx_t_5spacy_4gold_GoldParseC const *);
__pyx_t_5thinc_8typedefs_weight_t (*label_cost)(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *, struct __pyx_t_5spacy_4gold_GoldParseC const *, __pyx_t_5spacy_8typedefs_attr_t);
};
static struct __pyx_vtabstruct_5spacy_6syntax_9arc_eager_LeftArc *__pyx_vtabptr_5spacy_6syntax_9arc_eager_LeftArc;
static CYTHON_INLINE __pyx_t_5thinc_8typedefs_weight_t __pyx_f_5spacy_6syntax_9arc_eager_7LeftArc_move_cost(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *, struct __pyx_t_5spacy_4gold_GoldParseC const *);
static CYTHON_INLINE __pyx_t_5thinc_8typedefs_weight_t __pyx_f_5spacy_6syntax_9arc_eager_7LeftArc_label_cost(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *, struct __pyx_t_5spacy_4gold_GoldParseC const *, __pyx_t_5spacy_8typedefs_attr_t);
/* "spacy/syntax/arc_eager.pyx":220
*
*
* cdef class RightArc: # <<<<<<<<<<<<<<
* @staticmethod
* cdef bint is_valid(const StateC* st, attr_t label) nogil:
*/
struct __pyx_vtabstruct_5spacy_6syntax_9arc_eager_RightArc {
int (*is_valid)(__pyx_t_5spacy_6syntax_6_state_StateC const *, __pyx_t_5spacy_8typedefs_attr_t);
int (*transition)(__pyx_t_5spacy_6syntax_6_state_StateC *, __pyx_t_5spacy_8typedefs_attr_t);
__pyx_t_5thinc_8typedefs_weight_t (*cost)(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *, struct __pyx_t_5spacy_4gold_GoldParseC const *, __pyx_t_5spacy_8typedefs_attr_t);
__pyx_t_5thinc_8typedefs_weight_t (*move_cost)(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *, struct __pyx_t_5spacy_4gold_GoldParseC const *);
__pyx_t_5thinc_8typedefs_weight_t (*label_cost)(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *, struct __pyx_t_5spacy_4gold_GoldParseC const *, __pyx_t_5spacy_8typedefs_attr_t);
};
static struct __pyx_vtabstruct_5spacy_6syntax_9arc_eager_RightArc *__pyx_vtabptr_5spacy_6syntax_9arc_eager_RightArc;
static CYTHON_INLINE __pyx_t_5thinc_8typedefs_weight_t __pyx_f_5spacy_6syntax_9arc_eager_8RightArc_cost(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *, struct __pyx_t_5spacy_4gold_GoldParseC const *, __pyx_t_5spacy_8typedefs_attr_t);
static CYTHON_INLINE __pyx_t_5thinc_8typedefs_weight_t __pyx_f_5spacy_6syntax_9arc_eager_8RightArc_move_cost(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *, struct __pyx_t_5spacy_4gold_GoldParseC const *);
/* "spacy/syntax/arc_eager.pyx":253
*
*
* cdef class Break: # <<<<<<<<<<<<<<
* @staticmethod
* cdef bint is_valid(const StateC* st, attr_t label) nogil:
*/
struct __pyx_vtabstruct_5spacy_6syntax_9arc_eager_Break {
int (*is_valid)(__pyx_t_5spacy_6syntax_6_state_StateC const *, __pyx_t_5spacy_8typedefs_attr_t);
int (*transition)(__pyx_t_5spacy_6syntax_6_state_StateC *, __pyx_t_5spacy_8typedefs_attr_t);
__pyx_t_5thinc_8typedefs_weight_t (*cost)(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *, struct __pyx_t_5spacy_4gold_GoldParseC const *, __pyx_t_5spacy_8typedefs_attr_t);
__pyx_t_5thinc_8typedefs_weight_t (*move_cost)(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *, struct __pyx_t_5spacy_4gold_GoldParseC const *);
__pyx_t_5thinc_8typedefs_weight_t (*label_cost)(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *, struct __pyx_t_5spacy_4gold_GoldParseC const *, __pyx_t_5spacy_8typedefs_attr_t);
};
static struct __pyx_vtabstruct_5spacy_6syntax_9arc_eager_Break *__pyx_vtabptr_5spacy_6syntax_9arc_eager_Break;
static CYTHON_INLINE __pyx_t_5thinc_8typedefs_weight_t __pyx_f_5spacy_6syntax_9arc_eager_5Break_move_cost(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *, struct __pyx_t_5spacy_4gold_GoldParseC const *);
static CYTHON_INLINE __pyx_t_5thinc_8typedefs_weight_t __pyx_f_5spacy_6syntax_9arc_eager_5Break_label_cost(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *, struct __pyx_t_5spacy_4gold_GoldParseC const *, __pyx_t_5spacy_8typedefs_attr_t);
/* "View.MemoryView":105
*
* @cname("__pyx_array")
* cdef class array: # <<<<<<<<<<<<<<
*
* cdef:
*/
struct __pyx_vtabstruct_array {
PyObject *(*get_memview)(struct __pyx_array_obj *);
};
static struct __pyx_vtabstruct_array *__pyx_vtabptr_array;
/* "View.MemoryView":330
*
* @cname('__pyx_memoryview')
* cdef class memoryview(object): # <<<<<<<<<<<<<<
*
* cdef object obj
*/
struct __pyx_vtabstruct_memoryview {
char *(*get_item_pointer)(struct __pyx_memoryview_obj *, PyObject *);
PyObject *(*is_slice)(struct __pyx_memoryview_obj *, PyObject *);
PyObject *(*setitem_slice_assignment)(struct __pyx_memoryview_obj *, PyObject *, PyObject *);
PyObject *(*setitem_slice_assign_scalar)(struct __pyx_memoryview_obj *, struct __pyx_memoryview_obj *, PyObject *);
PyObject *(*setitem_indexed)(struct __pyx_memoryview_obj *, PyObject *, PyObject *);
PyObject *(*convert_item_to_object)(struct __pyx_memoryview_obj *, char *);
PyObject *(*assign_item_from_object)(struct __pyx_memoryview_obj *, char *, PyObject *);
};
static struct __pyx_vtabstruct_memoryview *__pyx_vtabptr_memoryview;
/* "View.MemoryView":965
*
* @cname('__pyx_memoryviewslice')
* cdef class _memoryviewslice(memoryview): # <<<<<<<<<<<<<<
* "Internal class for passing memoryview slices to Python"
*
*/
struct __pyx_vtabstruct__memoryviewslice {
struct __pyx_vtabstruct_memoryview __pyx_base;
};
static struct __pyx_vtabstruct__memoryviewslice *__pyx_vtabptr__memoryviewslice;
/* --- Runtime support code (head) --- */
/* Refnanny.proto */
#ifndef CYTHON_REFNANNY
#define CYTHON_REFNANNY 0
#endif
#if CYTHON_REFNANNY
typedef struct {
void (*INCREF)(void*, PyObject*, int);
void (*DECREF)(void*, PyObject*, int);
void (*GOTREF)(void*, PyObject*, int);
void (*GIVEREF)(void*, PyObject*, int);
void* (*SetupContext)(const char*, int, const char*);
void (*FinishContext)(void**);
} __Pyx_RefNannyAPIStruct;
static __Pyx_RefNannyAPIStruct *__Pyx_RefNanny = NULL;
static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname);
#define __Pyx_RefNannyDeclarations void *__pyx_refnanny = NULL;
#ifdef WITH_THREAD
#define __Pyx_RefNannySetupContext(name, acquire_gil)\
if (acquire_gil) {\
PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\
__pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);\
PyGILState_Release(__pyx_gilstate_save);\
} else {\
__pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);\
}
#else
#define __Pyx_RefNannySetupContext(name, acquire_gil)\
__pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__)
#endif
#define __Pyx_RefNannyFinishContext()\
__Pyx_RefNanny->FinishContext(&__pyx_refnanny)
#define __Pyx_INCREF(r) __Pyx_RefNanny->INCREF(__pyx_refnanny, (PyObject *)(r), __LINE__)
#define __Pyx_DECREF(r) __Pyx_RefNanny->DECREF(__pyx_refnanny, (PyObject *)(r), __LINE__)
#define __Pyx_GOTREF(r) __Pyx_RefNanny->GOTREF(__pyx_refnanny, (PyObject *)(r), __LINE__)
#define __Pyx_GIVEREF(r) __Pyx_RefNanny->GIVEREF(__pyx_refnanny, (PyObject *)(r), __LINE__)
#define __Pyx_XINCREF(r) do { if((r) != NULL) {__Pyx_INCREF(r); }} while(0)
#define __Pyx_XDECREF(r) do { if((r) != NULL) {__Pyx_DECREF(r); }} while(0)
#define __Pyx_XGOTREF(r) do { if((r) != NULL) {__Pyx_GOTREF(r); }} while(0)
#define __Pyx_XGIVEREF(r) do { if((r) != NULL) {__Pyx_GIVEREF(r);}} while(0)
#else
#define __Pyx_RefNannyDeclarations
#define __Pyx_RefNannySetupContext(name, acquire_gil)
#define __Pyx_RefNannyFinishContext()
#define __Pyx_INCREF(r) Py_INCREF(r)
#define __Pyx_DECREF(r) Py_DECREF(r)
#define __Pyx_GOTREF(r)
#define __Pyx_GIVEREF(r)
#define __Pyx_XINCREF(r) Py_XINCREF(r)
#define __Pyx_XDECREF(r) Py_XDECREF(r)
#define __Pyx_XGOTREF(r)
#define __Pyx_XGIVEREF(r)
#endif
#define __Pyx_XDECREF_SET(r, v) do {\
PyObject *tmp = (PyObject *) r;\
r = v; __Pyx_XDECREF(tmp);\
} while (0)
#define __Pyx_DECREF_SET(r, v) do {\
PyObject *tmp = (PyObject *) r;\
r = v; __Pyx_DECREF(tmp);\
} while (0)
#define __Pyx_CLEAR(r) do { PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);} while(0)
#define __Pyx_XCLEAR(r) do { if((r) != NULL) {PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);}} while(0)
/* PyObjectGetAttrStr.proto */
#if CYTHON_USE_TYPE_SLOTS
static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name);
#else
#define __Pyx_PyObject_GetAttrStr(o,n) PyObject_GetAttr(o,n)
#endif
/* GetBuiltinName.proto */
static PyObject *__Pyx_GetBuiltinName(PyObject *name);
/* PyThreadStateGet.proto */
#if CYTHON_FAST_THREAD_STATE
#define __Pyx_PyThreadState_declare PyThreadState *__pyx_tstate;
#define __Pyx_PyThreadState_assign __pyx_tstate = __Pyx_PyThreadState_Current;
#define __Pyx_PyErr_Occurred() __pyx_tstate->curexc_type
#else
#define __Pyx_PyThreadState_declare
#define __Pyx_PyThreadState_assign
#define __Pyx_PyErr_Occurred() PyErr_Occurred()
#endif
/* PyErrFetchRestore.proto */
#if CYTHON_FAST_THREAD_STATE
#define __Pyx_PyErr_Clear() __Pyx_ErrRestore(NULL, NULL, NULL)
#define __Pyx_ErrRestoreWithState(type, value, tb) __Pyx_ErrRestoreInState(PyThreadState_GET(), type, value, tb)
#define __Pyx_ErrFetchWithState(type, value, tb) __Pyx_ErrFetchInState(PyThreadState_GET(), type, value, tb)
#define __Pyx_ErrRestore(type, value, tb) __Pyx_ErrRestoreInState(__pyx_tstate, type, value, tb)
#define __Pyx_ErrFetch(type, value, tb) __Pyx_ErrFetchInState(__pyx_tstate, type, value, tb)
static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb);
static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb);
#if CYTHON_COMPILING_IN_CPYTHON
#define __Pyx_PyErr_SetNone(exc) (Py_INCREF(exc), __Pyx_ErrRestore((exc), NULL, NULL))
#else
#define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc)
#endif
#else
#define __Pyx_PyErr_Clear() PyErr_Clear()
#define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc)
#define __Pyx_ErrRestoreWithState(type, value, tb) PyErr_Restore(type, value, tb)
#define __Pyx_ErrFetchWithState(type, value, tb) PyErr_Fetch(type, value, tb)
#define __Pyx_ErrRestoreInState(tstate, type, value, tb) PyErr_Restore(type, value, tb)
#define __Pyx_ErrFetchInState(tstate, type, value, tb) PyErr_Fetch(type, value, tb)
#define __Pyx_ErrRestore(type, value, tb) PyErr_Restore(type, value, tb)
#define __Pyx_ErrFetch(type, value, tb) PyErr_Fetch(type, value, tb)
#endif
/* Profile.proto */
#ifndef CYTHON_PROFILE
#if CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_PYSTON
#define CYTHON_PROFILE 0
#else
#define CYTHON_PROFILE 1
#endif
#endif
#ifndef CYTHON_TRACE_NOGIL
#define CYTHON_TRACE_NOGIL 0
#else
#if CYTHON_TRACE_NOGIL && !defined(CYTHON_TRACE)
#define CYTHON_TRACE 1
#endif
#endif
#ifndef CYTHON_TRACE
#define CYTHON_TRACE 0
#endif
#if CYTHON_TRACE
#undef CYTHON_PROFILE_REUSE_FRAME
#endif
#ifndef CYTHON_PROFILE_REUSE_FRAME
#define CYTHON_PROFILE_REUSE_FRAME 0
#endif
#if CYTHON_PROFILE || CYTHON_TRACE
#include "compile.h"
#include "frameobject.h"
#include "traceback.h"
#if CYTHON_PROFILE_REUSE_FRAME
#define CYTHON_FRAME_MODIFIER static
#define CYTHON_FRAME_DEL(frame)
#else
#define CYTHON_FRAME_MODIFIER
#define CYTHON_FRAME_DEL(frame) Py_CLEAR(frame)
#endif
#define __Pyx_TraceDeclarations\
static PyCodeObject *__pyx_frame_code = NULL;\
CYTHON_FRAME_MODIFIER PyFrameObject *__pyx_frame = NULL;\
int __Pyx_use_tracing = 0;
#define __Pyx_TraceFrameInit(codeobj)\
if (codeobj) __pyx_frame_code = (PyCodeObject*) codeobj;
#ifdef WITH_THREAD
#define __Pyx_TraceCall(funcname, srcfile, firstlineno, nogil, goto_error)\
if (nogil) {\
if (CYTHON_TRACE_NOGIL) {\
PyThreadState *tstate;\
PyGILState_STATE state = PyGILState_Ensure();\
tstate = __Pyx_PyThreadState_Current;\
if (unlikely(tstate->use_tracing) && !tstate->tracing &&\
(tstate->c_profilefunc || (CYTHON_TRACE && tstate->c_tracefunc))) {\
__Pyx_use_tracing = __Pyx_TraceSetupAndCall(&__pyx_frame_code, &__pyx_frame, tstate, funcname, srcfile, firstlineno);\
}\
PyGILState_Release(state);\
if (unlikely(__Pyx_use_tracing < 0)) goto_error;\
}\
} else {\
PyThreadState* tstate = PyThreadState_GET();\
if (unlikely(tstate->use_tracing) && !tstate->tracing &&\
(tstate->c_profilefunc || (CYTHON_TRACE && tstate->c_tracefunc))) {\
__Pyx_use_tracing = __Pyx_TraceSetupAndCall(&__pyx_frame_code, &__pyx_frame, tstate, funcname, srcfile, firstlineno);\
if (unlikely(__Pyx_use_tracing < 0)) goto_error;\
}\
}
#else
#define __Pyx_TraceCall(funcname, srcfile, firstlineno, nogil, goto_error)\
{ PyThreadState* tstate = PyThreadState_GET();\
if (unlikely(tstate->use_tracing) && !tstate->tracing &&\
(tstate->c_profilefunc || (CYTHON_TRACE && tstate->c_tracefunc))) {\
__Pyx_use_tracing = __Pyx_TraceSetupAndCall(&__pyx_frame_code, &__pyx_frame, tstate, funcname, srcfile, firstlineno);\
if (unlikely(__Pyx_use_tracing < 0)) goto_error;\
}\
}
#endif
#define __Pyx_TraceException()\
if (likely(!__Pyx_use_tracing)); else {\
PyThreadState* tstate = __Pyx_PyThreadState_Current;\
if (tstate->use_tracing &&\
(tstate->c_profilefunc || (CYTHON_TRACE && tstate->c_tracefunc))) {\
tstate->tracing++;\
tstate->use_tracing = 0;\
PyObject *exc_info = __Pyx_GetExceptionTuple(tstate);\
if (exc_info) {\
if (CYTHON_TRACE && tstate->c_tracefunc)\
tstate->c_tracefunc(\
tstate->c_traceobj, __pyx_frame, PyTrace_EXCEPTION, exc_info);\
tstate->c_profilefunc(\
tstate->c_profileobj, __pyx_frame, PyTrace_EXCEPTION, exc_info);\
Py_DECREF(exc_info);\
}\
tstate->use_tracing = 1;\
tstate->tracing--;\
}\
}
static void __Pyx_call_return_trace_func(PyThreadState *tstate, PyFrameObject *frame, PyObject *result) {
PyObject *type, *value, *traceback;
__Pyx_ErrFetchInState(tstate, &type, &value, &traceback);
tstate->tracing++;
tstate->use_tracing = 0;
if (CYTHON_TRACE && tstate->c_tracefunc)
tstate->c_tracefunc(tstate->c_traceobj, frame, PyTrace_RETURN, result);
if (tstate->c_profilefunc)
tstate->c_profilefunc(tstate->c_profileobj, frame, PyTrace_RETURN, result);
CYTHON_FRAME_DEL(frame);
tstate->use_tracing = 1;
tstate->tracing--;
__Pyx_ErrRestoreInState(tstate, type, value, traceback);
}
#ifdef WITH_THREAD
#define __Pyx_TraceReturn(result, nogil)\
if (likely(!__Pyx_use_tracing)); else {\
if (nogil) {\
if (CYTHON_TRACE_NOGIL) {\
PyThreadState *tstate;\
PyGILState_STATE state = PyGILState_Ensure();\
tstate = __Pyx_PyThreadState_Current;\
if (tstate->use_tracing) {\
__Pyx_call_return_trace_func(tstate, __pyx_frame, (PyObject*)result);\
}\
PyGILState_Release(state);\
}\
} else {\
PyThreadState* tstate = __Pyx_PyThreadState_Current;\
if (tstate->use_tracing) {\
__Pyx_call_return_trace_func(tstate, __pyx_frame, (PyObject*)result);\
}\
}\
}
#else
#define __Pyx_TraceReturn(result, nogil)\
if (likely(!__Pyx_use_tracing)); else {\
PyThreadState* tstate = __Pyx_PyThreadState_Current;\
if (tstate->use_tracing) {\
__Pyx_call_return_trace_func(tstate, __pyx_frame, (PyObject*)result);\
}\
}
#endif
static PyCodeObject *__Pyx_createFrameCodeObject(const char *funcname, const char *srcfile, int firstlineno);
static int __Pyx_TraceSetupAndCall(PyCodeObject** code, PyFrameObject** frame, PyThreadState* tstate, const char *funcname, const char *srcfile, int firstlineno);
#else
#define __Pyx_TraceDeclarations
#define __Pyx_TraceFrameInit(codeobj)
#define __Pyx_TraceCall(funcname, srcfile, firstlineno, nogil, goto_error) if ((1)); else goto_error;
#define __Pyx_TraceException()
#define __Pyx_TraceReturn(result, nogil)
#endif
#if CYTHON_TRACE
static int __Pyx_call_line_trace_func(PyThreadState *tstate, PyFrameObject *frame, int lineno) {
int ret;
PyObject *type, *value, *traceback;
__Pyx_ErrFetchInState(tstate, &type, &value, &traceback);
__Pyx_PyFrame_SetLineNumber(frame, lineno);
tstate->tracing++;
tstate->use_tracing = 0;
ret = tstate->c_tracefunc(tstate->c_traceobj, frame, PyTrace_LINE, NULL);
tstate->use_tracing = 1;
tstate->tracing--;
if (likely(!ret)) {
__Pyx_ErrRestoreInState(tstate, type, value, traceback);
} else {
Py_XDECREF(type);
Py_XDECREF(value);
Py_XDECREF(traceback);
}
return ret;
}
#ifdef WITH_THREAD
#define __Pyx_TraceLine(lineno, nogil, goto_error)\
if (likely(!__Pyx_use_tracing)); else {\
if (nogil) {\
if (CYTHON_TRACE_NOGIL) {\
int ret = 0;\
PyThreadState *tstate;\
PyGILState_STATE state = PyGILState_Ensure();\
tstate = __Pyx_PyThreadState_Current;\
if (unlikely(tstate->use_tracing && tstate->c_tracefunc && __pyx_frame->f_trace)) {\
ret = __Pyx_call_line_trace_func(tstate, __pyx_frame, lineno);\
}\
PyGILState_Release(state);\
if (unlikely(ret)) goto_error;\
}\
} else {\
PyThreadState* tstate = __Pyx_PyThreadState_Current;\
if (unlikely(tstate->use_tracing && tstate->c_tracefunc && __pyx_frame->f_trace)) {\
int ret = __Pyx_call_line_trace_func(tstate, __pyx_frame, lineno);\
if (unlikely(ret)) goto_error;\
}\
}\
}
#else
#define __Pyx_TraceLine(lineno, nogil, goto_error)\
if (likely(!__Pyx_use_tracing)); else {\
PyThreadState* tstate = __Pyx_PyThreadState_Current;\
if (unlikely(tstate->use_tracing && tstate->c_tracefunc && __pyx_frame->f_trace)) {\
int ret = __Pyx_call_line_trace_func(tstate, __pyx_frame, lineno);\
if (unlikely(ret)) goto_error;\
}\
}
#endif
#else
#define __Pyx_TraceLine(lineno, nogil, goto_error) if ((1)); else goto_error;
#endif
/* WriteUnraisableException.proto */
static void __Pyx_WriteUnraisable(const char *name, int clineno,
int lineno, const char *filename,
int full_traceback, int nogil);
/* PyErrExceptionMatches.proto */
#if CYTHON_FAST_THREAD_STATE
#define __Pyx_PyErr_ExceptionMatches(err) __Pyx_PyErr_ExceptionMatchesInState(__pyx_tstate, err)
static CYTHON_INLINE int __Pyx_PyErr_ExceptionMatchesInState(PyThreadState* tstate, PyObject* err);
#else
#define __Pyx_PyErr_ExceptionMatches(err) PyErr_ExceptionMatches(err)
#endif
/* GetAttr.proto */
static CYTHON_INLINE PyObject *__Pyx_GetAttr(PyObject *, PyObject *);
/* GetAttr3.proto */
static CYTHON_INLINE PyObject *__Pyx_GetAttr3(PyObject *, PyObject *, PyObject *);
/* PyDictVersioning.proto */
#if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_TYPE_SLOTS
#define __PYX_DICT_VERSION_INIT ((PY_UINT64_T) -1)
#define __PYX_GET_DICT_VERSION(dict) (((PyDictObject*)(dict))->ma_version_tag)
#define __PYX_UPDATE_DICT_CACHE(dict, value, cache_var, version_var)\
(version_var) = __PYX_GET_DICT_VERSION(dict);\
(cache_var) = (value);
#define __PYX_PY_DICT_LOOKUP_IF_MODIFIED(VAR, DICT, LOOKUP) {\
static PY_UINT64_T __pyx_dict_version = 0;\
static PyObject *__pyx_dict_cached_value = NULL;\
if (likely(__PYX_GET_DICT_VERSION(DICT) == __pyx_dict_version)) {\
(VAR) = __pyx_dict_cached_value;\
} else {\
(VAR) = __pyx_dict_cached_value = (LOOKUP);\
__pyx_dict_version = __PYX_GET_DICT_VERSION(DICT);\
}\
}
static CYTHON_INLINE PY_UINT64_T __Pyx_get_tp_dict_version(PyObject *obj);
static CYTHON_INLINE PY_UINT64_T __Pyx_get_object_dict_version(PyObject *obj);
static CYTHON_INLINE int __Pyx_object_dict_version_matches(PyObject* obj, PY_UINT64_T tp_dict_version, PY_UINT64_T obj_dict_version);
#else
#define __PYX_GET_DICT_VERSION(dict) (0)
#define __PYX_UPDATE_DICT_CACHE(dict, value, cache_var, version_var)
#define __PYX_PY_DICT_LOOKUP_IF_MODIFIED(VAR, DICT, LOOKUP) (VAR) = (LOOKUP);
#endif
/* GetModuleGlobalName.proto */
#if CYTHON_USE_DICT_VERSIONS
#define __Pyx_GetModuleGlobalName(var, name) {\
static PY_UINT64_T __pyx_dict_version = 0;\
static PyObject *__pyx_dict_cached_value = NULL;\
(var) = (likely(__pyx_dict_version == __PYX_GET_DICT_VERSION(__pyx_d))) ?\
(likely(__pyx_dict_cached_value) ? __Pyx_NewRef(__pyx_dict_cached_value) : __Pyx_GetBuiltinName(name)) :\
__Pyx__GetModuleGlobalName(name, &__pyx_dict_version, &__pyx_dict_cached_value);\
}
#define __Pyx_GetModuleGlobalNameUncached(var, name) {\
PY_UINT64_T __pyx_dict_version;\
PyObject *__pyx_dict_cached_value;\
(var) = __Pyx__GetModuleGlobalName(name, &__pyx_dict_version, &__pyx_dict_cached_value);\
}
static PyObject *__Pyx__GetModuleGlobalName(PyObject *name, PY_UINT64_T *dict_version, PyObject **dict_cached_value);
#else
#define __Pyx_GetModuleGlobalName(var, name) (var) = __Pyx__GetModuleGlobalName(name)
#define __Pyx_GetModuleGlobalNameUncached(var, name) (var) = __Pyx__GetModuleGlobalName(name)
static CYTHON_INLINE PyObject *__Pyx__GetModuleGlobalName(PyObject *name);
#endif
/* KeywordStringCheck.proto */
static int __Pyx_CheckKeywordStrings(PyObject *kwdict, const char* function_name, int kw_allowed);
/* PyObjectCall.proto */
#if CYTHON_COMPILING_IN_CPYTHON
static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw);
#else
#define __Pyx_PyObject_Call(func, arg, kw) PyObject_Call(func, arg, kw)
#endif
/* RaiseArgTupleInvalid.proto */
static void __Pyx_RaiseArgtupleInvalid(const char* func_name, int exact,
Py_ssize_t num_min, Py_ssize_t num_max, Py_ssize_t num_found);
/* PyFunctionFastCall.proto */
#if CYTHON_FAST_PYCALL
#define __Pyx_PyFunction_FastCall(func, args, nargs)\
__Pyx_PyFunction_FastCallDict((func), (args), (nargs), NULL)
#if 1 || PY_VERSION_HEX < 0x030600B1
static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args, Py_ssize_t nargs, PyObject *kwargs);
#else
#define __Pyx_PyFunction_FastCallDict(func, args, nargs, kwargs) _PyFunction_FastCallDict(func, args, nargs, kwargs)
#endif
#define __Pyx_BUILD_ASSERT_EXPR(cond)\
(sizeof(char [1 - 2*!(cond)]) - 1)
#ifndef Py_MEMBER_SIZE
#define Py_MEMBER_SIZE(type, member) sizeof(((type *)0)->member)
#endif
static size_t __pyx_pyframe_localsplus_offset = 0;
#include "frameobject.h"
#define __Pxy_PyFrame_Initialize_Offsets()\
((void)__Pyx_BUILD_ASSERT_EXPR(sizeof(PyFrameObject) == offsetof(PyFrameObject, f_localsplus) + Py_MEMBER_SIZE(PyFrameObject, f_localsplus)),\
(void)(__pyx_pyframe_localsplus_offset = ((size_t)PyFrame_Type.tp_basicsize) - Py_MEMBER_SIZE(PyFrameObject, f_localsplus)))
#define __Pyx_PyFrame_GetLocalsplus(frame)\
(assert(__pyx_pyframe_localsplus_offset), (PyObject **)(((char *)(frame)) + __pyx_pyframe_localsplus_offset))
#endif
/* PyObjectCallMethO.proto */
#if CYTHON_COMPILING_IN_CPYTHON
static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg);
#endif
/* PyObjectCallNoArg.proto */
#if CYTHON_COMPILING_IN_CPYTHON
static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func);
#else
#define __Pyx_PyObject_CallNoArg(func) __Pyx_PyObject_Call(func, __pyx_empty_tuple, NULL)
#endif
/* PyCFunctionFastCall.proto */
#if CYTHON_FAST_PYCCALL
static CYTHON_INLINE PyObject *__Pyx_PyCFunction_FastCall(PyObject *func, PyObject **args, Py_ssize_t nargs);
#else
#define __Pyx_PyCFunction_FastCall(func, args, nargs) (assert(0), NULL)
#endif
/* PyObjectCallOneArg.proto */
static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg);
/* dict_getitem_default.proto */
static PyObject* __Pyx_PyDict_GetItemDefault(PyObject* d, PyObject* key, PyObject* default_value);
/* UnpackUnboundCMethod.proto */
typedef struct {
PyObject *type;
PyObject **method_name;
PyCFunction func;
PyObject *method;
int flag;
} __Pyx_CachedCFunction;
/* CallUnboundCMethod1.proto */
static PyObject* __Pyx__CallUnboundCMethod1(__Pyx_CachedCFunction* cfunc, PyObject* self, PyObject* arg);
#if CYTHON_COMPILING_IN_CPYTHON
static CYTHON_INLINE PyObject* __Pyx_CallUnboundCMethod1(__Pyx_CachedCFunction* cfunc, PyObject* self, PyObject* arg);
#else
#define __Pyx_CallUnboundCMethod1(cfunc, self, arg) __Pyx__CallUnboundCMethod1(cfunc, self, arg)
#endif
/* CallUnboundCMethod2.proto */
static PyObject* __Pyx__CallUnboundCMethod2(__Pyx_CachedCFunction* cfunc, PyObject* self, PyObject* arg1, PyObject* arg2);
#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030600B1
static CYTHON_INLINE PyObject *__Pyx_CallUnboundCMethod2(__Pyx_CachedCFunction *cfunc, PyObject *self, PyObject *arg1, PyObject *arg2);
#else
#define __Pyx_CallUnboundCMethod2(cfunc, self, arg1, arg2) __Pyx__CallUnboundCMethod2(cfunc, self, arg1, arg2)
#endif
/* FetchCommonType.proto */
static PyTypeObject* __Pyx_FetchCommonType(PyTypeObject* type);
/* CythonFunctionShared.proto */
#define __Pyx_CyFunction_USED 1
#define __Pyx_CYFUNCTION_STATICMETHOD 0x01
#define __Pyx_CYFUNCTION_CLASSMETHOD 0x02
#define __Pyx_CYFUNCTION_CCLASS 0x04
#define __Pyx_CyFunction_GetClosure(f)\
(((__pyx_CyFunctionObject *) (f))->func_closure)
#define __Pyx_CyFunction_GetClassObj(f)\
(((__pyx_CyFunctionObject *) (f))->func_classobj)
#define __Pyx_CyFunction_Defaults(type, f)\
((type *)(((__pyx_CyFunctionObject *) (f))->defaults))
#define __Pyx_CyFunction_SetDefaultsGetter(f, g)\
((__pyx_CyFunctionObject *) (f))->defaults_getter = (g)
typedef struct {
PyCFunctionObject func;
#if PY_VERSION_HEX < 0x030500A0
PyObject *func_weakreflist;
#endif
PyObject *func_dict;
PyObject *func_name;
PyObject *func_qualname;
PyObject *func_doc;
PyObject *func_globals;
PyObject *func_code;
PyObject *func_closure;
PyObject *func_classobj;
void *defaults;
int defaults_pyobjects;
size_t defaults_size; // used by FusedFunction for copying defaults
int flags;
PyObject *defaults_tuple;
PyObject *defaults_kwdict;
PyObject *(*defaults_getter)(PyObject *);
PyObject *func_annotations;
} __pyx_CyFunctionObject;
static PyTypeObject *__pyx_CyFunctionType = 0;
#define __Pyx_CyFunction_Check(obj) (__Pyx_TypeCheck(obj, __pyx_CyFunctionType))
static PyObject *__Pyx_CyFunction_Init(__pyx_CyFunctionObject* op, PyMethodDef *ml,
int flags, PyObject* qualname,
PyObject *self,
PyObject *module, PyObject *globals,
PyObject* code);
static CYTHON_INLINE void *__Pyx_CyFunction_InitDefaults(PyObject *m,
size_t size,
int pyobjects);
static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsTuple(PyObject *m,
PyObject *tuple);
static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsKwDict(PyObject *m,
PyObject *dict);
static CYTHON_INLINE void __Pyx_CyFunction_SetAnnotationsDict(PyObject *m,
PyObject *dict);
static int __pyx_CyFunction_init(void);
/* CythonFunction.proto */
static PyObject *__Pyx_CyFunction_New(PyMethodDef *ml,
int flags, PyObject* qualname,
PyObject *closure,
PyObject *module, PyObject *globals,
PyObject* code);
/* PyObjectCall2Args.proto */
static CYTHON_UNUSED PyObject* __Pyx_PyObject_Call2Args(PyObject* function, PyObject* arg1, PyObject* arg2);
/* GetItemInt.proto */
#define __Pyx_GetItemInt(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\
(__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\
__Pyx_GetItemInt_Fast(o, (Py_ssize_t)i, is_list, wraparound, boundscheck) :\
(is_list ? (PyErr_SetString(PyExc_IndexError, "list index out of range"), (PyObject*)NULL) :\
__Pyx_GetItemInt_Generic(o, to_py_func(i))))
#define __Pyx_GetItemInt_List(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\
(__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\
__Pyx_GetItemInt_List_Fast(o, (Py_ssize_t)i, wraparound, boundscheck) :\
(PyErr_SetString(PyExc_IndexError, "list index out of range"), (PyObject*)NULL))
static CYTHON_INLINE PyObject *__Pyx_GetItemInt_List_Fast(PyObject *o, Py_ssize_t i,
int wraparound, int boundscheck);
#define __Pyx_GetItemInt_Tuple(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\
(__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\
__Pyx_GetItemInt_Tuple_Fast(o, (Py_ssize_t)i, wraparound, boundscheck) :\
(PyErr_SetString(PyExc_IndexError, "tuple index out of range"), (PyObject*)NULL))
static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Tuple_Fast(PyObject *o, Py_ssize_t i,
int wraparound, int boundscheck);
static PyObject *__Pyx_GetItemInt_Generic(PyObject *o, PyObject* j);
static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Fast(PyObject *o, Py_ssize_t i,
int is_list, int wraparound, int boundscheck);
/* RaiseTooManyValuesToUnpack.proto */
static CYTHON_INLINE void __Pyx_RaiseTooManyValuesError(Py_ssize_t expected);
/* RaiseNeedMoreValuesToUnpack.proto */
static CYTHON_INLINE void __Pyx_RaiseNeedMoreValuesError(Py_ssize_t index);
/* IterFinish.proto */
static CYTHON_INLINE int __Pyx_IterFinish(void);
/* UnpackItemEndCheck.proto */
static int __Pyx_IternextUnpackEndCheck(PyObject *retval, Py_ssize_t expected);
/* IncludeStringH.proto */
#include <string.h>
/* BytesEquals.proto */
static CYTHON_INLINE int __Pyx_PyBytes_Equals(PyObject* s1, PyObject* s2, int equals);
/* UnicodeEquals.proto */
static CYTHON_INLINE int __Pyx_PyUnicode_Equals(PyObject* s1, PyObject* s2, int equals);
/* PyIntBinop.proto */
#if !CYTHON_COMPILING_IN_PYPY
static PyObject* __Pyx_PyInt_AddObjC(PyObject *op1, PyObject *op2, long intval, int inplace, int zerodivision_check);
#else
#define __Pyx_PyInt_AddObjC(op1, op2, intval, inplace, zerodivision_check)\
(inplace ? PyNumber_InPlaceAdd(op1, op2) : PyNumber_Add(op1, op2))
#endif
/* ObjectGetItem.proto */
#if CYTHON_USE_TYPE_SLOTS
static CYTHON_INLINE PyObject *__Pyx_PyObject_GetItem(PyObject *obj, PyObject* key);
#else
#define __Pyx_PyObject_GetItem(obj, key) PyObject_GetItem(obj, key)
#endif
/* DictGetItem.proto */
#if PY_MAJOR_VERSION >= 3 && !CYTHON_COMPILING_IN_PYPY
static PyObject *__Pyx_PyDict_GetItem(PyObject *d, PyObject* key);
#define __Pyx_PyObject_Dict_GetItem(obj, name)\
(likely(PyDict_CheckExact(obj)) ?\
__Pyx_PyDict_GetItem(obj, name) : PyObject_GetItem(obj, name))
#else
#define __Pyx_PyDict_GetItem(d, key) PyObject_GetItem(d, key)
#define __Pyx_PyObject_Dict_GetItem(obj, name) PyObject_GetItem(obj, name)
#endif
/* RaiseDoubleKeywords.proto */
static void __Pyx_RaiseDoubleKeywordsError(const char* func_name, PyObject* kw_name);
/* ParseKeywords.proto */
static int __Pyx_ParseOptionalKeywords(PyObject *kwds, PyObject **argnames[],\
PyObject *kwds2, PyObject *values[], Py_ssize_t num_pos_args,\
const char* function_name);
/* ArgTypeTest.proto */
#define __Pyx_ArgTypeTest(obj, type, none_allowed, name, exact)\
((likely((Py_TYPE(obj) == type) | (none_allowed && (obj == Py_None)))) ? 1 :\
__Pyx__ArgTypeTest(obj, type, name, exact))
static int __Pyx__ArgTypeTest(PyObject *obj, PyTypeObject *type, const char *name, int exact);
/* SliceTupleAndList.proto */
#if CYTHON_COMPILING_IN_CPYTHON
static CYTHON_INLINE PyObject* __Pyx_PyList_GetSlice(PyObject* src, Py_ssize_t start, Py_ssize_t stop);
static CYTHON_INLINE PyObject* __Pyx_PyTuple_GetSlice(PyObject* src, Py_ssize_t start, Py_ssize_t stop);
#else
#define __Pyx_PyList_GetSlice(seq, start, stop) PySequence_GetSlice(seq, start, stop)
#define __Pyx_PyTuple_GetSlice(seq, start, stop) PySequence_GetSlice(seq, start, stop)
#endif
/* ListCompAppend.proto */
#if CYTHON_USE_PYLIST_INTERNALS && CYTHON_ASSUME_SAFE_MACROS
static CYTHON_INLINE int __Pyx_ListComp_Append(PyObject* list, PyObject* x) {
PyListObject* L = (PyListObject*) list;
Py_ssize_t len = Py_SIZE(list);
if (likely(L->allocated > len)) {
Py_INCREF(x);
PyList_SET_ITEM(list, len, x);
__Pyx_SET_SIZE(list, len + 1);
return 0;
}
return PyList_Append(list, x);
}
#else
#define __Pyx_ListComp_Append(L,x) PyList_Append(L,x)
#endif
/* PySequenceContains.proto */
static CYTHON_INLINE int __Pyx_PySequence_ContainsTF(PyObject* item, PyObject* seq, int eq) {
int result = PySequence_Contains(seq, item);
return unlikely(result < 0) ? result : (result == (eq == Py_EQ));
}
/* ListAppend.proto */
#if CYTHON_USE_PYLIST_INTERNALS && CYTHON_ASSUME_SAFE_MACROS
static CYTHON_INLINE int __Pyx_PyList_Append(PyObject* list, PyObject* x) {
PyListObject* L = (PyListObject*) list;
Py_ssize_t len = Py_SIZE(list);
if (likely(L->allocated > len) & likely(len > (L->allocated >> 1))) {
Py_INCREF(x);
PyList_SET_ITEM(list, len, x);
__Pyx_SET_SIZE(list, len + 1);
return 0;
}
return PyList_Append(list, x);
}
#else
#define __Pyx_PyList_Append(L,x) PyList_Append(L,x)
#endif
/* RaiseException.proto */
static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause);
/* SetItemInt.proto */
#define __Pyx_SetItemInt(o, i, v, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\
(__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\
__Pyx_SetItemInt_Fast(o, (Py_ssize_t)i, v, is_list, wraparound, boundscheck) :\
(is_list ? (PyErr_SetString(PyExc_IndexError, "list assignment index out of range"), -1) :\
__Pyx_SetItemInt_Generic(o, to_py_func(i), v)))
static int __Pyx_SetItemInt_Generic(PyObject *o, PyObject *j, PyObject *v);
static CYTHON_INLINE int __Pyx_SetItemInt_Fast(PyObject *o, Py_ssize_t i, PyObject *v,
int is_list, int wraparound, int boundscheck);
/* Import.proto */
static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level);
/* ImportFrom.proto */
static PyObject* __Pyx_ImportFrom(PyObject* module, PyObject* name);
/* HasAttr.proto */
static CYTHON_INLINE int __Pyx_HasAttr(PyObject *, PyObject *);
/* RaiseNoneIterError.proto */
static CYTHON_INLINE void __Pyx_RaiseNoneNotIterableError(void);
/* ExtTypeTest.proto */
static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type);
/* GetTopmostException.proto */
#if CYTHON_USE_EXC_INFO_STACK
static _PyErr_StackItem * __Pyx_PyErr_GetTopmostException(PyThreadState *tstate);
#endif
/* SaveResetException.proto */
#if CYTHON_FAST_THREAD_STATE
#define __Pyx_ExceptionSave(type, value, tb) __Pyx__ExceptionSave(__pyx_tstate, type, value, tb)
static CYTHON_INLINE void __Pyx__ExceptionSave(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb);
#define __Pyx_ExceptionReset(type, value, tb) __Pyx__ExceptionReset(__pyx_tstate, type, value, tb)
static CYTHON_INLINE void __Pyx__ExceptionReset(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb);
#else
#define __Pyx_ExceptionSave(type, value, tb) PyErr_GetExcInfo(type, value, tb)
#define __Pyx_ExceptionReset(type, value, tb) PyErr_SetExcInfo(type, value, tb)
#endif
/* GetException.proto */
#if CYTHON_FAST_THREAD_STATE
#define __Pyx_GetException(type, value, tb) __Pyx__GetException(__pyx_tstate, type, value, tb)
static int __Pyx__GetException(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb);
#else
static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb);
#endif
/* tp_new.proto */
#define __Pyx_tp_new(type_obj, args) __Pyx_tp_new_kwargs(type_obj, args, NULL)
static CYTHON_INLINE PyObject* __Pyx_tp_new_kwargs(PyObject* type_obj, PyObject* args, PyObject* kwargs) {
return (PyObject*) (((PyTypeObject*)type_obj)->tp_new((PyTypeObject*)type_obj, args, kwargs));
}
/* StrEquals.proto */
#if PY_MAJOR_VERSION >= 3
#define __Pyx_PyString_Equals __Pyx_PyUnicode_Equals
#else
#define __Pyx_PyString_Equals __Pyx_PyBytes_Equals
#endif
/* UnaryNegOverflows.proto */
#define UNARY_NEG_WOULD_OVERFLOW(x)\
(((x) < 0) & ((unsigned long)(x) == 0-(unsigned long)(x)))
static CYTHON_UNUSED int __pyx_array_getbuffer(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags); /*proto*/
static PyObject *__pyx_array_get_memview(struct __pyx_array_obj *); /*proto*/
/* decode_c_string_utf16.proto */
static CYTHON_INLINE PyObject *__Pyx_PyUnicode_DecodeUTF16(const char *s, Py_ssize_t size, const char *errors) {
int byteorder = 0;
return PyUnicode_DecodeUTF16(s, size, errors, &byteorder);
}
static CYTHON_INLINE PyObject *__Pyx_PyUnicode_DecodeUTF16LE(const char *s, Py_ssize_t size, const char *errors) {
int byteorder = -1;
return PyUnicode_DecodeUTF16(s, size, errors, &byteorder);
}
static CYTHON_INLINE PyObject *__Pyx_PyUnicode_DecodeUTF16BE(const char *s, Py_ssize_t size, const char *errors) {
int byteorder = 1;
return PyUnicode_DecodeUTF16(s, size, errors, &byteorder);
}
/* decode_c_string.proto */
static CYTHON_INLINE PyObject* __Pyx_decode_c_string(
const char* cstring, Py_ssize_t start, Py_ssize_t stop,
const char* encoding, const char* errors,
PyObject* (*decode_func)(const char *s, Py_ssize_t size, const char *errors));
/* SwapException.proto */
#if CYTHON_FAST_THREAD_STATE
#define __Pyx_ExceptionSwap(type, value, tb) __Pyx__ExceptionSwap(__pyx_tstate, type, value, tb)
static CYTHON_INLINE void __Pyx__ExceptionSwap(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb);
#else
static CYTHON_INLINE void __Pyx_ExceptionSwap(PyObject **type, PyObject **value, PyObject **tb);
#endif
/* FastTypeChecks.proto */
#if CYTHON_COMPILING_IN_CPYTHON
#define __Pyx_TypeCheck(obj, type) __Pyx_IsSubtype(Py_TYPE(obj), (PyTypeObject *)type)
static CYTHON_INLINE int __Pyx_IsSubtype(PyTypeObject *a, PyTypeObject *b);
static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches(PyObject *err, PyObject *type);
static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches2(PyObject *err, PyObject *type1, PyObject *type2);
#else
#define __Pyx_TypeCheck(obj, type) PyObject_TypeCheck(obj, (PyTypeObject *)type)
#define __Pyx_PyErr_GivenExceptionMatches(err, type) PyErr_GivenExceptionMatches(err, type)
#define __Pyx_PyErr_GivenExceptionMatches2(err, type1, type2) (PyErr_GivenExceptionMatches(err, type1) || PyErr_GivenExceptionMatches(err, type2))
#endif
#define __Pyx_PyException_Check(obj) __Pyx_TypeCheck(obj, PyExc_Exception)
static CYTHON_UNUSED int __pyx_memoryview_getbuffer(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags); /*proto*/
/* ListExtend.proto */
static CYTHON_INLINE int __Pyx_PyList_Extend(PyObject* L, PyObject* v) {
#if CYTHON_COMPILING_IN_CPYTHON
PyObject* none = _PyList_Extend((PyListObject*)L, v);
if (unlikely(!none))
return -1;
Py_DECREF(none);
return 0;
#else
return PyList_SetSlice(L, PY_SSIZE_T_MAX, PY_SSIZE_T_MAX, v);
#endif
}
/* None.proto */
static CYTHON_INLINE void __Pyx_RaiseUnboundLocalError(const char *varname);
/* CallNextTpDealloc.proto */
static void __Pyx_call_next_tp_dealloc(PyObject* obj, destructor current_tp_dealloc);
/* CallNextTpTraverse.proto */
static int __Pyx_call_next_tp_traverse(PyObject* obj, visitproc v, void *a, traverseproc current_tp_traverse);
/* CallNextTpClear.proto */
static void __Pyx_call_next_tp_clear(PyObject* obj, inquiry current_tp_dealloc);
/* PyObject_GenericGetAttrNoDict.proto */
#if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000
static CYTHON_INLINE PyObject* __Pyx_PyObject_GenericGetAttrNoDict(PyObject* obj, PyObject* attr_name);
#else
#define __Pyx_PyObject_GenericGetAttrNoDict PyObject_GenericGetAttr
#endif
/* PyObject_GenericGetAttr.proto */
#if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000
static PyObject* __Pyx_PyObject_GenericGetAttr(PyObject* obj, PyObject* attr_name);
#else
#define __Pyx_PyObject_GenericGetAttr PyObject_GenericGetAttr
#endif
/* TypeImport.proto */
#ifndef __PYX_HAVE_RT_ImportType_proto
#define __PYX_HAVE_RT_ImportType_proto
enum __Pyx_ImportType_CheckSize {
__Pyx_ImportType_CheckSize_Error = 0,
__Pyx_ImportType_CheckSize_Warn = 1,
__Pyx_ImportType_CheckSize_Ignore = 2
};
static PyTypeObject *__Pyx_ImportType(PyObject* module, const char *module_name, const char *class_name, size_t size, enum __Pyx_ImportType_CheckSize check_size);
#endif
/* GetVTable.proto */
static void* __Pyx_GetVtable(PyObject *dict);
/* SetVTable.proto */
static int __Pyx_SetVtable(PyObject *dict, void *vtable);
/* PyObjectGetAttrStrNoError.proto */
static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStrNoError(PyObject* obj, PyObject* attr_name);
/* SetupReduce.proto */
static int __Pyx_setup_reduce(PyObject* type_obj);
/* ClassMethod.proto */
#include "descrobject.h"
static CYTHON_UNUSED PyObject* __Pyx_Method_ClassMethod(PyObject *method);
/* GetNameInClass.proto */
#define __Pyx_GetNameInClass(var, nmspace, name) (var) = __Pyx__GetNameInClass(nmspace, name)
static PyObject *__Pyx__GetNameInClass(PyObject *nmspace, PyObject *name);
/* CLineInTraceback.proto */
#ifdef CYTHON_CLINE_IN_TRACEBACK
#define __Pyx_CLineForTraceback(tstate, c_line) (((CYTHON_CLINE_IN_TRACEBACK)) ? c_line : 0)
#else
static int __Pyx_CLineForTraceback(PyThreadState *tstate, int c_line);
#endif
/* CodeObjectCache.proto */
typedef struct {
PyCodeObject* code_object;
int code_line;
} __Pyx_CodeObjectCacheEntry;
struct __Pyx_CodeObjectCache {
int count;
int max_count;
__Pyx_CodeObjectCacheEntry* entries;
};
static struct __Pyx_CodeObjectCache __pyx_code_cache = {0,0,NULL};
static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line);
static PyCodeObject *__pyx_find_code_object(int code_line);
static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object);
/* AddTraceback.proto */
static void __Pyx_AddTraceback(const char *funcname, int c_line,
int py_line, const char *filename);
/* CIntToPy.proto */
static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value);
/* CIntToPy.proto */
static CYTHON_INLINE PyObject* __Pyx_PyInt_From_uint64_t(uint64_t value);
/* CIntToPy.proto */
static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value);
/* CIntToPy.proto */
static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int32_t(int32_t value);
/* None.proto */
#include <new>
/* RealImag.proto */
#if CYTHON_CCOMPLEX
#ifdef __cplusplus
#define __Pyx_CREAL(z) ((z).real())
#define __Pyx_CIMAG(z) ((z).imag())
#else
#define __Pyx_CREAL(z) (__real__(z))
#define __Pyx_CIMAG(z) (__imag__(z))
#endif
#else
#define __Pyx_CREAL(z) ((z).real)
#define __Pyx_CIMAG(z) ((z).imag)
#endif
#if defined(__cplusplus) && CYTHON_CCOMPLEX\
&& (defined(_WIN32) || defined(__clang__) || (defined(__GNUC__) && (__GNUC__ >= 5 || __GNUC__ == 4 && __GNUC_MINOR__ >= 4 )) || __cplusplus >= 201103)
#define __Pyx_SET_CREAL(z,x) ((z).real(x))
#define __Pyx_SET_CIMAG(z,y) ((z).imag(y))
#else
#define __Pyx_SET_CREAL(z,x) __Pyx_CREAL(z) = (x)
#define __Pyx_SET_CIMAG(z,y) __Pyx_CIMAG(z) = (y)
#endif
/* Arithmetic.proto */
#if CYTHON_CCOMPLEX
#define __Pyx_c_eq_float(a, b) ((a)==(b))
#define __Pyx_c_sum_float(a, b) ((a)+(b))
#define __Pyx_c_diff_float(a, b) ((a)-(b))
#define __Pyx_c_prod_float(a, b) ((a)*(b))
#define __Pyx_c_quot_float(a, b) ((a)/(b))
#define __Pyx_c_neg_float(a) (-(a))
#ifdef __cplusplus
#define __Pyx_c_is_zero_float(z) ((z)==(float)0)
#define __Pyx_c_conj_float(z) (::std::conj(z))
#if 1
#define __Pyx_c_abs_float(z) (::std::abs(z))
#define __Pyx_c_pow_float(a, b) (::std::pow(a, b))
#endif
#else
#define __Pyx_c_is_zero_float(z) ((z)==0)
#define __Pyx_c_conj_float(z) (conjf(z))
#if 1
#define __Pyx_c_abs_float(z) (cabsf(z))
#define __Pyx_c_pow_float(a, b) (cpowf(a, b))
#endif
#endif
#else
static CYTHON_INLINE int __Pyx_c_eq_float(__pyx_t_float_complex, __pyx_t_float_complex);
static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_sum_float(__pyx_t_float_complex, __pyx_t_float_complex);
static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_diff_float(__pyx_t_float_complex, __pyx_t_float_complex);
static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_prod_float(__pyx_t_float_complex, __pyx_t_float_complex);
static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_quot_float(__pyx_t_float_complex, __pyx_t_float_complex);
static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_neg_float(__pyx_t_float_complex);
static CYTHON_INLINE int __Pyx_c_is_zero_float(__pyx_t_float_complex);
static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_conj_float(__pyx_t_float_complex);
#if 1
static CYTHON_INLINE float __Pyx_c_abs_float(__pyx_t_float_complex);
static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_pow_float(__pyx_t_float_complex, __pyx_t_float_complex);
#endif
#endif
/* Arithmetic.proto */
#if CYTHON_CCOMPLEX
#define __Pyx_c_eq_double(a, b) ((a)==(b))
#define __Pyx_c_sum_double(a, b) ((a)+(b))
#define __Pyx_c_diff_double(a, b) ((a)-(b))
#define __Pyx_c_prod_double(a, b) ((a)*(b))
#define __Pyx_c_quot_double(a, b) ((a)/(b))
#define __Pyx_c_neg_double(a) (-(a))
#ifdef __cplusplus
#define __Pyx_c_is_zero_double(z) ((z)==(double)0)
#define __Pyx_c_conj_double(z) (::std::conj(z))
#if 1
#define __Pyx_c_abs_double(z) (::std::abs(z))
#define __Pyx_c_pow_double(a, b) (::std::pow(a, b))
#endif
#else
#define __Pyx_c_is_zero_double(z) ((z)==0)
#define __Pyx_c_conj_double(z) (conj(z))
#if 1
#define __Pyx_c_abs_double(z) (cabs(z))
#define __Pyx_c_pow_double(a, b) (cpow(a, b))
#endif
#endif
#else
static CYTHON_INLINE int __Pyx_c_eq_double(__pyx_t_double_complex, __pyx_t_double_complex);
static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_sum_double(__pyx_t_double_complex, __pyx_t_double_complex);
static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_diff_double(__pyx_t_double_complex, __pyx_t_double_complex);
static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_prod_double(__pyx_t_double_complex, __pyx_t_double_complex);
static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_quot_double(__pyx_t_double_complex, __pyx_t_double_complex);
static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_neg_double(__pyx_t_double_complex);
static CYTHON_INLINE int __Pyx_c_is_zero_double(__pyx_t_double_complex);
static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_conj_double(__pyx_t_double_complex);
#if 1
static CYTHON_INLINE double __Pyx_c_abs_double(__pyx_t_double_complex);
static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_pow_double(__pyx_t_double_complex, __pyx_t_double_complex);
#endif
#endif
/* CIntToPy.proto */
static CYTHON_INLINE PyObject* __Pyx_PyInt_From_enum__NPY_TYPES(enum NPY_TYPES value);
#if PY_MAJOR_VERSION < 3
static int __Pyx_GetBuffer(PyObject *obj, Py_buffer *view, int flags);
static void __Pyx_ReleaseBuffer(Py_buffer *view);
#else
#define __Pyx_GetBuffer PyObject_GetBuffer
#define __Pyx_ReleaseBuffer PyBuffer_Release
#endif
/* BufferStructDeclare.proto */
typedef struct {
Py_ssize_t shape, strides, suboffsets;
} __Pyx_Buf_DimInfo;
typedef struct {
size_t refcount;
Py_buffer pybuffer;
} __Pyx_Buffer;
typedef struct {
__Pyx_Buffer *rcbuffer;
char *data;
__Pyx_Buf_DimInfo diminfo[8];
} __Pyx_LocalBuf_ND;
/* MemviewSliceIsContig.proto */
static int __pyx_memviewslice_is_contig(const __Pyx_memviewslice mvs, char order, int ndim);
/* OverlappingSlices.proto */
static int __pyx_slices_overlap(__Pyx_memviewslice *slice1,
__Pyx_memviewslice *slice2,
int ndim, size_t itemsize);
/* Capsule.proto */
static CYTHON_INLINE PyObject *__pyx_capsule_create(void *p, const char *sig);
/* CIntFromPy.proto */
static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *);
/* CIntFromPy.proto */
static CYTHON_INLINE uint64_t __Pyx_PyInt_As_uint64_t(PyObject *);
/* CIntFromPy.proto */
static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *);
/* CIntFromPy.proto */
static CYTHON_INLINE int32_t __Pyx_PyInt_As_int32_t(PyObject *);
/* MemviewSliceCopyTemplate.proto */
static __Pyx_memviewslice
__pyx_memoryview_copy_new_contig(const __Pyx_memviewslice *from_mvs,
const char *mode, int ndim,
size_t sizeof_dtype, int contig_flag,
int dtype_is_object);
/* MemviewSliceInit.proto */
#define __Pyx_BUF_MAX_NDIMS %(BUF_MAX_NDIMS)d
#define __Pyx_MEMVIEW_DIRECT 1
#define __Pyx_MEMVIEW_PTR 2
#define __Pyx_MEMVIEW_FULL 4
#define __Pyx_MEMVIEW_CONTIG 8
#define __Pyx_MEMVIEW_STRIDED 16
#define __Pyx_MEMVIEW_FOLLOW 32
#define __Pyx_IS_C_CONTIG 1
#define __Pyx_IS_F_CONTIG 2
static int __Pyx_init_memviewslice(
struct __pyx_memoryview_obj *memview,
int ndim,
__Pyx_memviewslice *memviewslice,
int memview_is_new_reference);
static CYTHON_INLINE int __pyx_add_acquisition_count_locked(
__pyx_atomic_int *acquisition_count, PyThread_type_lock lock);
static CYTHON_INLINE int __pyx_sub_acquisition_count_locked(
__pyx_atomic_int *acquisition_count, PyThread_type_lock lock);
#define __pyx_get_slice_count_pointer(memview) (memview->acquisition_count_aligned_p)
#define __pyx_get_slice_count(memview) (*__pyx_get_slice_count_pointer(memview))
#define __PYX_INC_MEMVIEW(slice, have_gil) __Pyx_INC_MEMVIEW(slice, have_gil, __LINE__)
#define __PYX_XDEC_MEMVIEW(slice, have_gil) __Pyx_XDEC_MEMVIEW(slice, have_gil, __LINE__)
static CYTHON_INLINE void __Pyx_INC_MEMVIEW(__Pyx_memviewslice *, int, int);
static CYTHON_INLINE void __Pyx_XDEC_MEMVIEW(__Pyx_memviewslice *, int, int);
/* CIntFromPy.proto */
static CYTHON_INLINE char __Pyx_PyInt_As_char(PyObject *);
/* CheckBinaryVersion.proto */
static int __Pyx_check_binary_version(void);
/* FunctionExport.proto */
static int __Pyx_ExportFunction(const char *name, void (*f)(void), const char *sig);
/* VoidPtrImport.proto */
static int __Pyx_ImportVoidPtr(PyObject *module, const char *name, void **p, const char *sig);
/* FunctionImport.proto */
static int __Pyx_ImportFunction(PyObject *module, const char *funcname, void (**f)(void), const char *sig);
/* InitStrings.proto */
static int __Pyx_InitStrings(__Pyx_StringTabEntry *t);
static int __pyx_f_5spacy_6syntax_9arc_eager_5Shift_is_valid(__pyx_t_5spacy_6syntax_6_state_StateC const *__pyx_v_st, CYTHON_UNUSED __pyx_t_5spacy_8typedefs_attr_t __pyx_v_label); /* proto*/
static int __pyx_f_5spacy_6syntax_9arc_eager_5Shift_transition(__pyx_t_5spacy_6syntax_6_state_StateC *__pyx_v_st, CYTHON_UNUSED __pyx_t_5spacy_8typedefs_attr_t __pyx_v_label); /* proto*/
static __pyx_t_5thinc_8typedefs_weight_t __pyx_f_5spacy_6syntax_9arc_eager_5Shift_cost(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *__pyx_v_st, struct __pyx_t_5spacy_4gold_GoldParseC const *__pyx_v_gold, __pyx_t_5spacy_8typedefs_attr_t __pyx_v_label); /* proto*/
static CYTHON_INLINE __pyx_t_5thinc_8typedefs_weight_t __pyx_f_5spacy_6syntax_9arc_eager_5Shift_move_cost(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *__pyx_v_s, struct __pyx_t_5spacy_4gold_GoldParseC const *__pyx_v_gold); /* proto*/
static CYTHON_INLINE __pyx_t_5thinc_8typedefs_weight_t __pyx_f_5spacy_6syntax_9arc_eager_5Shift_label_cost(CYTHON_UNUSED struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *__pyx_v_s, CYTHON_UNUSED struct __pyx_t_5spacy_4gold_GoldParseC const *__pyx_v_gold, CYTHON_UNUSED __pyx_t_5spacy_8typedefs_attr_t __pyx_v_label); /* proto*/
static int __pyx_f_5spacy_6syntax_9arc_eager_6Reduce_is_valid(__pyx_t_5spacy_6syntax_6_state_StateC const *__pyx_v_st, CYTHON_UNUSED __pyx_t_5spacy_8typedefs_attr_t __pyx_v_label); /* proto*/
static int __pyx_f_5spacy_6syntax_9arc_eager_6Reduce_transition(__pyx_t_5spacy_6syntax_6_state_StateC *__pyx_v_st, CYTHON_UNUSED __pyx_t_5spacy_8typedefs_attr_t __pyx_v_label); /* proto*/
static __pyx_t_5thinc_8typedefs_weight_t __pyx_f_5spacy_6syntax_9arc_eager_6Reduce_cost(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *__pyx_v_s, struct __pyx_t_5spacy_4gold_GoldParseC const *__pyx_v_gold, __pyx_t_5spacy_8typedefs_attr_t __pyx_v_label); /* proto*/
static CYTHON_INLINE __pyx_t_5thinc_8typedefs_weight_t __pyx_f_5spacy_6syntax_9arc_eager_6Reduce_move_cost(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *__pyx_v_st, struct __pyx_t_5spacy_4gold_GoldParseC const *__pyx_v_gold); /* proto*/
static CYTHON_INLINE __pyx_t_5thinc_8typedefs_weight_t __pyx_f_5spacy_6syntax_9arc_eager_6Reduce_label_cost(CYTHON_UNUSED struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *__pyx_v_s, CYTHON_UNUSED struct __pyx_t_5spacy_4gold_GoldParseC const *__pyx_v_gold, CYTHON_UNUSED __pyx_t_5spacy_8typedefs_attr_t __pyx_v_label); /* proto*/
static int __pyx_f_5spacy_6syntax_9arc_eager_7LeftArc_is_valid(__pyx_t_5spacy_6syntax_6_state_StateC const *__pyx_v_st, __pyx_t_5spacy_8typedefs_attr_t __pyx_v_label); /* proto*/
static int __pyx_f_5spacy_6syntax_9arc_eager_7LeftArc_transition(__pyx_t_5spacy_6syntax_6_state_StateC *__pyx_v_st, __pyx_t_5spacy_8typedefs_attr_t __pyx_v_label); /* proto*/
static __pyx_t_5thinc_8typedefs_weight_t __pyx_f_5spacy_6syntax_9arc_eager_7LeftArc_cost(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *__pyx_v_s, struct __pyx_t_5spacy_4gold_GoldParseC const *__pyx_v_gold, __pyx_t_5spacy_8typedefs_attr_t __pyx_v_label); /* proto*/
static CYTHON_INLINE __pyx_t_5thinc_8typedefs_weight_t __pyx_f_5spacy_6syntax_9arc_eager_7LeftArc_move_cost(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *__pyx_v_s, struct __pyx_t_5spacy_4gold_GoldParseC const *__pyx_v_gold); /* proto*/
static CYTHON_INLINE __pyx_t_5thinc_8typedefs_weight_t __pyx_f_5spacy_6syntax_9arc_eager_7LeftArc_label_cost(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *__pyx_v_s, struct __pyx_t_5spacy_4gold_GoldParseC const *__pyx_v_gold, __pyx_t_5spacy_8typedefs_attr_t __pyx_v_label); /* proto*/
static int __pyx_f_5spacy_6syntax_9arc_eager_8RightArc_is_valid(__pyx_t_5spacy_6syntax_6_state_StateC const *__pyx_v_st, __pyx_t_5spacy_8typedefs_attr_t __pyx_v_label); /* proto*/
static int __pyx_f_5spacy_6syntax_9arc_eager_8RightArc_transition(__pyx_t_5spacy_6syntax_6_state_StateC *__pyx_v_st, __pyx_t_5spacy_8typedefs_attr_t __pyx_v_label); /* proto*/
static CYTHON_INLINE __pyx_t_5thinc_8typedefs_weight_t __pyx_f_5spacy_6syntax_9arc_eager_8RightArc_cost(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *__pyx_v_s, struct __pyx_t_5spacy_4gold_GoldParseC const *__pyx_v_gold, __pyx_t_5spacy_8typedefs_attr_t __pyx_v_label); /* proto*/
static CYTHON_INLINE __pyx_t_5thinc_8typedefs_weight_t __pyx_f_5spacy_6syntax_9arc_eager_8RightArc_move_cost(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *__pyx_v_s, struct __pyx_t_5spacy_4gold_GoldParseC const *__pyx_v_gold); /* proto*/
static __pyx_t_5thinc_8typedefs_weight_t __pyx_f_5spacy_6syntax_9arc_eager_8RightArc_label_cost(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *__pyx_v_s, struct __pyx_t_5spacy_4gold_GoldParseC const *__pyx_v_gold, __pyx_t_5spacy_8typedefs_attr_t __pyx_v_label); /* proto*/
static int __pyx_f_5spacy_6syntax_9arc_eager_5Break_is_valid(__pyx_t_5spacy_6syntax_6_state_StateC const *__pyx_v_st, CYTHON_UNUSED __pyx_t_5spacy_8typedefs_attr_t __pyx_v_label); /* proto*/
static int __pyx_f_5spacy_6syntax_9arc_eager_5Break_transition(__pyx_t_5spacy_6syntax_6_state_StateC *__pyx_v_st, CYTHON_UNUSED __pyx_t_5spacy_8typedefs_attr_t __pyx_v_label); /* proto*/
static __pyx_t_5thinc_8typedefs_weight_t __pyx_f_5spacy_6syntax_9arc_eager_5Break_cost(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *__pyx_v_s, struct __pyx_t_5spacy_4gold_GoldParseC const *__pyx_v_gold, __pyx_t_5spacy_8typedefs_attr_t __pyx_v_label); /* proto*/
static CYTHON_INLINE __pyx_t_5thinc_8typedefs_weight_t __pyx_f_5spacy_6syntax_9arc_eager_5Break_move_cost(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *__pyx_v_s, struct __pyx_t_5spacy_4gold_GoldParseC const *__pyx_v_gold); /* proto*/
static CYTHON_INLINE __pyx_t_5thinc_8typedefs_weight_t __pyx_f_5spacy_6syntax_9arc_eager_5Break_label_cost(CYTHON_UNUSED struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *__pyx_v_s, CYTHON_UNUSED struct __pyx_t_5spacy_4gold_GoldParseC const *__pyx_v_gold, CYTHON_UNUSED __pyx_t_5spacy_8typedefs_attr_t __pyx_v_label); /* proto*/
static struct __pyx_t_5spacy_6syntax_17transition_system_Transition __pyx_f_5spacy_6syntax_9arc_eager_8ArcEager_lookup_transition(struct __pyx_obj_5spacy_6syntax_9arc_eager_ArcEager *__pyx_v_self, PyObject *__pyx_v_name_or_id); /* proto*/
static struct __pyx_t_5spacy_6syntax_17transition_system_Transition __pyx_f_5spacy_6syntax_9arc_eager_8ArcEager_init_transition(CYTHON_UNUSED struct __pyx_obj_5spacy_6syntax_9arc_eager_ArcEager *__pyx_v_self, int __pyx_v_clas, int __pyx_v_move, __pyx_t_5spacy_8typedefs_attr_t __pyx_v_label); /* proto*/
static int __pyx_f_5spacy_6syntax_9arc_eager_8ArcEager_initialize_state(CYTHON_UNUSED struct __pyx_obj_5spacy_6syntax_9arc_eager_ArcEager *__pyx_v_self, __pyx_t_5spacy_6syntax_6_state_StateC *__pyx_v_st); /* proto*/
static int __pyx_f_5spacy_6syntax_9arc_eager_8ArcEager_finalize_state(struct __pyx_obj_5spacy_6syntax_9arc_eager_ArcEager *__pyx_v_self, __pyx_t_5spacy_6syntax_6_state_StateC *__pyx_v_st); /* proto*/
static int __pyx_f_5spacy_6syntax_9arc_eager_8ArcEager_set_valid(struct __pyx_obj_5spacy_6syntax_9arc_eager_ArcEager *__pyx_v_self, int *__pyx_v_output, __pyx_t_5spacy_6syntax_6_state_StateC const *__pyx_v_st); /* proto*/
static int __pyx_f_5spacy_6syntax_9arc_eager_8ArcEager_set_costs(struct __pyx_obj_5spacy_6syntax_9arc_eager_ArcEager *__pyx_v_self, int *__pyx_v_is_valid, __pyx_t_5thinc_8typedefs_weight_t *__pyx_v_costs, struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *__pyx_v_stcls, struct __pyx_obj_5spacy_4gold_GoldParse *__pyx_v_gold); /* proto*/
static CYTHON_INLINE struct __pyx_obj_5spacy_6lexeme_Lexeme *__pyx_f_5spacy_6lexeme_6Lexeme_from_ptr(struct __pyx_t_5spacy_7structs_LexemeC *__pyx_v_lex, struct __pyx_obj_5spacy_5vocab_Vocab *__pyx_v_vocab, CYTHON_UNUSED int __pyx_v_vector_length); /* proto*/
static CYTHON_INLINE void __pyx_f_5spacy_6lexeme_6Lexeme_set_struct_attr(struct __pyx_t_5spacy_7structs_LexemeC *__pyx_v_lex, enum __pyx_t_5spacy_5attrs_attr_id_t __pyx_v_name, __pyx_t_5spacy_8typedefs_attr_t __pyx_v_value); /* proto*/
static CYTHON_INLINE __pyx_t_5spacy_8typedefs_attr_t __pyx_f_5spacy_6lexeme_6Lexeme_get_struct_attr(struct __pyx_t_5spacy_7structs_LexemeC const *__pyx_v_lex, enum __pyx_t_5spacy_5attrs_attr_id_t __pyx_v_feat_name); /* proto*/
static CYTHON_INLINE int __pyx_f_5spacy_6lexeme_6Lexeme_c_check_flag(struct __pyx_t_5spacy_7structs_LexemeC const *__pyx_v_lexeme, enum __pyx_t_5spacy_5attrs_attr_id_t __pyx_v_flag_id); /* proto*/
static CYTHON_INLINE int __pyx_f_5spacy_6lexeme_6Lexeme_c_set_flag(struct __pyx_t_5spacy_7structs_LexemeC *__pyx_v_lex, enum __pyx_t_5spacy_5attrs_attr_id_t __pyx_v_flag_id, int __pyx_v_value); /* proto*/
static CYTHON_INLINE struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *__pyx_f_5spacy_6syntax_10stateclass_10StateClass_init(struct __pyx_t_5spacy_7structs_TokenC const *__pyx_v_sent, int __pyx_v_length); /* proto*/
static CYTHON_INLINE struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *__pyx_f_5spacy_6syntax_10stateclass_10StateClass_borrow(__pyx_t_5spacy_6syntax_6_state_StateC *__pyx_v_ptr); /* proto*/
static CYTHON_INLINE struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *__pyx_f_5spacy_6syntax_10stateclass_10StateClass_init_offset(struct __pyx_t_5spacy_7structs_TokenC const *__pyx_v_sent, int __pyx_v_length, int __pyx_v_offset); /* proto*/
static CYTHON_INLINE int __pyx_f_5spacy_6syntax_10stateclass_10StateClass_S(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *__pyx_v_self, int __pyx_v_i); /* proto*/
static CYTHON_INLINE int __pyx_f_5spacy_6syntax_10stateclass_10StateClass_B(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *__pyx_v_self, int __pyx_v_i); /* proto*/
static CYTHON_INLINE struct __pyx_t_5spacy_7structs_TokenC const *__pyx_f_5spacy_6syntax_10stateclass_10StateClass_S_(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *__pyx_v_self, int __pyx_v_i); /* proto*/
static CYTHON_INLINE struct __pyx_t_5spacy_7structs_TokenC const *__pyx_f_5spacy_6syntax_10stateclass_10StateClass_B_(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *__pyx_v_self, int __pyx_v_i); /* proto*/
static CYTHON_INLINE struct __pyx_t_5spacy_7structs_TokenC const *__pyx_f_5spacy_6syntax_10stateclass_10StateClass_H_(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *__pyx_v_self, int __pyx_v_i); /* proto*/
static CYTHON_INLINE struct __pyx_t_5spacy_7structs_TokenC const *__pyx_f_5spacy_6syntax_10stateclass_10StateClass_E_(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *__pyx_v_self, int __pyx_v_i); /* proto*/
static CYTHON_INLINE struct __pyx_t_5spacy_7structs_TokenC const *__pyx_f_5spacy_6syntax_10stateclass_10StateClass_L_(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *__pyx_v_self, int __pyx_v_i, int __pyx_v_idx); /* proto*/
static CYTHON_INLINE struct __pyx_t_5spacy_7structs_TokenC const *__pyx_f_5spacy_6syntax_10stateclass_10StateClass_R_(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *__pyx_v_self, int __pyx_v_i, int __pyx_v_idx); /* proto*/
static CYTHON_INLINE struct __pyx_t_5spacy_7structs_TokenC const *__pyx_f_5spacy_6syntax_10stateclass_10StateClass_safe_get(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *__pyx_v_self, int __pyx_v_i); /* proto*/
static CYTHON_INLINE int __pyx_f_5spacy_6syntax_10stateclass_10StateClass_H(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *__pyx_v_self, int __pyx_v_i); /* proto*/
static CYTHON_INLINE int __pyx_f_5spacy_6syntax_10stateclass_10StateClass_E(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *__pyx_v_self, int __pyx_v_i); /* proto*/
static CYTHON_INLINE int __pyx_f_5spacy_6syntax_10stateclass_10StateClass_L(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *__pyx_v_self, int __pyx_v_i, int __pyx_v_idx); /* proto*/
static CYTHON_INLINE int __pyx_f_5spacy_6syntax_10stateclass_10StateClass_R(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *__pyx_v_self, int __pyx_v_i, int __pyx_v_idx); /* proto*/
static CYTHON_INLINE int __pyx_f_5spacy_6syntax_10stateclass_10StateClass_empty(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *__pyx_v_self); /* proto*/
static CYTHON_INLINE int __pyx_f_5spacy_6syntax_10stateclass_10StateClass_eol(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *__pyx_v_self); /* proto*/
static CYTHON_INLINE int __pyx_f_5spacy_6syntax_10stateclass_10StateClass_at_break(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *__pyx_v_self); /* proto*/
static CYTHON_INLINE int __pyx_f_5spacy_6syntax_10stateclass_10StateClass_has_head(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *__pyx_v_self, int __pyx_v_i); /* proto*/
static CYTHON_INLINE int __pyx_f_5spacy_6syntax_10stateclass_10StateClass_n_L(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *__pyx_v_self, int __pyx_v_i); /* proto*/
static CYTHON_INLINE int __pyx_f_5spacy_6syntax_10stateclass_10StateClass_n_R(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *__pyx_v_self, int __pyx_v_i); /* proto*/
static CYTHON_INLINE int __pyx_f_5spacy_6syntax_10stateclass_10StateClass_stack_is_connected(CYTHON_UNUSED struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *__pyx_v_self); /* proto*/
static CYTHON_INLINE int __pyx_f_5spacy_6syntax_10stateclass_10StateClass_entity_is_open(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *__pyx_v_self); /* proto*/
static CYTHON_INLINE int __pyx_f_5spacy_6syntax_10stateclass_10StateClass_stack_depth(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *__pyx_v_self); /* proto*/
static CYTHON_INLINE int __pyx_f_5spacy_6syntax_10stateclass_10StateClass_buffer_length(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *__pyx_v_self); /* proto*/
static CYTHON_INLINE void __pyx_f_5spacy_6syntax_10stateclass_10StateClass_push(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *__pyx_v_self); /* proto*/
static CYTHON_INLINE void __pyx_f_5spacy_6syntax_10stateclass_10StateClass_pop(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *__pyx_v_self); /* proto*/
static CYTHON_INLINE void __pyx_f_5spacy_6syntax_10stateclass_10StateClass_unshift(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *__pyx_v_self); /* proto*/
static CYTHON_INLINE void __pyx_f_5spacy_6syntax_10stateclass_10StateClass_add_arc(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *__pyx_v_self, int __pyx_v_head, int __pyx_v_child, __pyx_t_5spacy_8typedefs_attr_t __pyx_v_label); /* proto*/
static CYTHON_INLINE void __pyx_f_5spacy_6syntax_10stateclass_10StateClass_del_arc(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *__pyx_v_self, int __pyx_v_head, int __pyx_v_child); /* proto*/
static CYTHON_INLINE void __pyx_f_5spacy_6syntax_10stateclass_10StateClass_open_ent(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *__pyx_v_self, __pyx_t_5spacy_8typedefs_attr_t __pyx_v_label); /* proto*/
static CYTHON_INLINE void __pyx_f_5spacy_6syntax_10stateclass_10StateClass_close_ent(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *__pyx_v_self); /* proto*/
static CYTHON_INLINE void __pyx_f_5spacy_6syntax_10stateclass_10StateClass_set_ent_tag(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *__pyx_v_self, int __pyx_v_i, int __pyx_v_ent_iob, __pyx_t_5spacy_8typedefs_attr_t __pyx_v_ent_type); /* proto*/
static CYTHON_INLINE void __pyx_f_5spacy_6syntax_10stateclass_10StateClass_set_break(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *__pyx_v_self, int __pyx_v_i); /* proto*/
static CYTHON_INLINE void __pyx_f_5spacy_6syntax_10stateclass_10StateClass_clone(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *__pyx_v_self, struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *__pyx_v_src); /* proto*/
static CYTHON_INLINE void __pyx_f_5spacy_6syntax_10stateclass_10StateClass_fast_forward(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *__pyx_v_self); /* proto*/
static CYTHON_INLINE void *__pyx_f_5thinc_5extra_6search_4Beam_at(struct __pyx_obj_5thinc_5extra_6search_Beam *__pyx_v_self, int __pyx_v_i); /* proto*/
static CYTHON_INLINE void __pyx_f_5thinc_5extra_6search_4Beam_set_cell(struct __pyx_obj_5thinc_5extra_6search_Beam *__pyx_v_self, int __pyx_v_i, int __pyx_v_j, __pyx_t_5thinc_8typedefs_weight_t __pyx_v_score, int __pyx_v_is_valid, __pyx_t_5thinc_8typedefs_weight_t __pyx_v_cost); /* proto*/
static PyObject *__pyx_array_get_memview(struct __pyx_array_obj *__pyx_v_self); /* proto*/
static char *__pyx_memoryview_get_item_pointer(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_index); /* proto*/
static PyObject *__pyx_memoryview_is_slice(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_obj); /* proto*/
static PyObject *__pyx_memoryview_setitem_slice_assignment(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_dst, PyObject *__pyx_v_src); /* proto*/
static PyObject *__pyx_memoryview_setitem_slice_assign_scalar(struct __pyx_memoryview_obj *__pyx_v_self, struct __pyx_memoryview_obj *__pyx_v_dst, PyObject *__pyx_v_value); /* proto*/
static PyObject *__pyx_memoryview_setitem_indexed(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_index, PyObject *__pyx_v_value); /* proto*/
static PyObject *__pyx_memoryview_convert_item_to_object(struct __pyx_memoryview_obj *__pyx_v_self, char *__pyx_v_itemp); /* proto*/
static PyObject *__pyx_memoryview_assign_item_from_object(struct __pyx_memoryview_obj *__pyx_v_self, char *__pyx_v_itemp, PyObject *__pyx_v_value); /* proto*/
static PyObject *__pyx_memoryviewslice_convert_item_to_object(struct __pyx_memoryviewslice_obj *__pyx_v_self, char *__pyx_v_itemp); /* proto*/
static PyObject *__pyx_memoryviewslice_assign_item_from_object(struct __pyx_memoryviewslice_obj *__pyx_v_self, char *__pyx_v_itemp, PyObject *__pyx_v_value); /* proto*/
/* Module declarations from 'cymem.cymem' */
static PyTypeObject *__pyx_ptype_5cymem_5cymem_PyMalloc = 0;
static PyTypeObject *__pyx_ptype_5cymem_5cymem_PyFree = 0;
static PyTypeObject *__pyx_ptype_5cymem_5cymem_Pool = 0;
static PyTypeObject *__pyx_ptype_5cymem_5cymem_Address = 0;
/* Module declarations from 'libc.stdint' */
/* Module declarations from 'thinc.typedefs' */
/* Module declarations from 'libc.string' */
/* Module declarations from 'cython.view' */
/* Module declarations from 'cython' */
/* Module declarations from 'spacy.typedefs' */
/* Module declarations from 'spacy' */
/* Module declarations from 'spacy.symbols' */
/* Module declarations from 'spacy.parts_of_speech' */
/* Module declarations from 'libcpp.vector' */
/* Module declarations from 'spacy.structs' */
/* Module declarations from 'preshed.maps' */
static PyTypeObject *__pyx_ptype_7preshed_4maps_PreshMap = 0;
static PyTypeObject *__pyx_ptype_7preshed_4maps_PreshMapArray = 0;
/* Module declarations from 'murmurhash.mrmr' */
static uint64_t (*__pyx_f_10murmurhash_4mrmr_hash64)(void *, int, uint64_t); /*proto*/
/* Module declarations from 'libcpp.utility' */
/* Module declarations from 'libcpp.set' */
/* Module declarations from 'spacy.strings' */
static PyTypeObject *__pyx_ptype_5spacy_7strings_StringStore = 0;
static __pyx_t_5spacy_8typedefs_hash_t (*__pyx_f_5spacy_7strings_hash_string)(PyObject *, int __pyx_skip_dispatch); /*proto*/
/* Module declarations from 'murmurhash' */
/* Module declarations from 'spacy.morphology' */
static PyTypeObject *__pyx_ptype_5spacy_10morphology_Morphology = 0;
/* Module declarations from 'spacy.vocab' */
static PyTypeObject *__pyx_ptype_5spacy_5vocab_Vocab = 0;
static struct __pyx_t_5spacy_7structs_LexemeC *__pyx_vp_5spacy_5vocab_EMPTY_LEXEME = 0;
#define __pyx_v_5spacy_5vocab_EMPTY_LEXEME (*__pyx_vp_5spacy_5vocab_EMPTY_LEXEME)
/* Module declarations from 'libc.stdlib' */
/* Module declarations from 'libc.stdio' */
/* Module declarations from '__builtin__' */
/* Module declarations from 'cpython.type' */
static PyTypeObject *__pyx_ptype_7cpython_4type_type = 0;
/* Module declarations from 'cpython.buffer' */
/* Module declarations from 'cpython' */
/* Module declarations from 'cpython.object' */
/* Module declarations from 'cpython.exc' */
/* Module declarations from 'spacy.attrs' */
/* Module declarations from 'cpython.ref' */
/* Module declarations from 'cpython.mem' */
/* Module declarations from 'numpy' */
/* Module declarations from 'numpy' */
static PyTypeObject *__pyx_ptype_5numpy_dtype = 0;
static PyTypeObject *__pyx_ptype_5numpy_flatiter = 0;
static PyTypeObject *__pyx_ptype_5numpy_broadcast = 0;
static PyTypeObject *__pyx_ptype_5numpy_ndarray = 0;
static PyTypeObject *__pyx_ptype_5numpy_ufunc = 0;
static CYTHON_INLINE char *__pyx_f_5numpy__util_dtypestring(PyArray_Descr *, char *, char *, int *); /*proto*/
/* Module declarations from 'spacy.lexeme' */
static PyTypeObject *__pyx_ptype_5spacy_6lexeme_Lexeme = 0;
static struct __pyx_t_5spacy_7structs_LexemeC *__pyx_vp_5spacy_6lexeme_EMPTY_LEXEME = 0;
#define __pyx_v_5spacy_6lexeme_EMPTY_LEXEME (*__pyx_vp_5spacy_6lexeme_EMPTY_LEXEME)
static __pyx_t_5spacy_8typedefs_attr_t *__pyx_vp_5spacy_6lexeme_OOV_RANK = 0;
#define __pyx_v_5spacy_6lexeme_OOV_RANK (*__pyx_vp_5spacy_6lexeme_OOV_RANK)
/* Module declarations from 'spacy.syntax._state' */
static CYTHON_INLINE int __pyx_f_5spacy_6syntax_6_state_is_space_token(struct __pyx_t_5spacy_7structs_TokenC const *); /*proto*/
static CYTHON_INLINE int __pyx_f_5spacy_6syntax_6_state_ring_push(struct __pyx_t_5spacy_6syntax_6_state_RingBufferC *, int); /*proto*/
static CYTHON_INLINE int __pyx_f_5spacy_6syntax_6_state_ring_get(struct __pyx_t_5spacy_6syntax_6_state_RingBufferC *, int); /*proto*/
/* Module declarations from 'spacy.syntax.stateclass' */
static PyTypeObject *__pyx_ptype_5spacy_6syntax_10stateclass_StateClass = 0;
/* Module declarations from 'spacy.gold' */
static PyTypeObject *__pyx_ptype_5spacy_4gold_GoldParse = 0;
/* Module declarations from 'spacy.syntax.transition_system' */
static PyTypeObject *__pyx_ptype_5spacy_6syntax_17transition_system_TransitionSystem = 0;
/* Module declarations from 'libcpp.pair' */
/* Module declarations from 'libcpp.queue' */
/* Module declarations from 'thinc.extra.search' */
static PyTypeObject *__pyx_ptype_5thinc_5extra_6search_Beam = 0;
static PyTypeObject *__pyx_ptype_5thinc_5extra_6search_MaxViolation = 0;
/* Module declarations from 'spacy.tokens.doc' */
static PyTypeObject *__pyx_ptype_5spacy_6tokens_3doc_Doc = 0;
static int (*__pyx_f_5spacy_6tokens_3doc_set_children_from_heads)(struct __pyx_t_5spacy_7structs_TokenC *, int); /*proto*/
/* Module declarations from 'spacy.syntax.arc_eager' */
static PyTypeObject *__pyx_ptype_5spacy_6syntax_9arc_eager_ArcEager = 0;
static PyTypeObject *__pyx_ptype_5spacy_6syntax_9arc_eager_Shift = 0;
static PyTypeObject *__pyx_ptype_5spacy_6syntax_9arc_eager_Reduce = 0;
static PyTypeObject *__pyx_ptype_5spacy_6syntax_9arc_eager_LeftArc = 0;
static PyTypeObject *__pyx_ptype_5spacy_6syntax_9arc_eager_RightArc = 0;
static PyTypeObject *__pyx_ptype_5spacy_6syntax_9arc_eager_Break = 0;
static PyTypeObject *__pyx_array_type = 0;
static PyTypeObject *__pyx_MemviewEnum_type = 0;
static PyTypeObject *__pyx_memoryview_type = 0;
static PyTypeObject *__pyx_memoryviewslice_type = 0;
static int __pyx_v_5spacy_6syntax_9arc_eager_BINARY_COSTS;
static __pyx_t_5thinc_8typedefs_weight_t __pyx_v_5spacy_6syntax_9arc_eager_MIN_SCORE;
static __pyx_t_5spacy_8typedefs_attr_t __pyx_v_5spacy_6syntax_9arc_eager_SUBTOK_LABEL;
static PyObject *generic = 0;
static PyObject *strided = 0;
static PyObject *indirect = 0;
static PyObject *contiguous = 0;
static PyObject *indirect_contiguous = 0;
static int __pyx_memoryview_thread_locks_used;
static PyThread_type_lock __pyx_memoryview_thread_locks[8];
static __pyx_t_5thinc_8typedefs_weight_t __pyx_f_5spacy_6syntax_9arc_eager_push_cost(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *, struct __pyx_t_5spacy_4gold_GoldParseC const *, int); /*proto*/
static __pyx_t_5thinc_8typedefs_weight_t __pyx_f_5spacy_6syntax_9arc_eager_arc_cost(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *, struct __pyx_t_5spacy_4gold_GoldParseC const *, int, int); /*proto*/
static __pyx_t_5thinc_8typedefs_weight_t __pyx_f_5spacy_6syntax_9arc_eager_pop_cost(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *, struct __pyx_t_5spacy_4gold_GoldParseC const *, int); /*proto*/
static int __pyx_f_5spacy_6syntax_9arc_eager_arc_is_gold(struct __pyx_t_5spacy_4gold_GoldParseC const *, int, int); /*proto*/
static int __pyx_f_5spacy_6syntax_9arc_eager_label_is_gold(struct __pyx_t_5spacy_4gold_GoldParseC const *, int, int, __pyx_t_5spacy_8typedefs_attr_t); /*proto*/
static int __pyx_f_5spacy_6syntax_9arc_eager__get_root(int, struct __pyx_t_5spacy_4gold_GoldParseC const *); /*proto*/
static void *__pyx_f_5spacy_6syntax_9arc_eager__init_state(struct __pyx_obj_5cymem_5cymem_Pool *, int, void *); /*proto*/
static int __pyx_f_5spacy_6syntax_9arc_eager__del_state(struct __pyx_obj_5cymem_5cymem_Pool *, void *, void *); /*proto*/
static PyObject *__pyx_f_5spacy_6syntax_9arc_eager___pyx_unpickle_Shift__set_state(struct __pyx_obj_5spacy_6syntax_9arc_eager_Shift *, PyObject *); /*proto*/
static PyObject *__pyx_f_5spacy_6syntax_9arc_eager___pyx_unpickle_Reduce__set_state(struct __pyx_obj_5spacy_6syntax_9arc_eager_Reduce *, PyObject *); /*proto*/
static PyObject *__pyx_f_5spacy_6syntax_9arc_eager___pyx_unpickle_LeftArc__set_state(struct __pyx_obj_5spacy_6syntax_9arc_eager_LeftArc *, PyObject *); /*proto*/
static PyObject *__pyx_f_5spacy_6syntax_9arc_eager___pyx_unpickle_RightArc__set_state(struct __pyx_obj_5spacy_6syntax_9arc_eager_RightArc *, PyObject *); /*proto*/
static PyObject *__pyx_f_5spacy_6syntax_9arc_eager___pyx_unpickle_Break__set_state(struct __pyx_obj_5spacy_6syntax_9arc_eager_Break *, PyObject *); /*proto*/
static struct __pyx_array_obj *__pyx_array_new(PyObject *, Py_ssize_t, char *, char *, char *); /*proto*/
static void *__pyx_align_pointer(void *, size_t); /*proto*/
static PyObject *__pyx_memoryview_new(PyObject *, int, int, __Pyx_TypeInfo *); /*proto*/
static CYTHON_INLINE int __pyx_memoryview_check(PyObject *); /*proto*/
static PyObject *_unellipsify(PyObject *, int); /*proto*/
static PyObject *assert_direct_dimensions(Py_ssize_t *, int); /*proto*/
static struct __pyx_memoryview_obj *__pyx_memview_slice(struct __pyx_memoryview_obj *, PyObject *); /*proto*/
static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *, Py_ssize_t, Py_ssize_t, Py_ssize_t, int, int, int *, Py_ssize_t, Py_ssize_t, Py_ssize_t, int, int, int, int); /*proto*/
static char *__pyx_pybuffer_index(Py_buffer *, char *, Py_ssize_t, Py_ssize_t); /*proto*/
static int __pyx_memslice_transpose(__Pyx_memviewslice *); /*proto*/
static PyObject *__pyx_memoryview_fromslice(__Pyx_memviewslice, int, PyObject *(*)(char *), int (*)(char *, PyObject *), int); /*proto*/
static __Pyx_memviewslice *__pyx_memoryview_get_slice_from_memoryview(struct __pyx_memoryview_obj *, __Pyx_memviewslice *); /*proto*/
static void __pyx_memoryview_slice_copy(struct __pyx_memoryview_obj *, __Pyx_memviewslice *); /*proto*/
static PyObject *__pyx_memoryview_copy_object(struct __pyx_memoryview_obj *); /*proto*/
static PyObject *__pyx_memoryview_copy_object_from_slice(struct __pyx_memoryview_obj *, __Pyx_memviewslice *); /*proto*/
static Py_ssize_t abs_py_ssize_t(Py_ssize_t); /*proto*/
static char __pyx_get_best_slice_order(__Pyx_memviewslice *, int); /*proto*/
static void _copy_strided_to_strided(char *, Py_ssize_t *, char *, Py_ssize_t *, Py_ssize_t *, Py_ssize_t *, int, size_t); /*proto*/
static void copy_strided_to_strided(__Pyx_memviewslice *, __Pyx_memviewslice *, int, size_t); /*proto*/
static Py_ssize_t __pyx_memoryview_slice_get_size(__Pyx_memviewslice *, int); /*proto*/
static Py_ssize_t __pyx_fill_contig_strides_array(Py_ssize_t *, Py_ssize_t *, Py_ssize_t, int, char); /*proto*/
static void *__pyx_memoryview_copy_data_to_temp(__Pyx_memviewslice *, __Pyx_memviewslice *, char, int); /*proto*/
static int __pyx_memoryview_err_extents(int, Py_ssize_t, Py_ssize_t); /*proto*/
static int __pyx_memoryview_err_dim(PyObject *, char *, int); /*proto*/
static int __pyx_memoryview_err(PyObject *, char *); /*proto*/
static int __pyx_memoryview_copy_contents(__Pyx_memviewslice, __Pyx_memviewslice, int, int, int); /*proto*/
static void __pyx_memoryview_broadcast_leading(__Pyx_memviewslice *, int, int); /*proto*/
static void __pyx_memoryview_refcount_copying(__Pyx_memviewslice *, int, int, int); /*proto*/
static void __pyx_memoryview_refcount_objects_in_slice_with_gil(char *, Py_ssize_t *, Py_ssize_t *, int, int); /*proto*/
static void __pyx_memoryview_refcount_objects_in_slice(char *, Py_ssize_t *, Py_ssize_t *, int, int); /*proto*/
static void __pyx_memoryview_slice_assign_scalar(__Pyx_memviewslice *, int, size_t, void *, int); /*proto*/
static void __pyx_memoryview__slice_assign_scalar(char *, Py_ssize_t *, Py_ssize_t *, int, size_t, void *); /*proto*/
static PyObject *__pyx_unpickle_Enum__set_state(struct __pyx_MemviewEnum_obj *, PyObject *); /*proto*/
#define __Pyx_MODULE_NAME "spacy.syntax.arc_eager"
extern int __pyx_module_is_main_spacy__syntax__arc_eager;
int __pyx_module_is_main_spacy__syntax__arc_eager = 0;
/* Implementation of 'spacy.syntax.arc_eager' */
static PyObject *__pyx_builtin_range;
static PyObject *__pyx_builtin_zip;
static PyObject *__pyx_builtin_all;
static PyObject *__pyx_builtin_enumerate;
static PyObject *__pyx_builtin_ValueError;
static PyObject *__pyx_builtin_TypeError;
static PyObject *__pyx_builtin_RuntimeError;
static PyObject *__pyx_builtin_ImportError;
static PyObject *__pyx_builtin_MemoryError;
static PyObject *__pyx_builtin_Ellipsis;
static PyObject *__pyx_builtin_id;
static PyObject *__pyx_builtin_IndexError;
static const char __pyx_k_[] = "";
static const char __pyx_k_B[] = "B";
static const char __pyx_k_D[] = "D";
static const char __pyx_k_L[] = "L";
static const char __pyx_k_O[] = "O";
static const char __pyx_k_R[] = "R";
static const char __pyx_k_S[] = "S";
static const char __pyx_k_c[] = "c";
static const char __pyx_k__5[] = "-";
static const char __pyx_k_id[] = "id";
static const char __pyx_k_add[] = "add";
static const char __pyx_k_all[] = "all";
static const char __pyx_k_dep[] = "dep";
static const char __pyx_k_end[] = "end";
static const char __pyx_k_get[] = "get";
static const char __pyx_k_new[] = "__new__";
static const char __pyx_k_obj[] = "obj";
static const char __pyx_k_pop[] = "pop";
static const char __pyx_k_src[] = "src";
static const char __pyx_k_zip[] = "zip";
static const char __pyx_k_E019[] = "E019";
static const char __pyx_k_E020[] = "E020";
static const char __pyx_k_E021[] = "E021";
static const char __pyx_k_ROOT[] = "ROOT";
static const char __pyx_k_base[] = "base";
static const char __pyx_k_clas[] = "clas";
static const char __pyx_k_dict[] = "__dict__";
static const char __pyx_k_gold[] = "gold";
static const char __pyx_k_init[] = "__init__";
static const char __pyx_k_json[] = "json";
static const char __pyx_k_main[] = "__main__";
static const char __pyx_k_mode[] = "mode";
static const char __pyx_k_move[] = "move";
static const char __pyx_k_name[] = "name";
static const char __pyx_k_ndim[] = "ndim";
static const char __pyx_k_pack[] = "pack";
static const char __pyx_k_size[] = "size";
static const char __pyx_k_step[] = "step";
static const char __pyx_k_stop[] = "stop";
static const char __pyx_k_test[] = "__test__";
static const char __pyx_k_ASCII[] = "ASCII";
static const char __pyx_k_Break[] = "Break";
static const char __pyx_k_Shift[] = "Shift";
static const char __pyx_k_class[] = "__class__";
static const char __pyx_k_error[] = "error";
static const char __pyx_k_flags[] = "flags";
static const char __pyx_k_index[] = "index";
static const char __pyx_k_items[] = "items";
static const char __pyx_k_label[] = "label";
static const char __pyx_k_probs[] = "probs";
static const char __pyx_k_range[] = "range";
static const char __pyx_k_shape[] = "shape";
static const char __pyx_k_split[] = "split";
static const char __pyx_k_start[] = "start";
static const char __pyx_k_state[] = "state";
static const char __pyx_k_upper[] = "upper";
static const char __pyx_k_Errors[] = "Errors";
static const char __pyx_k_Reduce[] = "Reduce";
static const char __pyx_k_action[] = "action";
static const char __pyx_k_encode[] = "encode";
static const char __pyx_k_errors[] = "errors";
static const char __pyx_k_format[] = "format";
static const char __pyx_k_import[] = "__import__";
static const char __pyx_k_name_2[] = "__name__";
static const char __pyx_k_pickle[] = "pickle";
static const char __pyx_k_reduce[] = "__reduce__";
static const char __pyx_k_struct[] = "struct";
static const char __pyx_k_subtok[] = "subtok";
static const char __pyx_k_unpack[] = "unpack";
static const char __pyx_k_update[] = "update";
static const char __pyx_k_Counter[] = "Counter";
static const char __pyx_k_LeftArc[] = "LeftArc";
static const char __pyx_k_MISSING[] = "MISSING";
static const char __pyx_k_fortran[] = "fortran";
static const char __pyx_k_memview[] = "memview";
static const char __pyx_k_nonproj[] = "nonproj";
static const char __pyx_k_ArcEager[] = "ArcEager";
static const char __pyx_k_Ellipsis[] = "Ellipsis";
static const char __pyx_k_RightArc[] = "RightArc";
static const char __pyx_k_getstate[] = "__getstate__";
static const char __pyx_k_has_gold[] = "has_gold";
static const char __pyx_k_itemsize[] = "itemsize";
static const char __pyx_k_min_freq[] = "min_freq";
static const char __pyx_k_pyx_type[] = "__pyx_type";
static const char __pyx_k_setstate[] = "__setstate__";
static const char __pyx_k_TypeError[] = "TypeError";
static const char __pyx_k_arc_eager[] = "arc_eager";
static const char __pyx_k_decompose[] = "decompose";
static const char __pyx_k_enumerate[] = "enumerate";
static const char __pyx_k_move_name[] = "move_name";
static const char __pyx_k_n_actions[] = "n_actions";
static const char __pyx_k_pyx_state[] = "__pyx_state";
static const char __pyx_k_reduce_ex[] = "__reduce_ex__";
static const char __pyx_k_IndexError[] = "IndexError";
static const char __pyx_k_MOVE_NAMES[] = "MOVE_NAMES";
static const char __pyx_k_ValueError[] = "ValueError";
static const char __pyx_k_pyx_result[] = "__pyx_result";
static const char __pyx_k_pyx_vtable[] = "__pyx_vtable__";
static const char __pyx_k_setdefault[] = "setdefault";
static const char __pyx_k_ImportError[] = "ImportError";
static const char __pyx_k_MemoryError[] = "MemoryError";
static const char __pyx_k_OrderedDict[] = "OrderedDict";
static const char __pyx_k_PickleError[] = "PickleError";
static const char __pyx_k_collections[] = "collections";
static const char __pyx_k_defaultdict[] = "defaultdict";
static const char __pyx_k_get_actions[] = "get_actions";
static const char __pyx_k_gold_parses[] = "gold_parses";
static const char __pyx_k_left_labels[] = "left_labels";
static const char __pyx_k_print_state[] = "print_state";
static const char __pyx_k_RuntimeError[] = "RuntimeError";
static const char __pyx_k_is_decorated[] = "is_decorated";
static const char __pyx_k_learn_tokens[] = "learn_tokens";
static const char __pyx_k_projectivize[] = "projectivize";
static const char __pyx_k_pyx_checksum[] = "__pyx_checksum";
static const char __pyx_k_right_labels[] = "right_labels";
static const char __pyx_k_stringsource[] = "stringsource";
static const char __pyx_k_pyx_getbuffer[] = "__pyx_getbuffer";
static const char __pyx_k_reduce_cython[] = "__reduce_cython__";
static const char __pyx_k_View_MemoryView[] = "View.MemoryView";
static const char __pyx_k_allocate_buffer[] = "allocate_buffer";
static const char __pyx_k_dtype_is_object[] = "dtype_is_object";
static const char __pyx_k_is_nonproj_tree[] = "is_nonproj_tree";
static const char __pyx_k_pyx_PickleError[] = "__pyx_PickleError";
static const char __pyx_k_setstate_cython[] = "__setstate_cython__";
static const char __pyx_k_pyx_unpickle_Enum[] = "__pyx_unpickle_Enum";
static const char __pyx_k_cline_in_traceback[] = "cline_in_traceback";
static const char __pyx_k_pyx_unpickle_Break[] = "__pyx_unpickle_Break";
static const char __pyx_k_pyx_unpickle_Shift[] = "__pyx_unpickle_Shift";
static const char __pyx_k_strided_and_direct[] = "<strided and direct>";
static const char __pyx_k_pyx_unpickle_Reduce[] = "__pyx_unpickle_Reduce";
static const char __pyx_k_pyx_unpickle_LeftArc[] = "__pyx_unpickle_LeftArc";
static const char __pyx_k_strided_and_indirect[] = "<strided and indirect>";
static const char __pyx_k_contiguous_and_direct[] = "<contiguous and direct>";
static const char __pyx_k_pyx_unpickle_RightArc[] = "__pyx_unpickle_RightArc";
static const char __pyx_k_MemoryView_of_r_object[] = "<MemoryView of %r object>";
static const char __pyx_k_spacy_syntax_arc_eager[] = "spacy.syntax.arc_eager";
static const char __pyx_k_MemoryView_of_r_at_0x_x[] = "<MemoryView of %r at 0x%x>";
static const char __pyx_k_contiguous_and_indirect[] = "<contiguous and indirect>";
static const char __pyx_k_Cannot_index_with_type_s[] = "Cannot index with type '%s'";
static const char __pyx_k_Invalid_shape_in_axis_d_d[] = "Invalid shape in axis %d: %d.";
static const char __pyx_k_get_actions_locals_lambda[] = "get_actions.<locals>.<lambda>";
static const char __pyx_k_itemsize_0_for_cython_array[] = "itemsize <= 0 for cython.array";
static const char __pyx_k_unable_to_allocate_array_data[] = "unable to allocate array data.";
static const char __pyx_k_strided_and_direct_or_indirect[] = "<strided and direct or indirect>";
static const char __pyx_k_numpy_core_multiarray_failed_to[] = "numpy.core.multiarray failed to import";
static const char __pyx_k_self_c_self_del_beam_state_self[] = "self.c,self.del_beam_state,self.init_beam_state cannot be converted to a Python object for pickling";
static const char __pyx_k_unknown_dtype_code_in_numpy_pxd[] = "unknown dtype code in numpy.pxd (%d)";
static const char __pyx_k_Buffer_view_does_not_expose_stri[] = "Buffer view does not expose strides";
static const char __pyx_k_Can_only_create_a_buffer_that_is[] = "Can only create a buffer that is contiguous in memory.";
static const char __pyx_k_Cannot_assign_to_read_only_memor[] = "Cannot assign to read-only memoryview";
static const char __pyx_k_Cannot_create_writable_memory_vi[] = "Cannot create writable memory view from read-only memoryview";
static const char __pyx_k_Empty_shape_tuple_for_cython_arr[] = "Empty shape tuple for cython.array";
static const char __pyx_k_Format_string_allocated_too_shor[] = "Format string allocated too short, see comment in numpy.pxd";
static const char __pyx_k_Incompatible_checksums_s_vs_0xb0[] = "Incompatible checksums (%s vs 0xb068931 = (name))";
static const char __pyx_k_Incompatible_checksums_s_vs_0xd4[] = "Incompatible checksums (%s vs 0xd41d8cd = ())";
static const char __pyx_k_Indirect_dimensions_not_supporte[] = "Indirect dimensions not supported";
static const char __pyx_k_Invalid_mode_expected_c_or_fortr[] = "Invalid mode, expected 'c' or 'fortran', got %s";
static const char __pyx_k_Non_native_byte_order_not_suppor[] = "Non-native byte order not supported";
static const char __pyx_k_Out_of_bounds_on_buffer_access_a[] = "Out of bounds on buffer access (axis %d)";
static const char __pyx_k_Unable_to_convert_item_to_object[] = "Unable to convert item to object";
static const char __pyx_k_got_differing_extents_in_dimensi[] = "got differing extents in dimension %d (got %d and %d)";
static const char __pyx_k_no_default___reduce___due_to_non[] = "no default __reduce__ due to non-trivial __cinit__";
static const char __pyx_k_numpy_core_umath_failed_to_impor[] = "numpy.core.umath failed to import";
static const char __pyx_k_unable_to_allocate_shape_and_str[] = "unable to allocate shape and strides.";
static const char __pyx_k_Format_string_allocated_too_shor_2[] = "Format string allocated too short.";
static PyObject *__pyx_n_s_;
static PyObject *__pyx_kp_u_;
static PyObject *__pyx_n_s_ASCII;
static PyObject *__pyx_n_s_ArcEager;
static PyObject *__pyx_n_u_B;
static PyObject *__pyx_n_s_Break;
static PyObject *__pyx_kp_s_Buffer_view_does_not_expose_stri;
static PyObject *__pyx_kp_s_Can_only_create_a_buffer_that_is;
static PyObject *__pyx_kp_s_Cannot_assign_to_read_only_memor;
static PyObject *__pyx_kp_s_Cannot_create_writable_memory_vi;
static PyObject *__pyx_kp_s_Cannot_index_with_type_s;
static PyObject *__pyx_n_s_Counter;
static PyObject *__pyx_n_u_D;
static PyObject *__pyx_n_s_E019;
static PyObject *__pyx_n_s_E020;
static PyObject *__pyx_n_s_E021;
static PyObject *__pyx_n_s_Ellipsis;
static PyObject *__pyx_kp_s_Empty_shape_tuple_for_cython_arr;
static PyObject *__pyx_n_s_Errors;
static PyObject *__pyx_kp_u_Format_string_allocated_too_shor;
static PyObject *__pyx_kp_u_Format_string_allocated_too_shor_2;
static PyObject *__pyx_n_s_ImportError;
static PyObject *__pyx_kp_s_Incompatible_checksums_s_vs_0xb0;
static PyObject *__pyx_kp_s_Incompatible_checksums_s_vs_0xd4;
static PyObject *__pyx_n_s_IndexError;
static PyObject *__pyx_kp_s_Indirect_dimensions_not_supporte;
static PyObject *__pyx_kp_s_Invalid_mode_expected_c_or_fortr;
static PyObject *__pyx_kp_s_Invalid_shape_in_axis_d_d;
static PyObject *__pyx_n_u_L;
static PyObject *__pyx_n_s_LeftArc;
static PyObject *__pyx_n_s_MISSING;
static PyObject *__pyx_n_s_MOVE_NAMES;
static PyObject *__pyx_n_s_MemoryError;
static PyObject *__pyx_kp_s_MemoryView_of_r_at_0x_x;
static PyObject *__pyx_kp_s_MemoryView_of_r_object;
static PyObject *__pyx_kp_u_Non_native_byte_order_not_suppor;
static PyObject *__pyx_n_b_O;
static PyObject *__pyx_n_s_OrderedDict;
static PyObject *__pyx_kp_s_Out_of_bounds_on_buffer_access_a;
static PyObject *__pyx_n_s_PickleError;
static PyObject *__pyx_n_u_R;
static PyObject *__pyx_n_u_ROOT;
static PyObject *__pyx_n_s_Reduce;
static PyObject *__pyx_n_s_RightArc;
static PyObject *__pyx_n_s_RuntimeError;
static PyObject *__pyx_n_u_S;
static PyObject *__pyx_n_s_Shift;
static PyObject *__pyx_n_s_TypeError;
static PyObject *__pyx_kp_s_Unable_to_convert_item_to_object;
static PyObject *__pyx_n_s_ValueError;
static PyObject *__pyx_n_s_View_MemoryView;
static PyObject *__pyx_kp_u__5;
static PyObject *__pyx_n_s_action;
static PyObject *__pyx_n_s_add;
static PyObject *__pyx_n_s_all;
static PyObject *__pyx_n_s_allocate_buffer;
static PyObject *__pyx_n_u_arc_eager;
static PyObject *__pyx_n_s_base;
static PyObject *__pyx_n_s_c;
static PyObject *__pyx_n_u_c;
static PyObject *__pyx_n_s_clas;
static PyObject *__pyx_n_s_class;
static PyObject *__pyx_n_s_cline_in_traceback;
static PyObject *__pyx_n_s_collections;
static PyObject *__pyx_kp_s_contiguous_and_direct;
static PyObject *__pyx_kp_s_contiguous_and_indirect;
static PyObject *__pyx_n_s_decompose;
static PyObject *__pyx_n_s_defaultdict;
static PyObject *__pyx_n_u_dep;
static PyObject *__pyx_n_s_dict;
static PyObject *__pyx_n_s_dtype_is_object;
static PyObject *__pyx_n_s_encode;
static PyObject *__pyx_n_s_end;
static PyObject *__pyx_n_s_enumerate;
static PyObject *__pyx_n_s_error;
static PyObject *__pyx_n_s_errors;
static PyObject *__pyx_n_s_flags;
static PyObject *__pyx_n_s_format;
static PyObject *__pyx_n_s_fortran;
static PyObject *__pyx_n_u_fortran;
static PyObject *__pyx_n_s_get;
static PyObject *__pyx_n_s_get_actions;
static PyObject *__pyx_n_s_get_actions_locals_lambda;
static PyObject *__pyx_n_s_getstate;
static PyObject *__pyx_n_s_gold;
static PyObject *__pyx_n_u_gold_parses;
static PyObject *__pyx_kp_s_got_differing_extents_in_dimensi;
static PyObject *__pyx_n_s_has_gold;
static PyObject *__pyx_n_s_id;
static PyObject *__pyx_n_s_import;
static PyObject *__pyx_n_s_index;
static PyObject *__pyx_n_s_init;
static PyObject *__pyx_n_s_is_decorated;
static PyObject *__pyx_n_s_is_nonproj_tree;
static PyObject *__pyx_n_s_items;
static PyObject *__pyx_n_s_itemsize;
static PyObject *__pyx_kp_s_itemsize_0_for_cython_array;
static PyObject *__pyx_n_s_json;
static PyObject *__pyx_n_s_label;
static PyObject *__pyx_n_u_learn_tokens;
static PyObject *__pyx_n_u_left_labels;
static PyObject *__pyx_n_s_main;
static PyObject *__pyx_n_s_memview;
static PyObject *__pyx_n_u_min_freq;
static PyObject *__pyx_n_s_mode;
static PyObject *__pyx_n_s_move;
static PyObject *__pyx_n_s_move_name;
static PyObject *__pyx_n_s_n_actions;
static PyObject *__pyx_n_s_name;
static PyObject *__pyx_n_s_name_2;
static PyObject *__pyx_n_s_ndim;
static PyObject *__pyx_n_s_new;
static PyObject *__pyx_kp_s_no_default___reduce___due_to_non;
static PyObject *__pyx_n_s_nonproj;
static PyObject *__pyx_kp_s_numpy_core_multiarray_failed_to;
static PyObject *__pyx_kp_s_numpy_core_umath_failed_to_impor;
static PyObject *__pyx_n_s_obj;
static PyObject *__pyx_n_s_pack;
static PyObject *__pyx_n_s_pickle;
static PyObject *__pyx_n_s_pop;
static PyObject *__pyx_n_s_print_state;
static PyObject *__pyx_n_s_probs;
static PyObject *__pyx_n_s_projectivize;
static PyObject *__pyx_n_s_pyx_PickleError;
static PyObject *__pyx_n_s_pyx_checksum;
static PyObject *__pyx_n_s_pyx_getbuffer;
static PyObject *__pyx_n_s_pyx_result;
static PyObject *__pyx_n_s_pyx_state;
static PyObject *__pyx_n_s_pyx_type;
static PyObject *__pyx_n_s_pyx_unpickle_Break;
static PyObject *__pyx_n_s_pyx_unpickle_Enum;
static PyObject *__pyx_n_s_pyx_unpickle_LeftArc;
static PyObject *__pyx_n_s_pyx_unpickle_Reduce;
static PyObject *__pyx_n_s_pyx_unpickle_RightArc;
static PyObject *__pyx_n_s_pyx_unpickle_Shift;
static PyObject *__pyx_n_s_pyx_vtable;
static PyObject *__pyx_n_s_range;
static PyObject *__pyx_n_s_reduce;
static PyObject *__pyx_n_s_reduce_cython;
static PyObject *__pyx_n_s_reduce_ex;
static PyObject *__pyx_n_u_right_labels;
static PyObject *__pyx_kp_s_self_c_self_del_beam_state_self;
static PyObject *__pyx_n_s_setdefault;
static PyObject *__pyx_n_s_setstate;
static PyObject *__pyx_n_s_setstate_cython;
static PyObject *__pyx_n_s_shape;
static PyObject *__pyx_n_s_size;
static PyObject *__pyx_n_s_spacy_syntax_arc_eager;
static PyObject *__pyx_n_s_split;
static PyObject *__pyx_n_s_src;
static PyObject *__pyx_n_s_start;
static PyObject *__pyx_n_s_state;
static PyObject *__pyx_n_s_step;
static PyObject *__pyx_n_s_stop;
static PyObject *__pyx_kp_s_strided_and_direct;
static PyObject *__pyx_kp_s_strided_and_direct_or_indirect;
static PyObject *__pyx_kp_s_strided_and_indirect;
static PyObject *__pyx_kp_s_stringsource;
static PyObject *__pyx_n_s_struct;
static PyObject *__pyx_n_u_subtok;
static PyObject *__pyx_n_s_test;
static PyObject *__pyx_kp_s_unable_to_allocate_array_data;
static PyObject *__pyx_kp_s_unable_to_allocate_shape_and_str;
static PyObject *__pyx_kp_u_unknown_dtype_code_in_numpy_pxd;
static PyObject *__pyx_n_s_unpack;
static PyObject *__pyx_n_s_update;
static PyObject *__pyx_n_s_upper;
static PyObject *__pyx_n_s_zip;
static PyObject *__pyx_pf_5spacy_6syntax_9arc_eager_5Shift___reduce_cython__(struct __pyx_obj_5spacy_6syntax_9arc_eager_Shift *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_5spacy_6syntax_9arc_eager_5Shift_2__setstate_cython__(struct __pyx_obj_5spacy_6syntax_9arc_eager_Shift *__pyx_v_self, PyObject *__pyx_v___pyx_state); /* proto */
static PyObject *__pyx_pf_5spacy_6syntax_9arc_eager_6Reduce___reduce_cython__(struct __pyx_obj_5spacy_6syntax_9arc_eager_Reduce *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_5spacy_6syntax_9arc_eager_6Reduce_2__setstate_cython__(struct __pyx_obj_5spacy_6syntax_9arc_eager_Reduce *__pyx_v_self, PyObject *__pyx_v___pyx_state); /* proto */
static PyObject *__pyx_pf_5spacy_6syntax_9arc_eager_7LeftArc___reduce_cython__(struct __pyx_obj_5spacy_6syntax_9arc_eager_LeftArc *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_5spacy_6syntax_9arc_eager_7LeftArc_2__setstate_cython__(struct __pyx_obj_5spacy_6syntax_9arc_eager_LeftArc *__pyx_v_self, PyObject *__pyx_v___pyx_state); /* proto */
static PyObject *__pyx_pf_5spacy_6syntax_9arc_eager_8RightArc___reduce_cython__(struct __pyx_obj_5spacy_6syntax_9arc_eager_RightArc *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_5spacy_6syntax_9arc_eager_8RightArc_2__setstate_cython__(struct __pyx_obj_5spacy_6syntax_9arc_eager_RightArc *__pyx_v_self, PyObject *__pyx_v___pyx_state); /* proto */
static PyObject *__pyx_pf_5spacy_6syntax_9arc_eager_5Break___reduce_cython__(struct __pyx_obj_5spacy_6syntax_9arc_eager_Break *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_5spacy_6syntax_9arc_eager_5Break_2__setstate_cython__(struct __pyx_obj_5spacy_6syntax_9arc_eager_Break *__pyx_v_self, PyObject *__pyx_v___pyx_state); /* proto */
static int __pyx_pf_5spacy_6syntax_9arc_eager_8ArcEager___init__(struct __pyx_obj_5spacy_6syntax_9arc_eager_ArcEager *__pyx_v_self, PyObject *__pyx_v_args, PyObject *__pyx_v_kwargs); /* proto */
static PyObject *__pyx_lambda_funcdef_lambda(CYTHON_UNUSED PyObject *__pyx_self); /* proto */
static PyObject *__pyx_pf_5spacy_6syntax_9arc_eager_8ArcEager_2get_actions(CYTHON_UNUSED PyTypeObject *__pyx_v_cls, PyObject *__pyx_v_kwargs); /* proto */
static PyObject *__pyx_pf_5spacy_6syntax_9arc_eager_8ArcEager_12action_types___get__(CYTHON_UNUSED struct __pyx_obj_5spacy_6syntax_9arc_eager_ArcEager *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_5spacy_6syntax_9arc_eager_8ArcEager_4get_cost(struct __pyx_obj_5spacy_6syntax_9arc_eager_ArcEager *__pyx_v_self, struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *__pyx_v_state, struct __pyx_obj_5spacy_4gold_GoldParse *__pyx_v_gold, PyObject *__pyx_v_action); /* proto */
static PyObject *__pyx_pf_5spacy_6syntax_9arc_eager_8ArcEager_6transition(struct __pyx_obj_5spacy_6syntax_9arc_eager_ArcEager *__pyx_v_self, struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *__pyx_v_state, PyObject *__pyx_v_action); /* proto */
static PyObject *__pyx_pf_5spacy_6syntax_9arc_eager_8ArcEager_8is_gold_parse(struct __pyx_obj_5spacy_6syntax_9arc_eager_ArcEager *__pyx_v_self, struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *__pyx_v_state, struct __pyx_obj_5spacy_4gold_GoldParse *__pyx_v_gold); /* proto */
static PyObject *__pyx_pf_5spacy_6syntax_9arc_eager_8ArcEager_10has_gold(CYTHON_UNUSED struct __pyx_obj_5spacy_6syntax_9arc_eager_ArcEager *__pyx_v_self, struct __pyx_obj_5spacy_4gold_GoldParse *__pyx_v_gold, PyObject *__pyx_v_start, PyObject *__pyx_v_end); /* proto */
static PyObject *__pyx_pf_5spacy_6syntax_9arc_eager_8ArcEager_12preprocess_gold(struct __pyx_obj_5spacy_6syntax_9arc_eager_ArcEager *__pyx_v_self, struct __pyx_obj_5spacy_4gold_GoldParse *__pyx_v_gold); /* proto */
static PyObject *__pyx_pf_5spacy_6syntax_9arc_eager_8ArcEager_14get_beam_parses(struct __pyx_obj_5spacy_6syntax_9arc_eager_ArcEager *__pyx_v_self, struct __pyx_obj_5thinc_5extra_6search_Beam *__pyx_v_beam); /* proto */
static PyObject *__pyx_pf_5spacy_6syntax_9arc_eager_8ArcEager_16move_name(struct __pyx_obj_5spacy_6syntax_9arc_eager_ArcEager *__pyx_v_self, int __pyx_v_move, __pyx_t_5spacy_8typedefs_attr_t __pyx_v_label); /* proto */
static PyObject *__pyx_pf_5spacy_6syntax_9arc_eager_8ArcEager_18class_name(struct __pyx_obj_5spacy_6syntax_9arc_eager_ArcEager *__pyx_v_self, int __pyx_v_i); /* proto */
static PyObject *__pyx_pf_5spacy_6syntax_9arc_eager_8ArcEager_20finalize_doc(CYTHON_UNUSED struct __pyx_obj_5spacy_6syntax_9arc_eager_ArcEager *__pyx_v_self, struct __pyx_obj_5spacy_6tokens_3doc_Doc *__pyx_v_doc); /* proto */
static PyObject *__pyx_pf_5spacy_6syntax_9arc_eager_8ArcEager_22get_beam_annot(struct __pyx_obj_5spacy_6syntax_9arc_eager_ArcEager *__pyx_v_self, struct __pyx_obj_5thinc_5extra_6search_Beam *__pyx_v_beam); /* proto */
static PyObject *__pyx_pf_5spacy_6syntax_9arc_eager_8ArcEager_24__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_5spacy_6syntax_9arc_eager_ArcEager *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_5spacy_6syntax_9arc_eager_8ArcEager_26__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_5spacy_6syntax_9arc_eager_ArcEager *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */
static PyObject *__pyx_pf_5spacy_6syntax_9arc_eager___pyx_unpickle_Shift(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v___pyx_type, long __pyx_v___pyx_checksum, PyObject *__pyx_v___pyx_state); /* proto */
static PyObject *__pyx_pf_5spacy_6syntax_9arc_eager_2__pyx_unpickle_Reduce(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v___pyx_type, long __pyx_v___pyx_checksum, PyObject *__pyx_v___pyx_state); /* proto */
static PyObject *__pyx_pf_5spacy_6syntax_9arc_eager_4__pyx_unpickle_LeftArc(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v___pyx_type, long __pyx_v___pyx_checksum, PyObject *__pyx_v___pyx_state); /* proto */
static PyObject *__pyx_pf_5spacy_6syntax_9arc_eager_6__pyx_unpickle_RightArc(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v___pyx_type, long __pyx_v___pyx_checksum, PyObject *__pyx_v___pyx_state); /* proto */
static PyObject *__pyx_pf_5spacy_6syntax_9arc_eager_8__pyx_unpickle_Break(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v___pyx_type, long __pyx_v___pyx_checksum, PyObject *__pyx_v___pyx_state); /* proto */
static int __pyx_array___pyx_pf_15View_dot_MemoryView_5array___cinit__(struct __pyx_array_obj *__pyx_v_self, PyObject *__pyx_v_shape, Py_ssize_t __pyx_v_itemsize, PyObject *__pyx_v_format, PyObject *__pyx_v_mode, int __pyx_v_allocate_buffer); /* proto */
static int __pyx_array___pyx_pf_15View_dot_MemoryView_5array_2__getbuffer__(struct __pyx_array_obj *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags); /* proto */
static void __pyx_array___pyx_pf_15View_dot_MemoryView_5array_4__dealloc__(struct __pyx_array_obj *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_15View_dot_MemoryView_5array_7memview___get__(struct __pyx_array_obj *__pyx_v_self); /* proto */
static Py_ssize_t __pyx_array___pyx_pf_15View_dot_MemoryView_5array_6__len__(struct __pyx_array_obj *__pyx_v_self); /* proto */
static PyObject *__pyx_array___pyx_pf_15View_dot_MemoryView_5array_8__getattr__(struct __pyx_array_obj *__pyx_v_self, PyObject *__pyx_v_attr); /* proto */
static PyObject *__pyx_array___pyx_pf_15View_dot_MemoryView_5array_10__getitem__(struct __pyx_array_obj *__pyx_v_self, PyObject *__pyx_v_item); /* proto */
static int __pyx_array___pyx_pf_15View_dot_MemoryView_5array_12__setitem__(struct __pyx_array_obj *__pyx_v_self, PyObject *__pyx_v_item, PyObject *__pyx_v_value); /* proto */
static PyObject *__pyx_pf___pyx_array___reduce_cython__(CYTHON_UNUSED struct __pyx_array_obj *__pyx_v_self); /* proto */
static PyObject *__pyx_pf___pyx_array_2__setstate_cython__(CYTHON_UNUSED struct __pyx_array_obj *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */
static int __pyx_MemviewEnum___pyx_pf_15View_dot_MemoryView_4Enum___init__(struct __pyx_MemviewEnum_obj *__pyx_v_self, PyObject *__pyx_v_name); /* proto */
static PyObject *__pyx_MemviewEnum___pyx_pf_15View_dot_MemoryView_4Enum_2__repr__(struct __pyx_MemviewEnum_obj *__pyx_v_self); /* proto */
static PyObject *__pyx_pf___pyx_MemviewEnum___reduce_cython__(struct __pyx_MemviewEnum_obj *__pyx_v_self); /* proto */
static PyObject *__pyx_pf___pyx_MemviewEnum_2__setstate_cython__(struct __pyx_MemviewEnum_obj *__pyx_v_self, PyObject *__pyx_v___pyx_state); /* proto */
static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview___cinit__(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_obj, int __pyx_v_flags, int __pyx_v_dtype_is_object); /* proto */
static void __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_2__dealloc__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */
static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_4__getitem__(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_index); /* proto */
static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_6__setitem__(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_index, PyObject *__pyx_v_value); /* proto */
static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_8__getbuffer__(struct __pyx_memoryview_obj *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags); /* proto */
static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_1T___get__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_4base___get__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_5shape___get__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_7strides___get__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_10suboffsets___get__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_4ndim___get__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_8itemsize___get__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_6nbytes___get__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_4size___get__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */
static Py_ssize_t __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_10__len__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */
static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_12__repr__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */
static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_14__str__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */
static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_16is_c_contig(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */
static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_18is_f_contig(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */
static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_20copy(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */
static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_22copy_fortran(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */
static PyObject *__pyx_pf___pyx_memoryview___reduce_cython__(CYTHON_UNUSED struct __pyx_memoryview_obj *__pyx_v_self); /* proto */
static PyObject *__pyx_pf___pyx_memoryview_2__setstate_cython__(CYTHON_UNUSED struct __pyx_memoryview_obj *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */
static void __pyx_memoryviewslice___pyx_pf_15View_dot_MemoryView_16_memoryviewslice___dealloc__(struct __pyx_memoryviewslice_obj *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_15View_dot_MemoryView_16_memoryviewslice_4base___get__(struct __pyx_memoryviewslice_obj *__pyx_v_self); /* proto */
static PyObject *__pyx_pf___pyx_memoryviewslice___reduce_cython__(CYTHON_UNUSED struct __pyx_memoryviewslice_obj *__pyx_v_self); /* proto */
static PyObject *__pyx_pf___pyx_memoryviewslice_2__setstate_cython__(CYTHON_UNUSED struct __pyx_memoryviewslice_obj *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */
static PyObject *__pyx_pf_15View_dot_MemoryView___pyx_unpickle_Enum(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v___pyx_type, long __pyx_v___pyx_checksum, PyObject *__pyx_v___pyx_state); /* proto */
static PyObject *__pyx_tp_new_5spacy_6syntax_9arc_eager_ArcEager(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
static PyObject *__pyx_tp_new_5spacy_6syntax_9arc_eager_Shift(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
static PyObject *__pyx_tp_new_5spacy_6syntax_9arc_eager_Reduce(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
static PyObject *__pyx_tp_new_5spacy_6syntax_9arc_eager_LeftArc(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
static PyObject *__pyx_tp_new_5spacy_6syntax_9arc_eager_RightArc(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
static PyObject *__pyx_tp_new_5spacy_6syntax_9arc_eager_Break(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
static PyObject *__pyx_tp_new_array(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
static PyObject *__pyx_tp_new_Enum(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
static PyObject *__pyx_tp_new_memoryview(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
static PyObject *__pyx_tp_new__memoryviewslice(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
static __Pyx_CachedCFunction __pyx_umethod_PyDict_Type_get = {0, &__pyx_n_s_get, 0, 0, 0};
static PyObject *__pyx_float_0_0;
static PyObject *__pyx_int_0;
static PyObject *__pyx_int_1;
static PyObject *__pyx_int_9000;
static PyObject *__pyx_int_184977713;
static PyObject *__pyx_int_222419149;
static PyObject *__pyx_int_neg_1;
static PyObject *__pyx_tuple__2;
static PyObject *__pyx_tuple__3;
static PyObject *__pyx_tuple__4;
static PyObject *__pyx_tuple__6;
static PyObject *__pyx_tuple__7;
static PyObject *__pyx_tuple__8;
static PyObject *__pyx_slice__33;
static PyObject *__pyx_tuple__14;
static PyObject *__pyx_tuple__15;
static PyObject *__pyx_tuple__16;
static PyObject *__pyx_tuple__17;
static PyObject *__pyx_tuple__18;
static PyObject *__pyx_tuple__19;
static PyObject *__pyx_tuple__20;
static PyObject *__pyx_tuple__21;
static PyObject *__pyx_tuple__22;
static PyObject *__pyx_tuple__23;
static PyObject *__pyx_tuple__24;
static PyObject *__pyx_tuple__25;
static PyObject *__pyx_tuple__26;
static PyObject *__pyx_tuple__27;
static PyObject *__pyx_tuple__28;
static PyObject *__pyx_tuple__29;
static PyObject *__pyx_tuple__30;
static PyObject *__pyx_tuple__31;
static PyObject *__pyx_tuple__32;
static PyObject *__pyx_tuple__34;
static PyObject *__pyx_tuple__35;
static PyObject *__pyx_tuple__36;
static PyObject *__pyx_tuple__38;
static PyObject *__pyx_tuple__39;
static PyObject *__pyx_tuple__40;
static PyObject *__pyx_tuple__41;
static PyObject *__pyx_tuple__42;
static PyObject *__pyx_tuple__43;
static PyObject *__pyx_tuple__44;
static PyObject *__pyx_tuple__45;
static PyObject *__pyx_tuple__46;
static PyObject *__pyx_tuple__47;
static PyObject *__pyx_tuple__48;
static PyObject *__pyx_codeobj__9;
static PyObject *__pyx_codeobj__10;
static PyObject *__pyx_codeobj__11;
static PyObject *__pyx_codeobj__12;
static PyObject *__pyx_codeobj__13;
static PyObject *__pyx_codeobj__37;
/* Late includes */
/* "spacy/syntax/arc_eager.pyx":56
* # Helper functions for the arc-eager oracle
*
* cdef weight_t push_cost(StateClass stcls, const GoldParseC* gold, int target) nogil: # <<<<<<<<<<<<<<
* cdef weight_t cost = 0
* cdef int i, S_i
*/
static __pyx_t_5thinc_8typedefs_weight_t __pyx_f_5spacy_6syntax_9arc_eager_push_cost(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *__pyx_v_stcls, struct __pyx_t_5spacy_4gold_GoldParseC const *__pyx_v_gold, int __pyx_v_target) {
__pyx_t_5thinc_8typedefs_weight_t __pyx_v_cost;
int __pyx_v_i;
int __pyx_v_S_i;
__pyx_t_5thinc_8typedefs_weight_t __pyx_r;
__Pyx_TraceDeclarations
int __pyx_t_1;
int __pyx_t_2;
int __pyx_t_3;
int __pyx_t_4;
int __pyx_t_5;
__pyx_t_5thinc_8typedefs_weight_t __pyx_t_6;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_TraceCall("push_cost", __pyx_f[0], 56, 1, __PYX_ERR(0, 56, __pyx_L1_error));
/* "spacy/syntax/arc_eager.pyx":57
*
* cdef weight_t push_cost(StateClass stcls, const GoldParseC* gold, int target) nogil:
* cdef weight_t cost = 0 # <<<<<<<<<<<<<<
* cdef int i, S_i
* for i in range(stcls.stack_depth()):
*/
__pyx_v_cost = 0.0;
/* "spacy/syntax/arc_eager.pyx":59
* cdef weight_t cost = 0
* cdef int i, S_i
* for i in range(stcls.stack_depth()): # <<<<<<<<<<<<<<
* S_i = stcls.S(i)
* if gold.heads[target] == S_i:
*/
__pyx_t_1 = __pyx_f_5spacy_6syntax_10stateclass_10StateClass_stack_depth(__pyx_v_stcls);
__pyx_t_2 = __pyx_t_1;
for (__pyx_t_3 = 0; __pyx_t_3 < __pyx_t_2; __pyx_t_3+=1) {
__pyx_v_i = __pyx_t_3;
/* "spacy/syntax/arc_eager.pyx":60
* cdef int i, S_i
* for i in range(stcls.stack_depth()):
* S_i = stcls.S(i) # <<<<<<<<<<<<<<
* if gold.heads[target] == S_i:
* cost += 1
*/
__pyx_v_S_i = __pyx_f_5spacy_6syntax_10stateclass_10StateClass_S(__pyx_v_stcls, __pyx_v_i);
/* "spacy/syntax/arc_eager.pyx":61
* for i in range(stcls.stack_depth()):
* S_i = stcls.S(i)
* if gold.heads[target] == S_i: # <<<<<<<<<<<<<<
* cost += 1
* if gold.heads[S_i] == target and (NON_MONOTONIC or not stcls.has_head(S_i)):
*/
__pyx_t_4 = (((__pyx_v_gold->heads[__pyx_v_target]) == __pyx_v_S_i) != 0);
if (__pyx_t_4) {
/* "spacy/syntax/arc_eager.pyx":62
* S_i = stcls.S(i)
* if gold.heads[target] == S_i:
* cost += 1 # <<<<<<<<<<<<<<
* if gold.heads[S_i] == target and (NON_MONOTONIC or not stcls.has_head(S_i)):
* cost += 1
*/
__pyx_v_cost = (__pyx_v_cost + 1.0);
/* "spacy/syntax/arc_eager.pyx":61
* for i in range(stcls.stack_depth()):
* S_i = stcls.S(i)
* if gold.heads[target] == S_i: # <<<<<<<<<<<<<<
* cost += 1
* if gold.heads[S_i] == target and (NON_MONOTONIC or not stcls.has_head(S_i)):
*/
}
/* "spacy/syntax/arc_eager.pyx":63
* if gold.heads[target] == S_i:
* cost += 1
* if gold.heads[S_i] == target and (NON_MONOTONIC or not stcls.has_head(S_i)): # <<<<<<<<<<<<<<
* cost += 1
* if BINARY_COSTS and cost >= 1:
*/
__pyx_t_5 = (((__pyx_v_gold->heads[__pyx_v_S_i]) == __pyx_v_target) != 0);
if (__pyx_t_5) {
} else {
__pyx_t_4 = __pyx_t_5;
goto __pyx_L7_bool_binop_done;
}
__pyx_t_4 = 1;
__pyx_L7_bool_binop_done:;
if (__pyx_t_4) {
/* "spacy/syntax/arc_eager.pyx":64
* cost += 1
* if gold.heads[S_i] == target and (NON_MONOTONIC or not stcls.has_head(S_i)):
* cost += 1 # <<<<<<<<<<<<<<
* if BINARY_COSTS and cost >= 1:
* return cost
*/
__pyx_v_cost = (__pyx_v_cost + 1.0);
/* "spacy/syntax/arc_eager.pyx":63
* if gold.heads[target] == S_i:
* cost += 1
* if gold.heads[S_i] == target and (NON_MONOTONIC or not stcls.has_head(S_i)): # <<<<<<<<<<<<<<
* cost += 1
* if BINARY_COSTS and cost >= 1:
*/
}
/* "spacy/syntax/arc_eager.pyx":65
* if gold.heads[S_i] == target and (NON_MONOTONIC or not stcls.has_head(S_i)):
* cost += 1
* if BINARY_COSTS and cost >= 1: # <<<<<<<<<<<<<<
* return cost
* cost += Break.is_valid(stcls.c, 0) and Break.move_cost(stcls, gold) == 0
*/
__pyx_t_5 = (__pyx_v_5spacy_6syntax_9arc_eager_BINARY_COSTS != 0);
if (__pyx_t_5) {
} else {
__pyx_t_4 = __pyx_t_5;
goto __pyx_L10_bool_binop_done;
}
__pyx_t_5 = ((__pyx_v_cost >= 1.0) != 0);
__pyx_t_4 = __pyx_t_5;
__pyx_L10_bool_binop_done:;
if (__pyx_t_4) {
/* "spacy/syntax/arc_eager.pyx":66
* cost += 1
* if BINARY_COSTS and cost >= 1:
* return cost # <<<<<<<<<<<<<<
* cost += Break.is_valid(stcls.c, 0) and Break.move_cost(stcls, gold) == 0
* return cost
*/
__pyx_r = __pyx_v_cost;
goto __pyx_L0;
/* "spacy/syntax/arc_eager.pyx":65
* if gold.heads[S_i] == target and (NON_MONOTONIC or not stcls.has_head(S_i)):
* cost += 1
* if BINARY_COSTS and cost >= 1: # <<<<<<<<<<<<<<
* return cost
* cost += Break.is_valid(stcls.c, 0) and Break.move_cost(stcls, gold) == 0
*/
}
}
/* "spacy/syntax/arc_eager.pyx":67
* if BINARY_COSTS and cost >= 1:
* return cost
* cost += Break.is_valid(stcls.c, 0) and Break.move_cost(stcls, gold) == 0 # <<<<<<<<<<<<<<
* return cost
*
*/
__pyx_t_4 = __pyx_f_5spacy_6syntax_9arc_eager_5Break_is_valid(__pyx_v_stcls->c, 0);
if (__pyx_t_4) {
} else {
__pyx_t_6 = __pyx_t_4;
goto __pyx_L12_bool_binop_done;
}
__pyx_t_4 = (__pyx_f_5spacy_6syntax_9arc_eager_5Break_move_cost(__pyx_v_stcls, __pyx_v_gold) == 0.0);
__pyx_t_6 = __pyx_t_4;
__pyx_L12_bool_binop_done:;
__pyx_v_cost = (__pyx_v_cost + __pyx_t_6);
/* "spacy/syntax/arc_eager.pyx":68
* return cost
* cost += Break.is_valid(stcls.c, 0) and Break.move_cost(stcls, gold) == 0
* return cost # <<<<<<<<<<<<<<
*
*
*/
__pyx_r = __pyx_v_cost;
goto __pyx_L0;
/* "spacy/syntax/arc_eager.pyx":56
* # Helper functions for the arc-eager oracle
*
* cdef weight_t push_cost(StateClass stcls, const GoldParseC* gold, int target) nogil: # <<<<<<<<<<<<<<
* cdef weight_t cost = 0
* cdef int i, S_i
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_WriteUnraisable("spacy.syntax.arc_eager.push_cost", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 1);
__pyx_r = 0;
__pyx_L0:;
__Pyx_TraceReturn(Py_None, 1);
return __pyx_r;
}
/* "spacy/syntax/arc_eager.pyx":71
*
*
* cdef weight_t pop_cost(StateClass stcls, const GoldParseC* gold, int target) nogil: # <<<<<<<<<<<<<<
* cdef weight_t cost = 0
* cdef int i, B_i
*/
static __pyx_t_5thinc_8typedefs_weight_t __pyx_f_5spacy_6syntax_9arc_eager_pop_cost(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *__pyx_v_stcls, struct __pyx_t_5spacy_4gold_GoldParseC const *__pyx_v_gold, int __pyx_v_target) {
__pyx_t_5thinc_8typedefs_weight_t __pyx_v_cost;
int __pyx_v_i;
int __pyx_v_B_i;
__pyx_t_5thinc_8typedefs_weight_t __pyx_r;
__Pyx_TraceDeclarations
int __pyx_t_1;
int __pyx_t_2;
int __pyx_t_3;
int __pyx_t_4;
int __pyx_t_5;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_TraceCall("pop_cost", __pyx_f[0], 71, 1, __PYX_ERR(0, 71, __pyx_L1_error));
/* "spacy/syntax/arc_eager.pyx":72
*
* cdef weight_t pop_cost(StateClass stcls, const GoldParseC* gold, int target) nogil:
* cdef weight_t cost = 0 # <<<<<<<<<<<<<<
* cdef int i, B_i
* for i in range(stcls.buffer_length()):
*/
__pyx_v_cost = 0.0;
/* "spacy/syntax/arc_eager.pyx":74
* cdef weight_t cost = 0
* cdef int i, B_i
* for i in range(stcls.buffer_length()): # <<<<<<<<<<<<<<
* B_i = stcls.B(i)
* cost += gold.heads[B_i] == target
*/
__pyx_t_1 = __pyx_f_5spacy_6syntax_10stateclass_10StateClass_buffer_length(__pyx_v_stcls);
__pyx_t_2 = __pyx_t_1;
for (__pyx_t_3 = 0; __pyx_t_3 < __pyx_t_2; __pyx_t_3+=1) {
__pyx_v_i = __pyx_t_3;
/* "spacy/syntax/arc_eager.pyx":75
* cdef int i, B_i
* for i in range(stcls.buffer_length()):
* B_i = stcls.B(i) # <<<<<<<<<<<<<<
* cost += gold.heads[B_i] == target
* cost += gold.heads[target] == B_i
*/
__pyx_v_B_i = __pyx_f_5spacy_6syntax_10stateclass_10StateClass_B(__pyx_v_stcls, __pyx_v_i);
/* "spacy/syntax/arc_eager.pyx":76
* for i in range(stcls.buffer_length()):
* B_i = stcls.B(i)
* cost += gold.heads[B_i] == target # <<<<<<<<<<<<<<
* cost += gold.heads[target] == B_i
* if gold.heads[B_i] == B_i or gold.heads[B_i] < target:
*/
__pyx_v_cost = (__pyx_v_cost + ((__pyx_v_gold->heads[__pyx_v_B_i]) == __pyx_v_target));
/* "spacy/syntax/arc_eager.pyx":77
* B_i = stcls.B(i)
* cost += gold.heads[B_i] == target
* cost += gold.heads[target] == B_i # <<<<<<<<<<<<<<
* if gold.heads[B_i] == B_i or gold.heads[B_i] < target:
* break
*/
__pyx_v_cost = (__pyx_v_cost + ((__pyx_v_gold->heads[__pyx_v_target]) == __pyx_v_B_i));
/* "spacy/syntax/arc_eager.pyx":78
* cost += gold.heads[B_i] == target
* cost += gold.heads[target] == B_i
* if gold.heads[B_i] == B_i or gold.heads[B_i] < target: # <<<<<<<<<<<<<<
* break
* if BINARY_COSTS and cost >= 1:
*/
__pyx_t_5 = (((__pyx_v_gold->heads[__pyx_v_B_i]) == __pyx_v_B_i) != 0);
if (!__pyx_t_5) {
} else {
__pyx_t_4 = __pyx_t_5;
goto __pyx_L6_bool_binop_done;
}
__pyx_t_5 = (((__pyx_v_gold->heads[__pyx_v_B_i]) < __pyx_v_target) != 0);
__pyx_t_4 = __pyx_t_5;
__pyx_L6_bool_binop_done:;
if (__pyx_t_4) {
/* "spacy/syntax/arc_eager.pyx":79
* cost += gold.heads[target] == B_i
* if gold.heads[B_i] == B_i or gold.heads[B_i] < target:
* break # <<<<<<<<<<<<<<
* if BINARY_COSTS and cost >= 1:
* return cost
*/
goto __pyx_L4_break;
/* "spacy/syntax/arc_eager.pyx":78
* cost += gold.heads[B_i] == target
* cost += gold.heads[target] == B_i
* if gold.heads[B_i] == B_i or gold.heads[B_i] < target: # <<<<<<<<<<<<<<
* break
* if BINARY_COSTS and cost >= 1:
*/
}
/* "spacy/syntax/arc_eager.pyx":80
* if gold.heads[B_i] == B_i or gold.heads[B_i] < target:
* break
* if BINARY_COSTS and cost >= 1: # <<<<<<<<<<<<<<
* return cost
* if Break.is_valid(stcls.c, 0) and Break.move_cost(stcls, gold) == 0:
*/
__pyx_t_5 = (__pyx_v_5spacy_6syntax_9arc_eager_BINARY_COSTS != 0);
if (__pyx_t_5) {
} else {
__pyx_t_4 = __pyx_t_5;
goto __pyx_L9_bool_binop_done;
}
__pyx_t_5 = ((__pyx_v_cost >= 1.0) != 0);
__pyx_t_4 = __pyx_t_5;
__pyx_L9_bool_binop_done:;
if (__pyx_t_4) {
/* "spacy/syntax/arc_eager.pyx":81
* break
* if BINARY_COSTS and cost >= 1:
* return cost # <<<<<<<<<<<<<<
* if Break.is_valid(stcls.c, 0) and Break.move_cost(stcls, gold) == 0:
* cost += 1
*/
__pyx_r = __pyx_v_cost;
goto __pyx_L0;
/* "spacy/syntax/arc_eager.pyx":80
* if gold.heads[B_i] == B_i or gold.heads[B_i] < target:
* break
* if BINARY_COSTS and cost >= 1: # <<<<<<<<<<<<<<
* return cost
* if Break.is_valid(stcls.c, 0) and Break.move_cost(stcls, gold) == 0:
*/
}
}
__pyx_L4_break:;
/* "spacy/syntax/arc_eager.pyx":82
* if BINARY_COSTS and cost >= 1:
* return cost
* if Break.is_valid(stcls.c, 0) and Break.move_cost(stcls, gold) == 0: # <<<<<<<<<<<<<<
* cost += 1
* return cost
*/
__pyx_t_5 = (__pyx_f_5spacy_6syntax_9arc_eager_5Break_is_valid(__pyx_v_stcls->c, 0) != 0);
if (__pyx_t_5) {
} else {
__pyx_t_4 = __pyx_t_5;
goto __pyx_L12_bool_binop_done;
}
__pyx_t_5 = ((__pyx_f_5spacy_6syntax_9arc_eager_5Break_move_cost(__pyx_v_stcls, __pyx_v_gold) == 0.0) != 0);
__pyx_t_4 = __pyx_t_5;
__pyx_L12_bool_binop_done:;
if (__pyx_t_4) {
/* "spacy/syntax/arc_eager.pyx":83
* return cost
* if Break.is_valid(stcls.c, 0) and Break.move_cost(stcls, gold) == 0:
* cost += 1 # <<<<<<<<<<<<<<
* return cost
*
*/
__pyx_v_cost = (__pyx_v_cost + 1.0);
/* "spacy/syntax/arc_eager.pyx":82
* if BINARY_COSTS and cost >= 1:
* return cost
* if Break.is_valid(stcls.c, 0) and Break.move_cost(stcls, gold) == 0: # <<<<<<<<<<<<<<
* cost += 1
* return cost
*/
}
/* "spacy/syntax/arc_eager.pyx":84
* if Break.is_valid(stcls.c, 0) and Break.move_cost(stcls, gold) == 0:
* cost += 1
* return cost # <<<<<<<<<<<<<<
*
*
*/
__pyx_r = __pyx_v_cost;
goto __pyx_L0;
/* "spacy/syntax/arc_eager.pyx":71
*
*
* cdef weight_t pop_cost(StateClass stcls, const GoldParseC* gold, int target) nogil: # <<<<<<<<<<<<<<
* cdef weight_t cost = 0
* cdef int i, B_i
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_WriteUnraisable("spacy.syntax.arc_eager.pop_cost", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 1);
__pyx_r = 0;
__pyx_L0:;
__Pyx_TraceReturn(Py_None, 1);
return __pyx_r;
}
/* "spacy/syntax/arc_eager.pyx":87
*
*
* cdef weight_t arc_cost(StateClass stcls, const GoldParseC* gold, int head, int child) nogil: # <<<<<<<<<<<<<<
* if arc_is_gold(gold, head, child):
* return 0
*/
static __pyx_t_5thinc_8typedefs_weight_t __pyx_f_5spacy_6syntax_9arc_eager_arc_cost(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *__pyx_v_stcls, struct __pyx_t_5spacy_4gold_GoldParseC const *__pyx_v_gold, int __pyx_v_head, int __pyx_v_child) {
__pyx_t_5thinc_8typedefs_weight_t __pyx_r;
__Pyx_TraceDeclarations
int __pyx_t_1;
int __pyx_t_2;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_TraceCall("arc_cost", __pyx_f[0], 87, 1, __PYX_ERR(0, 87, __pyx_L1_error));
/* "spacy/syntax/arc_eager.pyx":88
*
* cdef weight_t arc_cost(StateClass stcls, const GoldParseC* gold, int head, int child) nogil:
* if arc_is_gold(gold, head, child): # <<<<<<<<<<<<<<
* return 0
* elif stcls.H(child) == gold.heads[child]:
*/
__pyx_t_1 = (__pyx_f_5spacy_6syntax_9arc_eager_arc_is_gold(__pyx_v_gold, __pyx_v_head, __pyx_v_child) != 0);
if (__pyx_t_1) {
/* "spacy/syntax/arc_eager.pyx":89
* cdef weight_t arc_cost(StateClass stcls, const GoldParseC* gold, int head, int child) nogil:
* if arc_is_gold(gold, head, child):
* return 0 # <<<<<<<<<<<<<<
* elif stcls.H(child) == gold.heads[child]:
* return 1
*/
__pyx_r = 0.0;
goto __pyx_L0;
/* "spacy/syntax/arc_eager.pyx":88
*
* cdef weight_t arc_cost(StateClass stcls, const GoldParseC* gold, int head, int child) nogil:
* if arc_is_gold(gold, head, child): # <<<<<<<<<<<<<<
* return 0
* elif stcls.H(child) == gold.heads[child]:
*/
}
/* "spacy/syntax/arc_eager.pyx":90
* if arc_is_gold(gold, head, child):
* return 0
* elif stcls.H(child) == gold.heads[child]: # <<<<<<<<<<<<<<
* return 1
* # Head in buffer
*/
__pyx_t_1 = ((__pyx_f_5spacy_6syntax_10stateclass_10StateClass_H(__pyx_v_stcls, __pyx_v_child) == (__pyx_v_gold->heads[__pyx_v_child])) != 0);
if (__pyx_t_1) {
/* "spacy/syntax/arc_eager.pyx":91
* return 0
* elif stcls.H(child) == gold.heads[child]:
* return 1 # <<<<<<<<<<<<<<
* # Head in buffer
* elif gold.heads[child] >= stcls.B(0) and stcls.B(1) != 0:
*/
__pyx_r = 1.0;
goto __pyx_L0;
/* "spacy/syntax/arc_eager.pyx":90
* if arc_is_gold(gold, head, child):
* return 0
* elif stcls.H(child) == gold.heads[child]: # <<<<<<<<<<<<<<
* return 1
* # Head in buffer
*/
}
/* "spacy/syntax/arc_eager.pyx":93
* return 1
* # Head in buffer
* elif gold.heads[child] >= stcls.B(0) and stcls.B(1) != 0: # <<<<<<<<<<<<<<
* return 1
* else:
*/
__pyx_t_2 = (((__pyx_v_gold->heads[__pyx_v_child]) >= __pyx_f_5spacy_6syntax_10stateclass_10StateClass_B(__pyx_v_stcls, 0)) != 0);
if (__pyx_t_2) {
} else {
__pyx_t_1 = __pyx_t_2;
goto __pyx_L4_bool_binop_done;
}
__pyx_t_2 = ((__pyx_f_5spacy_6syntax_10stateclass_10StateClass_B(__pyx_v_stcls, 1) != 0) != 0);
__pyx_t_1 = __pyx_t_2;
__pyx_L4_bool_binop_done:;
if (__pyx_t_1) {
/* "spacy/syntax/arc_eager.pyx":94
* # Head in buffer
* elif gold.heads[child] >= stcls.B(0) and stcls.B(1) != 0:
* return 1 # <<<<<<<<<<<<<<
* else:
* return 0
*/
__pyx_r = 1.0;
goto __pyx_L0;
/* "spacy/syntax/arc_eager.pyx":93
* return 1
* # Head in buffer
* elif gold.heads[child] >= stcls.B(0) and stcls.B(1) != 0: # <<<<<<<<<<<<<<
* return 1
* else:
*/
}
/* "spacy/syntax/arc_eager.pyx":96
* return 1
* else:
* return 0 # <<<<<<<<<<<<<<
*
*
*/
/*else*/ {
__pyx_r = 0.0;
goto __pyx_L0;
}
/* "spacy/syntax/arc_eager.pyx":87
*
*
* cdef weight_t arc_cost(StateClass stcls, const GoldParseC* gold, int head, int child) nogil: # <<<<<<<<<<<<<<
* if arc_is_gold(gold, head, child):
* return 0
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_WriteUnraisable("spacy.syntax.arc_eager.arc_cost", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 1);
__pyx_r = 0;
__pyx_L0:;
__Pyx_TraceReturn(Py_None, 1);
return __pyx_r;
}
/* "spacy/syntax/arc_eager.pyx":99
*
*
* cdef bint arc_is_gold(const GoldParseC* gold, int head, int child) nogil: # <<<<<<<<<<<<<<
* if not gold.has_dep[child]:
* return True
*/
static int __pyx_f_5spacy_6syntax_9arc_eager_arc_is_gold(struct __pyx_t_5spacy_4gold_GoldParseC const *__pyx_v_gold, int __pyx_v_head, int __pyx_v_child) {
int __pyx_r;
__Pyx_TraceDeclarations
int __pyx_t_1;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_TraceCall("arc_is_gold", __pyx_f[0], 99, 1, __PYX_ERR(0, 99, __pyx_L1_error));
/* "spacy/syntax/arc_eager.pyx":100
*
* cdef bint arc_is_gold(const GoldParseC* gold, int head, int child) nogil:
* if not gold.has_dep[child]: # <<<<<<<<<<<<<<
* return True
* elif gold.heads[child] == head:
*/
__pyx_t_1 = ((!((__pyx_v_gold->has_dep[__pyx_v_child]) != 0)) != 0);
if (__pyx_t_1) {
/* "spacy/syntax/arc_eager.pyx":101
* cdef bint arc_is_gold(const GoldParseC* gold, int head, int child) nogil:
* if not gold.has_dep[child]:
* return True # <<<<<<<<<<<<<<
* elif gold.heads[child] == head:
* return True
*/
__pyx_r = 1;
goto __pyx_L0;
/* "spacy/syntax/arc_eager.pyx":100
*
* cdef bint arc_is_gold(const GoldParseC* gold, int head, int child) nogil:
* if not gold.has_dep[child]: # <<<<<<<<<<<<<<
* return True
* elif gold.heads[child] == head:
*/
}
/* "spacy/syntax/arc_eager.pyx":102
* if not gold.has_dep[child]:
* return True
* elif gold.heads[child] == head: # <<<<<<<<<<<<<<
* return True
* else:
*/
__pyx_t_1 = (((__pyx_v_gold->heads[__pyx_v_child]) == __pyx_v_head) != 0);
if (__pyx_t_1) {
/* "spacy/syntax/arc_eager.pyx":103
* return True
* elif gold.heads[child] == head:
* return True # <<<<<<<<<<<<<<
* else:
* return False
*/
__pyx_r = 1;
goto __pyx_L0;
/* "spacy/syntax/arc_eager.pyx":102
* if not gold.has_dep[child]:
* return True
* elif gold.heads[child] == head: # <<<<<<<<<<<<<<
* return True
* else:
*/
}
/* "spacy/syntax/arc_eager.pyx":105
* return True
* else:
* return False # <<<<<<<<<<<<<<
*
*
*/
/*else*/ {
__pyx_r = 0;
goto __pyx_L0;
}
/* "spacy/syntax/arc_eager.pyx":99
*
*
* cdef bint arc_is_gold(const GoldParseC* gold, int head, int child) nogil: # <<<<<<<<<<<<<<
* if not gold.has_dep[child]:
* return True
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_WriteUnraisable("spacy.syntax.arc_eager.arc_is_gold", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 1);
__pyx_r = 0;
__pyx_L0:;
__Pyx_TraceReturn(Py_None, 1);
return __pyx_r;
}
/* "spacy/syntax/arc_eager.pyx":108
*
*
* cdef bint label_is_gold(const GoldParseC* gold, int head, int child, attr_t label) nogil: # <<<<<<<<<<<<<<
* if not gold.has_dep[child]:
* return True
*/
static int __pyx_f_5spacy_6syntax_9arc_eager_label_is_gold(struct __pyx_t_5spacy_4gold_GoldParseC const *__pyx_v_gold, CYTHON_UNUSED int __pyx_v_head, int __pyx_v_child, __pyx_t_5spacy_8typedefs_attr_t __pyx_v_label) {
int __pyx_r;
__Pyx_TraceDeclarations
int __pyx_t_1;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_TraceCall("label_is_gold", __pyx_f[0], 108, 1, __PYX_ERR(0, 108, __pyx_L1_error));
/* "spacy/syntax/arc_eager.pyx":109
*
* cdef bint label_is_gold(const GoldParseC* gold, int head, int child, attr_t label) nogil:
* if not gold.has_dep[child]: # <<<<<<<<<<<<<<
* return True
* elif label == 0:
*/
__pyx_t_1 = ((!((__pyx_v_gold->has_dep[__pyx_v_child]) != 0)) != 0);
if (__pyx_t_1) {
/* "spacy/syntax/arc_eager.pyx":110
* cdef bint label_is_gold(const GoldParseC* gold, int head, int child, attr_t label) nogil:
* if not gold.has_dep[child]:
* return True # <<<<<<<<<<<<<<
* elif label == 0:
* return True
*/
__pyx_r = 1;
goto __pyx_L0;
/* "spacy/syntax/arc_eager.pyx":109
*
* cdef bint label_is_gold(const GoldParseC* gold, int head, int child, attr_t label) nogil:
* if not gold.has_dep[child]: # <<<<<<<<<<<<<<
* return True
* elif label == 0:
*/
}
/* "spacy/syntax/arc_eager.pyx":111
* if not gold.has_dep[child]:
* return True
* elif label == 0: # <<<<<<<<<<<<<<
* return True
* elif gold.labels[child] == label:
*/
__pyx_t_1 = ((__pyx_v_label == 0) != 0);
if (__pyx_t_1) {
/* "spacy/syntax/arc_eager.pyx":112
* return True
* elif label == 0:
* return True # <<<<<<<<<<<<<<
* elif gold.labels[child] == label:
* return True
*/
__pyx_r = 1;
goto __pyx_L0;
/* "spacy/syntax/arc_eager.pyx":111
* if not gold.has_dep[child]:
* return True
* elif label == 0: # <<<<<<<<<<<<<<
* return True
* elif gold.labels[child] == label:
*/
}
/* "spacy/syntax/arc_eager.pyx":113
* elif label == 0:
* return True
* elif gold.labels[child] == label: # <<<<<<<<<<<<<<
* return True
* else:
*/
__pyx_t_1 = (((__pyx_v_gold->labels[__pyx_v_child]) == __pyx_v_label) != 0);
if (__pyx_t_1) {
/* "spacy/syntax/arc_eager.pyx":114
* return True
* elif gold.labels[child] == label:
* return True # <<<<<<<<<<<<<<
* else:
* return False
*/
__pyx_r = 1;
goto __pyx_L0;
/* "spacy/syntax/arc_eager.pyx":113
* elif label == 0:
* return True
* elif gold.labels[child] == label: # <<<<<<<<<<<<<<
* return True
* else:
*/
}
/* "spacy/syntax/arc_eager.pyx":116
* return True
* else:
* return False # <<<<<<<<<<<<<<
*
*
*/
/*else*/ {
__pyx_r = 0;
goto __pyx_L0;
}
/* "spacy/syntax/arc_eager.pyx":108
*
*
* cdef bint label_is_gold(const GoldParseC* gold, int head, int child, attr_t label) nogil: # <<<<<<<<<<<<<<
* if not gold.has_dep[child]:
* return True
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_WriteUnraisable("spacy.syntax.arc_eager.label_is_gold", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 1);
__pyx_r = 0;
__pyx_L0:;
__Pyx_TraceReturn(Py_None, 1);
return __pyx_r;
}
/* "spacy/syntax/arc_eager.pyx":119
*
*
* cdef bint _is_gold_root(const GoldParseC* gold, int word) nogil: # <<<<<<<<<<<<<<
* return gold.heads[word] == word or not gold.has_dep[word]
*
*/
static int __pyx_f_5spacy_6syntax_9arc_eager__is_gold_root(struct __pyx_t_5spacy_4gold_GoldParseC const *__pyx_v_gold, int __pyx_v_word) {
int __pyx_r;
__Pyx_TraceDeclarations
int __pyx_t_1;
int __pyx_t_2;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_TraceCall("_is_gold_root", __pyx_f[0], 119, 1, __PYX_ERR(0, 119, __pyx_L1_error));
/* "spacy/syntax/arc_eager.pyx":120
*
* cdef bint _is_gold_root(const GoldParseC* gold, int word) nogil:
* return gold.heads[word] == word or not gold.has_dep[word] # <<<<<<<<<<<<<<
*
* cdef class Shift:
*/
__pyx_t_2 = (((__pyx_v_gold->heads[__pyx_v_word]) == __pyx_v_word) != 0);
if (!__pyx_t_2) {
} else {
__pyx_t_1 = __pyx_t_2;
goto __pyx_L3_bool_binop_done;
}
__pyx_t_2 = ((!((__pyx_v_gold->has_dep[__pyx_v_word]) != 0)) != 0);
__pyx_t_1 = __pyx_t_2;
__pyx_L3_bool_binop_done:;
__pyx_r = __pyx_t_1;
goto __pyx_L0;
/* "spacy/syntax/arc_eager.pyx":119
*
*
* cdef bint _is_gold_root(const GoldParseC* gold, int word) nogil: # <<<<<<<<<<<<<<
* return gold.heads[word] == word or not gold.has_dep[word]
*
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_WriteUnraisable("spacy.syntax.arc_eager._is_gold_root", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 1);
__pyx_r = 0;
__pyx_L0:;
__Pyx_TraceReturn(Py_None, 1);
return __pyx_r;
}
/* "spacy/syntax/arc_eager.pyx":124
* cdef class Shift:
* @staticmethod
* cdef bint is_valid(const StateC* st, attr_t label) nogil: # <<<<<<<<<<<<<<
* sent_start = st._sent[st.B_(0).l_edge].sent_start
* return st.buffer_length() >= 2 and not st.shifted[st.B(0)] and sent_start != 1
*/
static int __pyx_f_5spacy_6syntax_9arc_eager_5Shift_is_valid(__pyx_t_5spacy_6syntax_6_state_StateC const *__pyx_v_st, CYTHON_UNUSED __pyx_t_5spacy_8typedefs_attr_t __pyx_v_label) {
int __pyx_v_sent_start;
int __pyx_r;
__Pyx_TraceDeclarations
int __pyx_t_1;
int __pyx_t_2;
int __pyx_t_3;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_TraceCall("is_valid", __pyx_f[0], 124, 1, __PYX_ERR(0, 124, __pyx_L1_error));
/* "spacy/syntax/arc_eager.pyx":125
* @staticmethod
* cdef bint is_valid(const StateC* st, attr_t label) nogil:
* sent_start = st._sent[st.B_(0).l_edge].sent_start # <<<<<<<<<<<<<<
* return st.buffer_length() >= 2 and not st.shifted[st.B(0)] and sent_start != 1
*
*/
__pyx_t_1 = (__pyx_v_st->_sent[__pyx_v_st->B_(0)->l_edge]).sent_start;
__pyx_v_sent_start = __pyx_t_1;
/* "spacy/syntax/arc_eager.pyx":126
* cdef bint is_valid(const StateC* st, attr_t label) nogil:
* sent_start = st._sent[st.B_(0).l_edge].sent_start
* return st.buffer_length() >= 2 and not st.shifted[st.B(0)] and sent_start != 1 # <<<<<<<<<<<<<<
*
* @staticmethod
*/
__pyx_t_3 = ((__pyx_v_st->buffer_length() >= 2) != 0);
if (__pyx_t_3) {
} else {
__pyx_t_2 = __pyx_t_3;
goto __pyx_L3_bool_binop_done;
}
__pyx_t_3 = ((!((__pyx_v_st->shifted[__pyx_v_st->B(0)]) != 0)) != 0);
if (__pyx_t_3) {
} else {
__pyx_t_2 = __pyx_t_3;
goto __pyx_L3_bool_binop_done;
}
__pyx_t_3 = ((__pyx_v_sent_start != 1) != 0);
__pyx_t_2 = __pyx_t_3;
__pyx_L3_bool_binop_done:;
__pyx_r = __pyx_t_2;
goto __pyx_L0;
/* "spacy/syntax/arc_eager.pyx":124
* cdef class Shift:
* @staticmethod
* cdef bint is_valid(const StateC* st, attr_t label) nogil: # <<<<<<<<<<<<<<
* sent_start = st._sent[st.B_(0).l_edge].sent_start
* return st.buffer_length() >= 2 and not st.shifted[st.B(0)] and sent_start != 1
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_WriteUnraisable("spacy.syntax.arc_eager.Shift.is_valid", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 1);
__pyx_r = 0;
__pyx_L0:;
__Pyx_TraceReturn(Py_None, 1);
return __pyx_r;
}
/* "spacy/syntax/arc_eager.pyx":129
*
* @staticmethod
* cdef int transition(StateC* st, attr_t label) nogil: # <<<<<<<<<<<<<<
* st.push()
* st.fast_forward()
*/
static int __pyx_f_5spacy_6syntax_9arc_eager_5Shift_transition(__pyx_t_5spacy_6syntax_6_state_StateC *__pyx_v_st, CYTHON_UNUSED __pyx_t_5spacy_8typedefs_attr_t __pyx_v_label) {
int __pyx_r;
__Pyx_TraceDeclarations
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_TraceCall("transition", __pyx_f[0], 129, 1, __PYX_ERR(0, 129, __pyx_L1_error));
/* "spacy/syntax/arc_eager.pyx":130
* @staticmethod
* cdef int transition(StateC* st, attr_t label) nogil:
* st.push() # <<<<<<<<<<<<<<
* st.fast_forward()
*
*/
__pyx_v_st->push();
/* "spacy/syntax/arc_eager.pyx":131
* cdef int transition(StateC* st, attr_t label) nogil:
* st.push()
* st.fast_forward() # <<<<<<<<<<<<<<
*
* @staticmethod
*/
__pyx_v_st->fast_forward();
/* "spacy/syntax/arc_eager.pyx":129
*
* @staticmethod
* cdef int transition(StateC* st, attr_t label) nogil: # <<<<<<<<<<<<<<
* st.push()
* st.fast_forward()
*/
/* function exit code */
__pyx_r = 0;
goto __pyx_L0;
__pyx_L1_error:;
__Pyx_WriteUnraisable("spacy.syntax.arc_eager.Shift.transition", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 1);
__pyx_r = 0;
__pyx_L0:;
__Pyx_TraceReturn(Py_None, 1);
return __pyx_r;
}
/* "spacy/syntax/arc_eager.pyx":134
*
* @staticmethod
* cdef weight_t cost(StateClass st, const GoldParseC* gold, attr_t label) nogil: # <<<<<<<<<<<<<<
* return Shift.move_cost(st, gold) + Shift.label_cost(st, gold, label)
*
*/
static __pyx_t_5thinc_8typedefs_weight_t __pyx_f_5spacy_6syntax_9arc_eager_5Shift_cost(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *__pyx_v_st, struct __pyx_t_5spacy_4gold_GoldParseC const *__pyx_v_gold, __pyx_t_5spacy_8typedefs_attr_t __pyx_v_label) {
__pyx_t_5thinc_8typedefs_weight_t __pyx_r;
__Pyx_TraceDeclarations
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_TraceCall("cost", __pyx_f[0], 134, 1, __PYX_ERR(0, 134, __pyx_L1_error));
/* "spacy/syntax/arc_eager.pyx":135
* @staticmethod
* cdef weight_t cost(StateClass st, const GoldParseC* gold, attr_t label) nogil:
* return Shift.move_cost(st, gold) + Shift.label_cost(st, gold, label) # <<<<<<<<<<<<<<
*
* @staticmethod
*/
__pyx_r = (__pyx_f_5spacy_6syntax_9arc_eager_5Shift_move_cost(__pyx_v_st, __pyx_v_gold) + __pyx_f_5spacy_6syntax_9arc_eager_5Shift_label_cost(__pyx_v_st, __pyx_v_gold, __pyx_v_label));
goto __pyx_L0;
/* "spacy/syntax/arc_eager.pyx":134
*
* @staticmethod
* cdef weight_t cost(StateClass st, const GoldParseC* gold, attr_t label) nogil: # <<<<<<<<<<<<<<
* return Shift.move_cost(st, gold) + Shift.label_cost(st, gold, label)
*
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_WriteUnraisable("spacy.syntax.arc_eager.Shift.cost", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 1);
__pyx_r = 0;
__pyx_L0:;
__Pyx_TraceReturn(Py_None, 1);
return __pyx_r;
}
/* "spacy/syntax/arc_eager.pyx":138
*
* @staticmethod
* cdef inline weight_t move_cost(StateClass s, const GoldParseC* gold) nogil: # <<<<<<<<<<<<<<
* return push_cost(s, gold, s.B(0))
*
*/
static CYTHON_INLINE __pyx_t_5thinc_8typedefs_weight_t __pyx_f_5spacy_6syntax_9arc_eager_5Shift_move_cost(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *__pyx_v_s, struct __pyx_t_5spacy_4gold_GoldParseC const *__pyx_v_gold) {
__pyx_t_5thinc_8typedefs_weight_t __pyx_r;
__Pyx_TraceDeclarations
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_TraceCall("move_cost", __pyx_f[0], 138, 1, __PYX_ERR(0, 138, __pyx_L1_error));
/* "spacy/syntax/arc_eager.pyx":139
* @staticmethod
* cdef inline weight_t move_cost(StateClass s, const GoldParseC* gold) nogil:
* return push_cost(s, gold, s.B(0)) # <<<<<<<<<<<<<<
*
* @staticmethod
*/
__pyx_r = __pyx_f_5spacy_6syntax_9arc_eager_push_cost(__pyx_v_s, __pyx_v_gold, __pyx_f_5spacy_6syntax_10stateclass_10StateClass_B(__pyx_v_s, 0));
goto __pyx_L0;
/* "spacy/syntax/arc_eager.pyx":138
*
* @staticmethod
* cdef inline weight_t move_cost(StateClass s, const GoldParseC* gold) nogil: # <<<<<<<<<<<<<<
* return push_cost(s, gold, s.B(0))
*
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_WriteUnraisable("spacy.syntax.arc_eager.Shift.move_cost", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 1);
__pyx_r = 0;
__pyx_L0:;
__Pyx_TraceReturn(Py_None, 1);
return __pyx_r;
}
/* "spacy/syntax/arc_eager.pyx":142
*
* @staticmethod
* cdef inline weight_t label_cost(StateClass s, const GoldParseC* gold, attr_t label) nogil: # <<<<<<<<<<<<<<
* return 0
*
*/
static CYTHON_INLINE __pyx_t_5thinc_8typedefs_weight_t __pyx_f_5spacy_6syntax_9arc_eager_5Shift_label_cost(CYTHON_UNUSED struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *__pyx_v_s, CYTHON_UNUSED struct __pyx_t_5spacy_4gold_GoldParseC const *__pyx_v_gold, CYTHON_UNUSED __pyx_t_5spacy_8typedefs_attr_t __pyx_v_label) {
__pyx_t_5thinc_8typedefs_weight_t __pyx_r;
__Pyx_TraceDeclarations
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_TraceCall("label_cost", __pyx_f[0], 142, 1, __PYX_ERR(0, 142, __pyx_L1_error));
/* "spacy/syntax/arc_eager.pyx":143
* @staticmethod
* cdef inline weight_t label_cost(StateClass s, const GoldParseC* gold, attr_t label) nogil:
* return 0 # <<<<<<<<<<<<<<
*
*
*/
__pyx_r = 0.0;
goto __pyx_L0;
/* "spacy/syntax/arc_eager.pyx":142
*
* @staticmethod
* cdef inline weight_t label_cost(StateClass s, const GoldParseC* gold, attr_t label) nogil: # <<<<<<<<<<<<<<
* return 0
*
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_WriteUnraisable("spacy.syntax.arc_eager.Shift.label_cost", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 1);
__pyx_r = 0;
__pyx_L0:;
__Pyx_TraceReturn(Py_None, 1);
return __pyx_r;
}
/* "(tree fragment)":1
* def __reduce_cython__(self): # <<<<<<<<<<<<<<
* cdef tuple state
* cdef object _dict
*/
/* Python wrapper */
static PyObject *__pyx_pw_5spacy_6syntax_9arc_eager_5Shift_1__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
static PyObject *__pyx_pw_5spacy_6syntax_9arc_eager_5Shift_1__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
PyObject *__pyx_r = 0;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0);
__pyx_r = __pyx_pf_5spacy_6syntax_9arc_eager_5Shift___reduce_cython__(((struct __pyx_obj_5spacy_6syntax_9arc_eager_Shift *)__pyx_v_self));
/* function exit code */
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
static PyObject *__pyx_pf_5spacy_6syntax_9arc_eager_5Shift___reduce_cython__(struct __pyx_obj_5spacy_6syntax_9arc_eager_Shift *__pyx_v_self) {
PyObject *__pyx_v_state = 0;
PyObject *__pyx_v__dict = 0;
int __pyx_v_use_setstate;
PyObject *__pyx_r = NULL;
__Pyx_TraceDeclarations
__Pyx_RefNannyDeclarations
PyObject *__pyx_t_1 = NULL;
int __pyx_t_2;
int __pyx_t_3;
PyObject *__pyx_t_4 = NULL;
PyObject *__pyx_t_5 = NULL;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("__reduce_cython__", 0);
__Pyx_TraceCall("__reduce_cython__", __pyx_f[1], 1, 0, __PYX_ERR(1, 1, __pyx_L1_error));
/* "(tree fragment)":5
* cdef object _dict
* cdef bint use_setstate
* state = () # <<<<<<<<<<<<<<
* _dict = getattr(self, '__dict__', None)
* if _dict is not None:
*/
__Pyx_INCREF(__pyx_empty_tuple);
__pyx_v_state = __pyx_empty_tuple;
/* "(tree fragment)":6
* cdef bint use_setstate
* state = ()
* _dict = getattr(self, '__dict__', None) # <<<<<<<<<<<<<<
* if _dict is not None:
* state += (_dict,)
*/
__pyx_t_1 = __Pyx_GetAttr3(((PyObject *)__pyx_v_self), __pyx_n_s_dict, Py_None); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 6, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_v__dict = __pyx_t_1;
__pyx_t_1 = 0;
/* "(tree fragment)":7
* state = ()
* _dict = getattr(self, '__dict__', None)
* if _dict is not None: # <<<<<<<<<<<<<<
* state += (_dict,)
* use_setstate = True
*/
__pyx_t_2 = (__pyx_v__dict != Py_None);
__pyx_t_3 = (__pyx_t_2 != 0);
if (__pyx_t_3) {
/* "(tree fragment)":8
* _dict = getattr(self, '__dict__', None)
* if _dict is not None:
* state += (_dict,) # <<<<<<<<<<<<<<
* use_setstate = True
* else:
*/
__pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 8, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_INCREF(__pyx_v__dict);
__Pyx_GIVEREF(__pyx_v__dict);
PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v__dict);
__pyx_t_4 = PyNumber_InPlaceAdd(__pyx_v_state, __pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 8, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__Pyx_DECREF_SET(__pyx_v_state, ((PyObject*)__pyx_t_4));
__pyx_t_4 = 0;
/* "(tree fragment)":9
* if _dict is not None:
* state += (_dict,)
* use_setstate = True # <<<<<<<<<<<<<<
* else:
* use_setstate = False
*/
__pyx_v_use_setstate = 1;
/* "(tree fragment)":7
* state = ()
* _dict = getattr(self, '__dict__', None)
* if _dict is not None: # <<<<<<<<<<<<<<
* state += (_dict,)
* use_setstate = True
*/
goto __pyx_L3;
}
/* "(tree fragment)":11
* use_setstate = True
* else:
* use_setstate = False # <<<<<<<<<<<<<<
* if use_setstate:
* return __pyx_unpickle_Shift, (type(self), 0xd41d8cd, None), state
*/
/*else*/ {
__pyx_v_use_setstate = 0;
}
__pyx_L3:;
/* "(tree fragment)":12
* else:
* use_setstate = False
* if use_setstate: # <<<<<<<<<<<<<<
* return __pyx_unpickle_Shift, (type(self), 0xd41d8cd, None), state
* else:
*/
__pyx_t_3 = (__pyx_v_use_setstate != 0);
if (__pyx_t_3) {
/* "(tree fragment)":13
* use_setstate = False
* if use_setstate:
* return __pyx_unpickle_Shift, (type(self), 0xd41d8cd, None), state # <<<<<<<<<<<<<<
* else:
* return __pyx_unpickle_Shift, (type(self), 0xd41d8cd, state)
*/
__Pyx_XDECREF(__pyx_r);
__Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_pyx_unpickle_Shift); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 13, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 13, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))));
__Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))));
PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))));
__Pyx_INCREF(__pyx_int_222419149);
__Pyx_GIVEREF(__pyx_int_222419149);
PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_int_222419149);
__Pyx_INCREF(Py_None);
__Pyx_GIVEREF(Py_None);
PyTuple_SET_ITEM(__pyx_t_1, 2, Py_None);
__pyx_t_5 = PyTuple_New(3); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 13, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_GIVEREF(__pyx_t_4);
PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_4);
__Pyx_GIVEREF(__pyx_t_1);
PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_1);
__Pyx_INCREF(__pyx_v_state);
__Pyx_GIVEREF(__pyx_v_state);
PyTuple_SET_ITEM(__pyx_t_5, 2, __pyx_v_state);
__pyx_t_4 = 0;
__pyx_t_1 = 0;
__pyx_r = __pyx_t_5;
__pyx_t_5 = 0;
goto __pyx_L0;
/* "(tree fragment)":12
* else:
* use_setstate = False
* if use_setstate: # <<<<<<<<<<<<<<
* return __pyx_unpickle_Shift, (type(self), 0xd41d8cd, None), state
* else:
*/
}
/* "(tree fragment)":15
* return __pyx_unpickle_Shift, (type(self), 0xd41d8cd, None), state
* else:
* return __pyx_unpickle_Shift, (type(self), 0xd41d8cd, state) # <<<<<<<<<<<<<<
* def __setstate_cython__(self, __pyx_state):
* __pyx_unpickle_Shift__set_state(self, __pyx_state)
*/
/*else*/ {
__Pyx_XDECREF(__pyx_r);
__Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_pyx_unpickle_Shift); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 15, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 15, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))));
__Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))));
PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))));
__Pyx_INCREF(__pyx_int_222419149);
__Pyx_GIVEREF(__pyx_int_222419149);
PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_int_222419149);
__Pyx_INCREF(__pyx_v_state);
__Pyx_GIVEREF(__pyx_v_state);
PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_v_state);
__pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 15, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_GIVEREF(__pyx_t_5);
PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_5);
__Pyx_GIVEREF(__pyx_t_1);
PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_1);
__pyx_t_5 = 0;
__pyx_t_1 = 0;
__pyx_r = __pyx_t_4;
__pyx_t_4 = 0;
goto __pyx_L0;
}
/* "(tree fragment)":1
* def __reduce_cython__(self): # <<<<<<<<<<<<<<
* cdef tuple state
* cdef object _dict
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_1);
__Pyx_XDECREF(__pyx_t_4);
__Pyx_XDECREF(__pyx_t_5);
__Pyx_AddTraceback("spacy.syntax.arc_eager.Shift.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = NULL;
__pyx_L0:;
__Pyx_XDECREF(__pyx_v_state);
__Pyx_XDECREF(__pyx_v__dict);
__Pyx_XGIVEREF(__pyx_r);
__Pyx_TraceReturn(__pyx_r, 0);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "(tree fragment)":16
* else:
* return __pyx_unpickle_Shift, (type(self), 0xd41d8cd, state)
* def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<<
* __pyx_unpickle_Shift__set_state(self, __pyx_state)
*/
/* Python wrapper */
static PyObject *__pyx_pw_5spacy_6syntax_9arc_eager_5Shift_3__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state); /*proto*/
static PyObject *__pyx_pw_5spacy_6syntax_9arc_eager_5Shift_3__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state) {
PyObject *__pyx_r = 0;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0);
__pyx_r = __pyx_pf_5spacy_6syntax_9arc_eager_5Shift_2__setstate_cython__(((struct __pyx_obj_5spacy_6syntax_9arc_eager_Shift *)__pyx_v_self), ((PyObject *)__pyx_v___pyx_state));
/* function exit code */
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
static PyObject *__pyx_pf_5spacy_6syntax_9arc_eager_5Shift_2__setstate_cython__(struct __pyx_obj_5spacy_6syntax_9arc_eager_Shift *__pyx_v_self, PyObject *__pyx_v___pyx_state) {
PyObject *__pyx_r = NULL;
__Pyx_TraceDeclarations
__Pyx_RefNannyDeclarations
PyObject *__pyx_t_1 = NULL;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("__setstate_cython__", 0);
__Pyx_TraceCall("__setstate_cython__", __pyx_f[1], 16, 0, __PYX_ERR(1, 16, __pyx_L1_error));
/* "(tree fragment)":17
* return __pyx_unpickle_Shift, (type(self), 0xd41d8cd, state)
* def __setstate_cython__(self, __pyx_state):
* __pyx_unpickle_Shift__set_state(self, __pyx_state) # <<<<<<<<<<<<<<
*/
if (!(likely(PyTuple_CheckExact(__pyx_v___pyx_state))||((__pyx_v___pyx_state) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "tuple", Py_TYPE(__pyx_v___pyx_state)->tp_name), 0))) __PYX_ERR(1, 17, __pyx_L1_error)
__pyx_t_1 = __pyx_f_5spacy_6syntax_9arc_eager___pyx_unpickle_Shift__set_state(__pyx_v_self, ((PyObject*)__pyx_v___pyx_state)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 17, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
/* "(tree fragment)":16
* else:
* return __pyx_unpickle_Shift, (type(self), 0xd41d8cd, state)
* def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<<
* __pyx_unpickle_Shift__set_state(self, __pyx_state)
*/
/* function exit code */
__pyx_r = Py_None; __Pyx_INCREF(Py_None);
goto __pyx_L0;
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_1);
__Pyx_AddTraceback("spacy.syntax.arc_eager.Shift.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = NULL;
__pyx_L0:;
__Pyx_XGIVEREF(__pyx_r);
__Pyx_TraceReturn(__pyx_r, 0);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "spacy/syntax/arc_eager.pyx":148
* cdef class Reduce:
* @staticmethod
* cdef bint is_valid(const StateC* st, attr_t label) nogil: # <<<<<<<<<<<<<<
* return st.stack_depth() >= 2
*
*/
static int __pyx_f_5spacy_6syntax_9arc_eager_6Reduce_is_valid(__pyx_t_5spacy_6syntax_6_state_StateC const *__pyx_v_st, CYTHON_UNUSED __pyx_t_5spacy_8typedefs_attr_t __pyx_v_label) {
int __pyx_r;
__Pyx_TraceDeclarations
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_TraceCall("is_valid", __pyx_f[0], 148, 1, __PYX_ERR(0, 148, __pyx_L1_error));
/* "spacy/syntax/arc_eager.pyx":149
* @staticmethod
* cdef bint is_valid(const StateC* st, attr_t label) nogil:
* return st.stack_depth() >= 2 # <<<<<<<<<<<<<<
*
* @staticmethod
*/
__pyx_r = (__pyx_v_st->stack_depth() >= 2);
goto __pyx_L0;
/* "spacy/syntax/arc_eager.pyx":148
* cdef class Reduce:
* @staticmethod
* cdef bint is_valid(const StateC* st, attr_t label) nogil: # <<<<<<<<<<<<<<
* return st.stack_depth() >= 2
*
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_WriteUnraisable("spacy.syntax.arc_eager.Reduce.is_valid", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 1);
__pyx_r = 0;
__pyx_L0:;
__Pyx_TraceReturn(Py_None, 1);
return __pyx_r;
}
/* "spacy/syntax/arc_eager.pyx":152
*
* @staticmethod
* cdef int transition(StateC* st, attr_t label) nogil: # <<<<<<<<<<<<<<
* if st.has_head(st.S(0)):
* st.pop()
*/
static int __pyx_f_5spacy_6syntax_9arc_eager_6Reduce_transition(__pyx_t_5spacy_6syntax_6_state_StateC *__pyx_v_st, CYTHON_UNUSED __pyx_t_5spacy_8typedefs_attr_t __pyx_v_label) {
int __pyx_r;
__Pyx_TraceDeclarations
int __pyx_t_1;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_TraceCall("transition", __pyx_f[0], 152, 1, __PYX_ERR(0, 152, __pyx_L1_error));
/* "spacy/syntax/arc_eager.pyx":153
* @staticmethod
* cdef int transition(StateC* st, attr_t label) nogil:
* if st.has_head(st.S(0)): # <<<<<<<<<<<<<<
* st.pop()
* else:
*/
__pyx_t_1 = (__pyx_v_st->has_head(__pyx_v_st->S(0)) != 0);
if (__pyx_t_1) {
/* "spacy/syntax/arc_eager.pyx":154
* cdef int transition(StateC* st, attr_t label) nogil:
* if st.has_head(st.S(0)):
* st.pop() # <<<<<<<<<<<<<<
* else:
* st.unshift()
*/
__pyx_v_st->pop();
/* "spacy/syntax/arc_eager.pyx":153
* @staticmethod
* cdef int transition(StateC* st, attr_t label) nogil:
* if st.has_head(st.S(0)): # <<<<<<<<<<<<<<
* st.pop()
* else:
*/
goto __pyx_L3;
}
/* "spacy/syntax/arc_eager.pyx":156
* st.pop()
* else:
* st.unshift() # <<<<<<<<<<<<<<
* st.fast_forward()
*
*/
/*else*/ {
__pyx_v_st->unshift();
}
__pyx_L3:;
/* "spacy/syntax/arc_eager.pyx":157
* else:
* st.unshift()
* st.fast_forward() # <<<<<<<<<<<<<<
*
* @staticmethod
*/
__pyx_v_st->fast_forward();
/* "spacy/syntax/arc_eager.pyx":152
*
* @staticmethod
* cdef int transition(StateC* st, attr_t label) nogil: # <<<<<<<<<<<<<<
* if st.has_head(st.S(0)):
* st.pop()
*/
/* function exit code */
__pyx_r = 0;
goto __pyx_L0;
__pyx_L1_error:;
__Pyx_WriteUnraisable("spacy.syntax.arc_eager.Reduce.transition", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 1);
__pyx_r = 0;
__pyx_L0:;
__Pyx_TraceReturn(Py_None, 1);
return __pyx_r;
}
/* "spacy/syntax/arc_eager.pyx":160
*
* @staticmethod
* cdef weight_t cost(StateClass s, const GoldParseC* gold, attr_t label) nogil: # <<<<<<<<<<<<<<
* return Reduce.move_cost(s, gold) + Reduce.label_cost(s, gold, label)
*
*/
static __pyx_t_5thinc_8typedefs_weight_t __pyx_f_5spacy_6syntax_9arc_eager_6Reduce_cost(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *__pyx_v_s, struct __pyx_t_5spacy_4gold_GoldParseC const *__pyx_v_gold, __pyx_t_5spacy_8typedefs_attr_t __pyx_v_label) {
__pyx_t_5thinc_8typedefs_weight_t __pyx_r;
__Pyx_TraceDeclarations
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_TraceCall("cost", __pyx_f[0], 160, 1, __PYX_ERR(0, 160, __pyx_L1_error));
/* "spacy/syntax/arc_eager.pyx":161
* @staticmethod
* cdef weight_t cost(StateClass s, const GoldParseC* gold, attr_t label) nogil:
* return Reduce.move_cost(s, gold) + Reduce.label_cost(s, gold, label) # <<<<<<<<<<<<<<
*
* @staticmethod
*/
__pyx_r = (__pyx_f_5spacy_6syntax_9arc_eager_6Reduce_move_cost(__pyx_v_s, __pyx_v_gold) + __pyx_f_5spacy_6syntax_9arc_eager_6Reduce_label_cost(__pyx_v_s, __pyx_v_gold, __pyx_v_label));
goto __pyx_L0;
/* "spacy/syntax/arc_eager.pyx":160
*
* @staticmethod
* cdef weight_t cost(StateClass s, const GoldParseC* gold, attr_t label) nogil: # <<<<<<<<<<<<<<
* return Reduce.move_cost(s, gold) + Reduce.label_cost(s, gold, label)
*
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_WriteUnraisable("spacy.syntax.arc_eager.Reduce.cost", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 1);
__pyx_r = 0;
__pyx_L0:;
__Pyx_TraceReturn(Py_None, 1);
return __pyx_r;
}
/* "spacy/syntax/arc_eager.pyx":164
*
* @staticmethod
* cdef inline weight_t move_cost(StateClass st, const GoldParseC* gold) nogil: # <<<<<<<<<<<<<<
* cost = pop_cost(st, gold, st.S(0))
* if not st.has_head(st.S(0)):
*/
static CYTHON_INLINE __pyx_t_5thinc_8typedefs_weight_t __pyx_f_5spacy_6syntax_9arc_eager_6Reduce_move_cost(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *__pyx_v_st, struct __pyx_t_5spacy_4gold_GoldParseC const *__pyx_v_gold) {
__pyx_t_5thinc_8typedefs_weight_t __pyx_v_cost;
long __pyx_v_i;
int __pyx_v_S_i;
__pyx_t_5thinc_8typedefs_weight_t __pyx_r;
__Pyx_TraceDeclarations
int __pyx_t_1;
int __pyx_t_2;
int __pyx_t_3;
long __pyx_t_4;
int __pyx_t_5;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_TraceCall("move_cost", __pyx_f[0], 164, 1, __PYX_ERR(0, 164, __pyx_L1_error));
/* "spacy/syntax/arc_eager.pyx":165
* @staticmethod
* cdef inline weight_t move_cost(StateClass st, const GoldParseC* gold) nogil:
* cost = pop_cost(st, gold, st.S(0)) # <<<<<<<<<<<<<<
* if not st.has_head(st.S(0)):
* # Decrement cost for the arcs e save
*/
__pyx_v_cost = __pyx_f_5spacy_6syntax_9arc_eager_pop_cost(__pyx_v_st, __pyx_v_gold, __pyx_f_5spacy_6syntax_10stateclass_10StateClass_S(__pyx_v_st, 0));
/* "spacy/syntax/arc_eager.pyx":166
* cdef inline weight_t move_cost(StateClass st, const GoldParseC* gold) nogil:
* cost = pop_cost(st, gold, st.S(0))
* if not st.has_head(st.S(0)): # <<<<<<<<<<<<<<
* # Decrement cost for the arcs e save
* for i in range(1, st.stack_depth()):
*/
__pyx_t_1 = ((!(__pyx_f_5spacy_6syntax_10stateclass_10StateClass_has_head(__pyx_v_st, __pyx_f_5spacy_6syntax_10stateclass_10StateClass_S(__pyx_v_st, 0)) != 0)) != 0);
if (__pyx_t_1) {
/* "spacy/syntax/arc_eager.pyx":168
* if not st.has_head(st.S(0)):
* # Decrement cost for the arcs e save
* for i in range(1, st.stack_depth()): # <<<<<<<<<<<<<<
* S_i = st.S(i)
* if gold.heads[st.S(0)] == S_i:
*/
__pyx_t_2 = __pyx_f_5spacy_6syntax_10stateclass_10StateClass_stack_depth(__pyx_v_st);
__pyx_t_3 = __pyx_t_2;
for (__pyx_t_4 = 1; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) {
__pyx_v_i = __pyx_t_4;
/* "spacy/syntax/arc_eager.pyx":169
* # Decrement cost for the arcs e save
* for i in range(1, st.stack_depth()):
* S_i = st.S(i) # <<<<<<<<<<<<<<
* if gold.heads[st.S(0)] == S_i:
* cost -= 1
*/
__pyx_v_S_i = __pyx_f_5spacy_6syntax_10stateclass_10StateClass_S(__pyx_v_st, __pyx_v_i);
/* "spacy/syntax/arc_eager.pyx":170
* for i in range(1, st.stack_depth()):
* S_i = st.S(i)
* if gold.heads[st.S(0)] == S_i: # <<<<<<<<<<<<<<
* cost -= 1
* if gold.heads[S_i] == st.S(0):
*/
__pyx_t_1 = (((__pyx_v_gold->heads[__pyx_f_5spacy_6syntax_10stateclass_10StateClass_S(__pyx_v_st, 0)]) == __pyx_v_S_i) != 0);
if (__pyx_t_1) {
/* "spacy/syntax/arc_eager.pyx":171
* S_i = st.S(i)
* if gold.heads[st.S(0)] == S_i:
* cost -= 1 # <<<<<<<<<<<<<<
* if gold.heads[S_i] == st.S(0):
* cost -= 1
*/
__pyx_v_cost = (__pyx_v_cost - 1.0);
/* "spacy/syntax/arc_eager.pyx":170
* for i in range(1, st.stack_depth()):
* S_i = st.S(i)
* if gold.heads[st.S(0)] == S_i: # <<<<<<<<<<<<<<
* cost -= 1
* if gold.heads[S_i] == st.S(0):
*/
}
/* "spacy/syntax/arc_eager.pyx":172
* if gold.heads[st.S(0)] == S_i:
* cost -= 1
* if gold.heads[S_i] == st.S(0): # <<<<<<<<<<<<<<
* cost -= 1
* if Break.is_valid(st.c, 0) and Break.move_cost(st, gold) == 0:
*/
__pyx_t_1 = (((__pyx_v_gold->heads[__pyx_v_S_i]) == __pyx_f_5spacy_6syntax_10stateclass_10StateClass_S(__pyx_v_st, 0)) != 0);
if (__pyx_t_1) {
/* "spacy/syntax/arc_eager.pyx":173
* cost -= 1
* if gold.heads[S_i] == st.S(0):
* cost -= 1 # <<<<<<<<<<<<<<
* if Break.is_valid(st.c, 0) and Break.move_cost(st, gold) == 0:
* cost -= 1
*/
__pyx_v_cost = (__pyx_v_cost - 1.0);
/* "spacy/syntax/arc_eager.pyx":172
* if gold.heads[st.S(0)] == S_i:
* cost -= 1
* if gold.heads[S_i] == st.S(0): # <<<<<<<<<<<<<<
* cost -= 1
* if Break.is_valid(st.c, 0) and Break.move_cost(st, gold) == 0:
*/
}
}
/* "spacy/syntax/arc_eager.pyx":174
* if gold.heads[S_i] == st.S(0):
* cost -= 1
* if Break.is_valid(st.c, 0) and Break.move_cost(st, gold) == 0: # <<<<<<<<<<<<<<
* cost -= 1
* return cost
*/
__pyx_t_5 = (__pyx_f_5spacy_6syntax_9arc_eager_5Break_is_valid(__pyx_v_st->c, 0) != 0);
if (__pyx_t_5) {
} else {
__pyx_t_1 = __pyx_t_5;
goto __pyx_L9_bool_binop_done;
}
__pyx_t_5 = ((__pyx_f_5spacy_6syntax_9arc_eager_5Break_move_cost(__pyx_v_st, __pyx_v_gold) == 0.0) != 0);
__pyx_t_1 = __pyx_t_5;
__pyx_L9_bool_binop_done:;
if (__pyx_t_1) {
/* "spacy/syntax/arc_eager.pyx":175
* cost -= 1
* if Break.is_valid(st.c, 0) and Break.move_cost(st, gold) == 0:
* cost -= 1 # <<<<<<<<<<<<<<
* return cost
*
*/
__pyx_v_cost = (__pyx_v_cost - 1.0);
/* "spacy/syntax/arc_eager.pyx":174
* if gold.heads[S_i] == st.S(0):
* cost -= 1
* if Break.is_valid(st.c, 0) and Break.move_cost(st, gold) == 0: # <<<<<<<<<<<<<<
* cost -= 1
* return cost
*/
}
/* "spacy/syntax/arc_eager.pyx":166
* cdef inline weight_t move_cost(StateClass st, const GoldParseC* gold) nogil:
* cost = pop_cost(st, gold, st.S(0))
* if not st.has_head(st.S(0)): # <<<<<<<<<<<<<<
* # Decrement cost for the arcs e save
* for i in range(1, st.stack_depth()):
*/
}
/* "spacy/syntax/arc_eager.pyx":176
* if Break.is_valid(st.c, 0) and Break.move_cost(st, gold) == 0:
* cost -= 1
* return cost # <<<<<<<<<<<<<<
*
* @staticmethod
*/
__pyx_r = __pyx_v_cost;
goto __pyx_L0;
/* "spacy/syntax/arc_eager.pyx":164
*
* @staticmethod
* cdef inline weight_t move_cost(StateClass st, const GoldParseC* gold) nogil: # <<<<<<<<<<<<<<
* cost = pop_cost(st, gold, st.S(0))
* if not st.has_head(st.S(0)):
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_WriteUnraisable("spacy.syntax.arc_eager.Reduce.move_cost", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 1);
__pyx_r = 0;
__pyx_L0:;
__Pyx_TraceReturn(Py_None, 1);
return __pyx_r;
}
/* "spacy/syntax/arc_eager.pyx":179
*
* @staticmethod
* cdef inline weight_t label_cost(StateClass s, const GoldParseC* gold, attr_t label) nogil: # <<<<<<<<<<<<<<
* return 0
*
*/
static CYTHON_INLINE __pyx_t_5thinc_8typedefs_weight_t __pyx_f_5spacy_6syntax_9arc_eager_6Reduce_label_cost(CYTHON_UNUSED struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *__pyx_v_s, CYTHON_UNUSED struct __pyx_t_5spacy_4gold_GoldParseC const *__pyx_v_gold, CYTHON_UNUSED __pyx_t_5spacy_8typedefs_attr_t __pyx_v_label) {
__pyx_t_5thinc_8typedefs_weight_t __pyx_r;
__Pyx_TraceDeclarations
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_TraceCall("label_cost", __pyx_f[0], 179, 1, __PYX_ERR(0, 179, __pyx_L1_error));
/* "spacy/syntax/arc_eager.pyx":180
* @staticmethod
* cdef inline weight_t label_cost(StateClass s, const GoldParseC* gold, attr_t label) nogil:
* return 0 # <<<<<<<<<<<<<<
*
*
*/
__pyx_r = 0.0;
goto __pyx_L0;
/* "spacy/syntax/arc_eager.pyx":179
*
* @staticmethod
* cdef inline weight_t label_cost(StateClass s, const GoldParseC* gold, attr_t label) nogil: # <<<<<<<<<<<<<<
* return 0
*
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_WriteUnraisable("spacy.syntax.arc_eager.Reduce.label_cost", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 1);
__pyx_r = 0;
__pyx_L0:;
__Pyx_TraceReturn(Py_None, 1);
return __pyx_r;
}
/* "(tree fragment)":1
* def __reduce_cython__(self): # <<<<<<<<<<<<<<
* cdef tuple state
* cdef object _dict
*/
/* Python wrapper */
static PyObject *__pyx_pw_5spacy_6syntax_9arc_eager_6Reduce_1__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
static PyObject *__pyx_pw_5spacy_6syntax_9arc_eager_6Reduce_1__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
PyObject *__pyx_r = 0;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0);
__pyx_r = __pyx_pf_5spacy_6syntax_9arc_eager_6Reduce___reduce_cython__(((struct __pyx_obj_5spacy_6syntax_9arc_eager_Reduce *)__pyx_v_self));
/* function exit code */
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
static PyObject *__pyx_pf_5spacy_6syntax_9arc_eager_6Reduce___reduce_cython__(struct __pyx_obj_5spacy_6syntax_9arc_eager_Reduce *__pyx_v_self) {
PyObject *__pyx_v_state = 0;
PyObject *__pyx_v__dict = 0;
int __pyx_v_use_setstate;
PyObject *__pyx_r = NULL;
__Pyx_TraceDeclarations
__Pyx_RefNannyDeclarations
PyObject *__pyx_t_1 = NULL;
int __pyx_t_2;
int __pyx_t_3;
PyObject *__pyx_t_4 = NULL;
PyObject *__pyx_t_5 = NULL;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("__reduce_cython__", 0);
__Pyx_TraceCall("__reduce_cython__", __pyx_f[1], 1, 0, __PYX_ERR(1, 1, __pyx_L1_error));
/* "(tree fragment)":5
* cdef object _dict
* cdef bint use_setstate
* state = () # <<<<<<<<<<<<<<
* _dict = getattr(self, '__dict__', None)
* if _dict is not None:
*/
__Pyx_INCREF(__pyx_empty_tuple);
__pyx_v_state = __pyx_empty_tuple;
/* "(tree fragment)":6
* cdef bint use_setstate
* state = ()
* _dict = getattr(self, '__dict__', None) # <<<<<<<<<<<<<<
* if _dict is not None:
* state += (_dict,)
*/
__pyx_t_1 = __Pyx_GetAttr3(((PyObject *)__pyx_v_self), __pyx_n_s_dict, Py_None); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 6, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_v__dict = __pyx_t_1;
__pyx_t_1 = 0;
/* "(tree fragment)":7
* state = ()
* _dict = getattr(self, '__dict__', None)
* if _dict is not None: # <<<<<<<<<<<<<<
* state += (_dict,)
* use_setstate = True
*/
__pyx_t_2 = (__pyx_v__dict != Py_None);
__pyx_t_3 = (__pyx_t_2 != 0);
if (__pyx_t_3) {
/* "(tree fragment)":8
* _dict = getattr(self, '__dict__', None)
* if _dict is not None:
* state += (_dict,) # <<<<<<<<<<<<<<
* use_setstate = True
* else:
*/
__pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 8, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_INCREF(__pyx_v__dict);
__Pyx_GIVEREF(__pyx_v__dict);
PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v__dict);
__pyx_t_4 = PyNumber_InPlaceAdd(__pyx_v_state, __pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 8, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__Pyx_DECREF_SET(__pyx_v_state, ((PyObject*)__pyx_t_4));
__pyx_t_4 = 0;
/* "(tree fragment)":9
* if _dict is not None:
* state += (_dict,)
* use_setstate = True # <<<<<<<<<<<<<<
* else:
* use_setstate = False
*/
__pyx_v_use_setstate = 1;
/* "(tree fragment)":7
* state = ()
* _dict = getattr(self, '__dict__', None)
* if _dict is not None: # <<<<<<<<<<<<<<
* state += (_dict,)
* use_setstate = True
*/
goto __pyx_L3;
}
/* "(tree fragment)":11
* use_setstate = True
* else:
* use_setstate = False # <<<<<<<<<<<<<<
* if use_setstate:
* return __pyx_unpickle_Reduce, (type(self), 0xd41d8cd, None), state
*/
/*else*/ {
__pyx_v_use_setstate = 0;
}
__pyx_L3:;
/* "(tree fragment)":12
* else:
* use_setstate = False
* if use_setstate: # <<<<<<<<<<<<<<
* return __pyx_unpickle_Reduce, (type(self), 0xd41d8cd, None), state
* else:
*/
__pyx_t_3 = (__pyx_v_use_setstate != 0);
if (__pyx_t_3) {
/* "(tree fragment)":13
* use_setstate = False
* if use_setstate:
* return __pyx_unpickle_Reduce, (type(self), 0xd41d8cd, None), state # <<<<<<<<<<<<<<
* else:
* return __pyx_unpickle_Reduce, (type(self), 0xd41d8cd, state)
*/
__Pyx_XDECREF(__pyx_r);
__Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_pyx_unpickle_Reduce); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 13, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 13, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))));
__Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))));
PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))));
__Pyx_INCREF(__pyx_int_222419149);
__Pyx_GIVEREF(__pyx_int_222419149);
PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_int_222419149);
__Pyx_INCREF(Py_None);
__Pyx_GIVEREF(Py_None);
PyTuple_SET_ITEM(__pyx_t_1, 2, Py_None);
__pyx_t_5 = PyTuple_New(3); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 13, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_GIVEREF(__pyx_t_4);
PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_4);
__Pyx_GIVEREF(__pyx_t_1);
PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_1);
__Pyx_INCREF(__pyx_v_state);
__Pyx_GIVEREF(__pyx_v_state);
PyTuple_SET_ITEM(__pyx_t_5, 2, __pyx_v_state);
__pyx_t_4 = 0;
__pyx_t_1 = 0;
__pyx_r = __pyx_t_5;
__pyx_t_5 = 0;
goto __pyx_L0;
/* "(tree fragment)":12
* else:
* use_setstate = False
* if use_setstate: # <<<<<<<<<<<<<<
* return __pyx_unpickle_Reduce, (type(self), 0xd41d8cd, None), state
* else:
*/
}
/* "(tree fragment)":15
* return __pyx_unpickle_Reduce, (type(self), 0xd41d8cd, None), state
* else:
* return __pyx_unpickle_Reduce, (type(self), 0xd41d8cd, state) # <<<<<<<<<<<<<<
* def __setstate_cython__(self, __pyx_state):
* __pyx_unpickle_Reduce__set_state(self, __pyx_state)
*/
/*else*/ {
__Pyx_XDECREF(__pyx_r);
__Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_pyx_unpickle_Reduce); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 15, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 15, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))));
__Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))));
PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))));
__Pyx_INCREF(__pyx_int_222419149);
__Pyx_GIVEREF(__pyx_int_222419149);
PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_int_222419149);
__Pyx_INCREF(__pyx_v_state);
__Pyx_GIVEREF(__pyx_v_state);
PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_v_state);
__pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 15, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_GIVEREF(__pyx_t_5);
PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_5);
__Pyx_GIVEREF(__pyx_t_1);
PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_1);
__pyx_t_5 = 0;
__pyx_t_1 = 0;
__pyx_r = __pyx_t_4;
__pyx_t_4 = 0;
goto __pyx_L0;
}
/* "(tree fragment)":1
* def __reduce_cython__(self): # <<<<<<<<<<<<<<
* cdef tuple state
* cdef object _dict
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_1);
__Pyx_XDECREF(__pyx_t_4);
__Pyx_XDECREF(__pyx_t_5);
__Pyx_AddTraceback("spacy.syntax.arc_eager.Reduce.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = NULL;
__pyx_L0:;
__Pyx_XDECREF(__pyx_v_state);
__Pyx_XDECREF(__pyx_v__dict);
__Pyx_XGIVEREF(__pyx_r);
__Pyx_TraceReturn(__pyx_r, 0);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "(tree fragment)":16
* else:
* return __pyx_unpickle_Reduce, (type(self), 0xd41d8cd, state)
* def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<<
* __pyx_unpickle_Reduce__set_state(self, __pyx_state)
*/
/* Python wrapper */
static PyObject *__pyx_pw_5spacy_6syntax_9arc_eager_6Reduce_3__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state); /*proto*/
static PyObject *__pyx_pw_5spacy_6syntax_9arc_eager_6Reduce_3__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state) {
PyObject *__pyx_r = 0;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0);
__pyx_r = __pyx_pf_5spacy_6syntax_9arc_eager_6Reduce_2__setstate_cython__(((struct __pyx_obj_5spacy_6syntax_9arc_eager_Reduce *)__pyx_v_self), ((PyObject *)__pyx_v___pyx_state));
/* function exit code */
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
static PyObject *__pyx_pf_5spacy_6syntax_9arc_eager_6Reduce_2__setstate_cython__(struct __pyx_obj_5spacy_6syntax_9arc_eager_Reduce *__pyx_v_self, PyObject *__pyx_v___pyx_state) {
PyObject *__pyx_r = NULL;
__Pyx_TraceDeclarations
__Pyx_RefNannyDeclarations
PyObject *__pyx_t_1 = NULL;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("__setstate_cython__", 0);
__Pyx_TraceCall("__setstate_cython__", __pyx_f[1], 16, 0, __PYX_ERR(1, 16, __pyx_L1_error));
/* "(tree fragment)":17
* return __pyx_unpickle_Reduce, (type(self), 0xd41d8cd, state)
* def __setstate_cython__(self, __pyx_state):
* __pyx_unpickle_Reduce__set_state(self, __pyx_state) # <<<<<<<<<<<<<<
*/
if (!(likely(PyTuple_CheckExact(__pyx_v___pyx_state))||((__pyx_v___pyx_state) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "tuple", Py_TYPE(__pyx_v___pyx_state)->tp_name), 0))) __PYX_ERR(1, 17, __pyx_L1_error)
__pyx_t_1 = __pyx_f_5spacy_6syntax_9arc_eager___pyx_unpickle_Reduce__set_state(__pyx_v_self, ((PyObject*)__pyx_v___pyx_state)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 17, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
/* "(tree fragment)":16
* else:
* return __pyx_unpickle_Reduce, (type(self), 0xd41d8cd, state)
* def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<<
* __pyx_unpickle_Reduce__set_state(self, __pyx_state)
*/
/* function exit code */
__pyx_r = Py_None; __Pyx_INCREF(Py_None);
goto __pyx_L0;
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_1);
__Pyx_AddTraceback("spacy.syntax.arc_eager.Reduce.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = NULL;
__pyx_L0:;
__Pyx_XGIVEREF(__pyx_r);
__Pyx_TraceReturn(__pyx_r, 0);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "spacy/syntax/arc_eager.pyx":185
* cdef class LeftArc:
* @staticmethod
* cdef bint is_valid(const StateC* st, attr_t label) nogil: # <<<<<<<<<<<<<<
* if label == SUBTOK_LABEL and st.S(0) != (st.B(0)-1):
* return 0
*/
static int __pyx_f_5spacy_6syntax_9arc_eager_7LeftArc_is_valid(__pyx_t_5spacy_6syntax_6_state_StateC const *__pyx_v_st, __pyx_t_5spacy_8typedefs_attr_t __pyx_v_label) {
int __pyx_v_sent_start;
int __pyx_r;
__Pyx_TraceDeclarations
int __pyx_t_1;
int __pyx_t_2;
int __pyx_t_3;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_TraceCall("is_valid", __pyx_f[0], 185, 1, __PYX_ERR(0, 185, __pyx_L1_error));
/* "spacy/syntax/arc_eager.pyx":186
* @staticmethod
* cdef bint is_valid(const StateC* st, attr_t label) nogil:
* if label == SUBTOK_LABEL and st.S(0) != (st.B(0)-1): # <<<<<<<<<<<<<<
* return 0
* sent_start = st._sent[st.B_(0).l_edge].sent_start
*/
__pyx_t_2 = ((__pyx_v_label == __pyx_v_5spacy_6syntax_9arc_eager_SUBTOK_LABEL) != 0);
if (__pyx_t_2) {
} else {
__pyx_t_1 = __pyx_t_2;
goto __pyx_L4_bool_binop_done;
}
__pyx_t_2 = ((__pyx_v_st->S(0) != (__pyx_v_st->B(0) - 1)) != 0);
__pyx_t_1 = __pyx_t_2;
__pyx_L4_bool_binop_done:;
if (__pyx_t_1) {
/* "spacy/syntax/arc_eager.pyx":187
* cdef bint is_valid(const StateC* st, attr_t label) nogil:
* if label == SUBTOK_LABEL and st.S(0) != (st.B(0)-1):
* return 0 # <<<<<<<<<<<<<<
* sent_start = st._sent[st.B_(0).l_edge].sent_start
* return sent_start != 1
*/
__pyx_r = 0;
goto __pyx_L0;
/* "spacy/syntax/arc_eager.pyx":186
* @staticmethod
* cdef bint is_valid(const StateC* st, attr_t label) nogil:
* if label == SUBTOK_LABEL and st.S(0) != (st.B(0)-1): # <<<<<<<<<<<<<<
* return 0
* sent_start = st._sent[st.B_(0).l_edge].sent_start
*/
}
/* "spacy/syntax/arc_eager.pyx":188
* if label == SUBTOK_LABEL and st.S(0) != (st.B(0)-1):
* return 0
* sent_start = st._sent[st.B_(0).l_edge].sent_start # <<<<<<<<<<<<<<
* return sent_start != 1
*
*/
__pyx_t_3 = (__pyx_v_st->_sent[__pyx_v_st->B_(0)->l_edge]).sent_start;
__pyx_v_sent_start = __pyx_t_3;
/* "spacy/syntax/arc_eager.pyx":189
* return 0
* sent_start = st._sent[st.B_(0).l_edge].sent_start
* return sent_start != 1 # <<<<<<<<<<<<<<
*
* @staticmethod
*/
__pyx_r = (__pyx_v_sent_start != 1);
goto __pyx_L0;
/* "spacy/syntax/arc_eager.pyx":185
* cdef class LeftArc:
* @staticmethod
* cdef bint is_valid(const StateC* st, attr_t label) nogil: # <<<<<<<<<<<<<<
* if label == SUBTOK_LABEL and st.S(0) != (st.B(0)-1):
* return 0
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_WriteUnraisable("spacy.syntax.arc_eager.LeftArc.is_valid", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 1);
__pyx_r = 0;
__pyx_L0:;
__Pyx_TraceReturn(Py_None, 1);
return __pyx_r;
}
/* "spacy/syntax/arc_eager.pyx":192
*
* @staticmethod
* cdef int transition(StateC* st, attr_t label) nogil: # <<<<<<<<<<<<<<
* st.add_arc(st.B(0), st.S(0), label)
* st.pop()
*/
static int __pyx_f_5spacy_6syntax_9arc_eager_7LeftArc_transition(__pyx_t_5spacy_6syntax_6_state_StateC *__pyx_v_st, __pyx_t_5spacy_8typedefs_attr_t __pyx_v_label) {
int __pyx_r;
__Pyx_TraceDeclarations
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_TraceCall("transition", __pyx_f[0], 192, 1, __PYX_ERR(0, 192, __pyx_L1_error));
/* "spacy/syntax/arc_eager.pyx":193
* @staticmethod
* cdef int transition(StateC* st, attr_t label) nogil:
* st.add_arc(st.B(0), st.S(0), label) # <<<<<<<<<<<<<<
* st.pop()
* st.fast_forward()
*/
__pyx_v_st->add_arc(__pyx_v_st->B(0), __pyx_v_st->S(0), __pyx_v_label);
/* "spacy/syntax/arc_eager.pyx":194
* cdef int transition(StateC* st, attr_t label) nogil:
* st.add_arc(st.B(0), st.S(0), label)
* st.pop() # <<<<<<<<<<<<<<
* st.fast_forward()
*
*/
__pyx_v_st->pop();
/* "spacy/syntax/arc_eager.pyx":195
* st.add_arc(st.B(0), st.S(0), label)
* st.pop()
* st.fast_forward() # <<<<<<<<<<<<<<
*
* @staticmethod
*/
__pyx_v_st->fast_forward();
/* "spacy/syntax/arc_eager.pyx":192
*
* @staticmethod
* cdef int transition(StateC* st, attr_t label) nogil: # <<<<<<<<<<<<<<
* st.add_arc(st.B(0), st.S(0), label)
* st.pop()
*/
/* function exit code */
__pyx_r = 0;
goto __pyx_L0;
__pyx_L1_error:;
__Pyx_WriteUnraisable("spacy.syntax.arc_eager.LeftArc.transition", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 1);
__pyx_r = 0;
__pyx_L0:;
__Pyx_TraceReturn(Py_None, 1);
return __pyx_r;
}
/* "spacy/syntax/arc_eager.pyx":198
*
* @staticmethod
* cdef weight_t cost(StateClass s, const GoldParseC* gold, attr_t label) nogil: # <<<<<<<<<<<<<<
* return LeftArc.move_cost(s, gold) + LeftArc.label_cost(s, gold, label)
*
*/
static __pyx_t_5thinc_8typedefs_weight_t __pyx_f_5spacy_6syntax_9arc_eager_7LeftArc_cost(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *__pyx_v_s, struct __pyx_t_5spacy_4gold_GoldParseC const *__pyx_v_gold, __pyx_t_5spacy_8typedefs_attr_t __pyx_v_label) {
__pyx_t_5thinc_8typedefs_weight_t __pyx_r;
__Pyx_TraceDeclarations
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_TraceCall("cost", __pyx_f[0], 198, 1, __PYX_ERR(0, 198, __pyx_L1_error));
/* "spacy/syntax/arc_eager.pyx":199
* @staticmethod
* cdef weight_t cost(StateClass s, const GoldParseC* gold, attr_t label) nogil:
* return LeftArc.move_cost(s, gold) + LeftArc.label_cost(s, gold, label) # <<<<<<<<<<<<<<
*
* @staticmethod
*/
__pyx_r = (__pyx_f_5spacy_6syntax_9arc_eager_7LeftArc_move_cost(__pyx_v_s, __pyx_v_gold) + __pyx_f_5spacy_6syntax_9arc_eager_7LeftArc_label_cost(__pyx_v_s, __pyx_v_gold, __pyx_v_label));
goto __pyx_L0;
/* "spacy/syntax/arc_eager.pyx":198
*
* @staticmethod
* cdef weight_t cost(StateClass s, const GoldParseC* gold, attr_t label) nogil: # <<<<<<<<<<<<<<
* return LeftArc.move_cost(s, gold) + LeftArc.label_cost(s, gold, label)
*
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_WriteUnraisable("spacy.syntax.arc_eager.LeftArc.cost", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 1);
__pyx_r = 0;
__pyx_L0:;
__Pyx_TraceReturn(Py_None, 1);
return __pyx_r;
}
/* "spacy/syntax/arc_eager.pyx":202
*
* @staticmethod
* cdef inline weight_t move_cost(StateClass s, const GoldParseC* gold) nogil: # <<<<<<<<<<<<<<
* cdef weight_t cost = 0
* if arc_is_gold(gold, s.B(0), s.S(0)):
*/
static CYTHON_INLINE __pyx_t_5thinc_8typedefs_weight_t __pyx_f_5spacy_6syntax_9arc_eager_7LeftArc_move_cost(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *__pyx_v_s, struct __pyx_t_5spacy_4gold_GoldParseC const *__pyx_v_gold) {
__pyx_t_5thinc_8typedefs_weight_t __pyx_v_cost;
long __pyx_v_i;
__pyx_t_5thinc_8typedefs_weight_t __pyx_r;
__Pyx_TraceDeclarations
int __pyx_t_1;
__pyx_t_5thinc_8typedefs_weight_t __pyx_t_2;
int __pyx_t_3;
int __pyx_t_4;
long __pyx_t_5;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_TraceCall("move_cost", __pyx_f[0], 202, 1, __PYX_ERR(0, 202, __pyx_L1_error));
/* "spacy/syntax/arc_eager.pyx":203
* @staticmethod
* cdef inline weight_t move_cost(StateClass s, const GoldParseC* gold) nogil:
* cdef weight_t cost = 0 # <<<<<<<<<<<<<<
* if arc_is_gold(gold, s.B(0), s.S(0)):
* # Have a negative cost if we 'recover' from the wrong dependency
*/
__pyx_v_cost = 0.0;
/* "spacy/syntax/arc_eager.pyx":204
* cdef inline weight_t move_cost(StateClass s, const GoldParseC* gold) nogil:
* cdef weight_t cost = 0
* if arc_is_gold(gold, s.B(0), s.S(0)): # <<<<<<<<<<<<<<
* # Have a negative cost if we 'recover' from the wrong dependency
* return 0 if not s.has_head(s.S(0)) else -1
*/
__pyx_t_1 = (__pyx_f_5spacy_6syntax_9arc_eager_arc_is_gold(__pyx_v_gold, __pyx_f_5spacy_6syntax_10stateclass_10StateClass_B(__pyx_v_s, 0), __pyx_f_5spacy_6syntax_10stateclass_10StateClass_S(__pyx_v_s, 0)) != 0);
if (__pyx_t_1) {
/* "spacy/syntax/arc_eager.pyx":206
* if arc_is_gold(gold, s.B(0), s.S(0)):
* # Have a negative cost if we 'recover' from the wrong dependency
* return 0 if not s.has_head(s.S(0)) else -1 # <<<<<<<<<<<<<<
* else:
* # Account for deps we might lose between S0 and stack
*/
if (((!(__pyx_f_5spacy_6syntax_10stateclass_10StateClass_has_head(__pyx_v_s, __pyx_f_5spacy_6syntax_10stateclass_10StateClass_S(__pyx_v_s, 0)) != 0)) != 0)) {
__pyx_t_2 = 0.0;
} else {
__pyx_t_2 = -1.0;
}
__pyx_r = __pyx_t_2;
goto __pyx_L0;
/* "spacy/syntax/arc_eager.pyx":204
* cdef inline weight_t move_cost(StateClass s, const GoldParseC* gold) nogil:
* cdef weight_t cost = 0
* if arc_is_gold(gold, s.B(0), s.S(0)): # <<<<<<<<<<<<<<
* # Have a negative cost if we 'recover' from the wrong dependency
* return 0 if not s.has_head(s.S(0)) else -1
*/
}
/* "spacy/syntax/arc_eager.pyx":209
* else:
* # Account for deps we might lose between S0 and stack
* if not s.has_head(s.S(0)): # <<<<<<<<<<<<<<
* for i in range(1, s.stack_depth()):
* cost += gold.heads[s.S(i)] == s.S(0)
*/
/*else*/ {
__pyx_t_1 = ((!(__pyx_f_5spacy_6syntax_10stateclass_10StateClass_has_head(__pyx_v_s, __pyx_f_5spacy_6syntax_10stateclass_10StateClass_S(__pyx_v_s, 0)) != 0)) != 0);
if (__pyx_t_1) {
/* "spacy/syntax/arc_eager.pyx":210
* # Account for deps we might lose between S0 and stack
* if not s.has_head(s.S(0)):
* for i in range(1, s.stack_depth()): # <<<<<<<<<<<<<<
* cost += gold.heads[s.S(i)] == s.S(0)
* cost += gold.heads[s.S(0)] == s.S(i)
*/
__pyx_t_3 = __pyx_f_5spacy_6syntax_10stateclass_10StateClass_stack_depth(__pyx_v_s);
__pyx_t_4 = __pyx_t_3;
for (__pyx_t_5 = 1; __pyx_t_5 < __pyx_t_4; __pyx_t_5+=1) {
__pyx_v_i = __pyx_t_5;
/* "spacy/syntax/arc_eager.pyx":211
* if not s.has_head(s.S(0)):
* for i in range(1, s.stack_depth()):
* cost += gold.heads[s.S(i)] == s.S(0) # <<<<<<<<<<<<<<
* cost += gold.heads[s.S(0)] == s.S(i)
* return cost + pop_cost(s, gold, s.S(0)) + arc_cost(s, gold, s.B(0), s.S(0))
*/
__pyx_v_cost = (__pyx_v_cost + ((__pyx_v_gold->heads[__pyx_f_5spacy_6syntax_10stateclass_10StateClass_S(__pyx_v_s, __pyx_v_i)]) == __pyx_f_5spacy_6syntax_10stateclass_10StateClass_S(__pyx_v_s, 0)));
/* "spacy/syntax/arc_eager.pyx":212
* for i in range(1, s.stack_depth()):
* cost += gold.heads[s.S(i)] == s.S(0)
* cost += gold.heads[s.S(0)] == s.S(i) # <<<<<<<<<<<<<<
* return cost + pop_cost(s, gold, s.S(0)) + arc_cost(s, gold, s.B(0), s.S(0))
*
*/
__pyx_v_cost = (__pyx_v_cost + ((__pyx_v_gold->heads[__pyx_f_5spacy_6syntax_10stateclass_10StateClass_S(__pyx_v_s, 0)]) == __pyx_f_5spacy_6syntax_10stateclass_10StateClass_S(__pyx_v_s, __pyx_v_i)));
}
/* "spacy/syntax/arc_eager.pyx":209
* else:
* # Account for deps we might lose between S0 and stack
* if not s.has_head(s.S(0)): # <<<<<<<<<<<<<<
* for i in range(1, s.stack_depth()):
* cost += gold.heads[s.S(i)] == s.S(0)
*/
}
/* "spacy/syntax/arc_eager.pyx":213
* cost += gold.heads[s.S(i)] == s.S(0)
* cost += gold.heads[s.S(0)] == s.S(i)
* return cost + pop_cost(s, gold, s.S(0)) + arc_cost(s, gold, s.B(0), s.S(0)) # <<<<<<<<<<<<<<
*
* @staticmethod
*/
__pyx_r = ((__pyx_v_cost + __pyx_f_5spacy_6syntax_9arc_eager_pop_cost(__pyx_v_s, __pyx_v_gold, __pyx_f_5spacy_6syntax_10stateclass_10StateClass_S(__pyx_v_s, 0))) + __pyx_f_5spacy_6syntax_9arc_eager_arc_cost(__pyx_v_s, __pyx_v_gold, __pyx_f_5spacy_6syntax_10stateclass_10StateClass_B(__pyx_v_s, 0), __pyx_f_5spacy_6syntax_10stateclass_10StateClass_S(__pyx_v_s, 0)));
goto __pyx_L0;
}
/* "spacy/syntax/arc_eager.pyx":202
*
* @staticmethod
* cdef inline weight_t move_cost(StateClass s, const GoldParseC* gold) nogil: # <<<<<<<<<<<<<<
* cdef weight_t cost = 0
* if arc_is_gold(gold, s.B(0), s.S(0)):
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_WriteUnraisable("spacy.syntax.arc_eager.LeftArc.move_cost", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 1);
__pyx_r = 0;
__pyx_L0:;
__Pyx_TraceReturn(Py_None, 1);
return __pyx_r;
}
/* "spacy/syntax/arc_eager.pyx":216
*
* @staticmethod
* cdef inline weight_t label_cost(StateClass s, const GoldParseC* gold, attr_t label) nogil: # <<<<<<<<<<<<<<
* return arc_is_gold(gold, s.B(0), s.S(0)) and not label_is_gold(gold, s.B(0), s.S(0), label)
*
*/
static CYTHON_INLINE __pyx_t_5thinc_8typedefs_weight_t __pyx_f_5spacy_6syntax_9arc_eager_7LeftArc_label_cost(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *__pyx_v_s, struct __pyx_t_5spacy_4gold_GoldParseC const *__pyx_v_gold, __pyx_t_5spacy_8typedefs_attr_t __pyx_v_label) {
__pyx_t_5thinc_8typedefs_weight_t __pyx_r;
__Pyx_TraceDeclarations
__pyx_t_5thinc_8typedefs_weight_t __pyx_t_1;
int __pyx_t_2;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_TraceCall("label_cost", __pyx_f[0], 216, 1, __PYX_ERR(0, 216, __pyx_L1_error));
/* "spacy/syntax/arc_eager.pyx":217
* @staticmethod
* cdef inline weight_t label_cost(StateClass s, const GoldParseC* gold, attr_t label) nogil:
* return arc_is_gold(gold, s.B(0), s.S(0)) and not label_is_gold(gold, s.B(0), s.S(0), label) # <<<<<<<<<<<<<<
*
*
*/
__pyx_t_2 = __pyx_f_5spacy_6syntax_9arc_eager_arc_is_gold(__pyx_v_gold, __pyx_f_5spacy_6syntax_10stateclass_10StateClass_B(__pyx_v_s, 0), __pyx_f_5spacy_6syntax_10stateclass_10StateClass_S(__pyx_v_s, 0));
if (__pyx_t_2) {
} else {
__pyx_t_1 = __pyx_t_2;
goto __pyx_L3_bool_binop_done;
}
__pyx_t_2 = (!(__pyx_f_5spacy_6syntax_9arc_eager_label_is_gold(__pyx_v_gold, __pyx_f_5spacy_6syntax_10stateclass_10StateClass_B(__pyx_v_s, 0), __pyx_f_5spacy_6syntax_10stateclass_10StateClass_S(__pyx_v_s, 0), __pyx_v_label) != 0));
__pyx_t_1 = __pyx_t_2;
__pyx_L3_bool_binop_done:;
__pyx_r = __pyx_t_1;
goto __pyx_L0;
/* "spacy/syntax/arc_eager.pyx":216
*
* @staticmethod
* cdef inline weight_t label_cost(StateClass s, const GoldParseC* gold, attr_t label) nogil: # <<<<<<<<<<<<<<
* return arc_is_gold(gold, s.B(0), s.S(0)) and not label_is_gold(gold, s.B(0), s.S(0), label)
*
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_WriteUnraisable("spacy.syntax.arc_eager.LeftArc.label_cost", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 1);
__pyx_r = 0;
__pyx_L0:;
__Pyx_TraceReturn(Py_None, 1);
return __pyx_r;
}
/* "(tree fragment)":1
* def __reduce_cython__(self): # <<<<<<<<<<<<<<
* cdef tuple state
* cdef object _dict
*/
/* Python wrapper */
static PyObject *__pyx_pw_5spacy_6syntax_9arc_eager_7LeftArc_1__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
static PyObject *__pyx_pw_5spacy_6syntax_9arc_eager_7LeftArc_1__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
PyObject *__pyx_r = 0;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0);
__pyx_r = __pyx_pf_5spacy_6syntax_9arc_eager_7LeftArc___reduce_cython__(((struct __pyx_obj_5spacy_6syntax_9arc_eager_LeftArc *)__pyx_v_self));
/* function exit code */
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
static PyObject *__pyx_pf_5spacy_6syntax_9arc_eager_7LeftArc___reduce_cython__(struct __pyx_obj_5spacy_6syntax_9arc_eager_LeftArc *__pyx_v_self) {
PyObject *__pyx_v_state = 0;
PyObject *__pyx_v__dict = 0;
int __pyx_v_use_setstate;
PyObject *__pyx_r = NULL;
__Pyx_TraceDeclarations
__Pyx_RefNannyDeclarations
PyObject *__pyx_t_1 = NULL;
int __pyx_t_2;
int __pyx_t_3;
PyObject *__pyx_t_4 = NULL;
PyObject *__pyx_t_5 = NULL;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("__reduce_cython__", 0);
__Pyx_TraceCall("__reduce_cython__", __pyx_f[1], 1, 0, __PYX_ERR(1, 1, __pyx_L1_error));
/* "(tree fragment)":5
* cdef object _dict
* cdef bint use_setstate
* state = () # <<<<<<<<<<<<<<
* _dict = getattr(self, '__dict__', None)
* if _dict is not None:
*/
__Pyx_INCREF(__pyx_empty_tuple);
__pyx_v_state = __pyx_empty_tuple;
/* "(tree fragment)":6
* cdef bint use_setstate
* state = ()
* _dict = getattr(self, '__dict__', None) # <<<<<<<<<<<<<<
* if _dict is not None:
* state += (_dict,)
*/
__pyx_t_1 = __Pyx_GetAttr3(((PyObject *)__pyx_v_self), __pyx_n_s_dict, Py_None); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 6, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_v__dict = __pyx_t_1;
__pyx_t_1 = 0;
/* "(tree fragment)":7
* state = ()
* _dict = getattr(self, '__dict__', None)
* if _dict is not None: # <<<<<<<<<<<<<<
* state += (_dict,)
* use_setstate = True
*/
__pyx_t_2 = (__pyx_v__dict != Py_None);
__pyx_t_3 = (__pyx_t_2 != 0);
if (__pyx_t_3) {
/* "(tree fragment)":8
* _dict = getattr(self, '__dict__', None)
* if _dict is not None:
* state += (_dict,) # <<<<<<<<<<<<<<
* use_setstate = True
* else:
*/
__pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 8, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_INCREF(__pyx_v__dict);
__Pyx_GIVEREF(__pyx_v__dict);
PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v__dict);
__pyx_t_4 = PyNumber_InPlaceAdd(__pyx_v_state, __pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 8, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__Pyx_DECREF_SET(__pyx_v_state, ((PyObject*)__pyx_t_4));
__pyx_t_4 = 0;
/* "(tree fragment)":9
* if _dict is not None:
* state += (_dict,)
* use_setstate = True # <<<<<<<<<<<<<<
* else:
* use_setstate = False
*/
__pyx_v_use_setstate = 1;
/* "(tree fragment)":7
* state = ()
* _dict = getattr(self, '__dict__', None)
* if _dict is not None: # <<<<<<<<<<<<<<
* state += (_dict,)
* use_setstate = True
*/
goto __pyx_L3;
}
/* "(tree fragment)":11
* use_setstate = True
* else:
* use_setstate = False # <<<<<<<<<<<<<<
* if use_setstate:
* return __pyx_unpickle_LeftArc, (type(self), 0xd41d8cd, None), state
*/
/*else*/ {
__pyx_v_use_setstate = 0;
}
__pyx_L3:;
/* "(tree fragment)":12
* else:
* use_setstate = False
* if use_setstate: # <<<<<<<<<<<<<<
* return __pyx_unpickle_LeftArc, (type(self), 0xd41d8cd, None), state
* else:
*/
__pyx_t_3 = (__pyx_v_use_setstate != 0);
if (__pyx_t_3) {
/* "(tree fragment)":13
* use_setstate = False
* if use_setstate:
* return __pyx_unpickle_LeftArc, (type(self), 0xd41d8cd, None), state # <<<<<<<<<<<<<<
* else:
* return __pyx_unpickle_LeftArc, (type(self), 0xd41d8cd, state)
*/
__Pyx_XDECREF(__pyx_r);
__Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_pyx_unpickle_LeftArc); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 13, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 13, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))));
__Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))));
PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))));
__Pyx_INCREF(__pyx_int_222419149);
__Pyx_GIVEREF(__pyx_int_222419149);
PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_int_222419149);
__Pyx_INCREF(Py_None);
__Pyx_GIVEREF(Py_None);
PyTuple_SET_ITEM(__pyx_t_1, 2, Py_None);
__pyx_t_5 = PyTuple_New(3); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 13, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_GIVEREF(__pyx_t_4);
PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_4);
__Pyx_GIVEREF(__pyx_t_1);
PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_1);
__Pyx_INCREF(__pyx_v_state);
__Pyx_GIVEREF(__pyx_v_state);
PyTuple_SET_ITEM(__pyx_t_5, 2, __pyx_v_state);
__pyx_t_4 = 0;
__pyx_t_1 = 0;
__pyx_r = __pyx_t_5;
__pyx_t_5 = 0;
goto __pyx_L0;
/* "(tree fragment)":12
* else:
* use_setstate = False
* if use_setstate: # <<<<<<<<<<<<<<
* return __pyx_unpickle_LeftArc, (type(self), 0xd41d8cd, None), state
* else:
*/
}
/* "(tree fragment)":15
* return __pyx_unpickle_LeftArc, (type(self), 0xd41d8cd, None), state
* else:
* return __pyx_unpickle_LeftArc, (type(self), 0xd41d8cd, state) # <<<<<<<<<<<<<<
* def __setstate_cython__(self, __pyx_state):
* __pyx_unpickle_LeftArc__set_state(self, __pyx_state)
*/
/*else*/ {
__Pyx_XDECREF(__pyx_r);
__Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_pyx_unpickle_LeftArc); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 15, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 15, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))));
__Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))));
PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))));
__Pyx_INCREF(__pyx_int_222419149);
__Pyx_GIVEREF(__pyx_int_222419149);
PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_int_222419149);
__Pyx_INCREF(__pyx_v_state);
__Pyx_GIVEREF(__pyx_v_state);
PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_v_state);
__pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 15, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_GIVEREF(__pyx_t_5);
PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_5);
__Pyx_GIVEREF(__pyx_t_1);
PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_1);
__pyx_t_5 = 0;
__pyx_t_1 = 0;
__pyx_r = __pyx_t_4;
__pyx_t_4 = 0;
goto __pyx_L0;
}
/* "(tree fragment)":1
* def __reduce_cython__(self): # <<<<<<<<<<<<<<
* cdef tuple state
* cdef object _dict
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_1);
__Pyx_XDECREF(__pyx_t_4);
__Pyx_XDECREF(__pyx_t_5);
__Pyx_AddTraceback("spacy.syntax.arc_eager.LeftArc.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = NULL;
__pyx_L0:;
__Pyx_XDECREF(__pyx_v_state);
__Pyx_XDECREF(__pyx_v__dict);
__Pyx_XGIVEREF(__pyx_r);
__Pyx_TraceReturn(__pyx_r, 0);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "(tree fragment)":16
* else:
* return __pyx_unpickle_LeftArc, (type(self), 0xd41d8cd, state)
* def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<<
* __pyx_unpickle_LeftArc__set_state(self, __pyx_state)
*/
/* Python wrapper */
static PyObject *__pyx_pw_5spacy_6syntax_9arc_eager_7LeftArc_3__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state); /*proto*/
static PyObject *__pyx_pw_5spacy_6syntax_9arc_eager_7LeftArc_3__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state) {
PyObject *__pyx_r = 0;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0);
__pyx_r = __pyx_pf_5spacy_6syntax_9arc_eager_7LeftArc_2__setstate_cython__(((struct __pyx_obj_5spacy_6syntax_9arc_eager_LeftArc *)__pyx_v_self), ((PyObject *)__pyx_v___pyx_state));
/* function exit code */
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
static PyObject *__pyx_pf_5spacy_6syntax_9arc_eager_7LeftArc_2__setstate_cython__(struct __pyx_obj_5spacy_6syntax_9arc_eager_LeftArc *__pyx_v_self, PyObject *__pyx_v___pyx_state) {
PyObject *__pyx_r = NULL;
__Pyx_TraceDeclarations
__Pyx_RefNannyDeclarations
PyObject *__pyx_t_1 = NULL;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("__setstate_cython__", 0);
__Pyx_TraceCall("__setstate_cython__", __pyx_f[1], 16, 0, __PYX_ERR(1, 16, __pyx_L1_error));
/* "(tree fragment)":17
* return __pyx_unpickle_LeftArc, (type(self), 0xd41d8cd, state)
* def __setstate_cython__(self, __pyx_state):
* __pyx_unpickle_LeftArc__set_state(self, __pyx_state) # <<<<<<<<<<<<<<
*/
if (!(likely(PyTuple_CheckExact(__pyx_v___pyx_state))||((__pyx_v___pyx_state) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "tuple", Py_TYPE(__pyx_v___pyx_state)->tp_name), 0))) __PYX_ERR(1, 17, __pyx_L1_error)
__pyx_t_1 = __pyx_f_5spacy_6syntax_9arc_eager___pyx_unpickle_LeftArc__set_state(__pyx_v_self, ((PyObject*)__pyx_v___pyx_state)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 17, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
/* "(tree fragment)":16
* else:
* return __pyx_unpickle_LeftArc, (type(self), 0xd41d8cd, state)
* def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<<
* __pyx_unpickle_LeftArc__set_state(self, __pyx_state)
*/
/* function exit code */
__pyx_r = Py_None; __Pyx_INCREF(Py_None);
goto __pyx_L0;
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_1);
__Pyx_AddTraceback("spacy.syntax.arc_eager.LeftArc.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = NULL;
__pyx_L0:;
__Pyx_XGIVEREF(__pyx_r);
__Pyx_TraceReturn(__pyx_r, 0);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "spacy/syntax/arc_eager.pyx":222
* cdef class RightArc:
* @staticmethod
* cdef bint is_valid(const StateC* st, attr_t label) nogil: # <<<<<<<<<<<<<<
* # If there's (perhaps partial) parse pre-set, don't allow cycle.
* if label == SUBTOK_LABEL and st.S(0) != (st.B(0)-1):
*/
static int __pyx_f_5spacy_6syntax_9arc_eager_8RightArc_is_valid(__pyx_t_5spacy_6syntax_6_state_StateC const *__pyx_v_st, __pyx_t_5spacy_8typedefs_attr_t __pyx_v_label) {
int __pyx_v_sent_start;
int __pyx_r;
__Pyx_TraceDeclarations
int __pyx_t_1;
int __pyx_t_2;
int __pyx_t_3;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_TraceCall("is_valid", __pyx_f[0], 222, 1, __PYX_ERR(0, 222, __pyx_L1_error));
/* "spacy/syntax/arc_eager.pyx":224
* cdef bint is_valid(const StateC* st, attr_t label) nogil:
* # If there's (perhaps partial) parse pre-set, don't allow cycle.
* if label == SUBTOK_LABEL and st.S(0) != (st.B(0)-1): # <<<<<<<<<<<<<<
* return 0
* sent_start = st._sent[st.B_(0).l_edge].sent_start
*/
__pyx_t_2 = ((__pyx_v_label == __pyx_v_5spacy_6syntax_9arc_eager_SUBTOK_LABEL) != 0);
if (__pyx_t_2) {
} else {
__pyx_t_1 = __pyx_t_2;
goto __pyx_L4_bool_binop_done;
}
__pyx_t_2 = ((__pyx_v_st->S(0) != (__pyx_v_st->B(0) - 1)) != 0);
__pyx_t_1 = __pyx_t_2;
__pyx_L4_bool_binop_done:;
if (__pyx_t_1) {
/* "spacy/syntax/arc_eager.pyx":225
* # If there's (perhaps partial) parse pre-set, don't allow cycle.
* if label == SUBTOK_LABEL and st.S(0) != (st.B(0)-1):
* return 0 # <<<<<<<<<<<<<<
* sent_start = st._sent[st.B_(0).l_edge].sent_start
* return sent_start != 1 and st.H(st.S(0)) != st.B(0)
*/
__pyx_r = 0;
goto __pyx_L0;
/* "spacy/syntax/arc_eager.pyx":224
* cdef bint is_valid(const StateC* st, attr_t label) nogil:
* # If there's (perhaps partial) parse pre-set, don't allow cycle.
* if label == SUBTOK_LABEL and st.S(0) != (st.B(0)-1): # <<<<<<<<<<<<<<
* return 0
* sent_start = st._sent[st.B_(0).l_edge].sent_start
*/
}
/* "spacy/syntax/arc_eager.pyx":226
* if label == SUBTOK_LABEL and st.S(0) != (st.B(0)-1):
* return 0
* sent_start = st._sent[st.B_(0).l_edge].sent_start # <<<<<<<<<<<<<<
* return sent_start != 1 and st.H(st.S(0)) != st.B(0)
*
*/
__pyx_t_3 = (__pyx_v_st->_sent[__pyx_v_st->B_(0)->l_edge]).sent_start;
__pyx_v_sent_start = __pyx_t_3;
/* "spacy/syntax/arc_eager.pyx":227
* return 0
* sent_start = st._sent[st.B_(0).l_edge].sent_start
* return sent_start != 1 and st.H(st.S(0)) != st.B(0) # <<<<<<<<<<<<<<
*
* @staticmethod
*/
__pyx_t_2 = ((__pyx_v_sent_start != 1) != 0);
if (__pyx_t_2) {
} else {
__pyx_t_1 = __pyx_t_2;
goto __pyx_L6_bool_binop_done;
}
__pyx_t_2 = ((__pyx_v_st->H(__pyx_v_st->S(0)) != __pyx_v_st->B(0)) != 0);
__pyx_t_1 = __pyx_t_2;
__pyx_L6_bool_binop_done:;
__pyx_r = __pyx_t_1;
goto __pyx_L0;
/* "spacy/syntax/arc_eager.pyx":222
* cdef class RightArc:
* @staticmethod
* cdef bint is_valid(const StateC* st, attr_t label) nogil: # <<<<<<<<<<<<<<
* # If there's (perhaps partial) parse pre-set, don't allow cycle.
* if label == SUBTOK_LABEL and st.S(0) != (st.B(0)-1):
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_WriteUnraisable("spacy.syntax.arc_eager.RightArc.is_valid", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 1);
__pyx_r = 0;
__pyx_L0:;
__Pyx_TraceReturn(Py_None, 1);
return __pyx_r;
}
/* "spacy/syntax/arc_eager.pyx":230
*
* @staticmethod
* cdef int transition(StateC* st, attr_t label) nogil: # <<<<<<<<<<<<<<
* st.add_arc(st.S(0), st.B(0), label)
* st.push()
*/
static int __pyx_f_5spacy_6syntax_9arc_eager_8RightArc_transition(__pyx_t_5spacy_6syntax_6_state_StateC *__pyx_v_st, __pyx_t_5spacy_8typedefs_attr_t __pyx_v_label) {
int __pyx_r;
__Pyx_TraceDeclarations
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_TraceCall("transition", __pyx_f[0], 230, 1, __PYX_ERR(0, 230, __pyx_L1_error));
/* "spacy/syntax/arc_eager.pyx":231
* @staticmethod
* cdef int transition(StateC* st, attr_t label) nogil:
* st.add_arc(st.S(0), st.B(0), label) # <<<<<<<<<<<<<<
* st.push()
* st.fast_forward()
*/
__pyx_v_st->add_arc(__pyx_v_st->S(0), __pyx_v_st->B(0), __pyx_v_label);
/* "spacy/syntax/arc_eager.pyx":232
* cdef int transition(StateC* st, attr_t label) nogil:
* st.add_arc(st.S(0), st.B(0), label)
* st.push() # <<<<<<<<<<<<<<
* st.fast_forward()
*
*/
__pyx_v_st->push();
/* "spacy/syntax/arc_eager.pyx":233
* st.add_arc(st.S(0), st.B(0), label)
* st.push()
* st.fast_forward() # <<<<<<<<<<<<<<
*
* @staticmethod
*/
__pyx_v_st->fast_forward();
/* "spacy/syntax/arc_eager.pyx":230
*
* @staticmethod
* cdef int transition(StateC* st, attr_t label) nogil: # <<<<<<<<<<<<<<
* st.add_arc(st.S(0), st.B(0), label)
* st.push()
*/
/* function exit code */
__pyx_r = 0;
goto __pyx_L0;
__pyx_L1_error:;
__Pyx_WriteUnraisable("spacy.syntax.arc_eager.RightArc.transition", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 1);
__pyx_r = 0;
__pyx_L0:;
__Pyx_TraceReturn(Py_None, 1);
return __pyx_r;
}
/* "spacy/syntax/arc_eager.pyx":236
*
* @staticmethod
* cdef inline weight_t cost(StateClass s, const GoldParseC* gold, attr_t label) nogil: # <<<<<<<<<<<<<<
* return RightArc.move_cost(s, gold) + RightArc.label_cost(s, gold, label)
*
*/
static CYTHON_INLINE __pyx_t_5thinc_8typedefs_weight_t __pyx_f_5spacy_6syntax_9arc_eager_8RightArc_cost(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *__pyx_v_s, struct __pyx_t_5spacy_4gold_GoldParseC const *__pyx_v_gold, __pyx_t_5spacy_8typedefs_attr_t __pyx_v_label) {
__pyx_t_5thinc_8typedefs_weight_t __pyx_r;
__Pyx_TraceDeclarations
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_TraceCall("cost", __pyx_f[0], 236, 1, __PYX_ERR(0, 236, __pyx_L1_error));
/* "spacy/syntax/arc_eager.pyx":237
* @staticmethod
* cdef inline weight_t cost(StateClass s, const GoldParseC* gold, attr_t label) nogil:
* return RightArc.move_cost(s, gold) + RightArc.label_cost(s, gold, label) # <<<<<<<<<<<<<<
*
* @staticmethod
*/
__pyx_r = (__pyx_f_5spacy_6syntax_9arc_eager_8RightArc_move_cost(__pyx_v_s, __pyx_v_gold) + __pyx_f_5spacy_6syntax_9arc_eager_8RightArc_label_cost(__pyx_v_s, __pyx_v_gold, __pyx_v_label));
goto __pyx_L0;
/* "spacy/syntax/arc_eager.pyx":236
*
* @staticmethod
* cdef inline weight_t cost(StateClass s, const GoldParseC* gold, attr_t label) nogil: # <<<<<<<<<<<<<<
* return RightArc.move_cost(s, gold) + RightArc.label_cost(s, gold, label)
*
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_WriteUnraisable("spacy.syntax.arc_eager.RightArc.cost", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 1);
__pyx_r = 0;
__pyx_L0:;
__Pyx_TraceReturn(Py_None, 1);
return __pyx_r;
}
/* "spacy/syntax/arc_eager.pyx":240
*
* @staticmethod
* cdef inline weight_t move_cost(StateClass s, const GoldParseC* gold) nogil: # <<<<<<<<<<<<<<
* if arc_is_gold(gold, s.S(0), s.B(0)):
* return 0
*/
static CYTHON_INLINE __pyx_t_5thinc_8typedefs_weight_t __pyx_f_5spacy_6syntax_9arc_eager_8RightArc_move_cost(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *__pyx_v_s, struct __pyx_t_5spacy_4gold_GoldParseC const *__pyx_v_gold) {
__pyx_t_5thinc_8typedefs_weight_t __pyx_r;
__Pyx_TraceDeclarations
int __pyx_t_1;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_TraceCall("move_cost", __pyx_f[0], 240, 1, __PYX_ERR(0, 240, __pyx_L1_error));
/* "spacy/syntax/arc_eager.pyx":241
* @staticmethod
* cdef inline weight_t move_cost(StateClass s, const GoldParseC* gold) nogil:
* if arc_is_gold(gold, s.S(0), s.B(0)): # <<<<<<<<<<<<<<
* return 0
* elif s.c.shifted[s.B(0)]:
*/
__pyx_t_1 = (__pyx_f_5spacy_6syntax_9arc_eager_arc_is_gold(__pyx_v_gold, __pyx_f_5spacy_6syntax_10stateclass_10StateClass_S(__pyx_v_s, 0), __pyx_f_5spacy_6syntax_10stateclass_10StateClass_B(__pyx_v_s, 0)) != 0);
if (__pyx_t_1) {
/* "spacy/syntax/arc_eager.pyx":242
* cdef inline weight_t move_cost(StateClass s, const GoldParseC* gold) nogil:
* if arc_is_gold(gold, s.S(0), s.B(0)):
* return 0 # <<<<<<<<<<<<<<
* elif s.c.shifted[s.B(0)]:
* return push_cost(s, gold, s.B(0))
*/
__pyx_r = 0.0;
goto __pyx_L0;
/* "spacy/syntax/arc_eager.pyx":241
* @staticmethod
* cdef inline weight_t move_cost(StateClass s, const GoldParseC* gold) nogil:
* if arc_is_gold(gold, s.S(0), s.B(0)): # <<<<<<<<<<<<<<
* return 0
* elif s.c.shifted[s.B(0)]:
*/
}
/* "spacy/syntax/arc_eager.pyx":243
* if arc_is_gold(gold, s.S(0), s.B(0)):
* return 0
* elif s.c.shifted[s.B(0)]: # <<<<<<<<<<<<<<
* return push_cost(s, gold, s.B(0))
* else:
*/
__pyx_t_1 = ((__pyx_v_s->c->shifted[__pyx_f_5spacy_6syntax_10stateclass_10StateClass_B(__pyx_v_s, 0)]) != 0);
if (__pyx_t_1) {
/* "spacy/syntax/arc_eager.pyx":244
* return 0
* elif s.c.shifted[s.B(0)]:
* return push_cost(s, gold, s.B(0)) # <<<<<<<<<<<<<<
* else:
* return push_cost(s, gold, s.B(0)) + arc_cost(s, gold, s.S(0), s.B(0))
*/
__pyx_r = __pyx_f_5spacy_6syntax_9arc_eager_push_cost(__pyx_v_s, __pyx_v_gold, __pyx_f_5spacy_6syntax_10stateclass_10StateClass_B(__pyx_v_s, 0));
goto __pyx_L0;
/* "spacy/syntax/arc_eager.pyx":243
* if arc_is_gold(gold, s.S(0), s.B(0)):
* return 0
* elif s.c.shifted[s.B(0)]: # <<<<<<<<<<<<<<
* return push_cost(s, gold, s.B(0))
* else:
*/
}
/* "spacy/syntax/arc_eager.pyx":246
* return push_cost(s, gold, s.B(0))
* else:
* return push_cost(s, gold, s.B(0)) + arc_cost(s, gold, s.S(0), s.B(0)) # <<<<<<<<<<<<<<
*
* @staticmethod
*/
/*else*/ {
__pyx_r = (__pyx_f_5spacy_6syntax_9arc_eager_push_cost(__pyx_v_s, __pyx_v_gold, __pyx_f_5spacy_6syntax_10stateclass_10StateClass_B(__pyx_v_s, 0)) + __pyx_f_5spacy_6syntax_9arc_eager_arc_cost(__pyx_v_s, __pyx_v_gold, __pyx_f_5spacy_6syntax_10stateclass_10StateClass_S(__pyx_v_s, 0), __pyx_f_5spacy_6syntax_10stateclass_10StateClass_B(__pyx_v_s, 0)));
goto __pyx_L0;
}
/* "spacy/syntax/arc_eager.pyx":240
*
* @staticmethod
* cdef inline weight_t move_cost(StateClass s, const GoldParseC* gold) nogil: # <<<<<<<<<<<<<<
* if arc_is_gold(gold, s.S(0), s.B(0)):
* return 0
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_WriteUnraisable("spacy.syntax.arc_eager.RightArc.move_cost", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 1);
__pyx_r = 0;
__pyx_L0:;
__Pyx_TraceReturn(Py_None, 1);
return __pyx_r;
}
/* "spacy/syntax/arc_eager.pyx":249
*
* @staticmethod
* cdef weight_t label_cost(StateClass s, const GoldParseC* gold, attr_t label) nogil: # <<<<<<<<<<<<<<
* return arc_is_gold(gold, s.S(0), s.B(0)) and not label_is_gold(gold, s.S(0), s.B(0), label)
*
*/
static __pyx_t_5thinc_8typedefs_weight_t __pyx_f_5spacy_6syntax_9arc_eager_8RightArc_label_cost(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *__pyx_v_s, struct __pyx_t_5spacy_4gold_GoldParseC const *__pyx_v_gold, __pyx_t_5spacy_8typedefs_attr_t __pyx_v_label) {
__pyx_t_5thinc_8typedefs_weight_t __pyx_r;
__Pyx_TraceDeclarations
__pyx_t_5thinc_8typedefs_weight_t __pyx_t_1;
int __pyx_t_2;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_TraceCall("label_cost", __pyx_f[0], 249, 1, __PYX_ERR(0, 249, __pyx_L1_error));
/* "spacy/syntax/arc_eager.pyx":250
* @staticmethod
* cdef weight_t label_cost(StateClass s, const GoldParseC* gold, attr_t label) nogil:
* return arc_is_gold(gold, s.S(0), s.B(0)) and not label_is_gold(gold, s.S(0), s.B(0), label) # <<<<<<<<<<<<<<
*
*
*/
__pyx_t_2 = __pyx_f_5spacy_6syntax_9arc_eager_arc_is_gold(__pyx_v_gold, __pyx_f_5spacy_6syntax_10stateclass_10StateClass_S(__pyx_v_s, 0), __pyx_f_5spacy_6syntax_10stateclass_10StateClass_B(__pyx_v_s, 0));
if (__pyx_t_2) {
} else {
__pyx_t_1 = __pyx_t_2;
goto __pyx_L3_bool_binop_done;
}
__pyx_t_2 = (!(__pyx_f_5spacy_6syntax_9arc_eager_label_is_gold(__pyx_v_gold, __pyx_f_5spacy_6syntax_10stateclass_10StateClass_S(__pyx_v_s, 0), __pyx_f_5spacy_6syntax_10stateclass_10StateClass_B(__pyx_v_s, 0), __pyx_v_label) != 0));
__pyx_t_1 = __pyx_t_2;
__pyx_L3_bool_binop_done:;
__pyx_r = __pyx_t_1;
goto __pyx_L0;
/* "spacy/syntax/arc_eager.pyx":249
*
* @staticmethod
* cdef weight_t label_cost(StateClass s, const GoldParseC* gold, attr_t label) nogil: # <<<<<<<<<<<<<<
* return arc_is_gold(gold, s.S(0), s.B(0)) and not label_is_gold(gold, s.S(0), s.B(0), label)
*
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_WriteUnraisable("spacy.syntax.arc_eager.RightArc.label_cost", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 1);
__pyx_r = 0;
__pyx_L0:;
__Pyx_TraceReturn(Py_None, 1);
return __pyx_r;
}
/* "(tree fragment)":1
* def __reduce_cython__(self): # <<<<<<<<<<<<<<
* cdef tuple state
* cdef object _dict
*/
/* Python wrapper */
static PyObject *__pyx_pw_5spacy_6syntax_9arc_eager_8RightArc_1__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
static PyObject *__pyx_pw_5spacy_6syntax_9arc_eager_8RightArc_1__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
PyObject *__pyx_r = 0;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0);
__pyx_r = __pyx_pf_5spacy_6syntax_9arc_eager_8RightArc___reduce_cython__(((struct __pyx_obj_5spacy_6syntax_9arc_eager_RightArc *)__pyx_v_self));
/* function exit code */
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
static PyObject *__pyx_pf_5spacy_6syntax_9arc_eager_8RightArc___reduce_cython__(struct __pyx_obj_5spacy_6syntax_9arc_eager_RightArc *__pyx_v_self) {
PyObject *__pyx_v_state = 0;
PyObject *__pyx_v__dict = 0;
int __pyx_v_use_setstate;
PyObject *__pyx_r = NULL;
__Pyx_TraceDeclarations
__Pyx_RefNannyDeclarations
PyObject *__pyx_t_1 = NULL;
int __pyx_t_2;
int __pyx_t_3;
PyObject *__pyx_t_4 = NULL;
PyObject *__pyx_t_5 = NULL;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("__reduce_cython__", 0);
__Pyx_TraceCall("__reduce_cython__", __pyx_f[1], 1, 0, __PYX_ERR(1, 1, __pyx_L1_error));
/* "(tree fragment)":5
* cdef object _dict
* cdef bint use_setstate
* state = () # <<<<<<<<<<<<<<
* _dict = getattr(self, '__dict__', None)
* if _dict is not None:
*/
__Pyx_INCREF(__pyx_empty_tuple);
__pyx_v_state = __pyx_empty_tuple;
/* "(tree fragment)":6
* cdef bint use_setstate
* state = ()
* _dict = getattr(self, '__dict__', None) # <<<<<<<<<<<<<<
* if _dict is not None:
* state += (_dict,)
*/
__pyx_t_1 = __Pyx_GetAttr3(((PyObject *)__pyx_v_self), __pyx_n_s_dict, Py_None); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 6, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_v__dict = __pyx_t_1;
__pyx_t_1 = 0;
/* "(tree fragment)":7
* state = ()
* _dict = getattr(self, '__dict__', None)
* if _dict is not None: # <<<<<<<<<<<<<<
* state += (_dict,)
* use_setstate = True
*/
__pyx_t_2 = (__pyx_v__dict != Py_None);
__pyx_t_3 = (__pyx_t_2 != 0);
if (__pyx_t_3) {
/* "(tree fragment)":8
* _dict = getattr(self, '__dict__', None)
* if _dict is not None:
* state += (_dict,) # <<<<<<<<<<<<<<
* use_setstate = True
* else:
*/
__pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 8, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_INCREF(__pyx_v__dict);
__Pyx_GIVEREF(__pyx_v__dict);
PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v__dict);
__pyx_t_4 = PyNumber_InPlaceAdd(__pyx_v_state, __pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 8, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__Pyx_DECREF_SET(__pyx_v_state, ((PyObject*)__pyx_t_4));
__pyx_t_4 = 0;
/* "(tree fragment)":9
* if _dict is not None:
* state += (_dict,)
* use_setstate = True # <<<<<<<<<<<<<<
* else:
* use_setstate = False
*/
__pyx_v_use_setstate = 1;
/* "(tree fragment)":7
* state = ()
* _dict = getattr(self, '__dict__', None)
* if _dict is not None: # <<<<<<<<<<<<<<
* state += (_dict,)
* use_setstate = True
*/
goto __pyx_L3;
}
/* "(tree fragment)":11
* use_setstate = True
* else:
* use_setstate = False # <<<<<<<<<<<<<<
* if use_setstate:
* return __pyx_unpickle_RightArc, (type(self), 0xd41d8cd, None), state
*/
/*else*/ {
__pyx_v_use_setstate = 0;
}
__pyx_L3:;
/* "(tree fragment)":12
* else:
* use_setstate = False
* if use_setstate: # <<<<<<<<<<<<<<
* return __pyx_unpickle_RightArc, (type(self), 0xd41d8cd, None), state
* else:
*/
__pyx_t_3 = (__pyx_v_use_setstate != 0);
if (__pyx_t_3) {
/* "(tree fragment)":13
* use_setstate = False
* if use_setstate:
* return __pyx_unpickle_RightArc, (type(self), 0xd41d8cd, None), state # <<<<<<<<<<<<<<
* else:
* return __pyx_unpickle_RightArc, (type(self), 0xd41d8cd, state)
*/
__Pyx_XDECREF(__pyx_r);
__Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_pyx_unpickle_RightArc); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 13, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 13, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))));
__Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))));
PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))));
__Pyx_INCREF(__pyx_int_222419149);
__Pyx_GIVEREF(__pyx_int_222419149);
PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_int_222419149);
__Pyx_INCREF(Py_None);
__Pyx_GIVEREF(Py_None);
PyTuple_SET_ITEM(__pyx_t_1, 2, Py_None);
__pyx_t_5 = PyTuple_New(3); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 13, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_GIVEREF(__pyx_t_4);
PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_4);
__Pyx_GIVEREF(__pyx_t_1);
PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_1);
__Pyx_INCREF(__pyx_v_state);
__Pyx_GIVEREF(__pyx_v_state);
PyTuple_SET_ITEM(__pyx_t_5, 2, __pyx_v_state);
__pyx_t_4 = 0;
__pyx_t_1 = 0;
__pyx_r = __pyx_t_5;
__pyx_t_5 = 0;
goto __pyx_L0;
/* "(tree fragment)":12
* else:
* use_setstate = False
* if use_setstate: # <<<<<<<<<<<<<<
* return __pyx_unpickle_RightArc, (type(self), 0xd41d8cd, None), state
* else:
*/
}
/* "(tree fragment)":15
* return __pyx_unpickle_RightArc, (type(self), 0xd41d8cd, None), state
* else:
* return __pyx_unpickle_RightArc, (type(self), 0xd41d8cd, state) # <<<<<<<<<<<<<<
* def __setstate_cython__(self, __pyx_state):
* __pyx_unpickle_RightArc__set_state(self, __pyx_state)
*/
/*else*/ {
__Pyx_XDECREF(__pyx_r);
__Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_pyx_unpickle_RightArc); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 15, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 15, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))));
__Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))));
PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))));
__Pyx_INCREF(__pyx_int_222419149);
__Pyx_GIVEREF(__pyx_int_222419149);
PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_int_222419149);
__Pyx_INCREF(__pyx_v_state);
__Pyx_GIVEREF(__pyx_v_state);
PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_v_state);
__pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 15, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_GIVEREF(__pyx_t_5);
PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_5);
__Pyx_GIVEREF(__pyx_t_1);
PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_1);
__pyx_t_5 = 0;
__pyx_t_1 = 0;
__pyx_r = __pyx_t_4;
__pyx_t_4 = 0;
goto __pyx_L0;
}
/* "(tree fragment)":1
* def __reduce_cython__(self): # <<<<<<<<<<<<<<
* cdef tuple state
* cdef object _dict
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_1);
__Pyx_XDECREF(__pyx_t_4);
__Pyx_XDECREF(__pyx_t_5);
__Pyx_AddTraceback("spacy.syntax.arc_eager.RightArc.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = NULL;
__pyx_L0:;
__Pyx_XDECREF(__pyx_v_state);
__Pyx_XDECREF(__pyx_v__dict);
__Pyx_XGIVEREF(__pyx_r);
__Pyx_TraceReturn(__pyx_r, 0);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "(tree fragment)":16
* else:
* return __pyx_unpickle_RightArc, (type(self), 0xd41d8cd, state)
* def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<<
* __pyx_unpickle_RightArc__set_state(self, __pyx_state)
*/
/* Python wrapper */
static PyObject *__pyx_pw_5spacy_6syntax_9arc_eager_8RightArc_3__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state); /*proto*/
static PyObject *__pyx_pw_5spacy_6syntax_9arc_eager_8RightArc_3__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state) {
PyObject *__pyx_r = 0;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0);
__pyx_r = __pyx_pf_5spacy_6syntax_9arc_eager_8RightArc_2__setstate_cython__(((struct __pyx_obj_5spacy_6syntax_9arc_eager_RightArc *)__pyx_v_self), ((PyObject *)__pyx_v___pyx_state));
/* function exit code */
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
static PyObject *__pyx_pf_5spacy_6syntax_9arc_eager_8RightArc_2__setstate_cython__(struct __pyx_obj_5spacy_6syntax_9arc_eager_RightArc *__pyx_v_self, PyObject *__pyx_v___pyx_state) {
PyObject *__pyx_r = NULL;
__Pyx_TraceDeclarations
__Pyx_RefNannyDeclarations
PyObject *__pyx_t_1 = NULL;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("__setstate_cython__", 0);
__Pyx_TraceCall("__setstate_cython__", __pyx_f[1], 16, 0, __PYX_ERR(1, 16, __pyx_L1_error));
/* "(tree fragment)":17
* return __pyx_unpickle_RightArc, (type(self), 0xd41d8cd, state)
* def __setstate_cython__(self, __pyx_state):
* __pyx_unpickle_RightArc__set_state(self, __pyx_state) # <<<<<<<<<<<<<<
*/
if (!(likely(PyTuple_CheckExact(__pyx_v___pyx_state))||((__pyx_v___pyx_state) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "tuple", Py_TYPE(__pyx_v___pyx_state)->tp_name), 0))) __PYX_ERR(1, 17, __pyx_L1_error)
__pyx_t_1 = __pyx_f_5spacy_6syntax_9arc_eager___pyx_unpickle_RightArc__set_state(__pyx_v_self, ((PyObject*)__pyx_v___pyx_state)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 17, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
/* "(tree fragment)":16
* else:
* return __pyx_unpickle_RightArc, (type(self), 0xd41d8cd, state)
* def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<<
* __pyx_unpickle_RightArc__set_state(self, __pyx_state)
*/
/* function exit code */
__pyx_r = Py_None; __Pyx_INCREF(Py_None);
goto __pyx_L0;
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_1);
__Pyx_AddTraceback("spacy.syntax.arc_eager.RightArc.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = NULL;
__pyx_L0:;
__Pyx_XGIVEREF(__pyx_r);
__Pyx_TraceReturn(__pyx_r, 0);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "spacy/syntax/arc_eager.pyx":255
* cdef class Break:
* @staticmethod
* cdef bint is_valid(const StateC* st, attr_t label) nogil: # <<<<<<<<<<<<<<
* cdef int i
* if not USE_BREAK:
*/
static int __pyx_f_5spacy_6syntax_9arc_eager_5Break_is_valid(__pyx_t_5spacy_6syntax_6_state_StateC const *__pyx_v_st, CYTHON_UNUSED __pyx_t_5spacy_8typedefs_attr_t __pyx_v_label) {
int __pyx_r;
__Pyx_TraceDeclarations
int __pyx_t_1;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_TraceCall("is_valid", __pyx_f[0], 255, 1, __PYX_ERR(0, 255, __pyx_L1_error));
/* "spacy/syntax/arc_eager.pyx":259
* if not USE_BREAK:
* return False
* elif st.at_break(): # <<<<<<<<<<<<<<
* return False
* elif st.stack_depth() < 1:
*/
__pyx_t_1 = (__pyx_v_st->at_break() != 0);
if (__pyx_t_1) {
/* "spacy/syntax/arc_eager.pyx":260
* return False
* elif st.at_break():
* return False # <<<<<<<<<<<<<<
* elif st.stack_depth() < 1:
* return False
*/
__pyx_r = 0;
goto __pyx_L0;
/* "spacy/syntax/arc_eager.pyx":259
* if not USE_BREAK:
* return False
* elif st.at_break(): # <<<<<<<<<<<<<<
* return False
* elif st.stack_depth() < 1:
*/
}
/* "spacy/syntax/arc_eager.pyx":261
* elif st.at_break():
* return False
* elif st.stack_depth() < 1: # <<<<<<<<<<<<<<
* return False
* elif st.B_(0).l_edge < 0:
*/
__pyx_t_1 = ((__pyx_v_st->stack_depth() < 1) != 0);
if (__pyx_t_1) {
/* "spacy/syntax/arc_eager.pyx":262
* return False
* elif st.stack_depth() < 1:
* return False # <<<<<<<<<<<<<<
* elif st.B_(0).l_edge < 0:
* return False
*/
__pyx_r = 0;
goto __pyx_L0;
/* "spacy/syntax/arc_eager.pyx":261
* elif st.at_break():
* return False
* elif st.stack_depth() < 1: # <<<<<<<<<<<<<<
* return False
* elif st.B_(0).l_edge < 0:
*/
}
/* "spacy/syntax/arc_eager.pyx":263
* elif st.stack_depth() < 1:
* return False
* elif st.B_(0).l_edge < 0: # <<<<<<<<<<<<<<
* return False
* elif st._sent[st.B_(0).l_edge].sent_start < 0:
*/
__pyx_t_1 = ((__pyx_v_st->B_(0)->l_edge < 0) != 0);
if (__pyx_t_1) {
/* "spacy/syntax/arc_eager.pyx":264
* return False
* elif st.B_(0).l_edge < 0:
* return False # <<<<<<<<<<<<<<
* elif st._sent[st.B_(0).l_edge].sent_start < 0:
* return False
*/
__pyx_r = 0;
goto __pyx_L0;
/* "spacy/syntax/arc_eager.pyx":263
* elif st.stack_depth() < 1:
* return False
* elif st.B_(0).l_edge < 0: # <<<<<<<<<<<<<<
* return False
* elif st._sent[st.B_(0).l_edge].sent_start < 0:
*/
}
/* "spacy/syntax/arc_eager.pyx":265
* elif st.B_(0).l_edge < 0:
* return False
* elif st._sent[st.B_(0).l_edge].sent_start < 0: # <<<<<<<<<<<<<<
* return False
* else:
*/
__pyx_t_1 = (((__pyx_v_st->_sent[__pyx_v_st->B_(0)->l_edge]).sent_start < 0) != 0);
if (__pyx_t_1) {
/* "spacy/syntax/arc_eager.pyx":266
* return False
* elif st._sent[st.B_(0).l_edge].sent_start < 0:
* return False # <<<<<<<<<<<<<<
* else:
* return True
*/
__pyx_r = 0;
goto __pyx_L0;
/* "spacy/syntax/arc_eager.pyx":265
* elif st.B_(0).l_edge < 0:
* return False
* elif st._sent[st.B_(0).l_edge].sent_start < 0: # <<<<<<<<<<<<<<
* return False
* else:
*/
}
/* "spacy/syntax/arc_eager.pyx":268
* return False
* else:
* return True # <<<<<<<<<<<<<<
*
* @staticmethod
*/
/*else*/ {
__pyx_r = 1;
goto __pyx_L0;
}
/* "spacy/syntax/arc_eager.pyx":255
* cdef class Break:
* @staticmethod
* cdef bint is_valid(const StateC* st, attr_t label) nogil: # <<<<<<<<<<<<<<
* cdef int i
* if not USE_BREAK:
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_WriteUnraisable("spacy.syntax.arc_eager.Break.is_valid", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 1);
__pyx_r = 0;
__pyx_L0:;
__Pyx_TraceReturn(Py_None, 1);
return __pyx_r;
}
/* "spacy/syntax/arc_eager.pyx":271
*
* @staticmethod
* cdef int transition(StateC* st, attr_t label) nogil: # <<<<<<<<<<<<<<
* st.set_break(st.B_(0).l_edge)
* st.fast_forward()
*/
static int __pyx_f_5spacy_6syntax_9arc_eager_5Break_transition(__pyx_t_5spacy_6syntax_6_state_StateC *__pyx_v_st, CYTHON_UNUSED __pyx_t_5spacy_8typedefs_attr_t __pyx_v_label) {
int __pyx_r;
__Pyx_TraceDeclarations
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_TraceCall("transition", __pyx_f[0], 271, 1, __PYX_ERR(0, 271, __pyx_L1_error));
/* "spacy/syntax/arc_eager.pyx":272
* @staticmethod
* cdef int transition(StateC* st, attr_t label) nogil:
* st.set_break(st.B_(0).l_edge) # <<<<<<<<<<<<<<
* st.fast_forward()
*
*/
__pyx_v_st->set_break(__pyx_v_st->B_(0)->l_edge);
/* "spacy/syntax/arc_eager.pyx":273
* cdef int transition(StateC* st, attr_t label) nogil:
* st.set_break(st.B_(0).l_edge)
* st.fast_forward() # <<<<<<<<<<<<<<
*
* @staticmethod
*/
__pyx_v_st->fast_forward();
/* "spacy/syntax/arc_eager.pyx":271
*
* @staticmethod
* cdef int transition(StateC* st, attr_t label) nogil: # <<<<<<<<<<<<<<
* st.set_break(st.B_(0).l_edge)
* st.fast_forward()
*/
/* function exit code */
__pyx_r = 0;
goto __pyx_L0;
__pyx_L1_error:;
__Pyx_WriteUnraisable("spacy.syntax.arc_eager.Break.transition", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 1);
__pyx_r = 0;
__pyx_L0:;
__Pyx_TraceReturn(Py_None, 1);
return __pyx_r;
}
/* "spacy/syntax/arc_eager.pyx":276
*
* @staticmethod
* cdef weight_t cost(StateClass s, const GoldParseC* gold, attr_t label) nogil: # <<<<<<<<<<<<<<
* return Break.move_cost(s, gold) + Break.label_cost(s, gold, label)
*
*/
static __pyx_t_5thinc_8typedefs_weight_t __pyx_f_5spacy_6syntax_9arc_eager_5Break_cost(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *__pyx_v_s, struct __pyx_t_5spacy_4gold_GoldParseC const *__pyx_v_gold, __pyx_t_5spacy_8typedefs_attr_t __pyx_v_label) {
__pyx_t_5thinc_8typedefs_weight_t __pyx_r;
__Pyx_TraceDeclarations
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_TraceCall("cost", __pyx_f[0], 276, 1, __PYX_ERR(0, 276, __pyx_L1_error));
/* "spacy/syntax/arc_eager.pyx":277
* @staticmethod
* cdef weight_t cost(StateClass s, const GoldParseC* gold, attr_t label) nogil:
* return Break.move_cost(s, gold) + Break.label_cost(s, gold, label) # <<<<<<<<<<<<<<
*
* @staticmethod
*/
__pyx_r = (__pyx_f_5spacy_6syntax_9arc_eager_5Break_move_cost(__pyx_v_s, __pyx_v_gold) + __pyx_f_5spacy_6syntax_9arc_eager_5Break_label_cost(__pyx_v_s, __pyx_v_gold, __pyx_v_label));
goto __pyx_L0;
/* "spacy/syntax/arc_eager.pyx":276
*
* @staticmethod
* cdef weight_t cost(StateClass s, const GoldParseC* gold, attr_t label) nogil: # <<<<<<<<<<<<<<
* return Break.move_cost(s, gold) + Break.label_cost(s, gold, label)
*
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_WriteUnraisable("spacy.syntax.arc_eager.Break.cost", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 1);
__pyx_r = 0;
__pyx_L0:;
__Pyx_TraceReturn(Py_None, 1);
return __pyx_r;
}
/* "spacy/syntax/arc_eager.pyx":280
*
* @staticmethod
* cdef inline weight_t move_cost(StateClass s, const GoldParseC* gold) nogil: # <<<<<<<<<<<<<<
* cdef weight_t cost = 0
* cdef int i, j, S_i, B_i
*/
static CYTHON_INLINE __pyx_t_5thinc_8typedefs_weight_t __pyx_f_5spacy_6syntax_9arc_eager_5Break_move_cost(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *__pyx_v_s, struct __pyx_t_5spacy_4gold_GoldParseC const *__pyx_v_gold) {
__pyx_t_5thinc_8typedefs_weight_t __pyx_v_cost;
int __pyx_v_i;
int __pyx_v_j;
int __pyx_v_S_i;
int __pyx_v_B_i;
int __pyx_v_s0_root;
int __pyx_v_b0_root;
__pyx_t_5thinc_8typedefs_weight_t __pyx_r;
__Pyx_TraceDeclarations
int __pyx_t_1;
int __pyx_t_2;
int __pyx_t_3;
int __pyx_t_4;
int __pyx_t_5;
int __pyx_t_6;
int __pyx_t_7;
int __pyx_t_8;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_TraceCall("move_cost", __pyx_f[0], 280, 1, __PYX_ERR(0, 280, __pyx_L1_error));
/* "spacy/syntax/arc_eager.pyx":281
* @staticmethod
* cdef inline weight_t move_cost(StateClass s, const GoldParseC* gold) nogil:
* cdef weight_t cost = 0 # <<<<<<<<<<<<<<
* cdef int i, j, S_i, B_i
* for i in range(s.stack_depth()):
*/
__pyx_v_cost = 0.0;
/* "spacy/syntax/arc_eager.pyx":283
* cdef weight_t cost = 0
* cdef int i, j, S_i, B_i
* for i in range(s.stack_depth()): # <<<<<<<<<<<<<<
* S_i = s.S(i)
* for j in range(s.buffer_length()):
*/
__pyx_t_1 = __pyx_f_5spacy_6syntax_10stateclass_10StateClass_stack_depth(__pyx_v_s);
__pyx_t_2 = __pyx_t_1;
for (__pyx_t_3 = 0; __pyx_t_3 < __pyx_t_2; __pyx_t_3+=1) {
__pyx_v_i = __pyx_t_3;
/* "spacy/syntax/arc_eager.pyx":284
* cdef int i, j, S_i, B_i
* for i in range(s.stack_depth()):
* S_i = s.S(i) # <<<<<<<<<<<<<<
* for j in range(s.buffer_length()):
* B_i = s.B(j)
*/
__pyx_v_S_i = __pyx_f_5spacy_6syntax_10stateclass_10StateClass_S(__pyx_v_s, __pyx_v_i);
/* "spacy/syntax/arc_eager.pyx":285
* for i in range(s.stack_depth()):
* S_i = s.S(i)
* for j in range(s.buffer_length()): # <<<<<<<<<<<<<<
* B_i = s.B(j)
* cost += gold.heads[S_i] == B_i
*/
__pyx_t_4 = __pyx_f_5spacy_6syntax_10stateclass_10StateClass_buffer_length(__pyx_v_s);
__pyx_t_5 = __pyx_t_4;
for (__pyx_t_6 = 0; __pyx_t_6 < __pyx_t_5; __pyx_t_6+=1) {
__pyx_v_j = __pyx_t_6;
/* "spacy/syntax/arc_eager.pyx":286
* S_i = s.S(i)
* for j in range(s.buffer_length()):
* B_i = s.B(j) # <<<<<<<<<<<<<<
* cost += gold.heads[S_i] == B_i
* cost += gold.heads[B_i] == S_i
*/
__pyx_v_B_i = __pyx_f_5spacy_6syntax_10stateclass_10StateClass_B(__pyx_v_s, __pyx_v_j);
/* "spacy/syntax/arc_eager.pyx":287
* for j in range(s.buffer_length()):
* B_i = s.B(j)
* cost += gold.heads[S_i] == B_i # <<<<<<<<<<<<<<
* cost += gold.heads[B_i] == S_i
* if cost != 0:
*/
__pyx_v_cost = (__pyx_v_cost + ((__pyx_v_gold->heads[__pyx_v_S_i]) == __pyx_v_B_i));
/* "spacy/syntax/arc_eager.pyx":288
* B_i = s.B(j)
* cost += gold.heads[S_i] == B_i
* cost += gold.heads[B_i] == S_i # <<<<<<<<<<<<<<
* if cost != 0:
* return cost
*/
__pyx_v_cost = (__pyx_v_cost + ((__pyx_v_gold->heads[__pyx_v_B_i]) == __pyx_v_S_i));
/* "spacy/syntax/arc_eager.pyx":289
* cost += gold.heads[S_i] == B_i
* cost += gold.heads[B_i] == S_i
* if cost != 0: # <<<<<<<<<<<<<<
* return cost
* # Check for sentence boundary --- if it's here, we can't have any deps
*/
__pyx_t_7 = ((__pyx_v_cost != 0.0) != 0);
if (__pyx_t_7) {
/* "spacy/syntax/arc_eager.pyx":290
* cost += gold.heads[B_i] == S_i
* if cost != 0:
* return cost # <<<<<<<<<<<<<<
* # Check for sentence boundary --- if it's here, we can't have any deps
* # between stack and buffer, so rest of action is irrelevant.
*/
__pyx_r = __pyx_v_cost;
goto __pyx_L0;
/* "spacy/syntax/arc_eager.pyx":289
* cost += gold.heads[S_i] == B_i
* cost += gold.heads[B_i] == S_i
* if cost != 0: # <<<<<<<<<<<<<<
* return cost
* # Check for sentence boundary --- if it's here, we can't have any deps
*/
}
}
}
/* "spacy/syntax/arc_eager.pyx":293
* # Check for sentence boundary --- if it's here, we can't have any deps
* # between stack and buffer, so rest of action is irrelevant.
* s0_root = _get_root(s.S(0), gold) # <<<<<<<<<<<<<<
* b0_root = _get_root(s.B(0), gold)
* if s0_root != b0_root or s0_root == -1 or b0_root == -1:
*/
__pyx_v_s0_root = __pyx_f_5spacy_6syntax_9arc_eager__get_root(__pyx_f_5spacy_6syntax_10stateclass_10StateClass_S(__pyx_v_s, 0), __pyx_v_gold);
/* "spacy/syntax/arc_eager.pyx":294
* # between stack and buffer, so rest of action is irrelevant.
* s0_root = _get_root(s.S(0), gold)
* b0_root = _get_root(s.B(0), gold) # <<<<<<<<<<<<<<
* if s0_root != b0_root or s0_root == -1 or b0_root == -1:
* return cost
*/
__pyx_v_b0_root = __pyx_f_5spacy_6syntax_9arc_eager__get_root(__pyx_f_5spacy_6syntax_10stateclass_10StateClass_B(__pyx_v_s, 0), __pyx_v_gold);
/* "spacy/syntax/arc_eager.pyx":295
* s0_root = _get_root(s.S(0), gold)
* b0_root = _get_root(s.B(0), gold)
* if s0_root != b0_root or s0_root == -1 or b0_root == -1: # <<<<<<<<<<<<<<
* return cost
* else:
*/
__pyx_t_8 = ((__pyx_v_s0_root != __pyx_v_b0_root) != 0);
if (!__pyx_t_8) {
} else {
__pyx_t_7 = __pyx_t_8;
goto __pyx_L9_bool_binop_done;
}
__pyx_t_8 = ((__pyx_v_s0_root == -1L) != 0);
if (!__pyx_t_8) {
} else {
__pyx_t_7 = __pyx_t_8;
goto __pyx_L9_bool_binop_done;
}
__pyx_t_8 = ((__pyx_v_b0_root == -1L) != 0);
__pyx_t_7 = __pyx_t_8;
__pyx_L9_bool_binop_done:;
if (__pyx_t_7) {
/* "spacy/syntax/arc_eager.pyx":296
* b0_root = _get_root(s.B(0), gold)
* if s0_root != b0_root or s0_root == -1 or b0_root == -1:
* return cost # <<<<<<<<<<<<<<
* else:
* return cost + 1
*/
__pyx_r = __pyx_v_cost;
goto __pyx_L0;
/* "spacy/syntax/arc_eager.pyx":295
* s0_root = _get_root(s.S(0), gold)
* b0_root = _get_root(s.B(0), gold)
* if s0_root != b0_root or s0_root == -1 or b0_root == -1: # <<<<<<<<<<<<<<
* return cost
* else:
*/
}
/* "spacy/syntax/arc_eager.pyx":298
* return cost
* else:
* return cost + 1 # <<<<<<<<<<<<<<
*
* @staticmethod
*/
/*else*/ {
__pyx_r = (__pyx_v_cost + 1.0);
goto __pyx_L0;
}
/* "spacy/syntax/arc_eager.pyx":280
*
* @staticmethod
* cdef inline weight_t move_cost(StateClass s, const GoldParseC* gold) nogil: # <<<<<<<<<<<<<<
* cdef weight_t cost = 0
* cdef int i, j, S_i, B_i
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_WriteUnraisable("spacy.syntax.arc_eager.Break.move_cost", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 1);
__pyx_r = 0;
__pyx_L0:;
__Pyx_TraceReturn(Py_None, 1);
return __pyx_r;
}
/* "spacy/syntax/arc_eager.pyx":301
*
* @staticmethod
* cdef inline weight_t label_cost(StateClass s, const GoldParseC* gold, attr_t label) nogil: # <<<<<<<<<<<<<<
* return 0
*
*/
static CYTHON_INLINE __pyx_t_5thinc_8typedefs_weight_t __pyx_f_5spacy_6syntax_9arc_eager_5Break_label_cost(CYTHON_UNUSED struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *__pyx_v_s, CYTHON_UNUSED struct __pyx_t_5spacy_4gold_GoldParseC const *__pyx_v_gold, CYTHON_UNUSED __pyx_t_5spacy_8typedefs_attr_t __pyx_v_label) {
__pyx_t_5thinc_8typedefs_weight_t __pyx_r;
__Pyx_TraceDeclarations
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_TraceCall("label_cost", __pyx_f[0], 301, 1, __PYX_ERR(0, 301, __pyx_L1_error));
/* "spacy/syntax/arc_eager.pyx":302
* @staticmethod
* cdef inline weight_t label_cost(StateClass s, const GoldParseC* gold, attr_t label) nogil:
* return 0 # <<<<<<<<<<<<<<
*
* cdef int _get_root(int word, const GoldParseC* gold) nogil:
*/
__pyx_r = 0.0;
goto __pyx_L0;
/* "spacy/syntax/arc_eager.pyx":301
*
* @staticmethod
* cdef inline weight_t label_cost(StateClass s, const GoldParseC* gold, attr_t label) nogil: # <<<<<<<<<<<<<<
* return 0
*
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_WriteUnraisable("spacy.syntax.arc_eager.Break.label_cost", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 1);
__pyx_r = 0;
__pyx_L0:;
__Pyx_TraceReturn(Py_None, 1);
return __pyx_r;
}
/* "(tree fragment)":1
* def __reduce_cython__(self): # <<<<<<<<<<<<<<
* cdef tuple state
* cdef object _dict
*/
/* Python wrapper */
static PyObject *__pyx_pw_5spacy_6syntax_9arc_eager_5Break_1__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
static PyObject *__pyx_pw_5spacy_6syntax_9arc_eager_5Break_1__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
PyObject *__pyx_r = 0;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0);
__pyx_r = __pyx_pf_5spacy_6syntax_9arc_eager_5Break___reduce_cython__(((struct __pyx_obj_5spacy_6syntax_9arc_eager_Break *)__pyx_v_self));
/* function exit code */
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
static PyObject *__pyx_pf_5spacy_6syntax_9arc_eager_5Break___reduce_cython__(struct __pyx_obj_5spacy_6syntax_9arc_eager_Break *__pyx_v_self) {
PyObject *__pyx_v_state = 0;
PyObject *__pyx_v__dict = 0;
int __pyx_v_use_setstate;
PyObject *__pyx_r = NULL;
__Pyx_TraceDeclarations
__Pyx_RefNannyDeclarations
PyObject *__pyx_t_1 = NULL;
int __pyx_t_2;
int __pyx_t_3;
PyObject *__pyx_t_4 = NULL;
PyObject *__pyx_t_5 = NULL;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("__reduce_cython__", 0);
__Pyx_TraceCall("__reduce_cython__", __pyx_f[1], 1, 0, __PYX_ERR(1, 1, __pyx_L1_error));
/* "(tree fragment)":5
* cdef object _dict
* cdef bint use_setstate
* state = () # <<<<<<<<<<<<<<
* _dict = getattr(self, '__dict__', None)
* if _dict is not None:
*/
__Pyx_INCREF(__pyx_empty_tuple);
__pyx_v_state = __pyx_empty_tuple;
/* "(tree fragment)":6
* cdef bint use_setstate
* state = ()
* _dict = getattr(self, '__dict__', None) # <<<<<<<<<<<<<<
* if _dict is not None:
* state += (_dict,)
*/
__pyx_t_1 = __Pyx_GetAttr3(((PyObject *)__pyx_v_self), __pyx_n_s_dict, Py_None); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 6, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_v__dict = __pyx_t_1;
__pyx_t_1 = 0;
/* "(tree fragment)":7
* state = ()
* _dict = getattr(self, '__dict__', None)
* if _dict is not None: # <<<<<<<<<<<<<<
* state += (_dict,)
* use_setstate = True
*/
__pyx_t_2 = (__pyx_v__dict != Py_None);
__pyx_t_3 = (__pyx_t_2 != 0);
if (__pyx_t_3) {
/* "(tree fragment)":8
* _dict = getattr(self, '__dict__', None)
* if _dict is not None:
* state += (_dict,) # <<<<<<<<<<<<<<
* use_setstate = True
* else:
*/
__pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 8, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_INCREF(__pyx_v__dict);
__Pyx_GIVEREF(__pyx_v__dict);
PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v__dict);
__pyx_t_4 = PyNumber_InPlaceAdd(__pyx_v_state, __pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 8, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__Pyx_DECREF_SET(__pyx_v_state, ((PyObject*)__pyx_t_4));
__pyx_t_4 = 0;
/* "(tree fragment)":9
* if _dict is not None:
* state += (_dict,)
* use_setstate = True # <<<<<<<<<<<<<<
* else:
* use_setstate = False
*/
__pyx_v_use_setstate = 1;
/* "(tree fragment)":7
* state = ()
* _dict = getattr(self, '__dict__', None)
* if _dict is not None: # <<<<<<<<<<<<<<
* state += (_dict,)
* use_setstate = True
*/
goto __pyx_L3;
}
/* "(tree fragment)":11
* use_setstate = True
* else:
* use_setstate = False # <<<<<<<<<<<<<<
* if use_setstate:
* return __pyx_unpickle_Break, (type(self), 0xd41d8cd, None), state
*/
/*else*/ {
__pyx_v_use_setstate = 0;
}
__pyx_L3:;
/* "(tree fragment)":12
* else:
* use_setstate = False
* if use_setstate: # <<<<<<<<<<<<<<
* return __pyx_unpickle_Break, (type(self), 0xd41d8cd, None), state
* else:
*/
__pyx_t_3 = (__pyx_v_use_setstate != 0);
if (__pyx_t_3) {
/* "(tree fragment)":13
* use_setstate = False
* if use_setstate:
* return __pyx_unpickle_Break, (type(self), 0xd41d8cd, None), state # <<<<<<<<<<<<<<
* else:
* return __pyx_unpickle_Break, (type(self), 0xd41d8cd, state)
*/
__Pyx_XDECREF(__pyx_r);
__Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_pyx_unpickle_Break); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 13, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 13, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))));
__Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))));
PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))));
__Pyx_INCREF(__pyx_int_222419149);
__Pyx_GIVEREF(__pyx_int_222419149);
PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_int_222419149);
__Pyx_INCREF(Py_None);
__Pyx_GIVEREF(Py_None);
PyTuple_SET_ITEM(__pyx_t_1, 2, Py_None);
__pyx_t_5 = PyTuple_New(3); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 13, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_GIVEREF(__pyx_t_4);
PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_4);
__Pyx_GIVEREF(__pyx_t_1);
PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_1);
__Pyx_INCREF(__pyx_v_state);
__Pyx_GIVEREF(__pyx_v_state);
PyTuple_SET_ITEM(__pyx_t_5, 2, __pyx_v_state);
__pyx_t_4 = 0;
__pyx_t_1 = 0;
__pyx_r = __pyx_t_5;
__pyx_t_5 = 0;
goto __pyx_L0;
/* "(tree fragment)":12
* else:
* use_setstate = False
* if use_setstate: # <<<<<<<<<<<<<<
* return __pyx_unpickle_Break, (type(self), 0xd41d8cd, None), state
* else:
*/
}
/* "(tree fragment)":15
* return __pyx_unpickle_Break, (type(self), 0xd41d8cd, None), state
* else:
* return __pyx_unpickle_Break, (type(self), 0xd41d8cd, state) # <<<<<<<<<<<<<<
* def __setstate_cython__(self, __pyx_state):
* __pyx_unpickle_Break__set_state(self, __pyx_state)
*/
/*else*/ {
__Pyx_XDECREF(__pyx_r);
__Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_pyx_unpickle_Break); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 15, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 15, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))));
__Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))));
PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))));
__Pyx_INCREF(__pyx_int_222419149);
__Pyx_GIVEREF(__pyx_int_222419149);
PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_int_222419149);
__Pyx_INCREF(__pyx_v_state);
__Pyx_GIVEREF(__pyx_v_state);
PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_v_state);
__pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 15, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_GIVEREF(__pyx_t_5);
PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_5);
__Pyx_GIVEREF(__pyx_t_1);
PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_1);
__pyx_t_5 = 0;
__pyx_t_1 = 0;
__pyx_r = __pyx_t_4;
__pyx_t_4 = 0;
goto __pyx_L0;
}
/* "(tree fragment)":1
* def __reduce_cython__(self): # <<<<<<<<<<<<<<
* cdef tuple state
* cdef object _dict
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_1);
__Pyx_XDECREF(__pyx_t_4);
__Pyx_XDECREF(__pyx_t_5);
__Pyx_AddTraceback("spacy.syntax.arc_eager.Break.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = NULL;
__pyx_L0:;
__Pyx_XDECREF(__pyx_v_state);
__Pyx_XDECREF(__pyx_v__dict);
__Pyx_XGIVEREF(__pyx_r);
__Pyx_TraceReturn(__pyx_r, 0);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "(tree fragment)":16
* else:
* return __pyx_unpickle_Break, (type(self), 0xd41d8cd, state)
* def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<<
* __pyx_unpickle_Break__set_state(self, __pyx_state)
*/
/* Python wrapper */
static PyObject *__pyx_pw_5spacy_6syntax_9arc_eager_5Break_3__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state); /*proto*/
static PyObject *__pyx_pw_5spacy_6syntax_9arc_eager_5Break_3__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state) {
PyObject *__pyx_r = 0;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0);
__pyx_r = __pyx_pf_5spacy_6syntax_9arc_eager_5Break_2__setstate_cython__(((struct __pyx_obj_5spacy_6syntax_9arc_eager_Break *)__pyx_v_self), ((PyObject *)__pyx_v___pyx_state));
/* function exit code */
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
static PyObject *__pyx_pf_5spacy_6syntax_9arc_eager_5Break_2__setstate_cython__(struct __pyx_obj_5spacy_6syntax_9arc_eager_Break *__pyx_v_self, PyObject *__pyx_v___pyx_state) {
PyObject *__pyx_r = NULL;
__Pyx_TraceDeclarations
__Pyx_RefNannyDeclarations
PyObject *__pyx_t_1 = NULL;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("__setstate_cython__", 0);
__Pyx_TraceCall("__setstate_cython__", __pyx_f[1], 16, 0, __PYX_ERR(1, 16, __pyx_L1_error));
/* "(tree fragment)":17
* return __pyx_unpickle_Break, (type(self), 0xd41d8cd, state)
* def __setstate_cython__(self, __pyx_state):
* __pyx_unpickle_Break__set_state(self, __pyx_state) # <<<<<<<<<<<<<<
*/
if (!(likely(PyTuple_CheckExact(__pyx_v___pyx_state))||((__pyx_v___pyx_state) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "tuple", Py_TYPE(__pyx_v___pyx_state)->tp_name), 0))) __PYX_ERR(1, 17, __pyx_L1_error)
__pyx_t_1 = __pyx_f_5spacy_6syntax_9arc_eager___pyx_unpickle_Break__set_state(__pyx_v_self, ((PyObject*)__pyx_v___pyx_state)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 17, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
/* "(tree fragment)":16
* else:
* return __pyx_unpickle_Break, (type(self), 0xd41d8cd, state)
* def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<<
* __pyx_unpickle_Break__set_state(self, __pyx_state)
*/
/* function exit code */
__pyx_r = Py_None; __Pyx_INCREF(Py_None);
goto __pyx_L0;
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_1);
__Pyx_AddTraceback("spacy.syntax.arc_eager.Break.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = NULL;
__pyx_L0:;
__Pyx_XGIVEREF(__pyx_r);
__Pyx_TraceReturn(__pyx_r, 0);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "spacy/syntax/arc_eager.pyx":304
* return 0
*
* cdef int _get_root(int word, const GoldParseC* gold) nogil: # <<<<<<<<<<<<<<
* while gold.heads[word] != word and gold.has_dep[word] and word >= 0:
* word = gold.heads[word]
*/
static int __pyx_f_5spacy_6syntax_9arc_eager__get_root(int __pyx_v_word, struct __pyx_t_5spacy_4gold_GoldParseC const *__pyx_v_gold) {
int __pyx_r;
__Pyx_TraceDeclarations
int __pyx_t_1;
int __pyx_t_2;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_TraceCall("_get_root", __pyx_f[0], 304, 1, __PYX_ERR(0, 304, __pyx_L1_error));
/* "spacy/syntax/arc_eager.pyx":305
*
* cdef int _get_root(int word, const GoldParseC* gold) nogil:
* while gold.heads[word] != word and gold.has_dep[word] and word >= 0: # <<<<<<<<<<<<<<
* word = gold.heads[word]
* if not gold.has_dep[word]:
*/
while (1) {
__pyx_t_2 = (((__pyx_v_gold->heads[__pyx_v_word]) != __pyx_v_word) != 0);
if (__pyx_t_2) {
} else {
__pyx_t_1 = __pyx_t_2;
goto __pyx_L5_bool_binop_done;
}
__pyx_t_2 = ((__pyx_v_gold->has_dep[__pyx_v_word]) != 0);
if (__pyx_t_2) {
} else {
__pyx_t_1 = __pyx_t_2;
goto __pyx_L5_bool_binop_done;
}
__pyx_t_2 = ((__pyx_v_word >= 0) != 0);
__pyx_t_1 = __pyx_t_2;
__pyx_L5_bool_binop_done:;
if (!__pyx_t_1) break;
/* "spacy/syntax/arc_eager.pyx":306
* cdef int _get_root(int word, const GoldParseC* gold) nogil:
* while gold.heads[word] != word and gold.has_dep[word] and word >= 0:
* word = gold.heads[word] # <<<<<<<<<<<<<<
* if not gold.has_dep[word]:
* return -1
*/
__pyx_v_word = (__pyx_v_gold->heads[__pyx_v_word]);
}
/* "spacy/syntax/arc_eager.pyx":307
* while gold.heads[word] != word and gold.has_dep[word] and word >= 0:
* word = gold.heads[word]
* if not gold.has_dep[word]: # <<<<<<<<<<<<<<
* return -1
* else:
*/
__pyx_t_1 = ((!((__pyx_v_gold->has_dep[__pyx_v_word]) != 0)) != 0);
if (__pyx_t_1) {
/* "spacy/syntax/arc_eager.pyx":308
* word = gold.heads[word]
* if not gold.has_dep[word]:
* return -1 # <<<<<<<<<<<<<<
* else:
* return word
*/
__pyx_r = -1;
goto __pyx_L0;
/* "spacy/syntax/arc_eager.pyx":307
* while gold.heads[word] != word and gold.has_dep[word] and word >= 0:
* word = gold.heads[word]
* if not gold.has_dep[word]: # <<<<<<<<<<<<<<
* return -1
* else:
*/
}
/* "spacy/syntax/arc_eager.pyx":310
* return -1
* else:
* return word # <<<<<<<<<<<<<<
*
*
*/
/*else*/ {
__pyx_r = __pyx_v_word;
goto __pyx_L0;
}
/* "spacy/syntax/arc_eager.pyx":304
* return 0
*
* cdef int _get_root(int word, const GoldParseC* gold) nogil: # <<<<<<<<<<<<<<
* while gold.heads[word] != word and gold.has_dep[word] and word >= 0:
* word = gold.heads[word]
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_WriteUnraisable("spacy.syntax.arc_eager._get_root", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 1);
__pyx_r = 0;
__pyx_L0:;
__Pyx_TraceReturn(Py_None, 1);
return __pyx_r;
}
/* "spacy/syntax/arc_eager.pyx":313
*
*
* cdef void* _init_state(Pool mem, int length, void* tokens) except NULL: # <<<<<<<<<<<<<<
* st = new StateC(<const TokenC*>tokens, length)
* for i in range(st.length):
*/
static void *__pyx_f_5spacy_6syntax_9arc_eager__init_state(CYTHON_UNUSED struct __pyx_obj_5cymem_5cymem_Pool *__pyx_v_mem, int __pyx_v_length, void *__pyx_v_tokens) {
__pyx_t_5spacy_6syntax_6_state_StateC *__pyx_v_st;
int __pyx_v_i;
void *__pyx_r;
__Pyx_TraceDeclarations
__Pyx_RefNannyDeclarations
int __pyx_t_1;
int __pyx_t_2;
int __pyx_t_3;
int __pyx_t_4;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("_init_state", 0);
__Pyx_TraceCall("_init_state", __pyx_f[0], 313, 0, __PYX_ERR(0, 313, __pyx_L1_error));
/* "spacy/syntax/arc_eager.pyx":314
*
* cdef void* _init_state(Pool mem, int length, void* tokens) except NULL:
* st = new StateC(<const TokenC*>tokens, length) # <<<<<<<<<<<<<<
* for i in range(st.length):
* if st._sent[i].dep == 0:
*/
__pyx_v_st = new __pyx_t_5spacy_6syntax_6_state_StateC(((struct __pyx_t_5spacy_7structs_TokenC const *)__pyx_v_tokens), __pyx_v_length);
/* "spacy/syntax/arc_eager.pyx":315
* cdef void* _init_state(Pool mem, int length, void* tokens) except NULL:
* st = new StateC(<const TokenC*>tokens, length)
* for i in range(st.length): # <<<<<<<<<<<<<<
* if st._sent[i].dep == 0:
* st._sent[i].l_edge = i
*/
__pyx_t_1 = __pyx_v_st->length;
__pyx_t_2 = __pyx_t_1;
for (__pyx_t_3 = 0; __pyx_t_3 < __pyx_t_2; __pyx_t_3+=1) {
__pyx_v_i = __pyx_t_3;
/* "spacy/syntax/arc_eager.pyx":316
* st = new StateC(<const TokenC*>tokens, length)
* for i in range(st.length):
* if st._sent[i].dep == 0: # <<<<<<<<<<<<<<
* st._sent[i].l_edge = i
* st._sent[i].r_edge = i
*/
__pyx_t_4 = (((__pyx_v_st->_sent[__pyx_v_i]).dep == 0) != 0);
if (__pyx_t_4) {
/* "spacy/syntax/arc_eager.pyx":317
* for i in range(st.length):
* if st._sent[i].dep == 0:
* st._sent[i].l_edge = i # <<<<<<<<<<<<<<
* st._sent[i].r_edge = i
* st._sent[i].head = 0
*/
(__pyx_v_st->_sent[__pyx_v_i]).l_edge = __pyx_v_i;
/* "spacy/syntax/arc_eager.pyx":318
* if st._sent[i].dep == 0:
* st._sent[i].l_edge = i
* st._sent[i].r_edge = i # <<<<<<<<<<<<<<
* st._sent[i].head = 0
* st._sent[i].dep = 0
*/
(__pyx_v_st->_sent[__pyx_v_i]).r_edge = __pyx_v_i;
/* "spacy/syntax/arc_eager.pyx":319
* st._sent[i].l_edge = i
* st._sent[i].r_edge = i
* st._sent[i].head = 0 # <<<<<<<<<<<<<<
* st._sent[i].dep = 0
* st._sent[i].l_kids = 0
*/
(__pyx_v_st->_sent[__pyx_v_i]).head = 0;
/* "spacy/syntax/arc_eager.pyx":320
* st._sent[i].r_edge = i
* st._sent[i].head = 0
* st._sent[i].dep = 0 # <<<<<<<<<<<<<<
* st._sent[i].l_kids = 0
* st._sent[i].r_kids = 0
*/
(__pyx_v_st->_sent[__pyx_v_i]).dep = 0;
/* "spacy/syntax/arc_eager.pyx":321
* st._sent[i].head = 0
* st._sent[i].dep = 0
* st._sent[i].l_kids = 0 # <<<<<<<<<<<<<<
* st._sent[i].r_kids = 0
* st.fast_forward()
*/
(__pyx_v_st->_sent[__pyx_v_i]).l_kids = 0;
/* "spacy/syntax/arc_eager.pyx":322
* st._sent[i].dep = 0
* st._sent[i].l_kids = 0
* st._sent[i].r_kids = 0 # <<<<<<<<<<<<<<
* st.fast_forward()
* return <void*>st
*/
(__pyx_v_st->_sent[__pyx_v_i]).r_kids = 0;
/* "spacy/syntax/arc_eager.pyx":316
* st = new StateC(<const TokenC*>tokens, length)
* for i in range(st.length):
* if st._sent[i].dep == 0: # <<<<<<<<<<<<<<
* st._sent[i].l_edge = i
* st._sent[i].r_edge = i
*/
}
}
/* "spacy/syntax/arc_eager.pyx":323
* st._sent[i].l_kids = 0
* st._sent[i].r_kids = 0
* st.fast_forward() # <<<<<<<<<<<<<<
* return <void*>st
*
*/
__pyx_v_st->fast_forward();
/* "spacy/syntax/arc_eager.pyx":324
* st._sent[i].r_kids = 0
* st.fast_forward()
* return <void*>st # <<<<<<<<<<<<<<
*
*
*/
__pyx_r = ((void *)__pyx_v_st);
goto __pyx_L0;
/* "spacy/syntax/arc_eager.pyx":313
*
*
* cdef void* _init_state(Pool mem, int length, void* tokens) except NULL: # <<<<<<<<<<<<<<
* st = new StateC(<const TokenC*>tokens, length)
* for i in range(st.length):
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_AddTraceback("spacy.syntax.arc_eager._init_state", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = NULL;
__pyx_L0:;
__Pyx_TraceReturn(Py_None, 0);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "spacy/syntax/arc_eager.pyx":327
*
*
* cdef int _del_state(Pool mem, void* state, void* x) except -1: # <<<<<<<<<<<<<<
* cdef StateC* st = <StateC*>state
* del st
*/
static int __pyx_f_5spacy_6syntax_9arc_eager__del_state(CYTHON_UNUSED struct __pyx_obj_5cymem_5cymem_Pool *__pyx_v_mem, void *__pyx_v_state, CYTHON_UNUSED void *__pyx_v_x) {
__pyx_t_5spacy_6syntax_6_state_StateC *__pyx_v_st;
int __pyx_r;
__Pyx_TraceDeclarations
__Pyx_RefNannyDeclarations
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("_del_state", 0);
__Pyx_TraceCall("_del_state", __pyx_f[0], 327, 0, __PYX_ERR(0, 327, __pyx_L1_error));
/* "spacy/syntax/arc_eager.pyx":328
*
* cdef int _del_state(Pool mem, void* state, void* x) except -1:
* cdef StateC* st = <StateC*>state # <<<<<<<<<<<<<<
* del st
*
*/
__pyx_v_st = ((__pyx_t_5spacy_6syntax_6_state_StateC *)__pyx_v_state);
/* "spacy/syntax/arc_eager.pyx":329
* cdef int _del_state(Pool mem, void* state, void* x) except -1:
* cdef StateC* st = <StateC*>state
* del st # <<<<<<<<<<<<<<
*
*
*/
delete __pyx_v_st;
/* "spacy/syntax/arc_eager.pyx":327
*
*
* cdef int _del_state(Pool mem, void* state, void* x) except -1: # <<<<<<<<<<<<<<
* cdef StateC* st = <StateC*>state
* del st
*/
/* function exit code */
__pyx_r = 0;
goto __pyx_L0;
__pyx_L1_error:;
__Pyx_AddTraceback("spacy.syntax.arc_eager._del_state", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = -1;
__pyx_L0:;
__Pyx_TraceReturn(Py_None, 0);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "spacy/syntax/arc_eager.pyx":333
*
* cdef class ArcEager(TransitionSystem):
* def __init__(self, *args, **kwargs): # <<<<<<<<<<<<<<
* TransitionSystem.__init__(self, *args, **kwargs)
* self.init_beam_state = _init_state
*/
/* Python wrapper */
static int __pyx_pw_5spacy_6syntax_9arc_eager_8ArcEager_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static int __pyx_pw_5spacy_6syntax_9arc_eager_8ArcEager_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
PyObject *__pyx_v_args = 0;
PyObject *__pyx_v_kwargs = 0;
int __pyx_r;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("__init__ (wrapper)", 0);
if (unlikely(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__init__", 1))) return -1;
if (unlikely(__pyx_kwds)) {
__pyx_v_kwargs = PyDict_Copy(__pyx_kwds); if (unlikely(!__pyx_v_kwargs)) return -1;
__Pyx_GOTREF(__pyx_v_kwargs);
} else {
__pyx_v_kwargs = NULL;
}
__Pyx_INCREF(__pyx_args);
__pyx_v_args = __pyx_args;
__pyx_r = __pyx_pf_5spacy_6syntax_9arc_eager_8ArcEager___init__(((struct __pyx_obj_5spacy_6syntax_9arc_eager_ArcEager *)__pyx_v_self), __pyx_v_args, __pyx_v_kwargs);
/* function exit code */
__Pyx_XDECREF(__pyx_v_args);
__Pyx_XDECREF(__pyx_v_kwargs);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
static int __pyx_pf_5spacy_6syntax_9arc_eager_8ArcEager___init__(struct __pyx_obj_5spacy_6syntax_9arc_eager_ArcEager *__pyx_v_self, PyObject *__pyx_v_args, PyObject *__pyx_v_kwargs) {
int __pyx_r;
__Pyx_TraceDeclarations
__Pyx_RefNannyDeclarations
PyObject *__pyx_t_1 = NULL;
PyObject *__pyx_t_2 = NULL;
PyObject *__pyx_t_3 = NULL;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("__init__", 0);
__Pyx_TraceCall("__init__", __pyx_f[0], 333, 0, __PYX_ERR(0, 333, __pyx_L1_error));
/* "spacy/syntax/arc_eager.pyx":334
* cdef class ArcEager(TransitionSystem):
* def __init__(self, *args, **kwargs):
* TransitionSystem.__init__(self, *args, **kwargs) # <<<<<<<<<<<<<<
* self.init_beam_state = _init_state
* self.del_beam_state = _del_state
*/
__pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_ptype_5spacy_6syntax_17transition_system_TransitionSystem), __pyx_n_s_init); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 334, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 334, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_INCREF(((PyObject *)__pyx_v_self));
__Pyx_GIVEREF(((PyObject *)__pyx_v_self));
PyTuple_SET_ITEM(__pyx_t_2, 0, ((PyObject *)__pyx_v_self));
__pyx_t_3 = PyNumber_Add(__pyx_t_2, __pyx_v_args); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 334, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_3, __pyx_v_kwargs); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 334, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
/* "spacy/syntax/arc_eager.pyx":335
* def __init__(self, *args, **kwargs):
* TransitionSystem.__init__(self, *args, **kwargs)
* self.init_beam_state = _init_state # <<<<<<<<<<<<<<
* self.del_beam_state = _del_state
*
*/
__pyx_v_self->__pyx_base.init_beam_state = __pyx_f_5spacy_6syntax_9arc_eager__init_state;
/* "spacy/syntax/arc_eager.pyx":336
* TransitionSystem.__init__(self, *args, **kwargs)
* self.init_beam_state = _init_state
* self.del_beam_state = _del_state # <<<<<<<<<<<<<<
*
* @classmethod
*/
__pyx_v_self->__pyx_base.del_beam_state = __pyx_f_5spacy_6syntax_9arc_eager__del_state;
/* "spacy/syntax/arc_eager.pyx":333
*
* cdef class ArcEager(TransitionSystem):
* def __init__(self, *args, **kwargs): # <<<<<<<<<<<<<<
* TransitionSystem.__init__(self, *args, **kwargs)
* self.init_beam_state = _init_state
*/
/* function exit code */
__pyx_r = 0;
goto __pyx_L0;
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_1);
__Pyx_XDECREF(__pyx_t_2);
__Pyx_XDECREF(__pyx_t_3);
__Pyx_AddTraceback("spacy.syntax.arc_eager.ArcEager.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = -1;
__pyx_L0:;
__Pyx_TraceReturn(Py_None, 0);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "spacy/syntax/arc_eager.pyx":339
*
* @classmethod
* def get_actions(cls, **kwargs): # <<<<<<<<<<<<<<
* min_freq = kwargs.get('min_freq', None)
* actions = defaultdict(lambda: Counter())
*/
/* Python wrapper */
static PyObject *__pyx_pw_5spacy_6syntax_9arc_eager_8ArcEager_3get_actions(PyObject *__pyx_v_cls, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static PyObject *__pyx_pw_5spacy_6syntax_9arc_eager_8ArcEager_3get_actions(PyObject *__pyx_v_cls, PyObject *__pyx_args, PyObject *__pyx_kwds) {
PyObject *__pyx_v_kwargs = 0;
PyObject *__pyx_r = 0;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("get_actions (wrapper)", 0);
if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
__Pyx_RaiseArgtupleInvalid("get_actions", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
if (__pyx_kwds && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "get_actions", 1))) return NULL;
__pyx_v_kwargs = (__pyx_kwds) ? PyDict_Copy(__pyx_kwds) : PyDict_New(); if (unlikely(!__pyx_v_kwargs)) return NULL;
__Pyx_GOTREF(__pyx_v_kwargs);
__pyx_r = __pyx_pf_5spacy_6syntax_9arc_eager_8ArcEager_2get_actions(((PyTypeObject*)__pyx_v_cls), __pyx_v_kwargs);
/* function exit code */
__Pyx_XDECREF(__pyx_v_kwargs);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "spacy/syntax/arc_eager.pyx":341
* def get_actions(cls, **kwargs):
* min_freq = kwargs.get('min_freq', None)
* actions = defaultdict(lambda: Counter()) # <<<<<<<<<<<<<<
* actions[SHIFT][''] = 1
* actions[REDUCE][''] = 1
*/
/* Python wrapper */
static PyObject *__pyx_pw_5spacy_6syntax_9arc_eager_8ArcEager_11get_actions_lambda(PyObject *__pyx_self, CYTHON_UNUSED PyObject *unused); /*proto*/
static PyMethodDef __pyx_mdef_5spacy_6syntax_9arc_eager_8ArcEager_11get_actions_lambda = {"lambda", (PyCFunction)__pyx_pw_5spacy_6syntax_9arc_eager_8ArcEager_11get_actions_lambda, METH_NOARGS, 0};
static PyObject *__pyx_pw_5spacy_6syntax_9arc_eager_8ArcEager_11get_actions_lambda(PyObject *__pyx_self, CYTHON_UNUSED PyObject *unused) {
PyObject *__pyx_r = 0;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("lambda (wrapper)", 0);
__pyx_r = __pyx_lambda_funcdef_lambda(__pyx_self);
/* function exit code */
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
static PyObject *__pyx_lambda_funcdef_lambda(CYTHON_UNUSED PyObject *__pyx_self) {
PyObject *__pyx_r = NULL;
__Pyx_TraceDeclarations
__Pyx_RefNannyDeclarations
PyObject *__pyx_t_1 = NULL;
PyObject *__pyx_t_2 = NULL;
PyObject *__pyx_t_3 = NULL;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("lambda", 0);
__Pyx_TraceCall("lambda", __pyx_f[0], 341, 0, __PYX_ERR(0, 341, __pyx_L1_error));
__Pyx_XDECREF(__pyx_r);
__Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_Counter); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 341, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__pyx_t_3 = NULL;
if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) {
__pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
if (likely(__pyx_t_3)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
__Pyx_INCREF(__pyx_t_3);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_2, function);
}
}
__pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3) : __Pyx_PyObject_CallNoArg(__pyx_t_2);
__Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 341, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__pyx_r = __pyx_t_1;
__pyx_t_1 = 0;
goto __pyx_L0;
/* function exit code */
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_1);
__Pyx_XDECREF(__pyx_t_2);
__Pyx_XDECREF(__pyx_t_3);
__Pyx_AddTraceback("spacy.syntax.arc_eager.ArcEager.get_actions.lambda", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = NULL;
__pyx_L0:;
__Pyx_XGIVEREF(__pyx_r);
__Pyx_TraceReturn(__pyx_r, 0);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "spacy/syntax/arc_eager.pyx":339
*
* @classmethod
* def get_actions(cls, **kwargs): # <<<<<<<<<<<<<<
* min_freq = kwargs.get('min_freq', None)
* actions = defaultdict(lambda: Counter())
*/
static PyObject *__pyx_pf_5spacy_6syntax_9arc_eager_8ArcEager_2get_actions(CYTHON_UNUSED PyTypeObject *__pyx_v_cls, PyObject *__pyx_v_kwargs) {
PyObject *__pyx_v_min_freq = NULL;
PyObject *__pyx_v_actions = NULL;
PyObject *__pyx_v_label = NULL;
CYTHON_UNUSED PyObject *__pyx_v_raw_text = NULL;
PyObject *__pyx_v_sents = NULL;
PyObject *__pyx_v_ids = NULL;
CYTHON_UNUSED PyObject *__pyx_v_words = NULL;
CYTHON_UNUSED PyObject *__pyx_v_tags = NULL;
PyObject *__pyx_v_heads = NULL;
PyObject *__pyx_v_labels = NULL;
CYTHON_UNUSED PyObject *__pyx_v_iob = NULL;
CYTHON_UNUSED PyObject *__pyx_v_ctnts = NULL;
PyObject *__pyx_v_child = NULL;
PyObject *__pyx_v_head = NULL;
CYTHON_UNUSED PyObject *__pyx_v_action = NULL;
PyObject *__pyx_v_label_freqs = NULL;
PyObject *__pyx_v_freq = NULL;
PyObject *__pyx_r = NULL;
__Pyx_TraceDeclarations
__Pyx_RefNannyDeclarations
PyObject *__pyx_t_1 = NULL;
PyObject *__pyx_t_2 = NULL;
PyObject *__pyx_t_3 = NULL;
PyObject *__pyx_t_4 = NULL;
Py_ssize_t __pyx_t_5;
PyObject *(*__pyx_t_6)(PyObject *);
PyObject *__pyx_t_7 = NULL;
PyObject *(*__pyx_t_8)(PyObject *);
Py_ssize_t __pyx_t_9;
PyObject *(*__pyx_t_10)(PyObject *);
PyObject *__pyx_t_11 = NULL;
PyObject *__pyx_t_12 = NULL;
PyObject *__pyx_t_13 = NULL;
PyObject *__pyx_t_14 = NULL;
PyObject *__pyx_t_15 = NULL;
PyObject *__pyx_t_16 = NULL;
PyObject *__pyx_t_17 = NULL;
int __pyx_t_18;
Py_ssize_t __pyx_t_19;
PyObject *(*__pyx_t_20)(PyObject *);
int __pyx_t_21;
PyObject *__pyx_t_22 = NULL;
int __pyx_t_23;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("get_actions", 0);
__Pyx_TraceCall("get_actions", __pyx_f[0], 339, 0, __PYX_ERR(0, 339, __pyx_L1_error));
/* "spacy/syntax/arc_eager.pyx":340
* @classmethod
* def get_actions(cls, **kwargs):
* min_freq = kwargs.get('min_freq', None) # <<<<<<<<<<<<<<
* actions = defaultdict(lambda: Counter())
* actions[SHIFT][''] = 1
*/
__pyx_t_1 = __Pyx_PyDict_GetItemDefault(__pyx_v_kwargs, __pyx_n_u_min_freq, Py_None); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 340, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_v_min_freq = __pyx_t_1;
__pyx_t_1 = 0;
/* "spacy/syntax/arc_eager.pyx":341
* def get_actions(cls, **kwargs):
* min_freq = kwargs.get('min_freq', None)
* actions = defaultdict(lambda: Counter()) # <<<<<<<<<<<<<<
* actions[SHIFT][''] = 1
* actions[REDUCE][''] = 1
*/
__Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_defaultdict); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 341, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5spacy_6syntax_9arc_eager_8ArcEager_11get_actions_lambda, 0, __pyx_n_s_get_actions_locals_lambda, NULL, __pyx_n_s_spacy_syntax_arc_eager, __pyx_d, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 341, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__pyx_t_4 = NULL;
if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) {
__pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2);
if (likely(__pyx_t_4)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
__Pyx_INCREF(__pyx_t_4);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_2, function);
}
}
__pyx_t_1 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_4, __pyx_t_3) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3);
__Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 341, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__pyx_v_actions = __pyx_t_1;
__pyx_t_1 = 0;
/* "spacy/syntax/arc_eager.pyx":342
* min_freq = kwargs.get('min_freq', None)
* actions = defaultdict(lambda: Counter())
* actions[SHIFT][''] = 1 # <<<<<<<<<<<<<<
* actions[REDUCE][''] = 1
* for label in kwargs.get('left_labels', []):
*/
__pyx_t_1 = __Pyx_GetItemInt(__pyx_v_actions, __pyx_e_5spacy_6syntax_9arc_eager_SHIFT, int, 1, __Pyx_PyInt_From_int, 0, 1, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 342, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
if (unlikely(PyObject_SetItem(__pyx_t_1, __pyx_kp_u_, __pyx_int_1) < 0)) __PYX_ERR(0, 342, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
/* "spacy/syntax/arc_eager.pyx":343
* actions = defaultdict(lambda: Counter())
* actions[SHIFT][''] = 1
* actions[REDUCE][''] = 1 # <<<<<<<<<<<<<<
* for label in kwargs.get('left_labels', []):
* actions[LEFT][label] = 1
*/
__pyx_t_1 = __Pyx_GetItemInt(__pyx_v_actions, __pyx_e_5spacy_6syntax_9arc_eager_REDUCE, int, 1, __Pyx_PyInt_From_int, 0, 1, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 343, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
if (unlikely(PyObject_SetItem(__pyx_t_1, __pyx_kp_u_, __pyx_int_1) < 0)) __PYX_ERR(0, 343, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
/* "spacy/syntax/arc_eager.pyx":344
* actions[SHIFT][''] = 1
* actions[REDUCE][''] = 1
* for label in kwargs.get('left_labels', []): # <<<<<<<<<<<<<<
* actions[LEFT][label] = 1
* actions[SHIFT][label] = 1
*/
__pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 344, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_t_2 = __Pyx_PyDict_GetItemDefault(__pyx_v_kwargs, __pyx_n_u_left_labels, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 344, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
if (likely(PyList_CheckExact(__pyx_t_2)) || PyTuple_CheckExact(__pyx_t_2)) {
__pyx_t_1 = __pyx_t_2; __Pyx_INCREF(__pyx_t_1); __pyx_t_5 = 0;
__pyx_t_6 = NULL;
} else {
__pyx_t_5 = -1; __pyx_t_1 = PyObject_GetIter(__pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 344, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_t_6 = Py_TYPE(__pyx_t_1)->tp_iternext; if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 344, __pyx_L1_error)
}
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
for (;;) {
if (likely(!__pyx_t_6)) {
if (likely(PyList_CheckExact(__pyx_t_1))) {
if (__pyx_t_5 >= PyList_GET_SIZE(__pyx_t_1)) break;
#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
__pyx_t_2 = PyList_GET_ITEM(__pyx_t_1, __pyx_t_5); __Pyx_INCREF(__pyx_t_2); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(0, 344, __pyx_L1_error)
#else
__pyx_t_2 = PySequence_ITEM(__pyx_t_1, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 344, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
#endif
} else {
if (__pyx_t_5 >= PyTuple_GET_SIZE(__pyx_t_1)) break;
#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
__pyx_t_2 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_5); __Pyx_INCREF(__pyx_t_2); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(0, 344, __pyx_L1_error)
#else
__pyx_t_2 = PySequence_ITEM(__pyx_t_1, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 344, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
#endif
}
} else {
__pyx_t_2 = __pyx_t_6(__pyx_t_1);
if (unlikely(!__pyx_t_2)) {
PyObject* exc_type = PyErr_Occurred();
if (exc_type) {
if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
else __PYX_ERR(0, 344, __pyx_L1_error)
}
break;
}
__Pyx_GOTREF(__pyx_t_2);
}
__Pyx_XDECREF_SET(__pyx_v_label, __pyx_t_2);
__pyx_t_2 = 0;
/* "spacy/syntax/arc_eager.pyx":345
* actions[REDUCE][''] = 1
* for label in kwargs.get('left_labels', []):
* actions[LEFT][label] = 1 # <<<<<<<<<<<<<<
* actions[SHIFT][label] = 1
* for label in kwargs.get('right_labels', []):
*/
__pyx_t_2 = __Pyx_GetItemInt(__pyx_v_actions, __pyx_e_5spacy_6syntax_9arc_eager_LEFT, int, 1, __Pyx_PyInt_From_int, 0, 1, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 345, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
if (unlikely(PyObject_SetItem(__pyx_t_2, __pyx_v_label, __pyx_int_1) < 0)) __PYX_ERR(0, 345, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
/* "spacy/syntax/arc_eager.pyx":346
* for label in kwargs.get('left_labels', []):
* actions[LEFT][label] = 1
* actions[SHIFT][label] = 1 # <<<<<<<<<<<<<<
* for label in kwargs.get('right_labels', []):
* actions[RIGHT][label] = 1
*/
__pyx_t_2 = __Pyx_GetItemInt(__pyx_v_actions, __pyx_e_5spacy_6syntax_9arc_eager_SHIFT, int, 1, __Pyx_PyInt_From_int, 0, 1, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 346, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
if (unlikely(PyObject_SetItem(__pyx_t_2, __pyx_v_label, __pyx_int_1) < 0)) __PYX_ERR(0, 346, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
/* "spacy/syntax/arc_eager.pyx":344
* actions[SHIFT][''] = 1
* actions[REDUCE][''] = 1
* for label in kwargs.get('left_labels', []): # <<<<<<<<<<<<<<
* actions[LEFT][label] = 1
* actions[SHIFT][label] = 1
*/
}
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
/* "spacy/syntax/arc_eager.pyx":347
* actions[LEFT][label] = 1
* actions[SHIFT][label] = 1
* for label in kwargs.get('right_labels', []): # <<<<<<<<<<<<<<
* actions[RIGHT][label] = 1
* actions[REDUCE][label] = 1
*/
__pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 347, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_t_2 = __Pyx_PyDict_GetItemDefault(__pyx_v_kwargs, __pyx_n_u_right_labels, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 347, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
if (likely(PyList_CheckExact(__pyx_t_2)) || PyTuple_CheckExact(__pyx_t_2)) {
__pyx_t_1 = __pyx_t_2; __Pyx_INCREF(__pyx_t_1); __pyx_t_5 = 0;
__pyx_t_6 = NULL;
} else {
__pyx_t_5 = -1; __pyx_t_1 = PyObject_GetIter(__pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 347, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_t_6 = Py_TYPE(__pyx_t_1)->tp_iternext; if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 347, __pyx_L1_error)
}
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
for (;;) {
if (likely(!__pyx_t_6)) {
if (likely(PyList_CheckExact(__pyx_t_1))) {
if (__pyx_t_5 >= PyList_GET_SIZE(__pyx_t_1)) break;
#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
__pyx_t_2 = PyList_GET_ITEM(__pyx_t_1, __pyx_t_5); __Pyx_INCREF(__pyx_t_2); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(0, 347, __pyx_L1_error)
#else
__pyx_t_2 = PySequence_ITEM(__pyx_t_1, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 347, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
#endif
} else {
if (__pyx_t_5 >= PyTuple_GET_SIZE(__pyx_t_1)) break;
#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
__pyx_t_2 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_5); __Pyx_INCREF(__pyx_t_2); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(0, 347, __pyx_L1_error)
#else
__pyx_t_2 = PySequence_ITEM(__pyx_t_1, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 347, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
#endif
}
} else {
__pyx_t_2 = __pyx_t_6(__pyx_t_1);
if (unlikely(!__pyx_t_2)) {
PyObject* exc_type = PyErr_Occurred();
if (exc_type) {
if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
else __PYX_ERR(0, 347, __pyx_L1_error)
}
break;
}
__Pyx_GOTREF(__pyx_t_2);
}
__Pyx_XDECREF_SET(__pyx_v_label, __pyx_t_2);
__pyx_t_2 = 0;
/* "spacy/syntax/arc_eager.pyx":348
* actions[SHIFT][label] = 1
* for label in kwargs.get('right_labels', []):
* actions[RIGHT][label] = 1 # <<<<<<<<<<<<<<
* actions[REDUCE][label] = 1
* for raw_text, sents in kwargs.get('gold_parses', []):
*/
__pyx_t_2 = __Pyx_GetItemInt(__pyx_v_actions, __pyx_e_5spacy_6syntax_9arc_eager_RIGHT, int, 1, __Pyx_PyInt_From_int, 0, 1, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 348, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
if (unlikely(PyObject_SetItem(__pyx_t_2, __pyx_v_label, __pyx_int_1) < 0)) __PYX_ERR(0, 348, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
/* "spacy/syntax/arc_eager.pyx":349
* for label in kwargs.get('right_labels', []):
* actions[RIGHT][label] = 1
* actions[REDUCE][label] = 1 # <<<<<<<<<<<<<<
* for raw_text, sents in kwargs.get('gold_parses', []):
* for (ids, words, tags, heads, labels, iob), ctnts in sents:
*/
__pyx_t_2 = __Pyx_GetItemInt(__pyx_v_actions, __pyx_e_5spacy_6syntax_9arc_eager_REDUCE, int, 1, __Pyx_PyInt_From_int, 0, 1, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 349, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
if (unlikely(PyObject_SetItem(__pyx_t_2, __pyx_v_label, __pyx_int_1) < 0)) __PYX_ERR(0, 349, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
/* "spacy/syntax/arc_eager.pyx":347
* actions[LEFT][label] = 1
* actions[SHIFT][label] = 1
* for label in kwargs.get('right_labels', []): # <<<<<<<<<<<<<<
* actions[RIGHT][label] = 1
* actions[REDUCE][label] = 1
*/
}
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
/* "spacy/syntax/arc_eager.pyx":350
* actions[RIGHT][label] = 1
* actions[REDUCE][label] = 1
* for raw_text, sents in kwargs.get('gold_parses', []): # <<<<<<<<<<<<<<
* for (ids, words, tags, heads, labels, iob), ctnts in sents:
* heads, labels = nonproj.projectivize(heads, labels)
*/
__pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 350, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_t_2 = __Pyx_PyDict_GetItemDefault(__pyx_v_kwargs, __pyx_n_u_gold_parses, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 350, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
if (likely(PyList_CheckExact(__pyx_t_2)) || PyTuple_CheckExact(__pyx_t_2)) {
__pyx_t_1 = __pyx_t_2; __Pyx_INCREF(__pyx_t_1); __pyx_t_5 = 0;
__pyx_t_6 = NULL;
} else {
__pyx_t_5 = -1; __pyx_t_1 = PyObject_GetIter(__pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 350, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_t_6 = Py_TYPE(__pyx_t_1)->tp_iternext; if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 350, __pyx_L1_error)
}
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
for (;;) {
if (likely(!__pyx_t_6)) {
if (likely(PyList_CheckExact(__pyx_t_1))) {
if (__pyx_t_5 >= PyList_GET_SIZE(__pyx_t_1)) break;
#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
__pyx_t_2 = PyList_GET_ITEM(__pyx_t_1, __pyx_t_5); __Pyx_INCREF(__pyx_t_2); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(0, 350, __pyx_L1_error)
#else
__pyx_t_2 = PySequence_ITEM(__pyx_t_1, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 350, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
#endif
} else {
if (__pyx_t_5 >= PyTuple_GET_SIZE(__pyx_t_1)) break;
#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
__pyx_t_2 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_5); __Pyx_INCREF(__pyx_t_2); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(0, 350, __pyx_L1_error)
#else
__pyx_t_2 = PySequence_ITEM(__pyx_t_1, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 350, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
#endif
}
} else {
__pyx_t_2 = __pyx_t_6(__pyx_t_1);
if (unlikely(!__pyx_t_2)) {
PyObject* exc_type = PyErr_Occurred();
if (exc_type) {
if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
else __PYX_ERR(0, 350, __pyx_L1_error)
}
break;
}
__Pyx_GOTREF(__pyx_t_2);
}
if ((likely(PyTuple_CheckExact(__pyx_t_2))) || (PyList_CheckExact(__pyx_t_2))) {
PyObject* sequence = __pyx_t_2;
Py_ssize_t size = __Pyx_PySequence_SIZE(sequence);
if (unlikely(size != 2)) {
if (size > 2) __Pyx_RaiseTooManyValuesError(2);
else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
__PYX_ERR(0, 350, __pyx_L1_error)
}
#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
if (likely(PyTuple_CheckExact(sequence))) {
__pyx_t_3 = PyTuple_GET_ITEM(sequence, 0);
__pyx_t_4 = PyTuple_GET_ITEM(sequence, 1);
} else {
__pyx_t_3 = PyList_GET_ITEM(sequence, 0);
__pyx_t_4 = PyList_GET_ITEM(sequence, 1);
}
__Pyx_INCREF(__pyx_t_3);
__Pyx_INCREF(__pyx_t_4);
#else
__pyx_t_3 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 350, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__pyx_t_4 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 350, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
#endif
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
} else {
Py_ssize_t index = -1;
__pyx_t_7 = PyObject_GetIter(__pyx_t_2); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 350, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__pyx_t_8 = Py_TYPE(__pyx_t_7)->tp_iternext;
index = 0; __pyx_t_3 = __pyx_t_8(__pyx_t_7); if (unlikely(!__pyx_t_3)) goto __pyx_L9_unpacking_failed;
__Pyx_GOTREF(__pyx_t_3);
index = 1; __pyx_t_4 = __pyx_t_8(__pyx_t_7); if (unlikely(!__pyx_t_4)) goto __pyx_L9_unpacking_failed;
__Pyx_GOTREF(__pyx_t_4);
if (__Pyx_IternextUnpackEndCheck(__pyx_t_8(__pyx_t_7), 2) < 0) __PYX_ERR(0, 350, __pyx_L1_error)
__pyx_t_8 = NULL;
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
goto __pyx_L10_unpacking_done;
__pyx_L9_unpacking_failed:;
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
__pyx_t_8 = NULL;
if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index);
__PYX_ERR(0, 350, __pyx_L1_error)
__pyx_L10_unpacking_done:;
}
__Pyx_XDECREF_SET(__pyx_v_raw_text, __pyx_t_3);
__pyx_t_3 = 0;
__Pyx_XDECREF_SET(__pyx_v_sents, __pyx_t_4);
__pyx_t_4 = 0;
/* "spacy/syntax/arc_eager.pyx":351
* actions[REDUCE][label] = 1
* for raw_text, sents in kwargs.get('gold_parses', []):
* for (ids, words, tags, heads, labels, iob), ctnts in sents: # <<<<<<<<<<<<<<
* heads, labels = nonproj.projectivize(heads, labels)
* for child, head, label in zip(ids, heads, labels):
*/
if (likely(PyList_CheckExact(__pyx_v_sents)) || PyTuple_CheckExact(__pyx_v_sents)) {
__pyx_t_2 = __pyx_v_sents; __Pyx_INCREF(__pyx_t_2); __pyx_t_9 = 0;
__pyx_t_10 = NULL;
} else {
__pyx_t_9 = -1; __pyx_t_2 = PyObject_GetIter(__pyx_v_sents); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 351, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__pyx_t_10 = Py_TYPE(__pyx_t_2)->tp_iternext; if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 351, __pyx_L1_error)
}
for (;;) {
if (likely(!__pyx_t_10)) {
if (likely(PyList_CheckExact(__pyx_t_2))) {
if (__pyx_t_9 >= PyList_GET_SIZE(__pyx_t_2)) break;
#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
__pyx_t_4 = PyList_GET_ITEM(__pyx_t_2, __pyx_t_9); __Pyx_INCREF(__pyx_t_4); __pyx_t_9++; if (unlikely(0 < 0)) __PYX_ERR(0, 351, __pyx_L1_error)
#else
__pyx_t_4 = PySequence_ITEM(__pyx_t_2, __pyx_t_9); __pyx_t_9++; if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 351, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
#endif
} else {
if (__pyx_t_9 >= PyTuple_GET_SIZE(__pyx_t_2)) break;
#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
__pyx_t_4 = PyTuple_GET_ITEM(__pyx_t_2, __pyx_t_9); __Pyx_INCREF(__pyx_t_4); __pyx_t_9++; if (unlikely(0 < 0)) __PYX_ERR(0, 351, __pyx_L1_error)
#else
__pyx_t_4 = PySequence_ITEM(__pyx_t_2, __pyx_t_9); __pyx_t_9++; if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 351, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
#endif
}
} else {
__pyx_t_4 = __pyx_t_10(__pyx_t_2);
if (unlikely(!__pyx_t_4)) {
PyObject* exc_type = PyErr_Occurred();
if (exc_type) {
if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
else __PYX_ERR(0, 351, __pyx_L1_error)
}
break;
}
__Pyx_GOTREF(__pyx_t_4);
}
if ((likely(PyTuple_CheckExact(__pyx_t_4))) || (PyList_CheckExact(__pyx_t_4))) {
PyObject* sequence = __pyx_t_4;
Py_ssize_t size = __Pyx_PySequence_SIZE(sequence);
if (unlikely(size != 2)) {
if (size > 2) __Pyx_RaiseTooManyValuesError(2);
else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
__PYX_ERR(0, 351, __pyx_L1_error)
}
#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
if (likely(PyTuple_CheckExact(sequence))) {
__pyx_t_3 = PyTuple_GET_ITEM(sequence, 0);
__pyx_t_7 = PyTuple_GET_ITEM(sequence, 1);
} else {
__pyx_t_3 = PyList_GET_ITEM(sequence, 0);
__pyx_t_7 = PyList_GET_ITEM(sequence, 1);
}
__Pyx_INCREF(__pyx_t_3);
__Pyx_INCREF(__pyx_t_7);
#else
__pyx_t_3 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 351, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__pyx_t_7 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 351, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
#endif
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
} else {
Py_ssize_t index = -1;
__pyx_t_11 = PyObject_GetIter(__pyx_t_4); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 351, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_11);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__pyx_t_8 = Py_TYPE(__pyx_t_11)->tp_iternext;
index = 0; __pyx_t_3 = __pyx_t_8(__pyx_t_11); if (unlikely(!__pyx_t_3)) goto __pyx_L13_unpacking_failed;
__Pyx_GOTREF(__pyx_t_3);
index = 1; __pyx_t_7 = __pyx_t_8(__pyx_t_11); if (unlikely(!__pyx_t_7)) goto __pyx_L13_unpacking_failed;
__Pyx_GOTREF(__pyx_t_7);
if (__Pyx_IternextUnpackEndCheck(__pyx_t_8(__pyx_t_11), 2) < 0) __PYX_ERR(0, 351, __pyx_L1_error)
__pyx_t_8 = NULL;
__Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
goto __pyx_L14_unpacking_done;
__pyx_L13_unpacking_failed:;
__Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
__pyx_t_8 = NULL;
if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index);
__PYX_ERR(0, 351, __pyx_L1_error)
__pyx_L14_unpacking_done:;
}
if ((likely(PyTuple_CheckExact(__pyx_t_3))) || (PyList_CheckExact(__pyx_t_3))) {
PyObject* sequence = __pyx_t_3;
Py_ssize_t size = __Pyx_PySequence_SIZE(sequence);
if (unlikely(size != 6)) {
if (size > 6) __Pyx_RaiseTooManyValuesError(6);
else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
__PYX_ERR(0, 351, __pyx_L1_error)
}
#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
if (likely(PyTuple_CheckExact(sequence))) {
__pyx_t_11 = PyTuple_GET_ITEM(sequence, 0);
__pyx_t_12 = PyTuple_GET_ITEM(sequence, 1);
__pyx_t_13 = PyTuple_GET_ITEM(sequence, 2);
__pyx_t_14 = PyTuple_GET_ITEM(sequence, 3);
__pyx_t_15 = PyTuple_GET_ITEM(sequence, 4);
__pyx_t_16 = PyTuple_GET_ITEM(sequence, 5);
} else {
__pyx_t_11 = PyList_GET_ITEM(sequence, 0);
__pyx_t_12 = PyList_GET_ITEM(sequence, 1);
__pyx_t_13 = PyList_GET_ITEM(sequence, 2);
__pyx_t_14 = PyList_GET_ITEM(sequence, 3);
__pyx_t_15 = PyList_GET_ITEM(sequence, 4);
__pyx_t_16 = PyList_GET_ITEM(sequence, 5);
}
__Pyx_INCREF(__pyx_t_11);
__Pyx_INCREF(__pyx_t_12);
__Pyx_INCREF(__pyx_t_13);
__Pyx_INCREF(__pyx_t_14);
__Pyx_INCREF(__pyx_t_15);
__Pyx_INCREF(__pyx_t_16);
#else
{
Py_ssize_t i;
PyObject** temps[6] = {&__pyx_t_11,&__pyx_t_12,&__pyx_t_13,&__pyx_t_14,&__pyx_t_15,&__pyx_t_16};
for (i=0; i < 6; i++) {
PyObject* item = PySequence_ITEM(sequence, i); if (unlikely(!item)) __PYX_ERR(0, 351, __pyx_L1_error)
__Pyx_GOTREF(item);
*(temps[i]) = item;
}
}
#endif
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
} else {
Py_ssize_t index = -1;
PyObject** temps[6] = {&__pyx_t_11,&__pyx_t_12,&__pyx_t_13,&__pyx_t_14,&__pyx_t_15,&__pyx_t_16};
__pyx_t_17 = PyObject_GetIter(__pyx_t_3); if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 351, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_17);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__pyx_t_8 = Py_TYPE(__pyx_t_17)->tp_iternext;
for (index=0; index < 6; index++) {
PyObject* item = __pyx_t_8(__pyx_t_17); if (unlikely(!item)) goto __pyx_L15_unpacking_failed;
__Pyx_GOTREF(item);
*(temps[index]) = item;
}
if (__Pyx_IternextUnpackEndCheck(__pyx_t_8(__pyx_t_17), 6) < 0) __PYX_ERR(0, 351, __pyx_L1_error)
__pyx_t_8 = NULL;
__Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0;
goto __pyx_L16_unpacking_done;
__pyx_L15_unpacking_failed:;
__Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0;
__pyx_t_8 = NULL;
if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index);
__PYX_ERR(0, 351, __pyx_L1_error)
__pyx_L16_unpacking_done:;
}
__Pyx_XDECREF_SET(__pyx_v_ids, __pyx_t_11);
__pyx_t_11 = 0;
__Pyx_XDECREF_SET(__pyx_v_words, __pyx_t_12);
__pyx_t_12 = 0;
__Pyx_XDECREF_SET(__pyx_v_tags, __pyx_t_13);
__pyx_t_13 = 0;
__Pyx_XDECREF_SET(__pyx_v_heads, __pyx_t_14);
__pyx_t_14 = 0;
__Pyx_XDECREF_SET(__pyx_v_labels, __pyx_t_15);
__pyx_t_15 = 0;
__Pyx_XDECREF_SET(__pyx_v_iob, __pyx_t_16);
__pyx_t_16 = 0;
__Pyx_XDECREF_SET(__pyx_v_ctnts, __pyx_t_7);
__pyx_t_7 = 0;
/* "spacy/syntax/arc_eager.pyx":352
* for raw_text, sents in kwargs.get('gold_parses', []):
* for (ids, words, tags, heads, labels, iob), ctnts in sents:
* heads, labels = nonproj.projectivize(heads, labels) # <<<<<<<<<<<<<<
* for child, head, label in zip(ids, heads, labels):
* if label.upper() == 'ROOT' :
*/
__Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_nonproj); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 352, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_projectivize); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 352, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
__pyx_t_7 = NULL;
__pyx_t_18 = 0;
if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
__pyx_t_7 = PyMethod_GET_SELF(__pyx_t_3);
if (likely(__pyx_t_7)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
__Pyx_INCREF(__pyx_t_7);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_3, function);
__pyx_t_18 = 1;
}
}
#if CYTHON_FAST_PYCALL
if (PyFunction_Check(__pyx_t_3)) {
PyObject *__pyx_temp[3] = {__pyx_t_7, __pyx_v_heads, __pyx_v_labels};
__pyx_t_4 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_18, 2+__pyx_t_18); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 352, __pyx_L1_error)
__Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
__Pyx_GOTREF(__pyx_t_4);
} else
#endif
#if CYTHON_FAST_PYCCALL
if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) {
PyObject *__pyx_temp[3] = {__pyx_t_7, __pyx_v_heads, __pyx_v_labels};
__pyx_t_4 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_18, 2+__pyx_t_18); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 352, __pyx_L1_error)
__Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
__Pyx_GOTREF(__pyx_t_4);
} else
#endif
{
__pyx_t_16 = PyTuple_New(2+__pyx_t_18); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 352, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_16);
if (__pyx_t_7) {
__Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_16, 0, __pyx_t_7); __pyx_t_7 = NULL;
}
__Pyx_INCREF(__pyx_v_heads);
__Pyx_GIVEREF(__pyx_v_heads);
PyTuple_SET_ITEM(__pyx_t_16, 0+__pyx_t_18, __pyx_v_heads);
__Pyx_INCREF(__pyx_v_labels);
__Pyx_GIVEREF(__pyx_v_labels);
PyTuple_SET_ITEM(__pyx_t_16, 1+__pyx_t_18, __pyx_v_labels);
__pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_16, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 352, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0;
}
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
if ((likely(PyTuple_CheckExact(__pyx_t_4))) || (PyList_CheckExact(__pyx_t_4))) {
PyObject* sequence = __pyx_t_4;
Py_ssize_t size = __Pyx_PySequence_SIZE(sequence);
if (unlikely(size != 2)) {
if (size > 2) __Pyx_RaiseTooManyValuesError(2);
else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
__PYX_ERR(0, 352, __pyx_L1_error)
}
#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
if (likely(PyTuple_CheckExact(sequence))) {
__pyx_t_3 = PyTuple_GET_ITEM(sequence, 0);
__pyx_t_16 = PyTuple_GET_ITEM(sequence, 1);
} else {
__pyx_t_3 = PyList_GET_ITEM(sequence, 0);
__pyx_t_16 = PyList_GET_ITEM(sequence, 1);
}
__Pyx_INCREF(__pyx_t_3);
__Pyx_INCREF(__pyx_t_16);
#else
__pyx_t_3 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 352, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__pyx_t_16 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 352, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_16);
#endif
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
} else {
Py_ssize_t index = -1;
__pyx_t_7 = PyObject_GetIter(__pyx_t_4); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 352, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__pyx_t_8 = Py_TYPE(__pyx_t_7)->tp_iternext;
index = 0; __pyx_t_3 = __pyx_t_8(__pyx_t_7); if (unlikely(!__pyx_t_3)) goto __pyx_L17_unpacking_failed;
__Pyx_GOTREF(__pyx_t_3);
index = 1; __pyx_t_16 = __pyx_t_8(__pyx_t_7); if (unlikely(!__pyx_t_16)) goto __pyx_L17_unpacking_failed;
__Pyx_GOTREF(__pyx_t_16);
if (__Pyx_IternextUnpackEndCheck(__pyx_t_8(__pyx_t_7), 2) < 0) __PYX_ERR(0, 352, __pyx_L1_error)
__pyx_t_8 = NULL;
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
goto __pyx_L18_unpacking_done;
__pyx_L17_unpacking_failed:;
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
__pyx_t_8 = NULL;
if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index);
__PYX_ERR(0, 352, __pyx_L1_error)
__pyx_L18_unpacking_done:;
}
__Pyx_DECREF_SET(__pyx_v_heads, __pyx_t_3);
__pyx_t_3 = 0;
__Pyx_DECREF_SET(__pyx_v_labels, __pyx_t_16);
__pyx_t_16 = 0;
/* "spacy/syntax/arc_eager.pyx":353
* for (ids, words, tags, heads, labels, iob), ctnts in sents:
* heads, labels = nonproj.projectivize(heads, labels)
* for child, head, label in zip(ids, heads, labels): # <<<<<<<<<<<<<<
* if label.upper() == 'ROOT' :
* label = 'ROOT'
*/
__pyx_t_4 = PyTuple_New(3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 353, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_INCREF(__pyx_v_ids);
__Pyx_GIVEREF(__pyx_v_ids);
PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_v_ids);
__Pyx_INCREF(__pyx_v_heads);
__Pyx_GIVEREF(__pyx_v_heads);
PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_v_heads);
__Pyx_INCREF(__pyx_v_labels);
__Pyx_GIVEREF(__pyx_v_labels);
PyTuple_SET_ITEM(__pyx_t_4, 2, __pyx_v_labels);
__pyx_t_16 = __Pyx_PyObject_Call(__pyx_builtin_zip, __pyx_t_4, NULL); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 353, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_16);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
if (likely(PyList_CheckExact(__pyx_t_16)) || PyTuple_CheckExact(__pyx_t_16)) {
__pyx_t_4 = __pyx_t_16; __Pyx_INCREF(__pyx_t_4); __pyx_t_19 = 0;
__pyx_t_20 = NULL;
} else {
__pyx_t_19 = -1; __pyx_t_4 = PyObject_GetIter(__pyx_t_16); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 353, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__pyx_t_20 = Py_TYPE(__pyx_t_4)->tp_iternext; if (unlikely(!__pyx_t_20)) __PYX_ERR(0, 353, __pyx_L1_error)
}
__Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0;
for (;;) {
if (likely(!__pyx_t_20)) {
if (likely(PyList_CheckExact(__pyx_t_4))) {
if (__pyx_t_19 >= PyList_GET_SIZE(__pyx_t_4)) break;
#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
__pyx_t_16 = PyList_GET_ITEM(__pyx_t_4, __pyx_t_19); __Pyx_INCREF(__pyx_t_16); __pyx_t_19++; if (unlikely(0 < 0)) __PYX_ERR(0, 353, __pyx_L1_error)
#else
__pyx_t_16 = PySequence_ITEM(__pyx_t_4, __pyx_t_19); __pyx_t_19++; if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 353, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_16);
#endif
} else {
if (__pyx_t_19 >= PyTuple_GET_SIZE(__pyx_t_4)) break;
#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
__pyx_t_16 = PyTuple_GET_ITEM(__pyx_t_4, __pyx_t_19); __Pyx_INCREF(__pyx_t_16); __pyx_t_19++; if (unlikely(0 < 0)) __PYX_ERR(0, 353, __pyx_L1_error)
#else
__pyx_t_16 = PySequence_ITEM(__pyx_t_4, __pyx_t_19); __pyx_t_19++; if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 353, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_16);
#endif
}
} else {
__pyx_t_16 = __pyx_t_20(__pyx_t_4);
if (unlikely(!__pyx_t_16)) {
PyObject* exc_type = PyErr_Occurred();
if (exc_type) {
if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
else __PYX_ERR(0, 353, __pyx_L1_error)
}
break;
}
__Pyx_GOTREF(__pyx_t_16);
}
if ((likely(PyTuple_CheckExact(__pyx_t_16))) || (PyList_CheckExact(__pyx_t_16))) {
PyObject* sequence = __pyx_t_16;
Py_ssize_t size = __Pyx_PySequence_SIZE(sequence);
if (unlikely(size != 3)) {
if (size > 3) __Pyx_RaiseTooManyValuesError(3);
else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
__PYX_ERR(0, 353, __pyx_L1_error)
}
#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
if (likely(PyTuple_CheckExact(sequence))) {
__pyx_t_3 = PyTuple_GET_ITEM(sequence, 0);
__pyx_t_7 = PyTuple_GET_ITEM(sequence, 1);
__pyx_t_15 = PyTuple_GET_ITEM(sequence, 2);
} else {
__pyx_t_3 = PyList_GET_ITEM(sequence, 0);
__pyx_t_7 = PyList_GET_ITEM(sequence, 1);
__pyx_t_15 = PyList_GET_ITEM(sequence, 2);
}
__Pyx_INCREF(__pyx_t_3);
__Pyx_INCREF(__pyx_t_7);
__Pyx_INCREF(__pyx_t_15);
#else
__pyx_t_3 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 353, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__pyx_t_7 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 353, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__pyx_t_15 = PySequence_ITEM(sequence, 2); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 353, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_15);
#endif
__Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0;
} else {
Py_ssize_t index = -1;
__pyx_t_14 = PyObject_GetIter(__pyx_t_16); if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 353, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_14);
__Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0;
__pyx_t_8 = Py_TYPE(__pyx_t_14)->tp_iternext;
index = 0; __pyx_t_3 = __pyx_t_8(__pyx_t_14); if (unlikely(!__pyx_t_3)) goto __pyx_L21_unpacking_failed;
__Pyx_GOTREF(__pyx_t_3);
index = 1; __pyx_t_7 = __pyx_t_8(__pyx_t_14); if (unlikely(!__pyx_t_7)) goto __pyx_L21_unpacking_failed;
__Pyx_GOTREF(__pyx_t_7);
index = 2; __pyx_t_15 = __pyx_t_8(__pyx_t_14); if (unlikely(!__pyx_t_15)) goto __pyx_L21_unpacking_failed;
__Pyx_GOTREF(__pyx_t_15);
if (__Pyx_IternextUnpackEndCheck(__pyx_t_8(__pyx_t_14), 3) < 0) __PYX_ERR(0, 353, __pyx_L1_error)
__pyx_t_8 = NULL;
__Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0;
goto __pyx_L22_unpacking_done;
__pyx_L21_unpacking_failed:;
__Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0;
__pyx_t_8 = NULL;
if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index);
__PYX_ERR(0, 353, __pyx_L1_error)
__pyx_L22_unpacking_done:;
}
__Pyx_XDECREF_SET(__pyx_v_child, __pyx_t_3);
__pyx_t_3 = 0;
__Pyx_XDECREF_SET(__pyx_v_head, __pyx_t_7);
__pyx_t_7 = 0;
__Pyx_XDECREF_SET(__pyx_v_label, __pyx_t_15);
__pyx_t_15 = 0;
/* "spacy/syntax/arc_eager.pyx":354
* heads, labels = nonproj.projectivize(heads, labels)
* for child, head, label in zip(ids, heads, labels):
* if label.upper() == 'ROOT' : # <<<<<<<<<<<<<<
* label = 'ROOT'
* if head == child:
*/
__pyx_t_15 = __Pyx_PyObject_GetAttrStr(__pyx_v_label, __pyx_n_s_upper); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 354, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_15);
__pyx_t_7 = NULL;
if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_15))) {
__pyx_t_7 = PyMethod_GET_SELF(__pyx_t_15);
if (likely(__pyx_t_7)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_15);
__Pyx_INCREF(__pyx_t_7);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_15, function);
}
}
__pyx_t_16 = (__pyx_t_7) ? __Pyx_PyObject_CallOneArg(__pyx_t_15, __pyx_t_7) : __Pyx_PyObject_CallNoArg(__pyx_t_15);
__Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 354, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_16);
__Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
__pyx_t_21 = (__Pyx_PyUnicode_Equals(__pyx_t_16, __pyx_n_u_ROOT, Py_EQ)); if (unlikely(__pyx_t_21 < 0)) __PYX_ERR(0, 354, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0;
if (__pyx_t_21) {
/* "spacy/syntax/arc_eager.pyx":355
* for child, head, label in zip(ids, heads, labels):
* if label.upper() == 'ROOT' :
* label = 'ROOT' # <<<<<<<<<<<<<<
* if head == child:
* actions[BREAK][label] += 1
*/
__Pyx_INCREF(__pyx_n_u_ROOT);
__Pyx_DECREF_SET(__pyx_v_label, __pyx_n_u_ROOT);
/* "spacy/syntax/arc_eager.pyx":354
* heads, labels = nonproj.projectivize(heads, labels)
* for child, head, label in zip(ids, heads, labels):
* if label.upper() == 'ROOT' : # <<<<<<<<<<<<<<
* label = 'ROOT'
* if head == child:
*/
}
/* "spacy/syntax/arc_eager.pyx":356
* if label.upper() == 'ROOT' :
* label = 'ROOT'
* if head == child: # <<<<<<<<<<<<<<
* actions[BREAK][label] += 1
* elif head < child:
*/
__pyx_t_16 = PyObject_RichCompare(__pyx_v_head, __pyx_v_child, Py_EQ); __Pyx_XGOTREF(__pyx_t_16); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 356, __pyx_L1_error)
__pyx_t_21 = __Pyx_PyObject_IsTrue(__pyx_t_16); if (unlikely(__pyx_t_21 < 0)) __PYX_ERR(0, 356, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0;
if (__pyx_t_21) {
/* "spacy/syntax/arc_eager.pyx":357
* label = 'ROOT'
* if head == child:
* actions[BREAK][label] += 1 # <<<<<<<<<<<<<<
* elif head < child:
* actions[RIGHT][label] += 1
*/
__pyx_t_16 = __Pyx_GetItemInt(__pyx_v_actions, __pyx_e_5spacy_6syntax_9arc_eager_BREAK, int, 1, __Pyx_PyInt_From_int, 0, 1, 1); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 357, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_16);
__Pyx_INCREF(__pyx_v_label);
__pyx_t_15 = __pyx_v_label;
__pyx_t_7 = __Pyx_PyObject_GetItem(__pyx_t_16, __pyx_t_15); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 357, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__pyx_t_3 = __Pyx_PyInt_AddObjC(__pyx_t_7, __pyx_int_1, 1, 1, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 357, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
if (unlikely(PyObject_SetItem(__pyx_t_16, __pyx_t_15, __pyx_t_3) < 0)) __PYX_ERR(0, 357, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
__Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0;
/* "spacy/syntax/arc_eager.pyx":356
* if label.upper() == 'ROOT' :
* label = 'ROOT'
* if head == child: # <<<<<<<<<<<<<<
* actions[BREAK][label] += 1
* elif head < child:
*/
goto __pyx_L24;
}
/* "spacy/syntax/arc_eager.pyx":358
* if head == child:
* actions[BREAK][label] += 1
* elif head < child: # <<<<<<<<<<<<<<
* actions[RIGHT][label] += 1
* actions[REDUCE][''] += 1
*/
__pyx_t_16 = PyObject_RichCompare(__pyx_v_head, __pyx_v_child, Py_LT); __Pyx_XGOTREF(__pyx_t_16); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 358, __pyx_L1_error)
__pyx_t_21 = __Pyx_PyObject_IsTrue(__pyx_t_16); if (unlikely(__pyx_t_21 < 0)) __PYX_ERR(0, 358, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0;
if (__pyx_t_21) {
/* "spacy/syntax/arc_eager.pyx":359
* actions[BREAK][label] += 1
* elif head < child:
* actions[RIGHT][label] += 1 # <<<<<<<<<<<<<<
* actions[REDUCE][''] += 1
* elif head > child:
*/
__pyx_t_16 = __Pyx_GetItemInt(__pyx_v_actions, __pyx_e_5spacy_6syntax_9arc_eager_RIGHT, int, 1, __Pyx_PyInt_From_int, 0, 1, 1); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 359, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_16);
__Pyx_INCREF(__pyx_v_label);
__pyx_t_15 = __pyx_v_label;
__pyx_t_3 = __Pyx_PyObject_GetItem(__pyx_t_16, __pyx_t_15); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 359, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__pyx_t_7 = __Pyx_PyInt_AddObjC(__pyx_t_3, __pyx_int_1, 1, 1, 0); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 359, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
if (unlikely(PyObject_SetItem(__pyx_t_16, __pyx_t_15, __pyx_t_7) < 0)) __PYX_ERR(0, 359, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
__Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
__Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0;
/* "spacy/syntax/arc_eager.pyx":360
* elif head < child:
* actions[RIGHT][label] += 1
* actions[REDUCE][''] += 1 # <<<<<<<<<<<<<<
* elif head > child:
* actions[LEFT][label] += 1
*/
__pyx_t_16 = __Pyx_GetItemInt(__pyx_v_actions, __pyx_e_5spacy_6syntax_9arc_eager_REDUCE, int, 1, __Pyx_PyInt_From_int, 0, 1, 1); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 360, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_16);
__Pyx_INCREF(__pyx_kp_u_);
__pyx_t_22 = __pyx_kp_u_;
__pyx_t_15 = __Pyx_PyObject_Dict_GetItem(__pyx_t_16, __pyx_t_22); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 360, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_15);
__pyx_t_7 = __Pyx_PyInt_AddObjC(__pyx_t_15, __pyx_int_1, 1, 1, 0); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 360, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
if (unlikely(PyObject_SetItem(__pyx_t_16, __pyx_t_22, __pyx_t_7) < 0)) __PYX_ERR(0, 360, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
__Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0;
__Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0;
/* "spacy/syntax/arc_eager.pyx":358
* if head == child:
* actions[BREAK][label] += 1
* elif head < child: # <<<<<<<<<<<<<<
* actions[RIGHT][label] += 1
* actions[REDUCE][''] += 1
*/
goto __pyx_L24;
}
/* "spacy/syntax/arc_eager.pyx":361
* actions[RIGHT][label] += 1
* actions[REDUCE][''] += 1
* elif head > child: # <<<<<<<<<<<<<<
* actions[LEFT][label] += 1
* actions[SHIFT][''] += 1
*/
__pyx_t_16 = PyObject_RichCompare(__pyx_v_head, __pyx_v_child, Py_GT); __Pyx_XGOTREF(__pyx_t_16); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 361, __pyx_L1_error)
__pyx_t_21 = __Pyx_PyObject_IsTrue(__pyx_t_16); if (unlikely(__pyx_t_21 < 0)) __PYX_ERR(0, 361, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0;
if (__pyx_t_21) {
/* "spacy/syntax/arc_eager.pyx":362
* actions[REDUCE][''] += 1
* elif head > child:
* actions[LEFT][label] += 1 # <<<<<<<<<<<<<<
* actions[SHIFT][''] += 1
* if min_freq is not None:
*/
__pyx_t_16 = __Pyx_GetItemInt(__pyx_v_actions, __pyx_e_5spacy_6syntax_9arc_eager_LEFT, int, 1, __Pyx_PyInt_From_int, 0, 1, 1); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 362, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_16);
__Pyx_INCREF(__pyx_v_label);
__pyx_t_7 = __pyx_v_label;
__pyx_t_15 = __Pyx_PyObject_GetItem(__pyx_t_16, __pyx_t_7); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 362, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_15);
__pyx_t_3 = __Pyx_PyInt_AddObjC(__pyx_t_15, __pyx_int_1, 1, 1, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 362, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
if (unlikely(PyObject_SetItem(__pyx_t_16, __pyx_t_7, __pyx_t_3) < 0)) __PYX_ERR(0, 362, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
__Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0;
/* "spacy/syntax/arc_eager.pyx":363
* elif head > child:
* actions[LEFT][label] += 1
* actions[SHIFT][''] += 1 # <<<<<<<<<<<<<<
* if min_freq is not None:
* for action, label_freqs in actions.items():
*/
__pyx_t_16 = __Pyx_GetItemInt(__pyx_v_actions, __pyx_e_5spacy_6syntax_9arc_eager_SHIFT, int, 1, __Pyx_PyInt_From_int, 0, 1, 1); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 363, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_16);
__Pyx_INCREF(__pyx_kp_u_);
__pyx_t_22 = __pyx_kp_u_;
__pyx_t_7 = __Pyx_PyObject_Dict_GetItem(__pyx_t_16, __pyx_t_22); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 363, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__pyx_t_3 = __Pyx_PyInt_AddObjC(__pyx_t_7, __pyx_int_1, 1, 1, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 363, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
if (unlikely(PyObject_SetItem(__pyx_t_16, __pyx_t_22, __pyx_t_3) < 0)) __PYX_ERR(0, 363, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0;
__Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0;
/* "spacy/syntax/arc_eager.pyx":361
* actions[RIGHT][label] += 1
* actions[REDUCE][''] += 1
* elif head > child: # <<<<<<<<<<<<<<
* actions[LEFT][label] += 1
* actions[SHIFT][''] += 1
*/
}
__pyx_L24:;
/* "spacy/syntax/arc_eager.pyx":353
* for (ids, words, tags, heads, labels, iob), ctnts in sents:
* heads, labels = nonproj.projectivize(heads, labels)
* for child, head, label in zip(ids, heads, labels): # <<<<<<<<<<<<<<
* if label.upper() == 'ROOT' :
* label = 'ROOT'
*/
}
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
/* "spacy/syntax/arc_eager.pyx":351
* actions[REDUCE][label] = 1
* for raw_text, sents in kwargs.get('gold_parses', []):
* for (ids, words, tags, heads, labels, iob), ctnts in sents: # <<<<<<<<<<<<<<
* heads, labels = nonproj.projectivize(heads, labels)
* for child, head, label in zip(ids, heads, labels):
*/
}
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
/* "spacy/syntax/arc_eager.pyx":350
* actions[RIGHT][label] = 1
* actions[REDUCE][label] = 1
* for raw_text, sents in kwargs.get('gold_parses', []): # <<<<<<<<<<<<<<
* for (ids, words, tags, heads, labels, iob), ctnts in sents:
* heads, labels = nonproj.projectivize(heads, labels)
*/
}
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
/* "spacy/syntax/arc_eager.pyx":364
* actions[LEFT][label] += 1
* actions[SHIFT][''] += 1
* if min_freq is not None: # <<<<<<<<<<<<<<
* for action, label_freqs in actions.items():
* for label, freq in list(label_freqs.items()):
*/
__pyx_t_21 = (__pyx_v_min_freq != Py_None);
__pyx_t_23 = (__pyx_t_21 != 0);
if (__pyx_t_23) {
/* "spacy/syntax/arc_eager.pyx":365
* actions[SHIFT][''] += 1
* if min_freq is not None:
* for action, label_freqs in actions.items(): # <<<<<<<<<<<<<<
* for label, freq in list(label_freqs.items()):
* if freq < min_freq:
*/
__pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_actions, __pyx_n_s_items); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 365, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__pyx_t_4 = NULL;
if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
__pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2);
if (likely(__pyx_t_4)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
__Pyx_INCREF(__pyx_t_4);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_2, function);
}
}
__pyx_t_1 = (__pyx_t_4) ? __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_4) : __Pyx_PyObject_CallNoArg(__pyx_t_2);
__Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 365, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
if (likely(PyList_CheckExact(__pyx_t_1)) || PyTuple_CheckExact(__pyx_t_1)) {
__pyx_t_2 = __pyx_t_1; __Pyx_INCREF(__pyx_t_2); __pyx_t_5 = 0;
__pyx_t_6 = NULL;
} else {
__pyx_t_5 = -1; __pyx_t_2 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 365, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__pyx_t_6 = Py_TYPE(__pyx_t_2)->tp_iternext; if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 365, __pyx_L1_error)
}
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
for (;;) {
if (likely(!__pyx_t_6)) {
if (likely(PyList_CheckExact(__pyx_t_2))) {
if (__pyx_t_5 >= PyList_GET_SIZE(__pyx_t_2)) break;
#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
__pyx_t_1 = PyList_GET_ITEM(__pyx_t_2, __pyx_t_5); __Pyx_INCREF(__pyx_t_1); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(0, 365, __pyx_L1_error)
#else
__pyx_t_1 = PySequence_ITEM(__pyx_t_2, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 365, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
#endif
} else {
if (__pyx_t_5 >= PyTuple_GET_SIZE(__pyx_t_2)) break;
#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
__pyx_t_1 = PyTuple_GET_ITEM(__pyx_t_2, __pyx_t_5); __Pyx_INCREF(__pyx_t_1); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(0, 365, __pyx_L1_error)
#else
__pyx_t_1 = PySequence_ITEM(__pyx_t_2, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 365, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
#endif
}
} else {
__pyx_t_1 = __pyx_t_6(__pyx_t_2);
if (unlikely(!__pyx_t_1)) {
PyObject* exc_type = PyErr_Occurred();
if (exc_type) {
if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
else __PYX_ERR(0, 365, __pyx_L1_error)
}
break;
}
__Pyx_GOTREF(__pyx_t_1);
}
if ((likely(PyTuple_CheckExact(__pyx_t_1))) || (PyList_CheckExact(__pyx_t_1))) {
PyObject* sequence = __pyx_t_1;
Py_ssize_t size = __Pyx_PySequence_SIZE(sequence);
if (unlikely(size != 2)) {
if (size > 2) __Pyx_RaiseTooManyValuesError(2);
else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
__PYX_ERR(0, 365, __pyx_L1_error)
}
#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
if (likely(PyTuple_CheckExact(sequence))) {
__pyx_t_4 = PyTuple_GET_ITEM(sequence, 0);
__pyx_t_16 = PyTuple_GET_ITEM(sequence, 1);
} else {
__pyx_t_4 = PyList_GET_ITEM(sequence, 0);
__pyx_t_16 = PyList_GET_ITEM(sequence, 1);
}
__Pyx_INCREF(__pyx_t_4);
__Pyx_INCREF(__pyx_t_16);
#else
__pyx_t_4 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 365, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__pyx_t_16 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 365, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_16);
#endif
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
} else {
Py_ssize_t index = -1;
__pyx_t_3 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 365, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__pyx_t_8 = Py_TYPE(__pyx_t_3)->tp_iternext;
index = 0; __pyx_t_4 = __pyx_t_8(__pyx_t_3); if (unlikely(!__pyx_t_4)) goto __pyx_L28_unpacking_failed;
__Pyx_GOTREF(__pyx_t_4);
index = 1; __pyx_t_16 = __pyx_t_8(__pyx_t_3); if (unlikely(!__pyx_t_16)) goto __pyx_L28_unpacking_failed;
__Pyx_GOTREF(__pyx_t_16);
if (__Pyx_IternextUnpackEndCheck(__pyx_t_8(__pyx_t_3), 2) < 0) __PYX_ERR(0, 365, __pyx_L1_error)
__pyx_t_8 = NULL;
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
goto __pyx_L29_unpacking_done;
__pyx_L28_unpacking_failed:;
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__pyx_t_8 = NULL;
if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index);
__PYX_ERR(0, 365, __pyx_L1_error)
__pyx_L29_unpacking_done:;
}
__Pyx_XDECREF_SET(__pyx_v_action, __pyx_t_4);
__pyx_t_4 = 0;
__Pyx_XDECREF_SET(__pyx_v_label_freqs, __pyx_t_16);
__pyx_t_16 = 0;
/* "spacy/syntax/arc_eager.pyx":366
* if min_freq is not None:
* for action, label_freqs in actions.items():
* for label, freq in list(label_freqs.items()): # <<<<<<<<<<<<<<
* if freq < min_freq:
* label_freqs.pop(label)
*/
__pyx_t_16 = __Pyx_PyObject_GetAttrStr(__pyx_v_label_freqs, __pyx_n_s_items); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 366, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_16);
__pyx_t_4 = NULL;
if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_16))) {
__pyx_t_4 = PyMethod_GET_SELF(__pyx_t_16);
if (likely(__pyx_t_4)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_16);
__Pyx_INCREF(__pyx_t_4);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_16, function);
}
}
__pyx_t_1 = (__pyx_t_4) ? __Pyx_PyObject_CallOneArg(__pyx_t_16, __pyx_t_4) : __Pyx_PyObject_CallNoArg(__pyx_t_16);
__Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 366, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0;
__pyx_t_16 = PySequence_List(__pyx_t_1); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 366, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_16);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__pyx_t_1 = __pyx_t_16; __Pyx_INCREF(__pyx_t_1); __pyx_t_9 = 0;
__Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0;
for (;;) {
if (__pyx_t_9 >= PyList_GET_SIZE(__pyx_t_1)) break;
#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
__pyx_t_16 = PyList_GET_ITEM(__pyx_t_1, __pyx_t_9); __Pyx_INCREF(__pyx_t_16); __pyx_t_9++; if (unlikely(0 < 0)) __PYX_ERR(0, 366, __pyx_L1_error)
#else
__pyx_t_16 = PySequence_ITEM(__pyx_t_1, __pyx_t_9); __pyx_t_9++; if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 366, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_16);
#endif
if ((likely(PyTuple_CheckExact(__pyx_t_16))) || (PyList_CheckExact(__pyx_t_16))) {
PyObject* sequence = __pyx_t_16;
Py_ssize_t size = __Pyx_PySequence_SIZE(sequence);
if (unlikely(size != 2)) {
if (size > 2) __Pyx_RaiseTooManyValuesError(2);
else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
__PYX_ERR(0, 366, __pyx_L1_error)
}
#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
if (likely(PyTuple_CheckExact(sequence))) {
__pyx_t_4 = PyTuple_GET_ITEM(sequence, 0);
__pyx_t_3 = PyTuple_GET_ITEM(sequence, 1);
} else {
__pyx_t_4 = PyList_GET_ITEM(sequence, 0);
__pyx_t_3 = PyList_GET_ITEM(sequence, 1);
}
__Pyx_INCREF(__pyx_t_4);
__Pyx_INCREF(__pyx_t_3);
#else
__pyx_t_4 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 366, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__pyx_t_3 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 366, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
#endif
__Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0;
} else {
Py_ssize_t index = -1;
__pyx_t_7 = PyObject_GetIter(__pyx_t_16); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 366, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0;
__pyx_t_8 = Py_TYPE(__pyx_t_7)->tp_iternext;
index = 0; __pyx_t_4 = __pyx_t_8(__pyx_t_7); if (unlikely(!__pyx_t_4)) goto __pyx_L32_unpacking_failed;
__Pyx_GOTREF(__pyx_t_4);
index = 1; __pyx_t_3 = __pyx_t_8(__pyx_t_7); if (unlikely(!__pyx_t_3)) goto __pyx_L32_unpacking_failed;
__Pyx_GOTREF(__pyx_t_3);
if (__Pyx_IternextUnpackEndCheck(__pyx_t_8(__pyx_t_7), 2) < 0) __PYX_ERR(0, 366, __pyx_L1_error)
__pyx_t_8 = NULL;
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
goto __pyx_L33_unpacking_done;
__pyx_L32_unpacking_failed:;
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
__pyx_t_8 = NULL;
if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index);
__PYX_ERR(0, 366, __pyx_L1_error)
__pyx_L33_unpacking_done:;
}
__Pyx_XDECREF_SET(__pyx_v_label, __pyx_t_4);
__pyx_t_4 = 0;
__Pyx_XDECREF_SET(__pyx_v_freq, __pyx_t_3);
__pyx_t_3 = 0;
/* "spacy/syntax/arc_eager.pyx":367
* for action, label_freqs in actions.items():
* for label, freq in list(label_freqs.items()):
* if freq < min_freq: # <<<<<<<<<<<<<<
* label_freqs.pop(label)
* # Ensure these actions are present
*/
__pyx_t_16 = PyObject_RichCompare(__pyx_v_freq, __pyx_v_min_freq, Py_LT); __Pyx_XGOTREF(__pyx_t_16); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 367, __pyx_L1_error)
__pyx_t_23 = __Pyx_PyObject_IsTrue(__pyx_t_16); if (unlikely(__pyx_t_23 < 0)) __PYX_ERR(0, 367, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0;
if (__pyx_t_23) {
/* "spacy/syntax/arc_eager.pyx":368
* for label, freq in list(label_freqs.items()):
* if freq < min_freq:
* label_freqs.pop(label) # <<<<<<<<<<<<<<
* # Ensure these actions are present
* actions[BREAK].setdefault('ROOT', 0)
*/
__pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_label_freqs, __pyx_n_s_pop); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 368, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__pyx_t_4 = NULL;
if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) {
__pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3);
if (likely(__pyx_t_4)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
__Pyx_INCREF(__pyx_t_4);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_3, function);
}
}
__pyx_t_16 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_4, __pyx_v_label) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_v_label);
__Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 368, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_16);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0;
/* "spacy/syntax/arc_eager.pyx":367
* for action, label_freqs in actions.items():
* for label, freq in list(label_freqs.items()):
* if freq < min_freq: # <<<<<<<<<<<<<<
* label_freqs.pop(label)
* # Ensure these actions are present
*/
}
/* "spacy/syntax/arc_eager.pyx":366
* if min_freq is not None:
* for action, label_freqs in actions.items():
* for label, freq in list(label_freqs.items()): # <<<<<<<<<<<<<<
* if freq < min_freq:
* label_freqs.pop(label)
*/
}
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
/* "spacy/syntax/arc_eager.pyx":365
* actions[SHIFT][''] += 1
* if min_freq is not None:
* for action, label_freqs in actions.items(): # <<<<<<<<<<<<<<
* for label, freq in list(label_freqs.items()):
* if freq < min_freq:
*/
}
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
/* "spacy/syntax/arc_eager.pyx":364
* actions[LEFT][label] += 1
* actions[SHIFT][''] += 1
* if min_freq is not None: # <<<<<<<<<<<<<<
* for action, label_freqs in actions.items():
* for label, freq in list(label_freqs.items()):
*/
}
/* "spacy/syntax/arc_eager.pyx":370
* label_freqs.pop(label)
* # Ensure these actions are present
* actions[BREAK].setdefault('ROOT', 0) # <<<<<<<<<<<<<<
* if kwargs.get("learn_tokens") is True:
* actions[RIGHT].setdefault('subtok', 0)
*/
__pyx_t_2 = __Pyx_GetItemInt(__pyx_v_actions, __pyx_e_5spacy_6syntax_9arc_eager_BREAK, int, 1, __Pyx_PyInt_From_int, 0, 1, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 370, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_setdefault); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 370, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_tuple__2, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 370, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
/* "spacy/syntax/arc_eager.pyx":371
* # Ensure these actions are present
* actions[BREAK].setdefault('ROOT', 0)
* if kwargs.get("learn_tokens") is True: # <<<<<<<<<<<<<<
* actions[RIGHT].setdefault('subtok', 0)
* actions[LEFT].setdefault('subtok', 0)
*/
__pyx_t_2 = __Pyx_PyDict_GetItemDefault(__pyx_v_kwargs, __pyx_n_u_learn_tokens, Py_None); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 371, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__pyx_t_23 = (__pyx_t_2 == Py_True);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__pyx_t_21 = (__pyx_t_23 != 0);
if (__pyx_t_21) {
/* "spacy/syntax/arc_eager.pyx":372
* actions[BREAK].setdefault('ROOT', 0)
* if kwargs.get("learn_tokens") is True:
* actions[RIGHT].setdefault('subtok', 0) # <<<<<<<<<<<<<<
* actions[LEFT].setdefault('subtok', 0)
* # Used for backoff
*/
__pyx_t_2 = __Pyx_GetItemInt(__pyx_v_actions, __pyx_e_5spacy_6syntax_9arc_eager_RIGHT, int, 1, __Pyx_PyInt_From_int, 0, 1, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 372, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_setdefault); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 372, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_tuple__3, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 372, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
/* "spacy/syntax/arc_eager.pyx":373
* if kwargs.get("learn_tokens") is True:
* actions[RIGHT].setdefault('subtok', 0)
* actions[LEFT].setdefault('subtok', 0) # <<<<<<<<<<<<<<
* # Used for backoff
* actions[RIGHT].setdefault('dep', 0)
*/
__pyx_t_2 = __Pyx_GetItemInt(__pyx_v_actions, __pyx_e_5spacy_6syntax_9arc_eager_LEFT, int, 1, __Pyx_PyInt_From_int, 0, 1, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 373, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_setdefault); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 373, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_tuple__3, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 373, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
/* "spacy/syntax/arc_eager.pyx":371
* # Ensure these actions are present
* actions[BREAK].setdefault('ROOT', 0)
* if kwargs.get("learn_tokens") is True: # <<<<<<<<<<<<<<
* actions[RIGHT].setdefault('subtok', 0)
* actions[LEFT].setdefault('subtok', 0)
*/
}
/* "spacy/syntax/arc_eager.pyx":375
* actions[LEFT].setdefault('subtok', 0)
* # Used for backoff
* actions[RIGHT].setdefault('dep', 0) # <<<<<<<<<<<<<<
* actions[LEFT].setdefault('dep', 0)
* return actions
*/
__pyx_t_2 = __Pyx_GetItemInt(__pyx_v_actions, __pyx_e_5spacy_6syntax_9arc_eager_RIGHT, int, 1, __Pyx_PyInt_From_int, 0, 1, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 375, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_setdefault); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 375, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_tuple__4, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 375, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
/* "spacy/syntax/arc_eager.pyx":376
* # Used for backoff
* actions[RIGHT].setdefault('dep', 0)
* actions[LEFT].setdefault('dep', 0) # <<<<<<<<<<<<<<
* return actions
*
*/
__pyx_t_2 = __Pyx_GetItemInt(__pyx_v_actions, __pyx_e_5spacy_6syntax_9arc_eager_LEFT, int, 1, __Pyx_PyInt_From_int, 0, 1, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 376, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_setdefault); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 376, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_tuple__4, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 376, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
/* "spacy/syntax/arc_eager.pyx":377
* actions[RIGHT].setdefault('dep', 0)
* actions[LEFT].setdefault('dep', 0)
* return actions # <<<<<<<<<<<<<<
*
* @property
*/
__Pyx_XDECREF(__pyx_r);
__Pyx_INCREF(__pyx_v_actions);
__pyx_r = __pyx_v_actions;
goto __pyx_L0;
/* "spacy/syntax/arc_eager.pyx":339
*
* @classmethod
* def get_actions(cls, **kwargs): # <<<<<<<<<<<<<<
* min_freq = kwargs.get('min_freq', None)
* actions = defaultdict(lambda: Counter())
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_1);
__Pyx_XDECREF(__pyx_t_2);
__Pyx_XDECREF(__pyx_t_3);
__Pyx_XDECREF(__pyx_t_4);
__Pyx_XDECREF(__pyx_t_7);
__Pyx_XDECREF(__pyx_t_11);
__Pyx_XDECREF(__pyx_t_12);
__Pyx_XDECREF(__pyx_t_13);
__Pyx_XDECREF(__pyx_t_14);
__Pyx_XDECREF(__pyx_t_15);
__Pyx_XDECREF(__pyx_t_16);
__Pyx_XDECREF(__pyx_t_17);
__Pyx_XDECREF(__pyx_t_22);
__Pyx_AddTraceback("spacy.syntax.arc_eager.ArcEager.get_actions", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = NULL;
__pyx_L0:;
__Pyx_XDECREF(__pyx_v_min_freq);
__Pyx_XDECREF(__pyx_v_actions);
__Pyx_XDECREF(__pyx_v_label);
__Pyx_XDECREF(__pyx_v_raw_text);
__Pyx_XDECREF(__pyx_v_sents);
__Pyx_XDECREF(__pyx_v_ids);
__Pyx_XDECREF(__pyx_v_words);
__Pyx_XDECREF(__pyx_v_tags);
__Pyx_XDECREF(__pyx_v_heads);
__Pyx_XDECREF(__pyx_v_labels);
__Pyx_XDECREF(__pyx_v_iob);
__Pyx_XDECREF(__pyx_v_ctnts);
__Pyx_XDECREF(__pyx_v_child);
__Pyx_XDECREF(__pyx_v_head);
__Pyx_XDECREF(__pyx_v_action);
__Pyx_XDECREF(__pyx_v_label_freqs);
__Pyx_XDECREF(__pyx_v_freq);
__Pyx_XGIVEREF(__pyx_r);
__Pyx_TraceReturn(__pyx_r, 0);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "spacy/syntax/arc_eager.pyx":380
*
* @property
* def action_types(self): # <<<<<<<<<<<<<<
* return (SHIFT, REDUCE, LEFT, RIGHT, BREAK)
*
*/
/* Python wrapper */
static PyObject *__pyx_pw_5spacy_6syntax_9arc_eager_8ArcEager_12action_types_1__get__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_5spacy_6syntax_9arc_eager_8ArcEager_12action_types_1__get__(PyObject *__pyx_v_self) {
PyObject *__pyx_r = 0;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
__pyx_r = __pyx_pf_5spacy_6syntax_9arc_eager_8ArcEager_12action_types___get__(((struct __pyx_obj_5spacy_6syntax_9arc_eager_ArcEager *)__pyx_v_self));
/* function exit code */
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
static PyObject *__pyx_pf_5spacy_6syntax_9arc_eager_8ArcEager_12action_types___get__(CYTHON_UNUSED struct __pyx_obj_5spacy_6syntax_9arc_eager_ArcEager *__pyx_v_self) {
PyObject *__pyx_r = NULL;
__Pyx_TraceDeclarations
__Pyx_RefNannyDeclarations
PyObject *__pyx_t_1 = NULL;
PyObject *__pyx_t_2 = NULL;
PyObject *__pyx_t_3 = NULL;
PyObject *__pyx_t_4 = NULL;
PyObject *__pyx_t_5 = NULL;
PyObject *__pyx_t_6 = NULL;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("__get__", 0);
__Pyx_TraceCall("__get__", __pyx_f[0], 380, 0, __PYX_ERR(0, 380, __pyx_L1_error));
/* "spacy/syntax/arc_eager.pyx":381
* @property
* def action_types(self):
* return (SHIFT, REDUCE, LEFT, RIGHT, BREAK) # <<<<<<<<<<<<<<
*
* def get_cost(self, StateClass state, GoldParse gold, action):
*/
__Pyx_XDECREF(__pyx_r);
__pyx_t_1 = __Pyx_PyInt_From_int(__pyx_e_5spacy_6syntax_9arc_eager_SHIFT); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 381, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_t_2 = __Pyx_PyInt_From_int(__pyx_e_5spacy_6syntax_9arc_eager_REDUCE); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 381, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__pyx_t_3 = __Pyx_PyInt_From_int(__pyx_e_5spacy_6syntax_9arc_eager_LEFT); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 381, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__pyx_t_4 = __Pyx_PyInt_From_int(__pyx_e_5spacy_6syntax_9arc_eager_RIGHT); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 381, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__pyx_t_5 = __Pyx_PyInt_From_int(__pyx_e_5spacy_6syntax_9arc_eager_BREAK); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 381, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__pyx_t_6 = PyTuple_New(5); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 381, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_GIVEREF(__pyx_t_1);
PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_1);
__Pyx_GIVEREF(__pyx_t_2);
PyTuple_SET_ITEM(__pyx_t_6, 1, __pyx_t_2);
__Pyx_GIVEREF(__pyx_t_3);
PyTuple_SET_ITEM(__pyx_t_6, 2, __pyx_t_3);
__Pyx_GIVEREF(__pyx_t_4);
PyTuple_SET_ITEM(__pyx_t_6, 3, __pyx_t_4);
__Pyx_GIVEREF(__pyx_t_5);
PyTuple_SET_ITEM(__pyx_t_6, 4, __pyx_t_5);
__pyx_t_1 = 0;
__pyx_t_2 = 0;
__pyx_t_3 = 0;
__pyx_t_4 = 0;
__pyx_t_5 = 0;
__pyx_r = __pyx_t_6;
__pyx_t_6 = 0;
goto __pyx_L0;
/* "spacy/syntax/arc_eager.pyx":380
*
* @property
* def action_types(self): # <<<<<<<<<<<<<<
* return (SHIFT, REDUCE, LEFT, RIGHT, BREAK)
*
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_1);
__Pyx_XDECREF(__pyx_t_2);
__Pyx_XDECREF(__pyx_t_3);
__Pyx_XDECREF(__pyx_t_4);
__Pyx_XDECREF(__pyx_t_5);
__Pyx_XDECREF(__pyx_t_6);
__Pyx_AddTraceback("spacy.syntax.arc_eager.ArcEager.action_types.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = NULL;
__pyx_L0:;
__Pyx_XGIVEREF(__pyx_r);
__Pyx_TraceReturn(__pyx_r, 0);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "spacy/syntax/arc_eager.pyx":383
* return (SHIFT, REDUCE, LEFT, RIGHT, BREAK)
*
* def get_cost(self, StateClass state, GoldParse gold, action): # <<<<<<<<<<<<<<
* cdef Transition t = self.lookup_transition(action)
* if not t.is_valid(state.c, t.label):
*/
/* Python wrapper */
static PyObject *__pyx_pw_5spacy_6syntax_9arc_eager_8ArcEager_5get_cost(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static PyObject *__pyx_pw_5spacy_6syntax_9arc_eager_8ArcEager_5get_cost(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *__pyx_v_state = 0;
struct __pyx_obj_5spacy_4gold_GoldParse *__pyx_v_gold = 0;
PyObject *__pyx_v_action = 0;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
PyObject *__pyx_r = 0;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("get_cost (wrapper)", 0);
{
static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_state,&__pyx_n_s_gold,&__pyx_n_s_action,0};
PyObject* values[3] = {0,0,0};
if (unlikely(__pyx_kwds)) {
Py_ssize_t kw_args;
const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
switch (pos_args) {
case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
CYTHON_FALLTHROUGH;
case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
CYTHON_FALLTHROUGH;
case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
CYTHON_FALLTHROUGH;
case 0: break;
default: goto __pyx_L5_argtuple_error;
}
kw_args = PyDict_Size(__pyx_kwds);
switch (pos_args) {
case 0:
if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_state)) != 0)) kw_args--;
else goto __pyx_L5_argtuple_error;
CYTHON_FALLTHROUGH;
case 1:
if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_gold)) != 0)) kw_args--;
else {
__Pyx_RaiseArgtupleInvalid("get_cost", 1, 3, 3, 1); __PYX_ERR(0, 383, __pyx_L3_error)
}
CYTHON_FALLTHROUGH;
case 2:
if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_action)) != 0)) kw_args--;
else {
__Pyx_RaiseArgtupleInvalid("get_cost", 1, 3, 3, 2); __PYX_ERR(0, 383, __pyx_L3_error)
}
}
if (unlikely(kw_args > 0)) {
if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "get_cost") < 0)) __PYX_ERR(0, 383, __pyx_L3_error)
}
} else if (PyTuple_GET_SIZE(__pyx_args) != 3) {
goto __pyx_L5_argtuple_error;
} else {
values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
}
__pyx_v_state = ((struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *)values[0]);
__pyx_v_gold = ((struct __pyx_obj_5spacy_4gold_GoldParse *)values[1]);
__pyx_v_action = values[2];
}
goto __pyx_L4_argument_unpacking_done;
__pyx_L5_argtuple_error:;
__Pyx_RaiseArgtupleInvalid("get_cost", 1, 3, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 383, __pyx_L3_error)
__pyx_L3_error:;
__Pyx_AddTraceback("spacy.syntax.arc_eager.ArcEager.get_cost", __pyx_clineno, __pyx_lineno, __pyx_filename);
__Pyx_RefNannyFinishContext();
return NULL;
__pyx_L4_argument_unpacking_done:;
if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_state), __pyx_ptype_5spacy_6syntax_10stateclass_StateClass, 1, "state", 0))) __PYX_ERR(0, 383, __pyx_L1_error)
if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_gold), __pyx_ptype_5spacy_4gold_GoldParse, 1, "gold", 0))) __PYX_ERR(0, 383, __pyx_L1_error)
__pyx_r = __pyx_pf_5spacy_6syntax_9arc_eager_8ArcEager_4get_cost(((struct __pyx_obj_5spacy_6syntax_9arc_eager_ArcEager *)__pyx_v_self), __pyx_v_state, __pyx_v_gold, __pyx_v_action);
/* function exit code */
goto __pyx_L0;
__pyx_L1_error:;
__pyx_r = NULL;
__pyx_L0:;
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
static PyObject *__pyx_pf_5spacy_6syntax_9arc_eager_8ArcEager_4get_cost(struct __pyx_obj_5spacy_6syntax_9arc_eager_ArcEager *__pyx_v_self, struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *__pyx_v_state, struct __pyx_obj_5spacy_4gold_GoldParse *__pyx_v_gold, PyObject *__pyx_v_action) {
struct __pyx_t_5spacy_6syntax_17transition_system_Transition __pyx_v_t;
PyObject *__pyx_r = NULL;
__Pyx_TraceDeclarations
__Pyx_RefNannyDeclarations
struct __pyx_t_5spacy_6syntax_17transition_system_Transition __pyx_t_1;
int __pyx_t_2;
PyObject *__pyx_t_3 = NULL;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("get_cost", 0);
__Pyx_TraceCall("get_cost", __pyx_f[0], 383, 0, __PYX_ERR(0, 383, __pyx_L1_error));
/* "spacy/syntax/arc_eager.pyx":384
*
* def get_cost(self, StateClass state, GoldParse gold, action):
* cdef Transition t = self.lookup_transition(action) # <<<<<<<<<<<<<<
* if not t.is_valid(state.c, t.label):
* return 9000
*/
__pyx_t_1 = ((struct __pyx_vtabstruct_5spacy_6syntax_9arc_eager_ArcEager *)__pyx_v_self->__pyx_base.__pyx_vtab)->__pyx_base.lookup_transition(((struct __pyx_obj_5spacy_6syntax_17transition_system_TransitionSystem *)__pyx_v_self), __pyx_v_action); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 384, __pyx_L1_error)
__pyx_v_t = __pyx_t_1;
/* "spacy/syntax/arc_eager.pyx":385
* def get_cost(self, StateClass state, GoldParse gold, action):
* cdef Transition t = self.lookup_transition(action)
* if not t.is_valid(state.c, t.label): # <<<<<<<<<<<<<<
* return 9000
* else:
*/
__pyx_t_2 = ((!(__pyx_v_t.is_valid(__pyx_v_state->c, __pyx_v_t.label) != 0)) != 0);
if (__pyx_t_2) {
/* "spacy/syntax/arc_eager.pyx":386
* cdef Transition t = self.lookup_transition(action)
* if not t.is_valid(state.c, t.label):
* return 9000 # <<<<<<<<<<<<<<
* else:
* return t.get_cost(state, &gold.c, t.label)
*/
__Pyx_XDECREF(__pyx_r);
__Pyx_INCREF(__pyx_int_9000);
__pyx_r = __pyx_int_9000;
goto __pyx_L0;
/* "spacy/syntax/arc_eager.pyx":385
* def get_cost(self, StateClass state, GoldParse gold, action):
* cdef Transition t = self.lookup_transition(action)
* if not t.is_valid(state.c, t.label): # <<<<<<<<<<<<<<
* return 9000
* else:
*/
}
/* "spacy/syntax/arc_eager.pyx":388
* return 9000
* else:
* return t.get_cost(state, &gold.c, t.label) # <<<<<<<<<<<<<<
*
* def transition(self, StateClass state, action):
*/
/*else*/ {
__Pyx_XDECREF(__pyx_r);
__pyx_t_3 = PyFloat_FromDouble(__pyx_v_t.get_cost(__pyx_v_state, (&__pyx_v_gold->c), __pyx_v_t.label)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 388, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__pyx_r = __pyx_t_3;
__pyx_t_3 = 0;
goto __pyx_L0;
}
/* "spacy/syntax/arc_eager.pyx":383
* return (SHIFT, REDUCE, LEFT, RIGHT, BREAK)
*
* def get_cost(self, StateClass state, GoldParse gold, action): # <<<<<<<<<<<<<<
* cdef Transition t = self.lookup_transition(action)
* if not t.is_valid(state.c, t.label):
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_3);
__Pyx_AddTraceback("spacy.syntax.arc_eager.ArcEager.get_cost", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = NULL;
__pyx_L0:;
__Pyx_XGIVEREF(__pyx_r);
__Pyx_TraceReturn(__pyx_r, 0);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "spacy/syntax/arc_eager.pyx":390
* return t.get_cost(state, &gold.c, t.label)
*
* def transition(self, StateClass state, action): # <<<<<<<<<<<<<<
* cdef Transition t = self.lookup_transition(action)
* t.do(state.c, t.label)
*/
/* Python wrapper */
static PyObject *__pyx_pw_5spacy_6syntax_9arc_eager_8ArcEager_7transition(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static PyObject *__pyx_pw_5spacy_6syntax_9arc_eager_8ArcEager_7transition(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *__pyx_v_state = 0;
PyObject *__pyx_v_action = 0;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
PyObject *__pyx_r = 0;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("transition (wrapper)", 0);
{
static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_state,&__pyx_n_s_action,0};
PyObject* values[2] = {0,0};
if (unlikely(__pyx_kwds)) {
Py_ssize_t kw_args;
const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
switch (pos_args) {
case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
CYTHON_FALLTHROUGH;
case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
CYTHON_FALLTHROUGH;
case 0: break;
default: goto __pyx_L5_argtuple_error;
}
kw_args = PyDict_Size(__pyx_kwds);
switch (pos_args) {
case 0:
if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_state)) != 0)) kw_args--;
else goto __pyx_L5_argtuple_error;
CYTHON_FALLTHROUGH;
case 1:
if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_action)) != 0)) kw_args--;
else {
__Pyx_RaiseArgtupleInvalid("transition", 1, 2, 2, 1); __PYX_ERR(0, 390, __pyx_L3_error)
}
}
if (unlikely(kw_args > 0)) {
if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "transition") < 0)) __PYX_ERR(0, 390, __pyx_L3_error)
}
} else if (PyTuple_GET_SIZE(__pyx_args) != 2) {
goto __pyx_L5_argtuple_error;
} else {
values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
}
__pyx_v_state = ((struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *)values[0]);
__pyx_v_action = values[1];
}
goto __pyx_L4_argument_unpacking_done;
__pyx_L5_argtuple_error:;
__Pyx_RaiseArgtupleInvalid("transition", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 390, __pyx_L3_error)
__pyx_L3_error:;
__Pyx_AddTraceback("spacy.syntax.arc_eager.ArcEager.transition", __pyx_clineno, __pyx_lineno, __pyx_filename);
__Pyx_RefNannyFinishContext();
return NULL;
__pyx_L4_argument_unpacking_done:;
if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_state), __pyx_ptype_5spacy_6syntax_10stateclass_StateClass, 1, "state", 0))) __PYX_ERR(0, 390, __pyx_L1_error)
__pyx_r = __pyx_pf_5spacy_6syntax_9arc_eager_8ArcEager_6transition(((struct __pyx_obj_5spacy_6syntax_9arc_eager_ArcEager *)__pyx_v_self), __pyx_v_state, __pyx_v_action);
/* function exit code */
goto __pyx_L0;
__pyx_L1_error:;
__pyx_r = NULL;
__pyx_L0:;
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
static PyObject *__pyx_pf_5spacy_6syntax_9arc_eager_8ArcEager_6transition(struct __pyx_obj_5spacy_6syntax_9arc_eager_ArcEager *__pyx_v_self, struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *__pyx_v_state, PyObject *__pyx_v_action) {
struct __pyx_t_5spacy_6syntax_17transition_system_Transition __pyx_v_t;
PyObject *__pyx_r = NULL;
__Pyx_TraceDeclarations
__Pyx_RefNannyDeclarations
struct __pyx_t_5spacy_6syntax_17transition_system_Transition __pyx_t_1;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("transition", 0);
__Pyx_TraceCall("transition", __pyx_f[0], 390, 0, __PYX_ERR(0, 390, __pyx_L1_error));
/* "spacy/syntax/arc_eager.pyx":391
*
* def transition(self, StateClass state, action):
* cdef Transition t = self.lookup_transition(action) # <<<<<<<<<<<<<<
* t.do(state.c, t.label)
* return state
*/
__pyx_t_1 = ((struct __pyx_vtabstruct_5spacy_6syntax_9arc_eager_ArcEager *)__pyx_v_self->__pyx_base.__pyx_vtab)->__pyx_base.lookup_transition(((struct __pyx_obj_5spacy_6syntax_17transition_system_TransitionSystem *)__pyx_v_self), __pyx_v_action); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 391, __pyx_L1_error)
__pyx_v_t = __pyx_t_1;
/* "spacy/syntax/arc_eager.pyx":392
* def transition(self, StateClass state, action):
* cdef Transition t = self.lookup_transition(action)
* t.do(state.c, t.label) # <<<<<<<<<<<<<<
* return state
*
*/
(void)(__pyx_v_t.__pyx_do(__pyx_v_state->c, __pyx_v_t.label));
/* "spacy/syntax/arc_eager.pyx":393
* cdef Transition t = self.lookup_transition(action)
* t.do(state.c, t.label)
* return state # <<<<<<<<<<<<<<
*
* def is_gold_parse(self, StateClass state, GoldParse gold):
*/
__Pyx_XDECREF(__pyx_r);
__Pyx_INCREF(((PyObject *)__pyx_v_state));
__pyx_r = ((PyObject *)__pyx_v_state);
goto __pyx_L0;
/* "spacy/syntax/arc_eager.pyx":390
* return t.get_cost(state, &gold.c, t.label)
*
* def transition(self, StateClass state, action): # <<<<<<<<<<<<<<
* cdef Transition t = self.lookup_transition(action)
* t.do(state.c, t.label)
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_AddTraceback("spacy.syntax.arc_eager.ArcEager.transition", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = NULL;
__pyx_L0:;
__Pyx_XGIVEREF(__pyx_r);
__Pyx_TraceReturn(__pyx_r, 0);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "spacy/syntax/arc_eager.pyx":395
* return state
*
* def is_gold_parse(self, StateClass state, GoldParse gold): # <<<<<<<<<<<<<<
* predicted = set()
* truth = set()
*/
/* Python wrapper */
static PyObject *__pyx_pw_5spacy_6syntax_9arc_eager_8ArcEager_9is_gold_parse(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static PyObject *__pyx_pw_5spacy_6syntax_9arc_eager_8ArcEager_9is_gold_parse(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *__pyx_v_state = 0;
struct __pyx_obj_5spacy_4gold_GoldParse *__pyx_v_gold = 0;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
PyObject *__pyx_r = 0;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("is_gold_parse (wrapper)", 0);
{
static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_state,&__pyx_n_s_gold,0};
PyObject* values[2] = {0,0};
if (unlikely(__pyx_kwds)) {
Py_ssize_t kw_args;
const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
switch (pos_args) {
case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
CYTHON_FALLTHROUGH;
case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
CYTHON_FALLTHROUGH;
case 0: break;
default: goto __pyx_L5_argtuple_error;
}
kw_args = PyDict_Size(__pyx_kwds);
switch (pos_args) {
case 0:
if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_state)) != 0)) kw_args--;
else goto __pyx_L5_argtuple_error;
CYTHON_FALLTHROUGH;
case 1:
if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_gold)) != 0)) kw_args--;
else {
__Pyx_RaiseArgtupleInvalid("is_gold_parse", 1, 2, 2, 1); __PYX_ERR(0, 395, __pyx_L3_error)
}
}
if (unlikely(kw_args > 0)) {
if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "is_gold_parse") < 0)) __PYX_ERR(0, 395, __pyx_L3_error)
}
} else if (PyTuple_GET_SIZE(__pyx_args) != 2) {
goto __pyx_L5_argtuple_error;
} else {
values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
}
__pyx_v_state = ((struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *)values[0]);
__pyx_v_gold = ((struct __pyx_obj_5spacy_4gold_GoldParse *)values[1]);
}
goto __pyx_L4_argument_unpacking_done;
__pyx_L5_argtuple_error:;
__Pyx_RaiseArgtupleInvalid("is_gold_parse", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 395, __pyx_L3_error)
__pyx_L3_error:;
__Pyx_AddTraceback("spacy.syntax.arc_eager.ArcEager.is_gold_parse", __pyx_clineno, __pyx_lineno, __pyx_filename);
__Pyx_RefNannyFinishContext();
return NULL;
__pyx_L4_argument_unpacking_done:;
if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_state), __pyx_ptype_5spacy_6syntax_10stateclass_StateClass, 1, "state", 0))) __PYX_ERR(0, 395, __pyx_L1_error)
if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_gold), __pyx_ptype_5spacy_4gold_GoldParse, 1, "gold", 0))) __PYX_ERR(0, 395, __pyx_L1_error)
__pyx_r = __pyx_pf_5spacy_6syntax_9arc_eager_8ArcEager_8is_gold_parse(((struct __pyx_obj_5spacy_6syntax_9arc_eager_ArcEager *)__pyx_v_self), __pyx_v_state, __pyx_v_gold);
/* function exit code */
goto __pyx_L0;
__pyx_L1_error:;
__pyx_r = NULL;
__pyx_L0:;
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
static PyObject *__pyx_pf_5spacy_6syntax_9arc_eager_8ArcEager_8is_gold_parse(struct __pyx_obj_5spacy_6syntax_9arc_eager_ArcEager *__pyx_v_self, struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *__pyx_v_state, struct __pyx_obj_5spacy_4gold_GoldParse *__pyx_v_gold) {
PyObject *__pyx_v_predicted = NULL;
PyObject *__pyx_v_truth = NULL;
int __pyx_v_i;
PyObject *__pyx_v_id_ = NULL;
CYTHON_UNUSED PyObject *__pyx_v_word = NULL;
CYTHON_UNUSED PyObject *__pyx_v_tag = NULL;
PyObject *__pyx_v_head = NULL;
PyObject *__pyx_v_dep = NULL;
CYTHON_UNUSED PyObject *__pyx_v_ner = NULL;
PyObject *__pyx_r = NULL;
__Pyx_TraceDeclarations
__Pyx_RefNannyDeclarations
PyObject *__pyx_t_1 = NULL;
int __pyx_t_2;
int __pyx_t_3;
int __pyx_t_4;
int __pyx_t_5;
int __pyx_t_6;
PyObject *__pyx_t_7 = NULL;
__pyx_t_5spacy_8typedefs_attr_t __pyx_t_8;
PyObject *__pyx_t_9 = NULL;
PyObject *__pyx_t_10 = NULL;
int __pyx_t_11;
PyObject *__pyx_t_12 = NULL;
PyObject *__pyx_t_13 = NULL;
PyObject *__pyx_t_14 = NULL;
PyObject *__pyx_t_15 = NULL;
PyObject *(*__pyx_t_16)(PyObject *);
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("is_gold_parse", 0);
__Pyx_TraceCall("is_gold_parse", __pyx_f[0], 395, 0, __PYX_ERR(0, 395, __pyx_L1_error));
/* "spacy/syntax/arc_eager.pyx":396
*
* def is_gold_parse(self, StateClass state, GoldParse gold):
* predicted = set() # <<<<<<<<<<<<<<
* truth = set()
* for i in range(gold.length):
*/
__pyx_t_1 = PySet_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 396, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_v_predicted = ((PyObject*)__pyx_t_1);
__pyx_t_1 = 0;
/* "spacy/syntax/arc_eager.pyx":397
* def is_gold_parse(self, StateClass state, GoldParse gold):
* predicted = set()
* truth = set() # <<<<<<<<<<<<<<
* for i in range(gold.length):
* if gold.cand_to_gold[i] is None:
*/
__pyx_t_1 = PySet_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 397, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_v_truth = ((PyObject*)__pyx_t_1);
__pyx_t_1 = 0;
/* "spacy/syntax/arc_eager.pyx":398
* predicted = set()
* truth = set()
* for i in range(gold.length): # <<<<<<<<<<<<<<
* if gold.cand_to_gold[i] is None:
* continue
*/
__pyx_t_2 = __pyx_v_gold->length;
__pyx_t_3 = __pyx_t_2;
for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) {
__pyx_v_i = __pyx_t_4;
/* "spacy/syntax/arc_eager.pyx":399
* truth = set()
* for i in range(gold.length):
* if gold.cand_to_gold[i] is None: # <<<<<<<<<<<<<<
* continue
* if state.safe_get(i).dep:
*/
if (unlikely(__pyx_v_gold->cand_to_gold == Py_None)) {
PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable");
__PYX_ERR(0, 399, __pyx_L1_error)
}
__pyx_t_1 = __Pyx_GetItemInt_List(__pyx_v_gold->cand_to_gold, __pyx_v_i, int, 1, __Pyx_PyInt_From_int, 1, 1, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 399, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_t_5 = (__pyx_t_1 == Py_None);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__pyx_t_6 = (__pyx_t_5 != 0);
if (__pyx_t_6) {
/* "spacy/syntax/arc_eager.pyx":400
* for i in range(gold.length):
* if gold.cand_to_gold[i] is None:
* continue # <<<<<<<<<<<<<<
* if state.safe_get(i).dep:
* predicted.add((i, state.H(i),
*/
goto __pyx_L3_continue;
/* "spacy/syntax/arc_eager.pyx":399
* truth = set()
* for i in range(gold.length):
* if gold.cand_to_gold[i] is None: # <<<<<<<<<<<<<<
* continue
* if state.safe_get(i).dep:
*/
}
/* "spacy/syntax/arc_eager.pyx":401
* if gold.cand_to_gold[i] is None:
* continue
* if state.safe_get(i).dep: # <<<<<<<<<<<<<<
* predicted.add((i, state.H(i),
* self.strings[state.safe_get(i).dep]))
*/
__pyx_t_6 = (__pyx_f_5spacy_6syntax_10stateclass_10StateClass_safe_get(__pyx_v_state, __pyx_v_i)->dep != 0);
if (__pyx_t_6) {
/* "spacy/syntax/arc_eager.pyx":402
* continue
* if state.safe_get(i).dep:
* predicted.add((i, state.H(i), # <<<<<<<<<<<<<<
* self.strings[state.safe_get(i).dep]))
* else:
*/
__pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_i); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 402, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_t_7 = __Pyx_PyInt_From_int(__pyx_f_5spacy_6syntax_10stateclass_10StateClass_H(__pyx_v_state, __pyx_v_i)); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 402, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
/* "spacy/syntax/arc_eager.pyx":403
* if state.safe_get(i).dep:
* predicted.add((i, state.H(i),
* self.strings[state.safe_get(i).dep])) # <<<<<<<<<<<<<<
* else:
* predicted.add((i, state.H(i), 'ROOT'))
*/
__pyx_t_8 = __pyx_f_5spacy_6syntax_10stateclass_10StateClass_safe_get(__pyx_v_state, __pyx_v_i)->dep;
__pyx_t_9 = __Pyx_GetItemInt(((PyObject *)__pyx_v_self->__pyx_base.strings), __pyx_t_8, __pyx_t_5spacy_8typedefs_attr_t const , 0, __Pyx_PyInt_From_uint64_t, 0, 0, 1); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 403, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_9);
/* "spacy/syntax/arc_eager.pyx":402
* continue
* if state.safe_get(i).dep:
* predicted.add((i, state.H(i), # <<<<<<<<<<<<<<
* self.strings[state.safe_get(i).dep]))
* else:
*/
__pyx_t_10 = PyTuple_New(3); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 402, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_10);
__Pyx_GIVEREF(__pyx_t_1);
PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_t_1);
__Pyx_GIVEREF(__pyx_t_7);
PyTuple_SET_ITEM(__pyx_t_10, 1, __pyx_t_7);
__Pyx_GIVEREF(__pyx_t_9);
PyTuple_SET_ITEM(__pyx_t_10, 2, __pyx_t_9);
__pyx_t_1 = 0;
__pyx_t_7 = 0;
__pyx_t_9 = 0;
__pyx_t_11 = PySet_Add(__pyx_v_predicted, __pyx_t_10); if (unlikely(__pyx_t_11 == ((int)-1))) __PYX_ERR(0, 402, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
/* "spacy/syntax/arc_eager.pyx":401
* if gold.cand_to_gold[i] is None:
* continue
* if state.safe_get(i).dep: # <<<<<<<<<<<<<<
* predicted.add((i, state.H(i),
* self.strings[state.safe_get(i).dep]))
*/
goto __pyx_L6;
}
/* "spacy/syntax/arc_eager.pyx":405
* self.strings[state.safe_get(i).dep]))
* else:
* predicted.add((i, state.H(i), 'ROOT')) # <<<<<<<<<<<<<<
* id_, word, tag, head, dep, ner = gold.orig_annot[gold.cand_to_gold[i]]
* truth.add((id_, head, dep))
*/
/*else*/ {
__pyx_t_10 = __Pyx_PyInt_From_int(__pyx_v_i); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 405, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_10);
__pyx_t_9 = __Pyx_PyInt_From_int(__pyx_f_5spacy_6syntax_10stateclass_10StateClass_H(__pyx_v_state, __pyx_v_i)); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 405, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_9);
__pyx_t_7 = PyTuple_New(3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 405, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_GIVEREF(__pyx_t_10);
PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_10);
__Pyx_GIVEREF(__pyx_t_9);
PyTuple_SET_ITEM(__pyx_t_7, 1, __pyx_t_9);
__Pyx_INCREF(__pyx_n_u_ROOT);
__Pyx_GIVEREF(__pyx_n_u_ROOT);
PyTuple_SET_ITEM(__pyx_t_7, 2, __pyx_n_u_ROOT);
__pyx_t_10 = 0;
__pyx_t_9 = 0;
__pyx_t_11 = PySet_Add(__pyx_v_predicted, __pyx_t_7); if (unlikely(__pyx_t_11 == ((int)-1))) __PYX_ERR(0, 405, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
}
__pyx_L6:;
/* "spacy/syntax/arc_eager.pyx":406
* else:
* predicted.add((i, state.H(i), 'ROOT'))
* id_, word, tag, head, dep, ner = gold.orig_annot[gold.cand_to_gold[i]] # <<<<<<<<<<<<<<
* truth.add((id_, head, dep))
* return truth == predicted
*/
if (unlikely(__pyx_v_gold->orig_annot == Py_None)) {
PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable");
__PYX_ERR(0, 406, __pyx_L1_error)
}
if (unlikely(__pyx_v_gold->cand_to_gold == Py_None)) {
PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable");
__PYX_ERR(0, 406, __pyx_L1_error)
}
__pyx_t_7 = __Pyx_GetItemInt_List(__pyx_v_gold->cand_to_gold, __pyx_v_i, int, 1, __Pyx_PyInt_From_int, 1, 1, 1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 406, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__pyx_t_9 = __Pyx_PyObject_GetItem(__pyx_v_gold->orig_annot, __pyx_t_7); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 406, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_9);
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
if ((likely(PyTuple_CheckExact(__pyx_t_9))) || (PyList_CheckExact(__pyx_t_9))) {
PyObject* sequence = __pyx_t_9;
Py_ssize_t size = __Pyx_PySequence_SIZE(sequence);
if (unlikely(size != 6)) {
if (size > 6) __Pyx_RaiseTooManyValuesError(6);
else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
__PYX_ERR(0, 406, __pyx_L1_error)
}
#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
if (likely(PyTuple_CheckExact(sequence))) {
__pyx_t_7 = PyTuple_GET_ITEM(sequence, 0);
__pyx_t_10 = PyTuple_GET_ITEM(sequence, 1);
__pyx_t_1 = PyTuple_GET_ITEM(sequence, 2);
__pyx_t_12 = PyTuple_GET_ITEM(sequence, 3);
__pyx_t_13 = PyTuple_GET_ITEM(sequence, 4);
__pyx_t_14 = PyTuple_GET_ITEM(sequence, 5);
} else {
__pyx_t_7 = PyList_GET_ITEM(sequence, 0);
__pyx_t_10 = PyList_GET_ITEM(sequence, 1);
__pyx_t_1 = PyList_GET_ITEM(sequence, 2);
__pyx_t_12 = PyList_GET_ITEM(sequence, 3);
__pyx_t_13 = PyList_GET_ITEM(sequence, 4);
__pyx_t_14 = PyList_GET_ITEM(sequence, 5);
}
__Pyx_INCREF(__pyx_t_7);
__Pyx_INCREF(__pyx_t_10);
__Pyx_INCREF(__pyx_t_1);
__Pyx_INCREF(__pyx_t_12);
__Pyx_INCREF(__pyx_t_13);
__Pyx_INCREF(__pyx_t_14);
#else
{
Py_ssize_t i;
PyObject** temps[6] = {&__pyx_t_7,&__pyx_t_10,&__pyx_t_1,&__pyx_t_12,&__pyx_t_13,&__pyx_t_14};
for (i=0; i < 6; i++) {
PyObject* item = PySequence_ITEM(sequence, i); if (unlikely(!item)) __PYX_ERR(0, 406, __pyx_L1_error)
__Pyx_GOTREF(item);
*(temps[i]) = item;
}
}
#endif
__Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
} else {
Py_ssize_t index = -1;
PyObject** temps[6] = {&__pyx_t_7,&__pyx_t_10,&__pyx_t_1,&__pyx_t_12,&__pyx_t_13,&__pyx_t_14};
__pyx_t_15 = PyObject_GetIter(__pyx_t_9); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 406, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_15);
__Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
__pyx_t_16 = Py_TYPE(__pyx_t_15)->tp_iternext;
for (index=0; index < 6; index++) {
PyObject* item = __pyx_t_16(__pyx_t_15); if (unlikely(!item)) goto __pyx_L7_unpacking_failed;
__Pyx_GOTREF(item);
*(temps[index]) = item;
}
if (__Pyx_IternextUnpackEndCheck(__pyx_t_16(__pyx_t_15), 6) < 0) __PYX_ERR(0, 406, __pyx_L1_error)
__pyx_t_16 = NULL;
__Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
goto __pyx_L8_unpacking_done;
__pyx_L7_unpacking_failed:;
__Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
__pyx_t_16 = NULL;
if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index);
__PYX_ERR(0, 406, __pyx_L1_error)
__pyx_L8_unpacking_done:;
}
__Pyx_XDECREF_SET(__pyx_v_id_, __pyx_t_7);
__pyx_t_7 = 0;
__Pyx_XDECREF_SET(__pyx_v_word, __pyx_t_10);
__pyx_t_10 = 0;
__Pyx_XDECREF_SET(__pyx_v_tag, __pyx_t_1);
__pyx_t_1 = 0;
__Pyx_XDECREF_SET(__pyx_v_head, __pyx_t_12);
__pyx_t_12 = 0;
__Pyx_XDECREF_SET(__pyx_v_dep, __pyx_t_13);
__pyx_t_13 = 0;
__Pyx_XDECREF_SET(__pyx_v_ner, __pyx_t_14);
__pyx_t_14 = 0;
/* "spacy/syntax/arc_eager.pyx":407
* predicted.add((i, state.H(i), 'ROOT'))
* id_, word, tag, head, dep, ner = gold.orig_annot[gold.cand_to_gold[i]]
* truth.add((id_, head, dep)) # <<<<<<<<<<<<<<
* return truth == predicted
*
*/
__pyx_t_9 = PyTuple_New(3); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 407, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_9);
__Pyx_INCREF(__pyx_v_id_);
__Pyx_GIVEREF(__pyx_v_id_);
PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_v_id_);
__Pyx_INCREF(__pyx_v_head);
__Pyx_GIVEREF(__pyx_v_head);
PyTuple_SET_ITEM(__pyx_t_9, 1, __pyx_v_head);
__Pyx_INCREF(__pyx_v_dep);
__Pyx_GIVEREF(__pyx_v_dep);
PyTuple_SET_ITEM(__pyx_t_9, 2, __pyx_v_dep);
__pyx_t_11 = PySet_Add(__pyx_v_truth, __pyx_t_9); if (unlikely(__pyx_t_11 == ((int)-1))) __PYX_ERR(0, 407, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
__pyx_L3_continue:;
}
/* "spacy/syntax/arc_eager.pyx":408
* id_, word, tag, head, dep, ner = gold.orig_annot[gold.cand_to_gold[i]]
* truth.add((id_, head, dep))
* return truth == predicted # <<<<<<<<<<<<<<
*
* def has_gold(self, GoldParse gold, start=0, end=None):
*/
__Pyx_XDECREF(__pyx_r);
__pyx_t_9 = PyObject_RichCompare(__pyx_v_truth, __pyx_v_predicted, Py_EQ); __Pyx_XGOTREF(__pyx_t_9); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 408, __pyx_L1_error)
__pyx_r = __pyx_t_9;
__pyx_t_9 = 0;
goto __pyx_L0;
/* "spacy/syntax/arc_eager.pyx":395
* return state
*
* def is_gold_parse(self, StateClass state, GoldParse gold): # <<<<<<<<<<<<<<
* predicted = set()
* truth = set()
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_1);
__Pyx_XDECREF(__pyx_t_7);
__Pyx_XDECREF(__pyx_t_9);
__Pyx_XDECREF(__pyx_t_10);
__Pyx_XDECREF(__pyx_t_12);
__Pyx_XDECREF(__pyx_t_13);
__Pyx_XDECREF(__pyx_t_14);
__Pyx_XDECREF(__pyx_t_15);
__Pyx_AddTraceback("spacy.syntax.arc_eager.ArcEager.is_gold_parse", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = NULL;
__pyx_L0:;
__Pyx_XDECREF(__pyx_v_predicted);
__Pyx_XDECREF(__pyx_v_truth);
__Pyx_XDECREF(__pyx_v_id_);
__Pyx_XDECREF(__pyx_v_word);
__Pyx_XDECREF(__pyx_v_tag);
__Pyx_XDECREF(__pyx_v_head);
__Pyx_XDECREF(__pyx_v_dep);
__Pyx_XDECREF(__pyx_v_ner);
__Pyx_XGIVEREF(__pyx_r);
__Pyx_TraceReturn(__pyx_r, 0);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "spacy/syntax/arc_eager.pyx":410
* return truth == predicted
*
* def has_gold(self, GoldParse gold, start=0, end=None): # <<<<<<<<<<<<<<
* end = end or len(gold.heads)
* if all([tag is None for tag in gold.heads[start:end]]):
*/
/* Python wrapper */
static PyObject *__pyx_pw_5spacy_6syntax_9arc_eager_8ArcEager_11has_gold(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static PyObject *__pyx_pw_5spacy_6syntax_9arc_eager_8ArcEager_11has_gold(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
struct __pyx_obj_5spacy_4gold_GoldParse *__pyx_v_gold = 0;
PyObject *__pyx_v_start = 0;
PyObject *__pyx_v_end = 0;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
PyObject *__pyx_r = 0;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("has_gold (wrapper)", 0);
{
static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_gold,&__pyx_n_s_start,&__pyx_n_s_end,0};
PyObject* values[3] = {0,0,0};
values[1] = ((PyObject *)__pyx_int_0);
values[2] = ((PyObject *)Py_None);
if (unlikely(__pyx_kwds)) {
Py_ssize_t kw_args;
const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
switch (pos_args) {
case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
CYTHON_FALLTHROUGH;
case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
CYTHON_FALLTHROUGH;
case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
CYTHON_FALLTHROUGH;
case 0: break;
default: goto __pyx_L5_argtuple_error;
}
kw_args = PyDict_Size(__pyx_kwds);
switch (pos_args) {
case 0:
if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_gold)) != 0)) kw_args--;
else goto __pyx_L5_argtuple_error;
CYTHON_FALLTHROUGH;
case 1:
if (kw_args > 0) {
PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_start);
if (value) { values[1] = value; kw_args--; }
}
CYTHON_FALLTHROUGH;
case 2:
if (kw_args > 0) {
PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_end);
if (value) { values[2] = value; kw_args--; }
}
}
if (unlikely(kw_args > 0)) {
if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "has_gold") < 0)) __PYX_ERR(0, 410, __pyx_L3_error)
}
} else {
switch (PyTuple_GET_SIZE(__pyx_args)) {
case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
CYTHON_FALLTHROUGH;
case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
CYTHON_FALLTHROUGH;
case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
break;
default: goto __pyx_L5_argtuple_error;
}
}
__pyx_v_gold = ((struct __pyx_obj_5spacy_4gold_GoldParse *)values[0]);
__pyx_v_start = values[1];
__pyx_v_end = values[2];
}
goto __pyx_L4_argument_unpacking_done;
__pyx_L5_argtuple_error:;
__Pyx_RaiseArgtupleInvalid("has_gold", 0, 1, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 410, __pyx_L3_error)
__pyx_L3_error:;
__Pyx_AddTraceback("spacy.syntax.arc_eager.ArcEager.has_gold", __pyx_clineno, __pyx_lineno, __pyx_filename);
__Pyx_RefNannyFinishContext();
return NULL;
__pyx_L4_argument_unpacking_done:;
if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_gold), __pyx_ptype_5spacy_4gold_GoldParse, 1, "gold", 0))) __PYX_ERR(0, 410, __pyx_L1_error)
__pyx_r = __pyx_pf_5spacy_6syntax_9arc_eager_8ArcEager_10has_gold(((struct __pyx_obj_5spacy_6syntax_9arc_eager_ArcEager *)__pyx_v_self), __pyx_v_gold, __pyx_v_start, __pyx_v_end);
/* function exit code */
goto __pyx_L0;
__pyx_L1_error:;
__pyx_r = NULL;
__pyx_L0:;
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
static PyObject *__pyx_pf_5spacy_6syntax_9arc_eager_8ArcEager_10has_gold(CYTHON_UNUSED struct __pyx_obj_5spacy_6syntax_9arc_eager_ArcEager *__pyx_v_self, struct __pyx_obj_5spacy_4gold_GoldParse *__pyx_v_gold, PyObject *__pyx_v_start, PyObject *__pyx_v_end) {
PyObject *__pyx_v_tag = NULL;
PyObject *__pyx_r = NULL;
__Pyx_TraceDeclarations
__Pyx_RefNannyDeclarations
PyObject *__pyx_t_1 = NULL;
int __pyx_t_2;
PyObject *__pyx_t_3 = NULL;
Py_ssize_t __pyx_t_4;
Py_ssize_t __pyx_t_5;
Py_ssize_t __pyx_t_6;
PyObject *__pyx_t_7 = NULL;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("has_gold", 0);
__Pyx_TraceCall("has_gold", __pyx_f[0], 410, 0, __PYX_ERR(0, 410, __pyx_L1_error));
__Pyx_INCREF(__pyx_v_end);
/* "spacy/syntax/arc_eager.pyx":411
*
* def has_gold(self, GoldParse gold, start=0, end=None):
* end = end or len(gold.heads) # <<<<<<<<<<<<<<
* if all([tag is None for tag in gold.heads[start:end]]):
* return False
*/
__pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_v_end); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 411, __pyx_L1_error)
if (!__pyx_t_2) {
} else {
__Pyx_INCREF(__pyx_v_end);
__pyx_t_1 = __pyx_v_end;
goto __pyx_L3_bool_binop_done;
}
__pyx_t_3 = __pyx_v_gold->heads;
__Pyx_INCREF(__pyx_t_3);
if (unlikely(__pyx_t_3 == Py_None)) {
PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()");
__PYX_ERR(0, 411, __pyx_L1_error)
}
__pyx_t_4 = PyList_GET_SIZE(__pyx_t_3); if (unlikely(__pyx_t_4 == ((Py_ssize_t)-1))) __PYX_ERR(0, 411, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__pyx_t_3 = PyInt_FromSsize_t(__pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 411, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__pyx_t_1 = __pyx_t_3;
__pyx_t_3 = 0;
__pyx_L3_bool_binop_done:;
__Pyx_DECREF_SET(__pyx_v_end, __pyx_t_1);
__pyx_t_1 = 0;
/* "spacy/syntax/arc_eager.pyx":412
* def has_gold(self, GoldParse gold, start=0, end=None):
* end = end or len(gold.heads)
* if all([tag is None for tag in gold.heads[start:end]]): # <<<<<<<<<<<<<<
* return False
* else:
*/
__pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 412, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
if (unlikely(__pyx_v_gold->heads == Py_None)) {
PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable");
__PYX_ERR(0, 412, __pyx_L1_error)
}
__Pyx_INCREF(__pyx_v_start);
__pyx_t_3 = __pyx_v_start;
__pyx_t_2 = (__pyx_t_3 == Py_None);
if (__pyx_t_2) {
__pyx_t_4 = 0;
} else {
__pyx_t_5 = __Pyx_PyIndex_AsSsize_t(__pyx_t_3); if (unlikely((__pyx_t_5 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 412, __pyx_L1_error)
__pyx_t_4 = __pyx_t_5;
}
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__Pyx_INCREF(__pyx_v_end);
__pyx_t_3 = __pyx_v_end;
__pyx_t_2 = (__pyx_t_3 == Py_None);
if (__pyx_t_2) {
__pyx_t_5 = PY_SSIZE_T_MAX;
} else {
__pyx_t_6 = __Pyx_PyIndex_AsSsize_t(__pyx_t_3); if (unlikely((__pyx_t_6 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 412, __pyx_L1_error)
__pyx_t_5 = __pyx_t_6;
}
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__pyx_t_3 = __Pyx_PyList_GetSlice(__pyx_v_gold->heads, __pyx_t_4, __pyx_t_5); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 412, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__pyx_t_7 = __pyx_t_3; __Pyx_INCREF(__pyx_t_7); __pyx_t_5 = 0;
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
for (;;) {
if (__pyx_t_5 >= PyList_GET_SIZE(__pyx_t_7)) break;
#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
__pyx_t_3 = PyList_GET_ITEM(__pyx_t_7, __pyx_t_5); __Pyx_INCREF(__pyx_t_3); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(0, 412, __pyx_L1_error)
#else
__pyx_t_3 = PySequence_ITEM(__pyx_t_7, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 412, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
#endif
__Pyx_XDECREF_SET(__pyx_v_tag, __pyx_t_3);
__pyx_t_3 = 0;
__pyx_t_2 = (__pyx_v_tag == Py_None);
__pyx_t_3 = __Pyx_PyBool_FromLong(__pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 412, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
if (unlikely(__Pyx_ListComp_Append(__pyx_t_1, (PyObject*)__pyx_t_3))) __PYX_ERR(0, 412, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
}
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
__pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_builtin_all, __pyx_t_1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 412, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 412, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
if (__pyx_t_2) {
/* "spacy/syntax/arc_eager.pyx":413
* end = end or len(gold.heads)
* if all([tag is None for tag in gold.heads[start:end]]):
* return False # <<<<<<<<<<<<<<
* else:
* return True
*/
__Pyx_XDECREF(__pyx_r);
__Pyx_INCREF(Py_False);
__pyx_r = Py_False;
goto __pyx_L0;
/* "spacy/syntax/arc_eager.pyx":412
* def has_gold(self, GoldParse gold, start=0, end=None):
* end = end or len(gold.heads)
* if all([tag is None for tag in gold.heads[start:end]]): # <<<<<<<<<<<<<<
* return False
* else:
*/
}
/* "spacy/syntax/arc_eager.pyx":415
* return False
* else:
* return True # <<<<<<<<<<<<<<
*
* def preprocess_gold(self, GoldParse gold):
*/
/*else*/ {
__Pyx_XDECREF(__pyx_r);
__Pyx_INCREF(Py_True);
__pyx_r = Py_True;
goto __pyx_L0;
}
/* "spacy/syntax/arc_eager.pyx":410
* return truth == predicted
*
* def has_gold(self, GoldParse gold, start=0, end=None): # <<<<<<<<<<<<<<
* end = end or len(gold.heads)
* if all([tag is None for tag in gold.heads[start:end]]):
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_1);
__Pyx_XDECREF(__pyx_t_3);
__Pyx_XDECREF(__pyx_t_7);
__Pyx_AddTraceback("spacy.syntax.arc_eager.ArcEager.has_gold", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = NULL;
__pyx_L0:;
__Pyx_XDECREF(__pyx_v_tag);
__Pyx_XDECREF(__pyx_v_end);
__Pyx_XGIVEREF(__pyx_r);
__Pyx_TraceReturn(__pyx_r, 0);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "spacy/syntax/arc_eager.pyx":417
* return True
*
* def preprocess_gold(self, GoldParse gold): # <<<<<<<<<<<<<<
* if not self.has_gold(gold):
* return None
*/
/* Python wrapper */
static PyObject *__pyx_pw_5spacy_6syntax_9arc_eager_8ArcEager_13preprocess_gold(PyObject *__pyx_v_self, PyObject *__pyx_v_gold); /*proto*/
static PyObject *__pyx_pw_5spacy_6syntax_9arc_eager_8ArcEager_13preprocess_gold(PyObject *__pyx_v_self, PyObject *__pyx_v_gold) {
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
PyObject *__pyx_r = 0;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("preprocess_gold (wrapper)", 0);
if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_gold), __pyx_ptype_5spacy_4gold_GoldParse, 1, "gold", 0))) __PYX_ERR(0, 417, __pyx_L1_error)
__pyx_r = __pyx_pf_5spacy_6syntax_9arc_eager_8ArcEager_12preprocess_gold(((struct __pyx_obj_5spacy_6syntax_9arc_eager_ArcEager *)__pyx_v_self), ((struct __pyx_obj_5spacy_4gold_GoldParse *)__pyx_v_gold));
/* function exit code */
goto __pyx_L0;
__pyx_L1_error:;
__pyx_r = NULL;
__pyx_L0:;
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
static PyObject *__pyx_pf_5spacy_6syntax_9arc_eager_8ArcEager_12preprocess_gold(struct __pyx_obj_5spacy_6syntax_9arc_eager_ArcEager *__pyx_v_self, struct __pyx_obj_5spacy_4gold_GoldParse *__pyx_v_gold) {
int __pyx_v_use_subtok;
PyObject *__pyx_v_action = NULL;
PyObject *__pyx_v_labels = NULL;
PyObject *__pyx_v_i = NULL;
PyObject *__pyx_v_head = NULL;
PyObject *__pyx_v_dep = NULL;
PyObject *__pyx_v_backoff = NULL;
PyObject *__pyx_r = NULL;
__Pyx_TraceDeclarations
__Pyx_RefNannyDeclarations
PyObject *__pyx_t_1 = NULL;
PyObject *__pyx_t_2 = NULL;
PyObject *__pyx_t_3 = NULL;
int __pyx_t_4;
int __pyx_t_5;
Py_ssize_t __pyx_t_6;
PyObject *(*__pyx_t_7)(PyObject *);
PyObject *__pyx_t_8 = NULL;
PyObject *__pyx_t_9 = NULL;
PyObject *(*__pyx_t_10)(PyObject *);
PyObject *__pyx_t_11 = NULL;
int __pyx_t_12;
int __pyx_t_13;
Py_ssize_t __pyx_t_14;
__pyx_t_5spacy_8typedefs_attr_t __pyx_t_15;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("preprocess_gold", 0);
__Pyx_TraceCall("preprocess_gold", __pyx_f[0], 417, 0, __PYX_ERR(0, 417, __pyx_L1_error));
/* "spacy/syntax/arc_eager.pyx":418
*
* def preprocess_gold(self, GoldParse gold):
* if not self.has_gold(gold): # <<<<<<<<<<<<<<
* return None
* # Figure out whether we're using subtok
*/
__pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_has_gold); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 418, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__pyx_t_3 = NULL;
if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
__pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
if (likely(__pyx_t_3)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
__Pyx_INCREF(__pyx_t_3);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_2, function);
}
}
__pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_3, ((PyObject *)__pyx_v_gold)) : __Pyx_PyObject_CallOneArg(__pyx_t_2, ((PyObject *)__pyx_v_gold));
__Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 418, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 418, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__pyx_t_5 = ((!__pyx_t_4) != 0);
if (__pyx_t_5) {
/* "spacy/syntax/arc_eager.pyx":419
* def preprocess_gold(self, GoldParse gold):
* if not self.has_gold(gold):
* return None # <<<<<<<<<<<<<<
* # Figure out whether we're using subtok
* use_subtok = False
*/
__Pyx_XDECREF(__pyx_r);
__pyx_r = Py_None; __Pyx_INCREF(Py_None);
goto __pyx_L0;
/* "spacy/syntax/arc_eager.pyx":418
*
* def preprocess_gold(self, GoldParse gold):
* if not self.has_gold(gold): # <<<<<<<<<<<<<<
* return None
* # Figure out whether we're using subtok
*/
}
/* "spacy/syntax/arc_eager.pyx":421
* return None
* # Figure out whether we're using subtok
* use_subtok = False # <<<<<<<<<<<<<<
* for action, labels in self.labels.items():
* if SUBTOK_LABEL in labels:
*/
__pyx_v_use_subtok = 0;
/* "spacy/syntax/arc_eager.pyx":422
* # Figure out whether we're using subtok
* use_subtok = False
* for action, labels in self.labels.items(): # <<<<<<<<<<<<<<
* if SUBTOK_LABEL in labels:
* use_subtok = True
*/
__pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->__pyx_base.labels, __pyx_n_s_items); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 422, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__pyx_t_3 = NULL;
if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
__pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
if (likely(__pyx_t_3)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
__Pyx_INCREF(__pyx_t_3);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_2, function);
}
}
__pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3) : __Pyx_PyObject_CallNoArg(__pyx_t_2);
__Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 422, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
if (likely(PyList_CheckExact(__pyx_t_1)) || PyTuple_CheckExact(__pyx_t_1)) {
__pyx_t_2 = __pyx_t_1; __Pyx_INCREF(__pyx_t_2); __pyx_t_6 = 0;
__pyx_t_7 = NULL;
} else {
__pyx_t_6 = -1; __pyx_t_2 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 422, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__pyx_t_7 = Py_TYPE(__pyx_t_2)->tp_iternext; if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 422, __pyx_L1_error)
}
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
for (;;) {
if (likely(!__pyx_t_7)) {
if (likely(PyList_CheckExact(__pyx_t_2))) {
if (__pyx_t_6 >= PyList_GET_SIZE(__pyx_t_2)) break;
#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
__pyx_t_1 = PyList_GET_ITEM(__pyx_t_2, __pyx_t_6); __Pyx_INCREF(__pyx_t_1); __pyx_t_6++; if (unlikely(0 < 0)) __PYX_ERR(0, 422, __pyx_L1_error)
#else
__pyx_t_1 = PySequence_ITEM(__pyx_t_2, __pyx_t_6); __pyx_t_6++; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 422, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
#endif
} else {
if (__pyx_t_6 >= PyTuple_GET_SIZE(__pyx_t_2)) break;
#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
__pyx_t_1 = PyTuple_GET_ITEM(__pyx_t_2, __pyx_t_6); __Pyx_INCREF(__pyx_t_1); __pyx_t_6++; if (unlikely(0 < 0)) __PYX_ERR(0, 422, __pyx_L1_error)
#else
__pyx_t_1 = PySequence_ITEM(__pyx_t_2, __pyx_t_6); __pyx_t_6++; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 422, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
#endif
}
} else {
__pyx_t_1 = __pyx_t_7(__pyx_t_2);
if (unlikely(!__pyx_t_1)) {
PyObject* exc_type = PyErr_Occurred();
if (exc_type) {
if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
else __PYX_ERR(0, 422, __pyx_L1_error)
}
break;
}
__Pyx_GOTREF(__pyx_t_1);
}
if ((likely(PyTuple_CheckExact(__pyx_t_1))) || (PyList_CheckExact(__pyx_t_1))) {
PyObject* sequence = __pyx_t_1;
Py_ssize_t size = __Pyx_PySequence_SIZE(sequence);
if (unlikely(size != 2)) {
if (size > 2) __Pyx_RaiseTooManyValuesError(2);
else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
__PYX_ERR(0, 422, __pyx_L1_error)
}
#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
if (likely(PyTuple_CheckExact(sequence))) {
__pyx_t_3 = PyTuple_GET_ITEM(sequence, 0);
__pyx_t_8 = PyTuple_GET_ITEM(sequence, 1);
} else {
__pyx_t_3 = PyList_GET_ITEM(sequence, 0);
__pyx_t_8 = PyList_GET_ITEM(sequence, 1);
}
__Pyx_INCREF(__pyx_t_3);
__Pyx_INCREF(__pyx_t_8);
#else
__pyx_t_3 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 422, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__pyx_t_8 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 422, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_8);
#endif
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
} else {
Py_ssize_t index = -1;
__pyx_t_9 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 422, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_9);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__pyx_t_10 = Py_TYPE(__pyx_t_9)->tp_iternext;
index = 0; __pyx_t_3 = __pyx_t_10(__pyx_t_9); if (unlikely(!__pyx_t_3)) goto __pyx_L6_unpacking_failed;
__Pyx_GOTREF(__pyx_t_3);
index = 1; __pyx_t_8 = __pyx_t_10(__pyx_t_9); if (unlikely(!__pyx_t_8)) goto __pyx_L6_unpacking_failed;
__Pyx_GOTREF(__pyx_t_8);
if (__Pyx_IternextUnpackEndCheck(__pyx_t_10(__pyx_t_9), 2) < 0) __PYX_ERR(0, 422, __pyx_L1_error)
__pyx_t_10 = NULL;
__Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
goto __pyx_L7_unpacking_done;
__pyx_L6_unpacking_failed:;
__Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
__pyx_t_10 = NULL;
if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index);
__PYX_ERR(0, 422, __pyx_L1_error)
__pyx_L7_unpacking_done:;
}
__Pyx_XDECREF_SET(__pyx_v_action, __pyx_t_3);
__pyx_t_3 = 0;
__Pyx_XDECREF_SET(__pyx_v_labels, __pyx_t_8);
__pyx_t_8 = 0;
/* "spacy/syntax/arc_eager.pyx":423
* use_subtok = False
* for action, labels in self.labels.items():
* if SUBTOK_LABEL in labels: # <<<<<<<<<<<<<<
* use_subtok = True
* break
*/
__pyx_t_1 = __Pyx_PyInt_From_uint64_t(__pyx_v_5spacy_6syntax_9arc_eager_SUBTOK_LABEL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 423, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_t_5 = (__Pyx_PySequence_ContainsTF(__pyx_t_1, __pyx_v_labels, Py_EQ)); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 423, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__pyx_t_4 = (__pyx_t_5 != 0);
if (__pyx_t_4) {
/* "spacy/syntax/arc_eager.pyx":424
* for action, labels in self.labels.items():
* if SUBTOK_LABEL in labels:
* use_subtok = True # <<<<<<<<<<<<<<
* break
* for i, (head, dep) in enumerate(zip(gold.heads, gold.labels)):
*/
__pyx_v_use_subtok = 1;
/* "spacy/syntax/arc_eager.pyx":425
* if SUBTOK_LABEL in labels:
* use_subtok = True
* break # <<<<<<<<<<<<<<
* for i, (head, dep) in enumerate(zip(gold.heads, gold.labels)):
* # Missing values
*/
goto __pyx_L5_break;
/* "spacy/syntax/arc_eager.pyx":423
* use_subtok = False
* for action, labels in self.labels.items():
* if SUBTOK_LABEL in labels: # <<<<<<<<<<<<<<
* use_subtok = True
* break
*/
}
/* "spacy/syntax/arc_eager.pyx":422
* # Figure out whether we're using subtok
* use_subtok = False
* for action, labels in self.labels.items(): # <<<<<<<<<<<<<<
* if SUBTOK_LABEL in labels:
* use_subtok = True
*/
}
__pyx_L5_break:;
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
/* "spacy/syntax/arc_eager.pyx":426
* use_subtok = True
* break
* for i, (head, dep) in enumerate(zip(gold.heads, gold.labels)): # <<<<<<<<<<<<<<
* # Missing values
* if head is None or dep is None:
*/
__Pyx_INCREF(__pyx_int_0);
__pyx_t_2 = __pyx_int_0;
__pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 426, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_INCREF(__pyx_v_gold->heads);
__Pyx_GIVEREF(__pyx_v_gold->heads);
PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v_gold->heads);
__Pyx_INCREF(__pyx_v_gold->labels);
__Pyx_GIVEREF(__pyx_v_gold->labels);
PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_v_gold->labels);
__pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_zip, __pyx_t_1, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 426, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_8);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
if (likely(PyList_CheckExact(__pyx_t_8)) || PyTuple_CheckExact(__pyx_t_8)) {
__pyx_t_1 = __pyx_t_8; __Pyx_INCREF(__pyx_t_1); __pyx_t_6 = 0;
__pyx_t_7 = NULL;
} else {
__pyx_t_6 = -1; __pyx_t_1 = PyObject_GetIter(__pyx_t_8); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 426, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_t_7 = Py_TYPE(__pyx_t_1)->tp_iternext; if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 426, __pyx_L1_error)
}
__Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
for (;;) {
if (likely(!__pyx_t_7)) {
if (likely(PyList_CheckExact(__pyx_t_1))) {
if (__pyx_t_6 >= PyList_GET_SIZE(__pyx_t_1)) break;
#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
__pyx_t_8 = PyList_GET_ITEM(__pyx_t_1, __pyx_t_6); __Pyx_INCREF(__pyx_t_8); __pyx_t_6++; if (unlikely(0 < 0)) __PYX_ERR(0, 426, __pyx_L1_error)
#else
__pyx_t_8 = PySequence_ITEM(__pyx_t_1, __pyx_t_6); __pyx_t_6++; if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 426, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_8);
#endif
} else {
if (__pyx_t_6 >= PyTuple_GET_SIZE(__pyx_t_1)) break;
#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
__pyx_t_8 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_6); __Pyx_INCREF(__pyx_t_8); __pyx_t_6++; if (unlikely(0 < 0)) __PYX_ERR(0, 426, __pyx_L1_error)
#else
__pyx_t_8 = PySequence_ITEM(__pyx_t_1, __pyx_t_6); __pyx_t_6++; if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 426, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_8);
#endif
}
} else {
__pyx_t_8 = __pyx_t_7(__pyx_t_1);
if (unlikely(!__pyx_t_8)) {
PyObject* exc_type = PyErr_Occurred();
if (exc_type) {
if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
else __PYX_ERR(0, 426, __pyx_L1_error)
}
break;
}
__Pyx_GOTREF(__pyx_t_8);
}
if ((likely(PyTuple_CheckExact(__pyx_t_8))) || (PyList_CheckExact(__pyx_t_8))) {
PyObject* sequence = __pyx_t_8;
Py_ssize_t size = __Pyx_PySequence_SIZE(sequence);
if (unlikely(size != 2)) {
if (size > 2) __Pyx_RaiseTooManyValuesError(2);
else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
__PYX_ERR(0, 426, __pyx_L1_error)
}
#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
if (likely(PyTuple_CheckExact(sequence))) {
__pyx_t_3 = PyTuple_GET_ITEM(sequence, 0);
__pyx_t_9 = PyTuple_GET_ITEM(sequence, 1);
} else {
__pyx_t_3 = PyList_GET_ITEM(sequence, 0);
__pyx_t_9 = PyList_GET_ITEM(sequence, 1);
}
__Pyx_INCREF(__pyx_t_3);
__Pyx_INCREF(__pyx_t_9);
#else
__pyx_t_3 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 426, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__pyx_t_9 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 426, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_9);
#endif
__Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
} else {
Py_ssize_t index = -1;
__pyx_t_11 = PyObject_GetIter(__pyx_t_8); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 426, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_11);
__Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
__pyx_t_10 = Py_TYPE(__pyx_t_11)->tp_iternext;
index = 0; __pyx_t_3 = __pyx_t_10(__pyx_t_11); if (unlikely(!__pyx_t_3)) goto __pyx_L11_unpacking_failed;
__Pyx_GOTREF(__pyx_t_3);
index = 1; __pyx_t_9 = __pyx_t_10(__pyx_t_11); if (unlikely(!__pyx_t_9)) goto __pyx_L11_unpacking_failed;
__Pyx_GOTREF(__pyx_t_9);
if (__Pyx_IternextUnpackEndCheck(__pyx_t_10(__pyx_t_11), 2) < 0) __PYX_ERR(0, 426, __pyx_L1_error)
__pyx_t_10 = NULL;
__Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
goto __pyx_L12_unpacking_done;
__pyx_L11_unpacking_failed:;
__Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
__pyx_t_10 = NULL;
if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index);
__PYX_ERR(0, 426, __pyx_L1_error)
__pyx_L12_unpacking_done:;
}
__Pyx_XDECREF_SET(__pyx_v_head, __pyx_t_3);
__pyx_t_3 = 0;
__Pyx_XDECREF_SET(__pyx_v_dep, __pyx_t_9);
__pyx_t_9 = 0;
__Pyx_INCREF(__pyx_t_2);
__Pyx_XDECREF_SET(__pyx_v_i, __pyx_t_2);
__pyx_t_8 = __Pyx_PyInt_AddObjC(__pyx_t_2, __pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 426, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_8);
__Pyx_DECREF(__pyx_t_2);
__pyx_t_2 = __pyx_t_8;
__pyx_t_8 = 0;
/* "spacy/syntax/arc_eager.pyx":428
* for i, (head, dep) in enumerate(zip(gold.heads, gold.labels)):
* # Missing values
* if head is None or dep is None: # <<<<<<<<<<<<<<
* gold.c.heads[i] = i
* gold.c.has_dep[i] = False
*/
__pyx_t_5 = (__pyx_v_head == Py_None);
__pyx_t_12 = (__pyx_t_5 != 0);
if (!__pyx_t_12) {
} else {
__pyx_t_4 = __pyx_t_12;
goto __pyx_L14_bool_binop_done;
}
__pyx_t_12 = (__pyx_v_dep == Py_None);
__pyx_t_5 = (__pyx_t_12 != 0);
__pyx_t_4 = __pyx_t_5;
__pyx_L14_bool_binop_done:;
if (__pyx_t_4) {
/* "spacy/syntax/arc_eager.pyx":429
* # Missing values
* if head is None or dep is None:
* gold.c.heads[i] = i # <<<<<<<<<<<<<<
* gold.c.has_dep[i] = False
* elif dep == SUBTOK_LABEL and not use_subtok:
*/
__pyx_t_13 = __Pyx_PyInt_As_int(__pyx_v_i); if (unlikely((__pyx_t_13 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 429, __pyx_L1_error)
__pyx_t_14 = __Pyx_PyIndex_AsSsize_t(__pyx_v_i); if (unlikely((__pyx_t_14 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 429, __pyx_L1_error)
(__pyx_v_gold->c.heads[__pyx_t_14]) = __pyx_t_13;
/* "spacy/syntax/arc_eager.pyx":430
* if head is None or dep is None:
* gold.c.heads[i] = i
* gold.c.has_dep[i] = False # <<<<<<<<<<<<<<
* elif dep == SUBTOK_LABEL and not use_subtok:
* # If we're not doing the joint tokenization and parsing,
*/
__pyx_t_14 = __Pyx_PyIndex_AsSsize_t(__pyx_v_i); if (unlikely((__pyx_t_14 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 430, __pyx_L1_error)
(__pyx_v_gold->c.has_dep[__pyx_t_14]) = 0;
/* "spacy/syntax/arc_eager.pyx":428
* for i, (head, dep) in enumerate(zip(gold.heads, gold.labels)):
* # Missing values
* if head is None or dep is None: # <<<<<<<<<<<<<<
* gold.c.heads[i] = i
* gold.c.has_dep[i] = False
*/
goto __pyx_L13;
}
/* "spacy/syntax/arc_eager.pyx":431
* gold.c.heads[i] = i
* gold.c.has_dep[i] = False
* elif dep == SUBTOK_LABEL and not use_subtok: # <<<<<<<<<<<<<<
* # If we're not doing the joint tokenization and parsing,
* # regard these subtok labels as missing
*/
__pyx_t_8 = __Pyx_PyInt_From_uint64_t(__pyx_v_5spacy_6syntax_9arc_eager_SUBTOK_LABEL); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 431, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_8);
__pyx_t_9 = PyObject_RichCompare(__pyx_v_dep, __pyx_t_8, Py_EQ); __Pyx_XGOTREF(__pyx_t_9); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 431, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
__pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_9); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 431, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
if (__pyx_t_5) {
} else {
__pyx_t_4 = __pyx_t_5;
goto __pyx_L16_bool_binop_done;
}
__pyx_t_5 = ((!(__pyx_v_use_subtok != 0)) != 0);
__pyx_t_4 = __pyx_t_5;
__pyx_L16_bool_binop_done:;
if (__pyx_t_4) {
/* "spacy/syntax/arc_eager.pyx":434
* # If we're not doing the joint tokenization and parsing,
* # regard these subtok labels as missing
* gold.c.heads[i] = i # <<<<<<<<<<<<<<
* gold.c.labels[i] = 0
* gold.c.has_dep[i] = False
*/
__pyx_t_13 = __Pyx_PyInt_As_int(__pyx_v_i); if (unlikely((__pyx_t_13 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 434, __pyx_L1_error)
__pyx_t_14 = __Pyx_PyIndex_AsSsize_t(__pyx_v_i); if (unlikely((__pyx_t_14 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 434, __pyx_L1_error)
(__pyx_v_gold->c.heads[__pyx_t_14]) = __pyx_t_13;
/* "spacy/syntax/arc_eager.pyx":435
* # regard these subtok labels as missing
* gold.c.heads[i] = i
* gold.c.labels[i] = 0 # <<<<<<<<<<<<<<
* gold.c.has_dep[i] = False
* else:
*/
__pyx_t_14 = __Pyx_PyIndex_AsSsize_t(__pyx_v_i); if (unlikely((__pyx_t_14 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 435, __pyx_L1_error)
(__pyx_v_gold->c.labels[__pyx_t_14]) = 0;
/* "spacy/syntax/arc_eager.pyx":436
* gold.c.heads[i] = i
* gold.c.labels[i] = 0
* gold.c.has_dep[i] = False # <<<<<<<<<<<<<<
* else:
* if head > i:
*/
__pyx_t_14 = __Pyx_PyIndex_AsSsize_t(__pyx_v_i); if (unlikely((__pyx_t_14 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 436, __pyx_L1_error)
(__pyx_v_gold->c.has_dep[__pyx_t_14]) = 0;
/* "spacy/syntax/arc_eager.pyx":431
* gold.c.heads[i] = i
* gold.c.has_dep[i] = False
* elif dep == SUBTOK_LABEL and not use_subtok: # <<<<<<<<<<<<<<
* # If we're not doing the joint tokenization and parsing,
* # regard these subtok labels as missing
*/
goto __pyx_L13;
}
/* "spacy/syntax/arc_eager.pyx":438
* gold.c.has_dep[i] = False
* else:
* if head > i: # <<<<<<<<<<<<<<
* action = LEFT
* elif head < i:
*/
/*else*/ {
__pyx_t_9 = PyObject_RichCompare(__pyx_v_head, __pyx_v_i, Py_GT); __Pyx_XGOTREF(__pyx_t_9); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 438, __pyx_L1_error)
__pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_9); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 438, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
if (__pyx_t_4) {
/* "spacy/syntax/arc_eager.pyx":439
* else:
* if head > i:
* action = LEFT # <<<<<<<<<<<<<<
* elif head < i:
* action = RIGHT
*/
__pyx_t_9 = __Pyx_PyInt_From_int(__pyx_e_5spacy_6syntax_9arc_eager_LEFT); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 439, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_9);
__Pyx_XDECREF_SET(__pyx_v_action, __pyx_t_9);
__pyx_t_9 = 0;
/* "spacy/syntax/arc_eager.pyx":438
* gold.c.has_dep[i] = False
* else:
* if head > i: # <<<<<<<<<<<<<<
* action = LEFT
* elif head < i:
*/
goto __pyx_L18;
}
/* "spacy/syntax/arc_eager.pyx":440
* if head > i:
* action = LEFT
* elif head < i: # <<<<<<<<<<<<<<
* action = RIGHT
* else:
*/
__pyx_t_9 = PyObject_RichCompare(__pyx_v_head, __pyx_v_i, Py_LT); __Pyx_XGOTREF(__pyx_t_9); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 440, __pyx_L1_error)
__pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_9); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 440, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
if (__pyx_t_4) {
/* "spacy/syntax/arc_eager.pyx":441
* action = LEFT
* elif head < i:
* action = RIGHT # <<<<<<<<<<<<<<
* else:
* action = BREAK
*/
__pyx_t_9 = __Pyx_PyInt_From_int(__pyx_e_5spacy_6syntax_9arc_eager_RIGHT); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 441, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_9);
__Pyx_XDECREF_SET(__pyx_v_action, __pyx_t_9);
__pyx_t_9 = 0;
/* "spacy/syntax/arc_eager.pyx":440
* if head > i:
* action = LEFT
* elif head < i: # <<<<<<<<<<<<<<
* action = RIGHT
* else:
*/
goto __pyx_L18;
}
/* "spacy/syntax/arc_eager.pyx":443
* action = RIGHT
* else:
* action = BREAK # <<<<<<<<<<<<<<
* if dep not in self.labels[action]:
* if action == BREAK:
*/
/*else*/ {
__pyx_t_9 = __Pyx_PyInt_From_int(__pyx_e_5spacy_6syntax_9arc_eager_BREAK); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 443, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_9);
__Pyx_XDECREF_SET(__pyx_v_action, __pyx_t_9);
__pyx_t_9 = 0;
}
__pyx_L18:;
/* "spacy/syntax/arc_eager.pyx":444
* else:
* action = BREAK
* if dep not in self.labels[action]: # <<<<<<<<<<<<<<
* if action == BREAK:
* dep = 'ROOT'
*/
__pyx_t_9 = __Pyx_PyObject_GetItem(__pyx_v_self->__pyx_base.labels, __pyx_v_action); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 444, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_9);
__pyx_t_4 = (__Pyx_PySequence_ContainsTF(__pyx_v_dep, __pyx_t_9, Py_NE)); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 444, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
__pyx_t_5 = (__pyx_t_4 != 0);
if (__pyx_t_5) {
/* "spacy/syntax/arc_eager.pyx":445
* action = BREAK
* if dep not in self.labels[action]:
* if action == BREAK: # <<<<<<<<<<<<<<
* dep = 'ROOT'
* elif nonproj.is_decorated(dep):
*/
__pyx_t_9 = __Pyx_PyInt_From_int(__pyx_e_5spacy_6syntax_9arc_eager_BREAK); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 445, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_9);
__pyx_t_8 = PyObject_RichCompare(__pyx_v_action, __pyx_t_9, Py_EQ); __Pyx_XGOTREF(__pyx_t_8); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 445, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
__pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 445, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
if (__pyx_t_5) {
/* "spacy/syntax/arc_eager.pyx":446
* if dep not in self.labels[action]:
* if action == BREAK:
* dep = 'ROOT' # <<<<<<<<<<<<<<
* elif nonproj.is_decorated(dep):
* backoff = nonproj.decompose(dep)[0]
*/
__Pyx_INCREF(__pyx_n_u_ROOT);
__Pyx_DECREF_SET(__pyx_v_dep, __pyx_n_u_ROOT);
/* "spacy/syntax/arc_eager.pyx":445
* action = BREAK
* if dep not in self.labels[action]:
* if action == BREAK: # <<<<<<<<<<<<<<
* dep = 'ROOT'
* elif nonproj.is_decorated(dep):
*/
goto __pyx_L20;
}
/* "spacy/syntax/arc_eager.pyx":447
* if action == BREAK:
* dep = 'ROOT'
* elif nonproj.is_decorated(dep): # <<<<<<<<<<<<<<
* backoff = nonproj.decompose(dep)[0]
* if backoff in self.labels[action]:
*/
__Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_n_s_nonproj); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 447, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_9);
__pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_9, __pyx_n_s_is_decorated); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 447, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
__pyx_t_9 = NULL;
if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
__pyx_t_9 = PyMethod_GET_SELF(__pyx_t_3);
if (likely(__pyx_t_9)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
__Pyx_INCREF(__pyx_t_9);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_3, function);
}
}
__pyx_t_8 = (__pyx_t_9) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_9, __pyx_v_dep) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_v_dep);
__Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 447, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_8);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 447, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
if (__pyx_t_5) {
/* "spacy/syntax/arc_eager.pyx":448
* dep = 'ROOT'
* elif nonproj.is_decorated(dep):
* backoff = nonproj.decompose(dep)[0] # <<<<<<<<<<<<<<
* if backoff in self.labels[action]:
* dep = backoff
*/
__Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_nonproj); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 448, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_decompose); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 448, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_9);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__pyx_t_3 = NULL;
if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_9))) {
__pyx_t_3 = PyMethod_GET_SELF(__pyx_t_9);
if (likely(__pyx_t_3)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_9);
__Pyx_INCREF(__pyx_t_3);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_9, function);
}
}
__pyx_t_8 = (__pyx_t_3) ? __Pyx_PyObject_Call2Args(__pyx_t_9, __pyx_t_3, __pyx_v_dep) : __Pyx_PyObject_CallOneArg(__pyx_t_9, __pyx_v_dep);
__Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 448, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_8);
__Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
__pyx_t_9 = __Pyx_GetItemInt(__pyx_t_8, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 448, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_9);
__Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
__Pyx_XDECREF_SET(__pyx_v_backoff, __pyx_t_9);
__pyx_t_9 = 0;
/* "spacy/syntax/arc_eager.pyx":449
* elif nonproj.is_decorated(dep):
* backoff = nonproj.decompose(dep)[0]
* if backoff in self.labels[action]: # <<<<<<<<<<<<<<
* dep = backoff
* else:
*/
__pyx_t_9 = __Pyx_PyObject_GetItem(__pyx_v_self->__pyx_base.labels, __pyx_v_action); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 449, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_9);
__pyx_t_5 = (__Pyx_PySequence_ContainsTF(__pyx_v_backoff, __pyx_t_9, Py_EQ)); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 449, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
__pyx_t_4 = (__pyx_t_5 != 0);
if (__pyx_t_4) {
/* "spacy/syntax/arc_eager.pyx":450
* backoff = nonproj.decompose(dep)[0]
* if backoff in self.labels[action]:
* dep = backoff # <<<<<<<<<<<<<<
* else:
* dep = 'dep'
*/
__Pyx_INCREF(__pyx_v_backoff);
__Pyx_DECREF_SET(__pyx_v_dep, __pyx_v_backoff);
/* "spacy/syntax/arc_eager.pyx":449
* elif nonproj.is_decorated(dep):
* backoff = nonproj.decompose(dep)[0]
* if backoff in self.labels[action]: # <<<<<<<<<<<<<<
* dep = backoff
* else:
*/
goto __pyx_L21;
}
/* "spacy/syntax/arc_eager.pyx":452
* dep = backoff
* else:
* dep = 'dep' # <<<<<<<<<<<<<<
* else:
* dep = 'dep'
*/
/*else*/ {
__Pyx_INCREF(__pyx_n_u_dep);
__Pyx_DECREF_SET(__pyx_v_dep, __pyx_n_u_dep);
}
__pyx_L21:;
/* "spacy/syntax/arc_eager.pyx":447
* if action == BREAK:
* dep = 'ROOT'
* elif nonproj.is_decorated(dep): # <<<<<<<<<<<<<<
* backoff = nonproj.decompose(dep)[0]
* if backoff in self.labels[action]:
*/
goto __pyx_L20;
}
/* "spacy/syntax/arc_eager.pyx":454
* dep = 'dep'
* else:
* dep = 'dep' # <<<<<<<<<<<<<<
* gold.c.has_dep[i] = True
* if dep.upper() == 'ROOT':
*/
/*else*/ {
__Pyx_INCREF(__pyx_n_u_dep);
__Pyx_DECREF_SET(__pyx_v_dep, __pyx_n_u_dep);
}
__pyx_L20:;
/* "spacy/syntax/arc_eager.pyx":444
* else:
* action = BREAK
* if dep not in self.labels[action]: # <<<<<<<<<<<<<<
* if action == BREAK:
* dep = 'ROOT'
*/
}
/* "spacy/syntax/arc_eager.pyx":455
* else:
* dep = 'dep'
* gold.c.has_dep[i] = True # <<<<<<<<<<<<<<
* if dep.upper() == 'ROOT':
* dep = 'ROOT'
*/
__pyx_t_14 = __Pyx_PyIndex_AsSsize_t(__pyx_v_i); if (unlikely((__pyx_t_14 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 455, __pyx_L1_error)
(__pyx_v_gold->c.has_dep[__pyx_t_14]) = 1;
/* "spacy/syntax/arc_eager.pyx":456
* dep = 'dep'
* gold.c.has_dep[i] = True
* if dep.upper() == 'ROOT': # <<<<<<<<<<<<<<
* dep = 'ROOT'
* gold.c.heads[i] = head
*/
__pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_dep, __pyx_n_s_upper); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 456, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_8);
__pyx_t_3 = NULL;
if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_8))) {
__pyx_t_3 = PyMethod_GET_SELF(__pyx_t_8);
if (likely(__pyx_t_3)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_8);
__Pyx_INCREF(__pyx_t_3);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_8, function);
}
}
__pyx_t_9 = (__pyx_t_3) ? __Pyx_PyObject_CallOneArg(__pyx_t_8, __pyx_t_3) : __Pyx_PyObject_CallNoArg(__pyx_t_8);
__Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 456, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_9);
__Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
__pyx_t_4 = (__Pyx_PyUnicode_Equals(__pyx_t_9, __pyx_n_u_ROOT, Py_EQ)); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 456, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
if (__pyx_t_4) {
/* "spacy/syntax/arc_eager.pyx":457
* gold.c.has_dep[i] = True
* if dep.upper() == 'ROOT':
* dep = 'ROOT' # <<<<<<<<<<<<<<
* gold.c.heads[i] = head
* gold.c.labels[i] = self.strings.add(dep)
*/
__Pyx_INCREF(__pyx_n_u_ROOT);
__Pyx_DECREF_SET(__pyx_v_dep, __pyx_n_u_ROOT);
/* "spacy/syntax/arc_eager.pyx":456
* dep = 'dep'
* gold.c.has_dep[i] = True
* if dep.upper() == 'ROOT': # <<<<<<<<<<<<<<
* dep = 'ROOT'
* gold.c.heads[i] = head
*/
}
/* "spacy/syntax/arc_eager.pyx":458
* if dep.upper() == 'ROOT':
* dep = 'ROOT'
* gold.c.heads[i] = head # <<<<<<<<<<<<<<
* gold.c.labels[i] = self.strings.add(dep)
* return gold
*/
__pyx_t_13 = __Pyx_PyInt_As_int(__pyx_v_head); if (unlikely((__pyx_t_13 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 458, __pyx_L1_error)
__pyx_t_14 = __Pyx_PyIndex_AsSsize_t(__pyx_v_i); if (unlikely((__pyx_t_14 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 458, __pyx_L1_error)
(__pyx_v_gold->c.heads[__pyx_t_14]) = __pyx_t_13;
/* "spacy/syntax/arc_eager.pyx":459
* dep = 'ROOT'
* gold.c.heads[i] = head
* gold.c.labels[i] = self.strings.add(dep) # <<<<<<<<<<<<<<
* return gold
*
*/
__pyx_t_8 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self->__pyx_base.strings), __pyx_n_s_add); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 459, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_8);
__pyx_t_3 = NULL;
if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_8))) {
__pyx_t_3 = PyMethod_GET_SELF(__pyx_t_8);
if (likely(__pyx_t_3)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_8);
__Pyx_INCREF(__pyx_t_3);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_8, function);
}
}
__pyx_t_9 = (__pyx_t_3) ? __Pyx_PyObject_Call2Args(__pyx_t_8, __pyx_t_3, __pyx_v_dep) : __Pyx_PyObject_CallOneArg(__pyx_t_8, __pyx_v_dep);
__Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 459, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_9);
__Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
__pyx_t_15 = __Pyx_PyInt_As_uint64_t(__pyx_t_9); if (unlikely((__pyx_t_15 == ((uint64_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 459, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
__pyx_t_14 = __Pyx_PyIndex_AsSsize_t(__pyx_v_i); if (unlikely((__pyx_t_14 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 459, __pyx_L1_error)
(__pyx_v_gold->c.labels[__pyx_t_14]) = __pyx_t_15;
}
__pyx_L13:;
/* "spacy/syntax/arc_eager.pyx":426
* use_subtok = True
* break
* for i, (head, dep) in enumerate(zip(gold.heads, gold.labels)): # <<<<<<<<<<<<<<
* # Missing values
* if head is None or dep is None:
*/
}
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
/* "spacy/syntax/arc_eager.pyx":460
* gold.c.heads[i] = head
* gold.c.labels[i] = self.strings.add(dep)
* return gold # <<<<<<<<<<<<<<
*
* def get_beam_parses(self, Beam beam):
*/
__Pyx_XDECREF(__pyx_r);
__Pyx_INCREF(((PyObject *)__pyx_v_gold));
__pyx_r = ((PyObject *)__pyx_v_gold);
goto __pyx_L0;
/* "spacy/syntax/arc_eager.pyx":417
* return True
*
* def preprocess_gold(self, GoldParse gold): # <<<<<<<<<<<<<<
* if not self.has_gold(gold):
* return None
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_1);
__Pyx_XDECREF(__pyx_t_2);
__Pyx_XDECREF(__pyx_t_3);
__Pyx_XDECREF(__pyx_t_8);
__Pyx_XDECREF(__pyx_t_9);
__Pyx_XDECREF(__pyx_t_11);
__Pyx_AddTraceback("spacy.syntax.arc_eager.ArcEager.preprocess_gold", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = NULL;
__pyx_L0:;
__Pyx_XDECREF(__pyx_v_action);
__Pyx_XDECREF(__pyx_v_labels);
__Pyx_XDECREF(__pyx_v_i);
__Pyx_XDECREF(__pyx_v_head);
__Pyx_XDECREF(__pyx_v_dep);
__Pyx_XDECREF(__pyx_v_backoff);
__Pyx_XGIVEREF(__pyx_r);
__Pyx_TraceReturn(__pyx_r, 0);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "spacy/syntax/arc_eager.pyx":462
* return gold
*
* def get_beam_parses(self, Beam beam): # <<<<<<<<<<<<<<
* parses = []
* probs = beam.probs
*/
/* Python wrapper */
static PyObject *__pyx_pw_5spacy_6syntax_9arc_eager_8ArcEager_15get_beam_parses(PyObject *__pyx_v_self, PyObject *__pyx_v_beam); /*proto*/
static PyObject *__pyx_pw_5spacy_6syntax_9arc_eager_8ArcEager_15get_beam_parses(PyObject *__pyx_v_self, PyObject *__pyx_v_beam) {
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
PyObject *__pyx_r = 0;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("get_beam_parses (wrapper)", 0);
if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_beam), __pyx_ptype_5thinc_5extra_6search_Beam, 1, "beam", 0))) __PYX_ERR(0, 462, __pyx_L1_error)
__pyx_r = __pyx_pf_5spacy_6syntax_9arc_eager_8ArcEager_14get_beam_parses(((struct __pyx_obj_5spacy_6syntax_9arc_eager_ArcEager *)__pyx_v_self), ((struct __pyx_obj_5thinc_5extra_6search_Beam *)__pyx_v_beam));
/* function exit code */
goto __pyx_L0;
__pyx_L1_error:;
__pyx_r = NULL;
__pyx_L0:;
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
static PyObject *__pyx_pf_5spacy_6syntax_9arc_eager_8ArcEager_14get_beam_parses(struct __pyx_obj_5spacy_6syntax_9arc_eager_ArcEager *__pyx_v_self, struct __pyx_obj_5thinc_5extra_6search_Beam *__pyx_v_beam) {
PyObject *__pyx_v_parses = NULL;
PyObject *__pyx_v_probs = NULL;
__pyx_t_5thinc_8typedefs_class_t __pyx_v_i;
__pyx_t_5spacy_6syntax_6_state_StateC *__pyx_v_state;
PyObject *__pyx_v_prob = NULL;
PyObject *__pyx_v_parse = NULL;
int __pyx_v_j;
int __pyx_v_head;
PyObject *__pyx_v_label = NULL;
PyObject *__pyx_r = NULL;
__Pyx_TraceDeclarations
__Pyx_RefNannyDeclarations
PyObject *__pyx_t_1 = NULL;
__pyx_t_5thinc_8typedefs_class_t __pyx_t_2;
__pyx_t_5thinc_8typedefs_class_t __pyx_t_3;
__pyx_t_5thinc_8typedefs_class_t __pyx_t_4;
int __pyx_t_5;
int __pyx_t_6;
int __pyx_t_7;
int __pyx_t_8;
PyObject *__pyx_t_9 = NULL;
PyObject *__pyx_t_10 = NULL;
int __pyx_t_11;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("get_beam_parses", 0);
__Pyx_TraceCall("get_beam_parses", __pyx_f[0], 462, 0, __PYX_ERR(0, 462, __pyx_L1_error));
/* "spacy/syntax/arc_eager.pyx":463
*
* def get_beam_parses(self, Beam beam):
* parses = [] # <<<<<<<<<<<<<<
* probs = beam.probs
* for i in range(beam.size):
*/
__pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 463, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_v_parses = ((PyObject*)__pyx_t_1);
__pyx_t_1 = 0;
/* "spacy/syntax/arc_eager.pyx":464
* def get_beam_parses(self, Beam beam):
* parses = []
* probs = beam.probs # <<<<<<<<<<<<<<
* for i in range(beam.size):
* state = <StateC*>beam.at(i)
*/
__pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_beam), __pyx_n_s_probs); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 464, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_v_probs = __pyx_t_1;
__pyx_t_1 = 0;
/* "spacy/syntax/arc_eager.pyx":465
* parses = []
* probs = beam.probs
* for i in range(beam.size): # <<<<<<<<<<<<<<
* state = <StateC*>beam.at(i)
* if state.is_final():
*/
__pyx_t_2 = __pyx_v_beam->size;
__pyx_t_3 = __pyx_t_2;
for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) {
__pyx_v_i = __pyx_t_4;
/* "spacy/syntax/arc_eager.pyx":466
* probs = beam.probs
* for i in range(beam.size):
* state = <StateC*>beam.at(i) # <<<<<<<<<<<<<<
* if state.is_final():
* self.finalize_state(state)
*/
__pyx_v_state = ((__pyx_t_5spacy_6syntax_6_state_StateC *)__pyx_f_5thinc_5extra_6search_4Beam_at(__pyx_v_beam, __pyx_v_i));
/* "spacy/syntax/arc_eager.pyx":467
* for i in range(beam.size):
* state = <StateC*>beam.at(i)
* if state.is_final(): # <<<<<<<<<<<<<<
* self.finalize_state(state)
* prob = probs[i]
*/
__pyx_t_5 = (__pyx_v_state->is_final() != 0);
if (__pyx_t_5) {
/* "spacy/syntax/arc_eager.pyx":468
* state = <StateC*>beam.at(i)
* if state.is_final():
* self.finalize_state(state) # <<<<<<<<<<<<<<
* prob = probs[i]
* parse = []
*/
(void)(((struct __pyx_vtabstruct_5spacy_6syntax_9arc_eager_ArcEager *)__pyx_v_self->__pyx_base.__pyx_vtab)->__pyx_base.finalize_state(((struct __pyx_obj_5spacy_6syntax_17transition_system_TransitionSystem *)__pyx_v_self), __pyx_v_state));
/* "spacy/syntax/arc_eager.pyx":469
* if state.is_final():
* self.finalize_state(state)
* prob = probs[i] # <<<<<<<<<<<<<<
* parse = []
* for j in range(state.length):
*/
__pyx_t_1 = __Pyx_GetItemInt(__pyx_v_probs, __pyx_v_i, __pyx_t_5thinc_8typedefs_class_t, 1, __Pyx_PyInt_From_int32_t, 0, 1, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 469, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_XDECREF_SET(__pyx_v_prob, __pyx_t_1);
__pyx_t_1 = 0;
/* "spacy/syntax/arc_eager.pyx":470
* self.finalize_state(state)
* prob = probs[i]
* parse = [] # <<<<<<<<<<<<<<
* for j in range(state.length):
* head = state.H(j)
*/
__pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 470, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_XDECREF_SET(__pyx_v_parse, ((PyObject*)__pyx_t_1));
__pyx_t_1 = 0;
/* "spacy/syntax/arc_eager.pyx":471
* prob = probs[i]
* parse = []
* for j in range(state.length): # <<<<<<<<<<<<<<
* head = state.H(j)
* label = self.strings[state._sent[j].dep]
*/
__pyx_t_6 = __pyx_v_state->length;
__pyx_t_7 = __pyx_t_6;
for (__pyx_t_8 = 0; __pyx_t_8 < __pyx_t_7; __pyx_t_8+=1) {
__pyx_v_j = __pyx_t_8;
/* "spacy/syntax/arc_eager.pyx":472
* parse = []
* for j in range(state.length):
* head = state.H(j) # <<<<<<<<<<<<<<
* label = self.strings[state._sent[j].dep]
* parse.append((head, j, label))
*/
__pyx_v_head = __pyx_v_state->H(__pyx_v_j);
/* "spacy/syntax/arc_eager.pyx":473
* for j in range(state.length):
* head = state.H(j)
* label = self.strings[state._sent[j].dep] # <<<<<<<<<<<<<<
* parse.append((head, j, label))
* parses.append((prob, parse))
*/
__pyx_t_1 = __Pyx_GetItemInt(((PyObject *)__pyx_v_self->__pyx_base.strings), (__pyx_v_state->_sent[__pyx_v_j]).dep, __pyx_t_5spacy_8typedefs_attr_t, 0, __Pyx_PyInt_From_uint64_t, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 473, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_XDECREF_SET(__pyx_v_label, __pyx_t_1);
__pyx_t_1 = 0;
/* "spacy/syntax/arc_eager.pyx":474
* head = state.H(j)
* label = self.strings[state._sent[j].dep]
* parse.append((head, j, label)) # <<<<<<<<<<<<<<
* parses.append((prob, parse))
* return parses
*/
__pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_head); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 474, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_t_9 = __Pyx_PyInt_From_int(__pyx_v_j); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 474, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_9);
__pyx_t_10 = PyTuple_New(3); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 474, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_10);
__Pyx_GIVEREF(__pyx_t_1);
PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_t_1);
__Pyx_GIVEREF(__pyx_t_9);
PyTuple_SET_ITEM(__pyx_t_10, 1, __pyx_t_9);
__Pyx_INCREF(__pyx_v_label);
__Pyx_GIVEREF(__pyx_v_label);
PyTuple_SET_ITEM(__pyx_t_10, 2, __pyx_v_label);
__pyx_t_1 = 0;
__pyx_t_9 = 0;
__pyx_t_11 = __Pyx_PyList_Append(__pyx_v_parse, __pyx_t_10); if (unlikely(__pyx_t_11 == ((int)-1))) __PYX_ERR(0, 474, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
}
/* "spacy/syntax/arc_eager.pyx":475
* label = self.strings[state._sent[j].dep]
* parse.append((head, j, label))
* parses.append((prob, parse)) # <<<<<<<<<<<<<<
* return parses
*
*/
__pyx_t_10 = PyTuple_New(2); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 475, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_10);
__Pyx_INCREF(__pyx_v_prob);
__Pyx_GIVEREF(__pyx_v_prob);
PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_v_prob);
__Pyx_INCREF(__pyx_v_parse);
__Pyx_GIVEREF(__pyx_v_parse);
PyTuple_SET_ITEM(__pyx_t_10, 1, __pyx_v_parse);
__pyx_t_11 = __Pyx_PyList_Append(__pyx_v_parses, __pyx_t_10); if (unlikely(__pyx_t_11 == ((int)-1))) __PYX_ERR(0, 475, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
/* "spacy/syntax/arc_eager.pyx":467
* for i in range(beam.size):
* state = <StateC*>beam.at(i)
* if state.is_final(): # <<<<<<<<<<<<<<
* self.finalize_state(state)
* prob = probs[i]
*/
}
}
/* "spacy/syntax/arc_eager.pyx":476
* parse.append((head, j, label))
* parses.append((prob, parse))
* return parses # <<<<<<<<<<<<<<
*
* cdef Transition lookup_transition(self, object name_or_id) except *:
*/
__Pyx_XDECREF(__pyx_r);
__Pyx_INCREF(__pyx_v_parses);
__pyx_r = __pyx_v_parses;
goto __pyx_L0;
/* "spacy/syntax/arc_eager.pyx":462
* return gold
*
* def get_beam_parses(self, Beam beam): # <<<<<<<<<<<<<<
* parses = []
* probs = beam.probs
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_1);
__Pyx_XDECREF(__pyx_t_9);
__Pyx_XDECREF(__pyx_t_10);
__Pyx_AddTraceback("spacy.syntax.arc_eager.ArcEager.get_beam_parses", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = NULL;
__pyx_L0:;
__Pyx_XDECREF(__pyx_v_parses);
__Pyx_XDECREF(__pyx_v_probs);
__Pyx_XDECREF(__pyx_v_prob);
__Pyx_XDECREF(__pyx_v_parse);
__Pyx_XDECREF(__pyx_v_label);
__Pyx_XGIVEREF(__pyx_r);
__Pyx_TraceReturn(__pyx_r, 0);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "spacy/syntax/arc_eager.pyx":478
* return parses
*
* cdef Transition lookup_transition(self, object name_or_id) except *: # <<<<<<<<<<<<<<
* if isinstance(name_or_id, int):
* return self.c[name_or_id]
*/
static struct __pyx_t_5spacy_6syntax_17transition_system_Transition __pyx_f_5spacy_6syntax_9arc_eager_8ArcEager_lookup_transition(struct __pyx_obj_5spacy_6syntax_9arc_eager_ArcEager *__pyx_v_self, PyObject *__pyx_v_name_or_id) {
PyObject *__pyx_v_name = NULL;
PyObject *__pyx_v_move_str = NULL;
PyObject *__pyx_v_label_str = NULL;
PyObject *__pyx_v_label = NULL;
PyObject *__pyx_v_move = NULL;
int __pyx_v_i;
struct __pyx_t_5spacy_6syntax_17transition_system_Transition __pyx_r;
__Pyx_TraceDeclarations
__Pyx_RefNannyDeclarations
int __pyx_t_1;
int __pyx_t_2;
Py_ssize_t __pyx_t_3;
PyObject *__pyx_t_4 = NULL;
PyObject *__pyx_t_5 = NULL;
PyObject *__pyx_t_6 = NULL;
PyObject *__pyx_t_7 = NULL;
PyObject *(*__pyx_t_8)(PyObject *);
int __pyx_t_9;
int __pyx_t_10;
int __pyx_t_11;
struct __pyx_t_5spacy_6syntax_17transition_system_Transition __pyx_t_12;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("lookup_transition", 0);
__Pyx_TraceCall("lookup_transition", __pyx_f[0], 478, 0, __PYX_ERR(0, 478, __pyx_L1_error));
/* "spacy/syntax/arc_eager.pyx":479
*
* cdef Transition lookup_transition(self, object name_or_id) except *:
* if isinstance(name_or_id, int): # <<<<<<<<<<<<<<
* return self.c[name_or_id]
* name = name_or_id
*/
__pyx_t_1 = PyInt_Check(__pyx_v_name_or_id);
__pyx_t_2 = (__pyx_t_1 != 0);
if (__pyx_t_2) {
/* "spacy/syntax/arc_eager.pyx":480
* cdef Transition lookup_transition(self, object name_or_id) except *:
* if isinstance(name_or_id, int):
* return self.c[name_or_id] # <<<<<<<<<<<<<<
* name = name_or_id
* if '-' in name:
*/
__pyx_t_3 = __Pyx_PyIndex_AsSsize_t(__pyx_v_name_or_id); if (unlikely((__pyx_t_3 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 480, __pyx_L1_error)
__pyx_r = (__pyx_v_self->__pyx_base.c[__pyx_t_3]);
goto __pyx_L0;
/* "spacy/syntax/arc_eager.pyx":479
*
* cdef Transition lookup_transition(self, object name_or_id) except *:
* if isinstance(name_or_id, int): # <<<<<<<<<<<<<<
* return self.c[name_or_id]
* name = name_or_id
*/
}
/* "spacy/syntax/arc_eager.pyx":481
* if isinstance(name_or_id, int):
* return self.c[name_or_id]
* name = name_or_id # <<<<<<<<<<<<<<
* if '-' in name:
* move_str, label_str = name.split('-', 1)
*/
__Pyx_INCREF(__pyx_v_name_or_id);
__pyx_v_name = __pyx_v_name_or_id;
/* "spacy/syntax/arc_eager.pyx":482
* return self.c[name_or_id]
* name = name_or_id
* if '-' in name: # <<<<<<<<<<<<<<
* move_str, label_str = name.split('-', 1)
* label = self.strings[label_str]
*/
__pyx_t_2 = (__Pyx_PySequence_ContainsTF(__pyx_kp_u__5, __pyx_v_name, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 482, __pyx_L1_error)
__pyx_t_1 = (__pyx_t_2 != 0);
if (__pyx_t_1) {
/* "spacy/syntax/arc_eager.pyx":483
* name = name_or_id
* if '-' in name:
* move_str, label_str = name.split('-', 1) # <<<<<<<<<<<<<<
* label = self.strings[label_str]
* else:
*/
__pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_name, __pyx_n_s_split); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 483, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_tuple__6, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 483, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
if ((likely(PyTuple_CheckExact(__pyx_t_5))) || (PyList_CheckExact(__pyx_t_5))) {
PyObject* sequence = __pyx_t_5;
Py_ssize_t size = __Pyx_PySequence_SIZE(sequence);
if (unlikely(size != 2)) {
if (size > 2) __Pyx_RaiseTooManyValuesError(2);
else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
__PYX_ERR(0, 483, __pyx_L1_error)
}
#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
if (likely(PyTuple_CheckExact(sequence))) {
__pyx_t_4 = PyTuple_GET_ITEM(sequence, 0);
__pyx_t_6 = PyTuple_GET_ITEM(sequence, 1);
} else {
__pyx_t_4 = PyList_GET_ITEM(sequence, 0);
__pyx_t_6 = PyList_GET_ITEM(sequence, 1);
}
__Pyx_INCREF(__pyx_t_4);
__Pyx_INCREF(__pyx_t_6);
#else
__pyx_t_4 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 483, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__pyx_t_6 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 483, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
#endif
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
} else {
Py_ssize_t index = -1;
__pyx_t_7 = PyObject_GetIter(__pyx_t_5); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 483, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
__pyx_t_8 = Py_TYPE(__pyx_t_7)->tp_iternext;
index = 0; __pyx_t_4 = __pyx_t_8(__pyx_t_7); if (unlikely(!__pyx_t_4)) goto __pyx_L5_unpacking_failed;
__Pyx_GOTREF(__pyx_t_4);
index = 1; __pyx_t_6 = __pyx_t_8(__pyx_t_7); if (unlikely(!__pyx_t_6)) goto __pyx_L5_unpacking_failed;
__Pyx_GOTREF(__pyx_t_6);
if (__Pyx_IternextUnpackEndCheck(__pyx_t_8(__pyx_t_7), 2) < 0) __PYX_ERR(0, 483, __pyx_L1_error)
__pyx_t_8 = NULL;
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
goto __pyx_L6_unpacking_done;
__pyx_L5_unpacking_failed:;
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
__pyx_t_8 = NULL;
if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index);
__PYX_ERR(0, 483, __pyx_L1_error)
__pyx_L6_unpacking_done:;
}
__pyx_v_move_str = __pyx_t_4;
__pyx_t_4 = 0;
__pyx_v_label_str = __pyx_t_6;
__pyx_t_6 = 0;
/* "spacy/syntax/arc_eager.pyx":484
* if '-' in name:
* move_str, label_str = name.split('-', 1)
* label = self.strings[label_str] # <<<<<<<<<<<<<<
* else:
* move_str = name
*/
__pyx_t_5 = __Pyx_PyObject_GetItem(((PyObject *)__pyx_v_self->__pyx_base.strings), __pyx_v_label_str); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 484, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__pyx_v_label = __pyx_t_5;
__pyx_t_5 = 0;
/* "spacy/syntax/arc_eager.pyx":482
* return self.c[name_or_id]
* name = name_or_id
* if '-' in name: # <<<<<<<<<<<<<<
* move_str, label_str = name.split('-', 1)
* label = self.strings[label_str]
*/
goto __pyx_L4;
}
/* "spacy/syntax/arc_eager.pyx":486
* label = self.strings[label_str]
* else:
* move_str = name # <<<<<<<<<<<<<<
* label = 0
* move = MOVE_NAMES.index(move_str)
*/
/*else*/ {
__Pyx_INCREF(__pyx_v_name);
__pyx_v_move_str = __pyx_v_name;
/* "spacy/syntax/arc_eager.pyx":487
* else:
* move_str = name
* label = 0 # <<<<<<<<<<<<<<
* move = MOVE_NAMES.index(move_str)
* for i in range(self.n_moves):
*/
__Pyx_INCREF(__pyx_int_0);
__pyx_v_label = __pyx_int_0;
}
__pyx_L4:;
/* "spacy/syntax/arc_eager.pyx":488
* move_str = name
* label = 0
* move = MOVE_NAMES.index(move_str) # <<<<<<<<<<<<<<
* for i in range(self.n_moves):
* if self.c[i].move == move and self.c[i].label == label:
*/
__Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_MOVE_NAMES); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 488, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_index); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 488, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
__pyx_t_6 = NULL;
if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) {
__pyx_t_6 = PyMethod_GET_SELF(__pyx_t_4);
if (likely(__pyx_t_6)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
__Pyx_INCREF(__pyx_t_6);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_4, function);
}
}
__pyx_t_5 = (__pyx_t_6) ? __Pyx_PyObject_Call2Args(__pyx_t_4, __pyx_t_6, __pyx_v_move_str) : __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_v_move_str);
__Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 488, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__pyx_v_move = __pyx_t_5;
__pyx_t_5 = 0;
/* "spacy/syntax/arc_eager.pyx":489
* label = 0
* move = MOVE_NAMES.index(move_str)
* for i in range(self.n_moves): # <<<<<<<<<<<<<<
* if self.c[i].move == move and self.c[i].label == label:
* return self.c[i]
*/
__pyx_t_9 = __pyx_v_self->__pyx_base.n_moves;
__pyx_t_10 = __pyx_t_9;
for (__pyx_t_11 = 0; __pyx_t_11 < __pyx_t_10; __pyx_t_11+=1) {
__pyx_v_i = __pyx_t_11;
/* "spacy/syntax/arc_eager.pyx":490
* move = MOVE_NAMES.index(move_str)
* for i in range(self.n_moves):
* if self.c[i].move == move and self.c[i].label == label: # <<<<<<<<<<<<<<
* return self.c[i]
* return Transition(clas=0, move=MISSING, label=0)
*/
__pyx_t_5 = __Pyx_PyInt_From_int((__pyx_v_self->__pyx_base.c[__pyx_v_i]).move); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 490, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__pyx_t_4 = PyObject_RichCompare(__pyx_t_5, __pyx_v_move, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 490, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
__pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 490, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
if (__pyx_t_2) {
} else {
__pyx_t_1 = __pyx_t_2;
goto __pyx_L10_bool_binop_done;
}
__pyx_t_4 = __Pyx_PyInt_From_uint64_t((__pyx_v_self->__pyx_base.c[__pyx_v_i]).label); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 490, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__pyx_t_5 = PyObject_RichCompare(__pyx_t_4, __pyx_v_label, Py_EQ); __Pyx_XGOTREF(__pyx_t_5); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 490, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 490, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
__pyx_t_1 = __pyx_t_2;
__pyx_L10_bool_binop_done:;
if (__pyx_t_1) {
/* "spacy/syntax/arc_eager.pyx":491
* for i in range(self.n_moves):
* if self.c[i].move == move and self.c[i].label == label:
* return self.c[i] # <<<<<<<<<<<<<<
* return Transition(clas=0, move=MISSING, label=0)
*
*/
__pyx_r = (__pyx_v_self->__pyx_base.c[__pyx_v_i]);
goto __pyx_L0;
/* "spacy/syntax/arc_eager.pyx":490
* move = MOVE_NAMES.index(move_str)
* for i in range(self.n_moves):
* if self.c[i].move == move and self.c[i].label == label: # <<<<<<<<<<<<<<
* return self.c[i]
* return Transition(clas=0, move=MISSING, label=0)
*/
}
}
/* "spacy/syntax/arc_eager.pyx":492
* if self.c[i].move == move and self.c[i].label == label:
* return self.c[i]
* return Transition(clas=0, move=MISSING, label=0) # <<<<<<<<<<<<<<
*
* def move_name(self, int move, attr_t label):
*/
__pyx_t_12.clas = 0;
__Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_MISSING); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 492, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__pyx_t_9 = __Pyx_PyInt_As_int(__pyx_t_5); if (unlikely((__pyx_t_9 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 492, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
__pyx_t_12.move = __pyx_t_9;
__pyx_t_12.label = 0;
__pyx_r = __pyx_t_12;
goto __pyx_L0;
/* "spacy/syntax/arc_eager.pyx":478
* return parses
*
* cdef Transition lookup_transition(self, object name_or_id) except *: # <<<<<<<<<<<<<<
* if isinstance(name_or_id, int):
* return self.c[name_or_id]
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_4);
__Pyx_XDECREF(__pyx_t_5);
__Pyx_XDECREF(__pyx_t_6);
__Pyx_XDECREF(__pyx_t_7);
__Pyx_AddTraceback("spacy.syntax.arc_eager.ArcEager.lookup_transition", __pyx_clineno, __pyx_lineno, __pyx_filename);
__Pyx_pretend_to_initialize(&__pyx_r);
__pyx_L0:;
__Pyx_XDECREF(__pyx_v_name);
__Pyx_XDECREF(__pyx_v_move_str);
__Pyx_XDECREF(__pyx_v_label_str);
__Pyx_XDECREF(__pyx_v_label);
__Pyx_XDECREF(__pyx_v_move);
__Pyx_TraceReturn(Py_None, 0);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "spacy/syntax/arc_eager.pyx":494
* return Transition(clas=0, move=MISSING, label=0)
*
* def move_name(self, int move, attr_t label): # <<<<<<<<<<<<<<
* label_str = self.strings[label]
* if label_str:
*/
/* Python wrapper */
static PyObject *__pyx_pw_5spacy_6syntax_9arc_eager_8ArcEager_17move_name(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static PyObject *__pyx_pw_5spacy_6syntax_9arc_eager_8ArcEager_17move_name(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
int __pyx_v_move;
__pyx_t_5spacy_8typedefs_attr_t __pyx_v_label;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
PyObject *__pyx_r = 0;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("move_name (wrapper)", 0);
{
static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_move,&__pyx_n_s_label,0};
PyObject* values[2] = {0,0};
if (unlikely(__pyx_kwds)) {
Py_ssize_t kw_args;
const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
switch (pos_args) {
case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
CYTHON_FALLTHROUGH;
case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
CYTHON_FALLTHROUGH;
case 0: break;
default: goto __pyx_L5_argtuple_error;
}
kw_args = PyDict_Size(__pyx_kwds);
switch (pos_args) {
case 0:
if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_move)) != 0)) kw_args--;
else goto __pyx_L5_argtuple_error;
CYTHON_FALLTHROUGH;
case 1:
if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_label)) != 0)) kw_args--;
else {
__Pyx_RaiseArgtupleInvalid("move_name", 1, 2, 2, 1); __PYX_ERR(0, 494, __pyx_L3_error)
}
}
if (unlikely(kw_args > 0)) {
if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "move_name") < 0)) __PYX_ERR(0, 494, __pyx_L3_error)
}
} else if (PyTuple_GET_SIZE(__pyx_args) != 2) {
goto __pyx_L5_argtuple_error;
} else {
values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
}
__pyx_v_move = __Pyx_PyInt_As_int(values[0]); if (unlikely((__pyx_v_move == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 494, __pyx_L3_error)
__pyx_v_label = __Pyx_PyInt_As_uint64_t(values[1]); if (unlikely((__pyx_v_label == ((uint64_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 494, __pyx_L3_error)
}
goto __pyx_L4_argument_unpacking_done;
__pyx_L5_argtuple_error:;
__Pyx_RaiseArgtupleInvalid("move_name", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 494, __pyx_L3_error)
__pyx_L3_error:;
__Pyx_AddTraceback("spacy.syntax.arc_eager.ArcEager.move_name", __pyx_clineno, __pyx_lineno, __pyx_filename);
__Pyx_RefNannyFinishContext();
return NULL;
__pyx_L4_argument_unpacking_done:;
__pyx_r = __pyx_pf_5spacy_6syntax_9arc_eager_8ArcEager_16move_name(((struct __pyx_obj_5spacy_6syntax_9arc_eager_ArcEager *)__pyx_v_self), __pyx_v_move, __pyx_v_label);
/* function exit code */
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
static PyObject *__pyx_pf_5spacy_6syntax_9arc_eager_8ArcEager_16move_name(struct __pyx_obj_5spacy_6syntax_9arc_eager_ArcEager *__pyx_v_self, int __pyx_v_move, __pyx_t_5spacy_8typedefs_attr_t __pyx_v_label) {
PyObject *__pyx_v_label_str = NULL;
PyObject *__pyx_r = NULL;
__Pyx_TraceDeclarations
__Pyx_RefNannyDeclarations
PyObject *__pyx_t_1 = NULL;
int __pyx_t_2;
PyObject *__pyx_t_3 = NULL;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("move_name", 0);
__Pyx_TraceCall("move_name", __pyx_f[0], 494, 0, __PYX_ERR(0, 494, __pyx_L1_error));
/* "spacy/syntax/arc_eager.pyx":495
*
* def move_name(self, int move, attr_t label):
* label_str = self.strings[label] # <<<<<<<<<<<<<<
* if label_str:
* return MOVE_NAMES[move] + '-' + label_str
*/
__pyx_t_1 = __Pyx_GetItemInt(((PyObject *)__pyx_v_self->__pyx_base.strings), __pyx_v_label, __pyx_t_5spacy_8typedefs_attr_t, 0, __Pyx_PyInt_From_uint64_t, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 495, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_v_label_str = __pyx_t_1;
__pyx_t_1 = 0;
/* "spacy/syntax/arc_eager.pyx":496
* def move_name(self, int move, attr_t label):
* label_str = self.strings[label]
* if label_str: # <<<<<<<<<<<<<<
* return MOVE_NAMES[move] + '-' + label_str
* else:
*/
__pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_v_label_str); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 496, __pyx_L1_error)
if (__pyx_t_2) {
/* "spacy/syntax/arc_eager.pyx":497
* label_str = self.strings[label]
* if label_str:
* return MOVE_NAMES[move] + '-' + label_str # <<<<<<<<<<<<<<
* else:
* return MOVE_NAMES[move]
*/
__Pyx_XDECREF(__pyx_r);
__Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_MOVE_NAMES); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 497, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_t_3 = __Pyx_GetItemInt(__pyx_t_1, __pyx_v_move, int, 1, __Pyx_PyInt_From_int, 0, 1, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 497, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__pyx_t_1 = PyNumber_Add(__pyx_t_3, __pyx_kp_u__5); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 497, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__pyx_t_3 = PyNumber_Add(__pyx_t_1, __pyx_v_label_str); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 497, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__pyx_r = __pyx_t_3;
__pyx_t_3 = 0;
goto __pyx_L0;
/* "spacy/syntax/arc_eager.pyx":496
* def move_name(self, int move, attr_t label):
* label_str = self.strings[label]
* if label_str: # <<<<<<<<<<<<<<
* return MOVE_NAMES[move] + '-' + label_str
* else:
*/
}
/* "spacy/syntax/arc_eager.pyx":499
* return MOVE_NAMES[move] + '-' + label_str
* else:
* return MOVE_NAMES[move] # <<<<<<<<<<<<<<
*
* def class_name(self, int i):
*/
/*else*/ {
__Pyx_XDECREF(__pyx_r);
__Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_MOVE_NAMES); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 499, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__pyx_t_1 = __Pyx_GetItemInt(__pyx_t_3, __pyx_v_move, int, 1, __Pyx_PyInt_From_int, 0, 1, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 499, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__pyx_r = __pyx_t_1;
__pyx_t_1 = 0;
goto __pyx_L0;
}
/* "spacy/syntax/arc_eager.pyx":494
* return Transition(clas=0, move=MISSING, label=0)
*
* def move_name(self, int move, attr_t label): # <<<<<<<<<<<<<<
* label_str = self.strings[label]
* if label_str:
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_1);
__Pyx_XDECREF(__pyx_t_3);
__Pyx_AddTraceback("spacy.syntax.arc_eager.ArcEager.move_name", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = NULL;
__pyx_L0:;
__Pyx_XDECREF(__pyx_v_label_str);
__Pyx_XGIVEREF(__pyx_r);
__Pyx_TraceReturn(__pyx_r, 0);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "spacy/syntax/arc_eager.pyx":501
* return MOVE_NAMES[move]
*
* def class_name(self, int i): # <<<<<<<<<<<<<<
* return self.move_name(self.c[i].move, self.c[i].label)
*
*/
/* Python wrapper */
static PyObject *__pyx_pw_5spacy_6syntax_9arc_eager_8ArcEager_19class_name(PyObject *__pyx_v_self, PyObject *__pyx_arg_i); /*proto*/
static PyObject *__pyx_pw_5spacy_6syntax_9arc_eager_8ArcEager_19class_name(PyObject *__pyx_v_self, PyObject *__pyx_arg_i) {
int __pyx_v_i;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
PyObject *__pyx_r = 0;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("class_name (wrapper)", 0);
assert(__pyx_arg_i); {
__pyx_v_i = __Pyx_PyInt_As_int(__pyx_arg_i); if (unlikely((__pyx_v_i == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 501, __pyx_L3_error)
}
goto __pyx_L4_argument_unpacking_done;
__pyx_L3_error:;
__Pyx_AddTraceback("spacy.syntax.arc_eager.ArcEager.class_name", __pyx_clineno, __pyx_lineno, __pyx_filename);
__Pyx_RefNannyFinishContext();
return NULL;
__pyx_L4_argument_unpacking_done:;
__pyx_r = __pyx_pf_5spacy_6syntax_9arc_eager_8ArcEager_18class_name(((struct __pyx_obj_5spacy_6syntax_9arc_eager_ArcEager *)__pyx_v_self), ((int)__pyx_v_i));
/* function exit code */
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
static PyObject *__pyx_pf_5spacy_6syntax_9arc_eager_8ArcEager_18class_name(struct __pyx_obj_5spacy_6syntax_9arc_eager_ArcEager *__pyx_v_self, int __pyx_v_i) {
PyObject *__pyx_r = NULL;
__Pyx_TraceDeclarations
__Pyx_RefNannyDeclarations
PyObject *__pyx_t_1 = NULL;
PyObject *__pyx_t_2 = NULL;
PyObject *__pyx_t_3 = NULL;
PyObject *__pyx_t_4 = NULL;
PyObject *__pyx_t_5 = NULL;
int __pyx_t_6;
PyObject *__pyx_t_7 = NULL;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("class_name", 0);
__Pyx_TraceCall("class_name", __pyx_f[0], 501, 0, __PYX_ERR(0, 501, __pyx_L1_error));
/* "spacy/syntax/arc_eager.pyx":502
*
* def class_name(self, int i):
* return self.move_name(self.c[i].move, self.c[i].label) # <<<<<<<<<<<<<<
*
* cdef Transition init_transition(self, int clas, int move, attr_t label) except *:
*/
__Pyx_XDECREF(__pyx_r);
__pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_move_name); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 502, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__pyx_t_3 = __Pyx_PyInt_From_int((__pyx_v_self->__pyx_base.c[__pyx_v_i]).move); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 502, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__pyx_t_4 = __Pyx_PyInt_From_uint64_t((__pyx_v_self->__pyx_base.c[__pyx_v_i]).label); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 502, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__pyx_t_5 = NULL;
__pyx_t_6 = 0;
if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
__pyx_t_5 = PyMethod_GET_SELF(__pyx_t_2);
if (likely(__pyx_t_5)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
__Pyx_INCREF(__pyx_t_5);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_2, function);
__pyx_t_6 = 1;
}
}
#if CYTHON_FAST_PYCALL
if (PyFunction_Check(__pyx_t_2)) {
PyObject *__pyx_temp[3] = {__pyx_t_5, __pyx_t_3, __pyx_t_4};
__pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 502, __pyx_L1_error)
__Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
} else
#endif
#if CYTHON_FAST_PYCCALL
if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) {
PyObject *__pyx_temp[3] = {__pyx_t_5, __pyx_t_3, __pyx_t_4};
__pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 502, __pyx_L1_error)
__Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
} else
#endif
{
__pyx_t_7 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 502, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
if (__pyx_t_5) {
__Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_5); __pyx_t_5 = NULL;
}
__Pyx_GIVEREF(__pyx_t_3);
PyTuple_SET_ITEM(__pyx_t_7, 0+__pyx_t_6, __pyx_t_3);
__Pyx_GIVEREF(__pyx_t_4);
PyTuple_SET_ITEM(__pyx_t_7, 1+__pyx_t_6, __pyx_t_4);
__pyx_t_3 = 0;
__pyx_t_4 = 0;
__pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_7, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 502, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
}
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__pyx_r = __pyx_t_1;
__pyx_t_1 = 0;
goto __pyx_L0;
/* "spacy/syntax/arc_eager.pyx":501
* return MOVE_NAMES[move]
*
* def class_name(self, int i): # <<<<<<<<<<<<<<
* return self.move_name(self.c[i].move, self.c[i].label)
*
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_1);
__Pyx_XDECREF(__pyx_t_2);
__Pyx_XDECREF(__pyx_t_3);
__Pyx_XDECREF(__pyx_t_4);
__Pyx_XDECREF(__pyx_t_5);
__Pyx_XDECREF(__pyx_t_7);
__Pyx_AddTraceback("spacy.syntax.arc_eager.ArcEager.class_name", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = NULL;
__pyx_L0:;
__Pyx_XGIVEREF(__pyx_r);
__Pyx_TraceReturn(__pyx_r, 0);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "spacy/syntax/arc_eager.pyx":504
* return self.move_name(self.c[i].move, self.c[i].label)
*
* cdef Transition init_transition(self, int clas, int move, attr_t label) except *: # <<<<<<<<<<<<<<
* # TODO: Apparent Cython bug here when we try to use the Transition()
* # constructor with the function pointers
*/
static struct __pyx_t_5spacy_6syntax_17transition_system_Transition __pyx_f_5spacy_6syntax_9arc_eager_8ArcEager_init_transition(CYTHON_UNUSED struct __pyx_obj_5spacy_6syntax_9arc_eager_ArcEager *__pyx_v_self, int __pyx_v_clas, int __pyx_v_move, __pyx_t_5spacy_8typedefs_attr_t __pyx_v_label) {
struct __pyx_t_5spacy_6syntax_17transition_system_Transition __pyx_v_t;
struct __pyx_t_5spacy_6syntax_17transition_system_Transition __pyx_r;
__Pyx_TraceDeclarations
__Pyx_RefNannyDeclarations
PyObject *__pyx_t_1 = NULL;
PyObject *__pyx_t_2 = NULL;
PyObject *__pyx_t_3 = NULL;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("init_transition", 0);
__Pyx_TraceCall("init_transition", __pyx_f[0], 504, 0, __PYX_ERR(0, 504, __pyx_L1_error));
/* "spacy/syntax/arc_eager.pyx":508
* # constructor with the function pointers
* cdef Transition t
* t.score = 0 # <<<<<<<<<<<<<<
* t.clas = clas
* t.move = move
*/
__pyx_v_t.score = 0.0;
/* "spacy/syntax/arc_eager.pyx":509
* cdef Transition t
* t.score = 0
* t.clas = clas # <<<<<<<<<<<<<<
* t.move = move
* t.label = label
*/
__pyx_v_t.clas = __pyx_v_clas;
/* "spacy/syntax/arc_eager.pyx":510
* t.score = 0
* t.clas = clas
* t.move = move # <<<<<<<<<<<<<<
* t.label = label
* if move == SHIFT:
*/
__pyx_v_t.move = __pyx_v_move;
/* "spacy/syntax/arc_eager.pyx":511
* t.clas = clas
* t.move = move
* t.label = label # <<<<<<<<<<<<<<
* if move == SHIFT:
* t.is_valid = Shift.is_valid
*/
__pyx_v_t.label = __pyx_v_label;
/* "spacy/syntax/arc_eager.pyx":512
* t.move = move
* t.label = label
* if move == SHIFT: # <<<<<<<<<<<<<<
* t.is_valid = Shift.is_valid
* t.do = Shift.transition
*/
switch (__pyx_v_move) {
case __pyx_e_5spacy_6syntax_9arc_eager_SHIFT:
/* "spacy/syntax/arc_eager.pyx":513
* t.label = label
* if move == SHIFT:
* t.is_valid = Shift.is_valid # <<<<<<<<<<<<<<
* t.do = Shift.transition
* t.get_cost = Shift.cost
*/
__pyx_v_t.is_valid = __pyx_f_5spacy_6syntax_9arc_eager_5Shift_is_valid;
/* "spacy/syntax/arc_eager.pyx":514
* if move == SHIFT:
* t.is_valid = Shift.is_valid
* t.do = Shift.transition # <<<<<<<<<<<<<<
* t.get_cost = Shift.cost
* elif move == REDUCE:
*/
__pyx_v_t.__pyx_do = __pyx_f_5spacy_6syntax_9arc_eager_5Shift_transition;
/* "spacy/syntax/arc_eager.pyx":515
* t.is_valid = Shift.is_valid
* t.do = Shift.transition
* t.get_cost = Shift.cost # <<<<<<<<<<<<<<
* elif move == REDUCE:
* t.is_valid = Reduce.is_valid
*/
__pyx_v_t.get_cost = __pyx_f_5spacy_6syntax_9arc_eager_5Shift_cost;
/* "spacy/syntax/arc_eager.pyx":512
* t.move = move
* t.label = label
* if move == SHIFT: # <<<<<<<<<<<<<<
* t.is_valid = Shift.is_valid
* t.do = Shift.transition
*/
break;
case __pyx_e_5spacy_6syntax_9arc_eager_REDUCE:
/* "spacy/syntax/arc_eager.pyx":517
* t.get_cost = Shift.cost
* elif move == REDUCE:
* t.is_valid = Reduce.is_valid # <<<<<<<<<<<<<<
* t.do = Reduce.transition
* t.get_cost = Reduce.cost
*/
__pyx_v_t.is_valid = __pyx_f_5spacy_6syntax_9arc_eager_6Reduce_is_valid;
/* "spacy/syntax/arc_eager.pyx":518
* elif move == REDUCE:
* t.is_valid = Reduce.is_valid
* t.do = Reduce.transition # <<<<<<<<<<<<<<
* t.get_cost = Reduce.cost
* elif move == LEFT:
*/
__pyx_v_t.__pyx_do = __pyx_f_5spacy_6syntax_9arc_eager_6Reduce_transition;
/* "spacy/syntax/arc_eager.pyx":519
* t.is_valid = Reduce.is_valid
* t.do = Reduce.transition
* t.get_cost = Reduce.cost # <<<<<<<<<<<<<<
* elif move == LEFT:
* t.is_valid = LeftArc.is_valid
*/
__pyx_v_t.get_cost = __pyx_f_5spacy_6syntax_9arc_eager_6Reduce_cost;
/* "spacy/syntax/arc_eager.pyx":516
* t.do = Shift.transition
* t.get_cost = Shift.cost
* elif move == REDUCE: # <<<<<<<<<<<<<<
* t.is_valid = Reduce.is_valid
* t.do = Reduce.transition
*/
break;
case __pyx_e_5spacy_6syntax_9arc_eager_LEFT:
/* "spacy/syntax/arc_eager.pyx":521
* t.get_cost = Reduce.cost
* elif move == LEFT:
* t.is_valid = LeftArc.is_valid # <<<<<<<<<<<<<<
* t.do = LeftArc.transition
* t.get_cost = LeftArc.cost
*/
__pyx_v_t.is_valid = __pyx_f_5spacy_6syntax_9arc_eager_7LeftArc_is_valid;
/* "spacy/syntax/arc_eager.pyx":522
* elif move == LEFT:
* t.is_valid = LeftArc.is_valid
* t.do = LeftArc.transition # <<<<<<<<<<<<<<
* t.get_cost = LeftArc.cost
* elif move == RIGHT:
*/
__pyx_v_t.__pyx_do = __pyx_f_5spacy_6syntax_9arc_eager_7LeftArc_transition;
/* "spacy/syntax/arc_eager.pyx":523
* t.is_valid = LeftArc.is_valid
* t.do = LeftArc.transition
* t.get_cost = LeftArc.cost # <<<<<<<<<<<<<<
* elif move == RIGHT:
* t.is_valid = RightArc.is_valid
*/
__pyx_v_t.get_cost = __pyx_f_5spacy_6syntax_9arc_eager_7LeftArc_cost;
/* "spacy/syntax/arc_eager.pyx":520
* t.do = Reduce.transition
* t.get_cost = Reduce.cost
* elif move == LEFT: # <<<<<<<<<<<<<<
* t.is_valid = LeftArc.is_valid
* t.do = LeftArc.transition
*/
break;
case __pyx_e_5spacy_6syntax_9arc_eager_RIGHT:
/* "spacy/syntax/arc_eager.pyx":525
* t.get_cost = LeftArc.cost
* elif move == RIGHT:
* t.is_valid = RightArc.is_valid # <<<<<<<<<<<<<<
* t.do = RightArc.transition
* t.get_cost = RightArc.cost
*/
__pyx_v_t.is_valid = __pyx_f_5spacy_6syntax_9arc_eager_8RightArc_is_valid;
/* "spacy/syntax/arc_eager.pyx":526
* elif move == RIGHT:
* t.is_valid = RightArc.is_valid
* t.do = RightArc.transition # <<<<<<<<<<<<<<
* t.get_cost = RightArc.cost
* elif move == BREAK:
*/
__pyx_v_t.__pyx_do = __pyx_f_5spacy_6syntax_9arc_eager_8RightArc_transition;
/* "spacy/syntax/arc_eager.pyx":527
* t.is_valid = RightArc.is_valid
* t.do = RightArc.transition
* t.get_cost = RightArc.cost # <<<<<<<<<<<<<<
* elif move == BREAK:
* t.is_valid = Break.is_valid
*/
__pyx_v_t.get_cost = __pyx_f_5spacy_6syntax_9arc_eager_8RightArc_cost;
/* "spacy/syntax/arc_eager.pyx":524
* t.do = LeftArc.transition
* t.get_cost = LeftArc.cost
* elif move == RIGHT: # <<<<<<<<<<<<<<
* t.is_valid = RightArc.is_valid
* t.do = RightArc.transition
*/
break;
case __pyx_e_5spacy_6syntax_9arc_eager_BREAK:
/* "spacy/syntax/arc_eager.pyx":529
* t.get_cost = RightArc.cost
* elif move == BREAK:
* t.is_valid = Break.is_valid # <<<<<<<<<<<<<<
* t.do = Break.transition
* t.get_cost = Break.cost
*/
__pyx_v_t.is_valid = __pyx_f_5spacy_6syntax_9arc_eager_5Break_is_valid;
/* "spacy/syntax/arc_eager.pyx":530
* elif move == BREAK:
* t.is_valid = Break.is_valid
* t.do = Break.transition # <<<<<<<<<<<<<<
* t.get_cost = Break.cost
* else:
*/
__pyx_v_t.__pyx_do = __pyx_f_5spacy_6syntax_9arc_eager_5Break_transition;
/* "spacy/syntax/arc_eager.pyx":531
* t.is_valid = Break.is_valid
* t.do = Break.transition
* t.get_cost = Break.cost # <<<<<<<<<<<<<<
* else:
* raise ValueError(Errors.E019.format(action=move, src='arc_eager'))
*/
__pyx_v_t.get_cost = __pyx_f_5spacy_6syntax_9arc_eager_5Break_cost;
/* "spacy/syntax/arc_eager.pyx":528
* t.do = RightArc.transition
* t.get_cost = RightArc.cost
* elif move == BREAK: # <<<<<<<<<<<<<<
* t.is_valid = Break.is_valid
* t.do = Break.transition
*/
break;
default:
/* "spacy/syntax/arc_eager.pyx":533
* t.get_cost = Break.cost
* else:
* raise ValueError(Errors.E019.format(action=move, src='arc_eager')) # <<<<<<<<<<<<<<
* return t
*
*/
__Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_Errors); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 533, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_E019); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 533, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_format); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 533, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__pyx_t_2 = __Pyx_PyDict_NewPresized(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 533, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_move); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 533, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_action, __pyx_t_3) < 0) __PYX_ERR(0, 533, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_src, __pyx_n_u_arc_eager) < 0) __PYX_ERR(0, 533, __pyx_L1_error)
__pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_empty_tuple, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 533, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 533, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__Pyx_Raise(__pyx_t_2, 0, 0, 0);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__PYX_ERR(0, 533, __pyx_L1_error)
break;
}
/* "spacy/syntax/arc_eager.pyx":534
* else:
* raise ValueError(Errors.E019.format(action=move, src='arc_eager'))
* return t # <<<<<<<<<<<<<<
*
* cdef int initialize_state(self, StateC* st) nogil:
*/
__pyx_r = __pyx_v_t;
goto __pyx_L0;
/* "spacy/syntax/arc_eager.pyx":504
* return self.move_name(self.c[i].move, self.c[i].label)
*
* cdef Transition init_transition(self, int clas, int move, attr_t label) except *: # <<<<<<<<<<<<<<
* # TODO: Apparent Cython bug here when we try to use the Transition()
* # constructor with the function pointers
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_1);
__Pyx_XDECREF(__pyx_t_2);
__Pyx_XDECREF(__pyx_t_3);
__Pyx_AddTraceback("spacy.syntax.arc_eager.ArcEager.init_transition", __pyx_clineno, __pyx_lineno, __pyx_filename);
__Pyx_pretend_to_initialize(&__pyx_r);
__pyx_L0:;
__Pyx_TraceReturn(Py_None, 0);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "spacy/syntax/arc_eager.pyx":536
* return t
*
* cdef int initialize_state(self, StateC* st) nogil: # <<<<<<<<<<<<<<
* for i in range(st.length):
* if st._sent[i].dep == 0:
*/
static int __pyx_f_5spacy_6syntax_9arc_eager_8ArcEager_initialize_state(CYTHON_UNUSED struct __pyx_obj_5spacy_6syntax_9arc_eager_ArcEager *__pyx_v_self, __pyx_t_5spacy_6syntax_6_state_StateC *__pyx_v_st) {
int __pyx_v_i;
int __pyx_r;
__Pyx_TraceDeclarations
int __pyx_t_1;
int __pyx_t_2;
int __pyx_t_3;
int __pyx_t_4;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_TraceCall("initialize_state", __pyx_f[0], 536, 1, __PYX_ERR(0, 536, __pyx_L1_error));
/* "spacy/syntax/arc_eager.pyx":537
*
* cdef int initialize_state(self, StateC* st) nogil:
* for i in range(st.length): # <<<<<<<<<<<<<<
* if st._sent[i].dep == 0:
* st._sent[i].l_edge = i
*/
__pyx_t_1 = __pyx_v_st->length;
__pyx_t_2 = __pyx_t_1;
for (__pyx_t_3 = 0; __pyx_t_3 < __pyx_t_2; __pyx_t_3+=1) {
__pyx_v_i = __pyx_t_3;
/* "spacy/syntax/arc_eager.pyx":538
* cdef int initialize_state(self, StateC* st) nogil:
* for i in range(st.length):
* if st._sent[i].dep == 0: # <<<<<<<<<<<<<<
* st._sent[i].l_edge = i
* st._sent[i].r_edge = i
*/
__pyx_t_4 = (((__pyx_v_st->_sent[__pyx_v_i]).dep == 0) != 0);
if (__pyx_t_4) {
/* "spacy/syntax/arc_eager.pyx":539
* for i in range(st.length):
* if st._sent[i].dep == 0:
* st._sent[i].l_edge = i # <<<<<<<<<<<<<<
* st._sent[i].r_edge = i
* st._sent[i].head = 0
*/
(__pyx_v_st->_sent[__pyx_v_i]).l_edge = __pyx_v_i;
/* "spacy/syntax/arc_eager.pyx":540
* if st._sent[i].dep == 0:
* st._sent[i].l_edge = i
* st._sent[i].r_edge = i # <<<<<<<<<<<<<<
* st._sent[i].head = 0
* st._sent[i].dep = 0
*/
(__pyx_v_st->_sent[__pyx_v_i]).r_edge = __pyx_v_i;
/* "spacy/syntax/arc_eager.pyx":541
* st._sent[i].l_edge = i
* st._sent[i].r_edge = i
* st._sent[i].head = 0 # <<<<<<<<<<<<<<
* st._sent[i].dep = 0
* st._sent[i].l_kids = 0
*/
(__pyx_v_st->_sent[__pyx_v_i]).head = 0;
/* "spacy/syntax/arc_eager.pyx":542
* st._sent[i].r_edge = i
* st._sent[i].head = 0
* st._sent[i].dep = 0 # <<<<<<<<<<<<<<
* st._sent[i].l_kids = 0
* st._sent[i].r_kids = 0
*/
(__pyx_v_st->_sent[__pyx_v_i]).dep = 0;
/* "spacy/syntax/arc_eager.pyx":543
* st._sent[i].head = 0
* st._sent[i].dep = 0
* st._sent[i].l_kids = 0 # <<<<<<<<<<<<<<
* st._sent[i].r_kids = 0
* st.fast_forward()
*/
(__pyx_v_st->_sent[__pyx_v_i]).l_kids = 0;
/* "spacy/syntax/arc_eager.pyx":544
* st._sent[i].dep = 0
* st._sent[i].l_kids = 0
* st._sent[i].r_kids = 0 # <<<<<<<<<<<<<<
* st.fast_forward()
*
*/
(__pyx_v_st->_sent[__pyx_v_i]).r_kids = 0;
/* "spacy/syntax/arc_eager.pyx":538
* cdef int initialize_state(self, StateC* st) nogil:
* for i in range(st.length):
* if st._sent[i].dep == 0: # <<<<<<<<<<<<<<
* st._sent[i].l_edge = i
* st._sent[i].r_edge = i
*/
}
}
/* "spacy/syntax/arc_eager.pyx":545
* st._sent[i].l_kids = 0
* st._sent[i].r_kids = 0
* st.fast_forward() # <<<<<<<<<<<<<<
*
* cdef int finalize_state(self, StateC* st) nogil:
*/
__pyx_v_st->fast_forward();
/* "spacy/syntax/arc_eager.pyx":536
* return t
*
* cdef int initialize_state(self, StateC* st) nogil: # <<<<<<<<<<<<<<
* for i in range(st.length):
* if st._sent[i].dep == 0:
*/
/* function exit code */
__pyx_r = 0;
goto __pyx_L0;
__pyx_L1_error:;
__Pyx_WriteUnraisable("spacy.syntax.arc_eager.ArcEager.initialize_state", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 1);
__pyx_r = 0;
__pyx_L0:;
__Pyx_TraceReturn(Py_None, 1);
return __pyx_r;
}
/* "spacy/syntax/arc_eager.pyx":547
* st.fast_forward()
*
* cdef int finalize_state(self, StateC* st) nogil: # <<<<<<<<<<<<<<
* cdef int i
* for i in range(st.length):
*/
static int __pyx_f_5spacy_6syntax_9arc_eager_8ArcEager_finalize_state(struct __pyx_obj_5spacy_6syntax_9arc_eager_ArcEager *__pyx_v_self, __pyx_t_5spacy_6syntax_6_state_StateC *__pyx_v_st) {
int __pyx_v_i;
int __pyx_r;
__Pyx_TraceDeclarations
int __pyx_t_1;
int __pyx_t_2;
int __pyx_t_3;
int __pyx_t_4;
__pyx_t_5spacy_8typedefs_attr_t __pyx_t_5;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_TraceCall("finalize_state", __pyx_f[0], 547, 1, __PYX_ERR(0, 547, __pyx_L1_error));
/* "spacy/syntax/arc_eager.pyx":549
* cdef int finalize_state(self, StateC* st) nogil:
* cdef int i
* for i in range(st.length): # <<<<<<<<<<<<<<
* if st._sent[i].head == 0:
* st._sent[i].dep = self.root_label
*/
__pyx_t_1 = __pyx_v_st->length;
__pyx_t_2 = __pyx_t_1;
for (__pyx_t_3 = 0; __pyx_t_3 < __pyx_t_2; __pyx_t_3+=1) {
__pyx_v_i = __pyx_t_3;
/* "spacy/syntax/arc_eager.pyx":550
* cdef int i
* for i in range(st.length):
* if st._sent[i].head == 0: # <<<<<<<<<<<<<<
* st._sent[i].dep = self.root_label
*
*/
__pyx_t_4 = (((__pyx_v_st->_sent[__pyx_v_i]).head == 0) != 0);
if (__pyx_t_4) {
/* "spacy/syntax/arc_eager.pyx":551
* for i in range(st.length):
* if st._sent[i].head == 0:
* st._sent[i].dep = self.root_label # <<<<<<<<<<<<<<
*
* def finalize_doc(self, Doc doc):
*/
__pyx_t_5 = __pyx_v_self->__pyx_base.root_label;
(__pyx_v_st->_sent[__pyx_v_i]).dep = __pyx_t_5;
/* "spacy/syntax/arc_eager.pyx":550
* cdef int i
* for i in range(st.length):
* if st._sent[i].head == 0: # <<<<<<<<<<<<<<
* st._sent[i].dep = self.root_label
*
*/
}
}
/* "spacy/syntax/arc_eager.pyx":547
* st.fast_forward()
*
* cdef int finalize_state(self, StateC* st) nogil: # <<<<<<<<<<<<<<
* cdef int i
* for i in range(st.length):
*/
/* function exit code */
__pyx_r = 0;
goto __pyx_L0;
__pyx_L1_error:;
__Pyx_WriteUnraisable("spacy.syntax.arc_eager.ArcEager.finalize_state", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 1);
__pyx_r = 0;
__pyx_L0:;
__Pyx_TraceReturn(Py_None, 1);
return __pyx_r;
}
/* "spacy/syntax/arc_eager.pyx":553
* st._sent[i].dep = self.root_label
*
* def finalize_doc(self, Doc doc): # <<<<<<<<<<<<<<
* doc.is_parsed = True
* set_children_from_heads(doc.c, doc.length)
*/
/* Python wrapper */
static PyObject *__pyx_pw_5spacy_6syntax_9arc_eager_8ArcEager_21finalize_doc(PyObject *__pyx_v_self, PyObject *__pyx_v_doc); /*proto*/
static PyObject *__pyx_pw_5spacy_6syntax_9arc_eager_8ArcEager_21finalize_doc(PyObject *__pyx_v_self, PyObject *__pyx_v_doc) {
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
PyObject *__pyx_r = 0;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("finalize_doc (wrapper)", 0);
if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_doc), __pyx_ptype_5spacy_6tokens_3doc_Doc, 1, "doc", 0))) __PYX_ERR(0, 553, __pyx_L1_error)
__pyx_r = __pyx_pf_5spacy_6syntax_9arc_eager_8ArcEager_20finalize_doc(((struct __pyx_obj_5spacy_6syntax_9arc_eager_ArcEager *)__pyx_v_self), ((struct __pyx_obj_5spacy_6tokens_3doc_Doc *)__pyx_v_doc));
/* function exit code */
goto __pyx_L0;
__pyx_L1_error:;
__pyx_r = NULL;
__pyx_L0:;
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
static PyObject *__pyx_pf_5spacy_6syntax_9arc_eager_8ArcEager_20finalize_doc(CYTHON_UNUSED struct __pyx_obj_5spacy_6syntax_9arc_eager_ArcEager *__pyx_v_self, struct __pyx_obj_5spacy_6tokens_3doc_Doc *__pyx_v_doc) {
PyObject *__pyx_r = NULL;
__Pyx_TraceDeclarations
__Pyx_RefNannyDeclarations
int __pyx_t_1;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("finalize_doc", 0);
__Pyx_TraceCall("finalize_doc", __pyx_f[0], 553, 0, __PYX_ERR(0, 553, __pyx_L1_error));
/* "spacy/syntax/arc_eager.pyx":554
*
* def finalize_doc(self, Doc doc):
* doc.is_parsed = True # <<<<<<<<<<<<<<
* set_children_from_heads(doc.c, doc.length)
*
*/
__pyx_v_doc->is_parsed = 1;
/* "spacy/syntax/arc_eager.pyx":555
* def finalize_doc(self, Doc doc):
* doc.is_parsed = True
* set_children_from_heads(doc.c, doc.length) # <<<<<<<<<<<<<<
*
* cdef int set_valid(self, int* output, const StateC* st) nogil:
*/
__pyx_t_1 = __pyx_f_5spacy_6tokens_3doc_set_children_from_heads(__pyx_v_doc->c, __pyx_v_doc->length); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 555, __pyx_L1_error)
/* "spacy/syntax/arc_eager.pyx":553
* st._sent[i].dep = self.root_label
*
* def finalize_doc(self, Doc doc): # <<<<<<<<<<<<<<
* doc.is_parsed = True
* set_children_from_heads(doc.c, doc.length)
*/
/* function exit code */
__pyx_r = Py_None; __Pyx_INCREF(Py_None);
goto __pyx_L0;
__pyx_L1_error:;
__Pyx_AddTraceback("spacy.syntax.arc_eager.ArcEager.finalize_doc", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = NULL;
__pyx_L0:;
__Pyx_XGIVEREF(__pyx_r);
__Pyx_TraceReturn(__pyx_r, 0);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "spacy/syntax/arc_eager.pyx":557
* set_children_from_heads(doc.c, doc.length)
*
* cdef int set_valid(self, int* output, const StateC* st) nogil: # <<<<<<<<<<<<<<
* cdef bint[N_MOVES] is_valid
* is_valid[SHIFT] = Shift.is_valid(st, 0)
*/
static int __pyx_f_5spacy_6syntax_9arc_eager_8ArcEager_set_valid(struct __pyx_obj_5spacy_6syntax_9arc_eager_ArcEager *__pyx_v_self, int *__pyx_v_output, __pyx_t_5spacy_6syntax_6_state_StateC const *__pyx_v_st) {
int __pyx_v_is_valid[__pyx_e_5spacy_6syntax_9arc_eager_N_MOVES];
int __pyx_v_i;
int __pyx_r;
__Pyx_TraceDeclarations
int __pyx_t_1;
int __pyx_t_2;
int __pyx_t_3;
int __pyx_t_4;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_TraceCall("set_valid", __pyx_f[0], 557, 1, __PYX_ERR(0, 557, __pyx_L1_error));
/* "spacy/syntax/arc_eager.pyx":559
* cdef int set_valid(self, int* output, const StateC* st) nogil:
* cdef bint[N_MOVES] is_valid
* is_valid[SHIFT] = Shift.is_valid(st, 0) # <<<<<<<<<<<<<<
* is_valid[REDUCE] = Reduce.is_valid(st, 0)
* is_valid[LEFT] = LeftArc.is_valid(st, 0)
*/
(__pyx_v_is_valid[__pyx_e_5spacy_6syntax_9arc_eager_SHIFT]) = __pyx_f_5spacy_6syntax_9arc_eager_5Shift_is_valid(__pyx_v_st, 0);
/* "spacy/syntax/arc_eager.pyx":560
* cdef bint[N_MOVES] is_valid
* is_valid[SHIFT] = Shift.is_valid(st, 0)
* is_valid[REDUCE] = Reduce.is_valid(st, 0) # <<<<<<<<<<<<<<
* is_valid[LEFT] = LeftArc.is_valid(st, 0)
* is_valid[RIGHT] = RightArc.is_valid(st, 0)
*/
(__pyx_v_is_valid[__pyx_e_5spacy_6syntax_9arc_eager_REDUCE]) = __pyx_f_5spacy_6syntax_9arc_eager_6Reduce_is_valid(__pyx_v_st, 0);
/* "spacy/syntax/arc_eager.pyx":561
* is_valid[SHIFT] = Shift.is_valid(st, 0)
* is_valid[REDUCE] = Reduce.is_valid(st, 0)
* is_valid[LEFT] = LeftArc.is_valid(st, 0) # <<<<<<<<<<<<<<
* is_valid[RIGHT] = RightArc.is_valid(st, 0)
* is_valid[BREAK] = Break.is_valid(st, 0)
*/
(__pyx_v_is_valid[__pyx_e_5spacy_6syntax_9arc_eager_LEFT]) = __pyx_f_5spacy_6syntax_9arc_eager_7LeftArc_is_valid(__pyx_v_st, 0);
/* "spacy/syntax/arc_eager.pyx":562
* is_valid[REDUCE] = Reduce.is_valid(st, 0)
* is_valid[LEFT] = LeftArc.is_valid(st, 0)
* is_valid[RIGHT] = RightArc.is_valid(st, 0) # <<<<<<<<<<<<<<
* is_valid[BREAK] = Break.is_valid(st, 0)
* cdef int i
*/
(__pyx_v_is_valid[__pyx_e_5spacy_6syntax_9arc_eager_RIGHT]) = __pyx_f_5spacy_6syntax_9arc_eager_8RightArc_is_valid(__pyx_v_st, 0);
/* "spacy/syntax/arc_eager.pyx":563
* is_valid[LEFT] = LeftArc.is_valid(st, 0)
* is_valid[RIGHT] = RightArc.is_valid(st, 0)
* is_valid[BREAK] = Break.is_valid(st, 0) # <<<<<<<<<<<<<<
* cdef int i
* for i in range(self.n_moves):
*/
(__pyx_v_is_valid[__pyx_e_5spacy_6syntax_9arc_eager_BREAK]) = __pyx_f_5spacy_6syntax_9arc_eager_5Break_is_valid(__pyx_v_st, 0);
/* "spacy/syntax/arc_eager.pyx":565
* is_valid[BREAK] = Break.is_valid(st, 0)
* cdef int i
* for i in range(self.n_moves): # <<<<<<<<<<<<<<
* if self.c[i].label == SUBTOK_LABEL:
* output[i] = self.c[i].is_valid(st, self.c[i].label)
*/
__pyx_t_1 = __pyx_v_self->__pyx_base.n_moves;
__pyx_t_2 = __pyx_t_1;
for (__pyx_t_3 = 0; __pyx_t_3 < __pyx_t_2; __pyx_t_3+=1) {
__pyx_v_i = __pyx_t_3;
/* "spacy/syntax/arc_eager.pyx":566
* cdef int i
* for i in range(self.n_moves):
* if self.c[i].label == SUBTOK_LABEL: # <<<<<<<<<<<<<<
* output[i] = self.c[i].is_valid(st, self.c[i].label)
* else:
*/
__pyx_t_4 = (((__pyx_v_self->__pyx_base.c[__pyx_v_i]).label == __pyx_v_5spacy_6syntax_9arc_eager_SUBTOK_LABEL) != 0);
if (__pyx_t_4) {
/* "spacy/syntax/arc_eager.pyx":567
* for i in range(self.n_moves):
* if self.c[i].label == SUBTOK_LABEL:
* output[i] = self.c[i].is_valid(st, self.c[i].label) # <<<<<<<<<<<<<<
* else:
* output[i] = is_valid[self.c[i].move]
*/
(__pyx_v_output[__pyx_v_i]) = (__pyx_v_self->__pyx_base.c[__pyx_v_i]).is_valid(__pyx_v_st, (__pyx_v_self->__pyx_base.c[__pyx_v_i]).label);
/* "spacy/syntax/arc_eager.pyx":566
* cdef int i
* for i in range(self.n_moves):
* if self.c[i].label == SUBTOK_LABEL: # <<<<<<<<<<<<<<
* output[i] = self.c[i].is_valid(st, self.c[i].label)
* else:
*/
goto __pyx_L5;
}
/* "spacy/syntax/arc_eager.pyx":569
* output[i] = self.c[i].is_valid(st, self.c[i].label)
* else:
* output[i] = is_valid[self.c[i].move] # <<<<<<<<<<<<<<
*
* cdef int set_costs(self, int* is_valid, weight_t* costs,
*/
/*else*/ {
(__pyx_v_output[__pyx_v_i]) = (__pyx_v_is_valid[(__pyx_v_self->__pyx_base.c[__pyx_v_i]).move]);
}
__pyx_L5:;
}
/* "spacy/syntax/arc_eager.pyx":557
* set_children_from_heads(doc.c, doc.length)
*
* cdef int set_valid(self, int* output, const StateC* st) nogil: # <<<<<<<<<<<<<<
* cdef bint[N_MOVES] is_valid
* is_valid[SHIFT] = Shift.is_valid(st, 0)
*/
/* function exit code */
__pyx_r = 0;
goto __pyx_L0;
__pyx_L1_error:;
__Pyx_WriteUnraisable("spacy.syntax.arc_eager.ArcEager.set_valid", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 1);
__pyx_r = 0;
__pyx_L0:;
__Pyx_TraceReturn(Py_None, 1);
return __pyx_r;
}
/* "spacy/syntax/arc_eager.pyx":571
* output[i] = is_valid[self.c[i].move]
*
* cdef int set_costs(self, int* is_valid, weight_t* costs, # <<<<<<<<<<<<<<
* StateClass stcls, GoldParse gold) except -1:
* cdef int i, move
*/
static int __pyx_f_5spacy_6syntax_9arc_eager_8ArcEager_set_costs(struct __pyx_obj_5spacy_6syntax_9arc_eager_ArcEager *__pyx_v_self, int *__pyx_v_is_valid, __pyx_t_5thinc_8typedefs_weight_t *__pyx_v_costs, struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *__pyx_v_stcls, struct __pyx_obj_5spacy_4gold_GoldParse *__pyx_v_gold) {
int __pyx_v_i;
int __pyx_v_move;
__pyx_t_5spacy_8typedefs_attr_t __pyx_v_label;
__pyx_t_5spacy_6syntax_17transition_system_label_cost_func_t __pyx_v_label_cost_funcs[__pyx_e_5spacy_6syntax_9arc_eager_N_MOVES];
__pyx_t_5spacy_6syntax_17transition_system_move_cost_func_t __pyx_v_move_cost_funcs[__pyx_e_5spacy_6syntax_9arc_eager_N_MOVES];
__pyx_t_5thinc_8typedefs_weight_t __pyx_v_move_costs[__pyx_e_5spacy_6syntax_9arc_eager_N_MOVES];
CYTHON_UNUSED __pyx_t_5spacy_8typedefs_attr_t *__pyx_v_labels;
CYTHON_UNUSED int *__pyx_v_heads;
PyObject *__pyx_v_n_gold = NULL;
PyObject *__pyx_v_failure_state = NULL;
int __pyx_r;
__Pyx_TraceDeclarations
__Pyx_RefNannyDeclarations
int __pyx_t_1;
int __pyx_t_2;
int __pyx_t_3;
__pyx_t_5spacy_8typedefs_attr_t *__pyx_t_4;
int *__pyx_t_5;
int __pyx_t_6;
int __pyx_t_7;
int __pyx_t_8;
int __pyx_t_9;
__pyx_t_5spacy_8typedefs_attr_t __pyx_t_10;
PyObject *__pyx_t_11 = NULL;
PyObject *__pyx_t_12 = NULL;
PyObject *__pyx_t_13 = NULL;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("set_costs", 0);
__Pyx_TraceCall("set_costs", __pyx_f[0], 571, 0, __PYX_ERR(0, 571, __pyx_L1_error));
/* "spacy/syntax/arc_eager.pyx":578
* cdef move_cost_func_t[N_MOVES] move_cost_funcs
* cdef weight_t[N_MOVES] move_costs
* for i in range(N_MOVES): # <<<<<<<<<<<<<<
* move_costs[i] = 9000
* move_cost_funcs[SHIFT] = Shift.move_cost
*/
__pyx_t_1 = __pyx_e_5spacy_6syntax_9arc_eager_N_MOVES;
__pyx_t_2 = __pyx_t_1;
for (__pyx_t_3 = 0; __pyx_t_3 < __pyx_t_2; __pyx_t_3+=1) {
__pyx_v_i = __pyx_t_3;
/* "spacy/syntax/arc_eager.pyx":579
* cdef weight_t[N_MOVES] move_costs
* for i in range(N_MOVES):
* move_costs[i] = 9000 # <<<<<<<<<<<<<<
* move_cost_funcs[SHIFT] = Shift.move_cost
* move_cost_funcs[REDUCE] = Reduce.move_cost
*/
(__pyx_v_move_costs[__pyx_v_i]) = 9000.0;
}
/* "spacy/syntax/arc_eager.pyx":580
* for i in range(N_MOVES):
* move_costs[i] = 9000
* move_cost_funcs[SHIFT] = Shift.move_cost # <<<<<<<<<<<<<<
* move_cost_funcs[REDUCE] = Reduce.move_cost
* move_cost_funcs[LEFT] = LeftArc.move_cost
*/
(__pyx_v_move_cost_funcs[__pyx_e_5spacy_6syntax_9arc_eager_SHIFT]) = __pyx_f_5spacy_6syntax_9arc_eager_5Shift_move_cost;
/* "spacy/syntax/arc_eager.pyx":581
* move_costs[i] = 9000
* move_cost_funcs[SHIFT] = Shift.move_cost
* move_cost_funcs[REDUCE] = Reduce.move_cost # <<<<<<<<<<<<<<
* move_cost_funcs[LEFT] = LeftArc.move_cost
* move_cost_funcs[RIGHT] = RightArc.move_cost
*/
(__pyx_v_move_cost_funcs[__pyx_e_5spacy_6syntax_9arc_eager_REDUCE]) = __pyx_f_5spacy_6syntax_9arc_eager_6Reduce_move_cost;
/* "spacy/syntax/arc_eager.pyx":582
* move_cost_funcs[SHIFT] = Shift.move_cost
* move_cost_funcs[REDUCE] = Reduce.move_cost
* move_cost_funcs[LEFT] = LeftArc.move_cost # <<<<<<<<<<<<<<
* move_cost_funcs[RIGHT] = RightArc.move_cost
* move_cost_funcs[BREAK] = Break.move_cost
*/
(__pyx_v_move_cost_funcs[__pyx_e_5spacy_6syntax_9arc_eager_LEFT]) = __pyx_f_5spacy_6syntax_9arc_eager_7LeftArc_move_cost;
/* "spacy/syntax/arc_eager.pyx":583
* move_cost_funcs[REDUCE] = Reduce.move_cost
* move_cost_funcs[LEFT] = LeftArc.move_cost
* move_cost_funcs[RIGHT] = RightArc.move_cost # <<<<<<<<<<<<<<
* move_cost_funcs[BREAK] = Break.move_cost
*
*/
(__pyx_v_move_cost_funcs[__pyx_e_5spacy_6syntax_9arc_eager_RIGHT]) = __pyx_f_5spacy_6syntax_9arc_eager_8RightArc_move_cost;
/* "spacy/syntax/arc_eager.pyx":584
* move_cost_funcs[LEFT] = LeftArc.move_cost
* move_cost_funcs[RIGHT] = RightArc.move_cost
* move_cost_funcs[BREAK] = Break.move_cost # <<<<<<<<<<<<<<
*
* label_cost_funcs[SHIFT] = Shift.label_cost
*/
(__pyx_v_move_cost_funcs[__pyx_e_5spacy_6syntax_9arc_eager_BREAK]) = __pyx_f_5spacy_6syntax_9arc_eager_5Break_move_cost;
/* "spacy/syntax/arc_eager.pyx":586
* move_cost_funcs[BREAK] = Break.move_cost
*
* label_cost_funcs[SHIFT] = Shift.label_cost # <<<<<<<<<<<<<<
* label_cost_funcs[REDUCE] = Reduce.label_cost
* label_cost_funcs[LEFT] = LeftArc.label_cost
*/
(__pyx_v_label_cost_funcs[__pyx_e_5spacy_6syntax_9arc_eager_SHIFT]) = __pyx_f_5spacy_6syntax_9arc_eager_5Shift_label_cost;
/* "spacy/syntax/arc_eager.pyx":587
*
* label_cost_funcs[SHIFT] = Shift.label_cost
* label_cost_funcs[REDUCE] = Reduce.label_cost # <<<<<<<<<<<<<<
* label_cost_funcs[LEFT] = LeftArc.label_cost
* label_cost_funcs[RIGHT] = RightArc.label_cost
*/
(__pyx_v_label_cost_funcs[__pyx_e_5spacy_6syntax_9arc_eager_REDUCE]) = __pyx_f_5spacy_6syntax_9arc_eager_6Reduce_label_cost;
/* "spacy/syntax/arc_eager.pyx":588
* label_cost_funcs[SHIFT] = Shift.label_cost
* label_cost_funcs[REDUCE] = Reduce.label_cost
* label_cost_funcs[LEFT] = LeftArc.label_cost # <<<<<<<<<<<<<<
* label_cost_funcs[RIGHT] = RightArc.label_cost
* label_cost_funcs[BREAK] = Break.label_cost
*/
(__pyx_v_label_cost_funcs[__pyx_e_5spacy_6syntax_9arc_eager_LEFT]) = __pyx_f_5spacy_6syntax_9arc_eager_7LeftArc_label_cost;
/* "spacy/syntax/arc_eager.pyx":589
* label_cost_funcs[REDUCE] = Reduce.label_cost
* label_cost_funcs[LEFT] = LeftArc.label_cost
* label_cost_funcs[RIGHT] = RightArc.label_cost # <<<<<<<<<<<<<<
* label_cost_funcs[BREAK] = Break.label_cost
*
*/
(__pyx_v_label_cost_funcs[__pyx_e_5spacy_6syntax_9arc_eager_RIGHT]) = __pyx_f_5spacy_6syntax_9arc_eager_8RightArc_label_cost;
/* "spacy/syntax/arc_eager.pyx":590
* label_cost_funcs[LEFT] = LeftArc.label_cost
* label_cost_funcs[RIGHT] = RightArc.label_cost
* label_cost_funcs[BREAK] = Break.label_cost # <<<<<<<<<<<<<<
*
* cdef attr_t* labels = gold.c.labels
*/
(__pyx_v_label_cost_funcs[__pyx_e_5spacy_6syntax_9arc_eager_BREAK]) = __pyx_f_5spacy_6syntax_9arc_eager_5Break_label_cost;
/* "spacy/syntax/arc_eager.pyx":592
* label_cost_funcs[BREAK] = Break.label_cost
*
* cdef attr_t* labels = gold.c.labels # <<<<<<<<<<<<<<
* cdef int* heads = gold.c.heads
*
*/
__pyx_t_4 = __pyx_v_gold->c.labels;
__pyx_v_labels = __pyx_t_4;
/* "spacy/syntax/arc_eager.pyx":593
*
* cdef attr_t* labels = gold.c.labels
* cdef int* heads = gold.c.heads # <<<<<<<<<<<<<<
*
* n_gold = 0
*/
__pyx_t_5 = __pyx_v_gold->c.heads;
__pyx_v_heads = __pyx_t_5;
/* "spacy/syntax/arc_eager.pyx":595
* cdef int* heads = gold.c.heads
*
* n_gold = 0 # <<<<<<<<<<<<<<
* for i in range(self.n_moves):
* if self.c[i].is_valid(stcls.c, self.c[i].label):
*/
__Pyx_INCREF(__pyx_int_0);
__pyx_v_n_gold = __pyx_int_0;
/* "spacy/syntax/arc_eager.pyx":596
*
* n_gold = 0
* for i in range(self.n_moves): # <<<<<<<<<<<<<<
* if self.c[i].is_valid(stcls.c, self.c[i].label):
* is_valid[i] = True
*/
__pyx_t_3 = __pyx_v_self->__pyx_base.n_moves;
__pyx_t_6 = __pyx_t_3;
for (__pyx_t_7 = 0; __pyx_t_7 < __pyx_t_6; __pyx_t_7+=1) {
__pyx_v_i = __pyx_t_7;
/* "spacy/syntax/arc_eager.pyx":597
* n_gold = 0
* for i in range(self.n_moves):
* if self.c[i].is_valid(stcls.c, self.c[i].label): # <<<<<<<<<<<<<<
* is_valid[i] = True
* move = self.c[i].move
*/
__pyx_t_8 = ((__pyx_v_self->__pyx_base.c[__pyx_v_i]).is_valid(__pyx_v_stcls->c, (__pyx_v_self->__pyx_base.c[__pyx_v_i]).label) != 0);
if (__pyx_t_8) {
/* "spacy/syntax/arc_eager.pyx":598
* for i in range(self.n_moves):
* if self.c[i].is_valid(stcls.c, self.c[i].label):
* is_valid[i] = True # <<<<<<<<<<<<<<
* move = self.c[i].move
* label = self.c[i].label
*/
(__pyx_v_is_valid[__pyx_v_i]) = 1;
/* "spacy/syntax/arc_eager.pyx":599
* if self.c[i].is_valid(stcls.c, self.c[i].label):
* is_valid[i] = True
* move = self.c[i].move # <<<<<<<<<<<<<<
* label = self.c[i].label
* if move_costs[move] == 9000:
*/
__pyx_t_9 = (__pyx_v_self->__pyx_base.c[__pyx_v_i]).move;
__pyx_v_move = __pyx_t_9;
/* "spacy/syntax/arc_eager.pyx":600
* is_valid[i] = True
* move = self.c[i].move
* label = self.c[i].label # <<<<<<<<<<<<<<
* if move_costs[move] == 9000:
* move_costs[move] = move_cost_funcs[move](stcls, &gold.c)
*/
__pyx_t_10 = (__pyx_v_self->__pyx_base.c[__pyx_v_i]).label;
__pyx_v_label = __pyx_t_10;
/* "spacy/syntax/arc_eager.pyx":601
* move = self.c[i].move
* label = self.c[i].label
* if move_costs[move] == 9000: # <<<<<<<<<<<<<<
* move_costs[move] = move_cost_funcs[move](stcls, &gold.c)
* costs[i] = move_costs[move] + label_cost_funcs[move](stcls, &gold.c, label)
*/
__pyx_t_8 = (((__pyx_v_move_costs[__pyx_v_move]) == 9000.0) != 0);
if (__pyx_t_8) {
/* "spacy/syntax/arc_eager.pyx":602
* label = self.c[i].label
* if move_costs[move] == 9000:
* move_costs[move] = move_cost_funcs[move](stcls, &gold.c) # <<<<<<<<<<<<<<
* costs[i] = move_costs[move] + label_cost_funcs[move](stcls, &gold.c, label)
* n_gold += costs[i] <= 0
*/
(__pyx_v_move_costs[__pyx_v_move]) = (__pyx_v_move_cost_funcs[__pyx_v_move])(__pyx_v_stcls, (&__pyx_v_gold->c));
/* "spacy/syntax/arc_eager.pyx":601
* move = self.c[i].move
* label = self.c[i].label
* if move_costs[move] == 9000: # <<<<<<<<<<<<<<
* move_costs[move] = move_cost_funcs[move](stcls, &gold.c)
* costs[i] = move_costs[move] + label_cost_funcs[move](stcls, &gold.c, label)
*/
}
/* "spacy/syntax/arc_eager.pyx":603
* if move_costs[move] == 9000:
* move_costs[move] = move_cost_funcs[move](stcls, &gold.c)
* costs[i] = move_costs[move] + label_cost_funcs[move](stcls, &gold.c, label) # <<<<<<<<<<<<<<
* n_gold += costs[i] <= 0
* else:
*/
(__pyx_v_costs[__pyx_v_i]) = ((__pyx_v_move_costs[__pyx_v_move]) + (__pyx_v_label_cost_funcs[__pyx_v_move])(__pyx_v_stcls, (&__pyx_v_gold->c), __pyx_v_label));
/* "spacy/syntax/arc_eager.pyx":604
* move_costs[move] = move_cost_funcs[move](stcls, &gold.c)
* costs[i] = move_costs[move] + label_cost_funcs[move](stcls, &gold.c, label)
* n_gold += costs[i] <= 0 # <<<<<<<<<<<<<<
* else:
* is_valid[i] = False
*/
__pyx_t_11 = __Pyx_PyBool_FromLong(((__pyx_v_costs[__pyx_v_i]) <= 0.0)); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 604, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_11);
__pyx_t_12 = PyNumber_InPlaceAdd(__pyx_v_n_gold, __pyx_t_11); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 604, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_12);
__Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
__Pyx_DECREF_SET(__pyx_v_n_gold, __pyx_t_12);
__pyx_t_12 = 0;
/* "spacy/syntax/arc_eager.pyx":597
* n_gold = 0
* for i in range(self.n_moves):
* if self.c[i].is_valid(stcls.c, self.c[i].label): # <<<<<<<<<<<<<<
* is_valid[i] = True
* move = self.c[i].move
*/
goto __pyx_L7;
}
/* "spacy/syntax/arc_eager.pyx":606
* n_gold += costs[i] <= 0
* else:
* is_valid[i] = False # <<<<<<<<<<<<<<
* costs[i] = 9000
* if n_gold < 1:
*/
/*else*/ {
(__pyx_v_is_valid[__pyx_v_i]) = 0;
/* "spacy/syntax/arc_eager.pyx":607
* else:
* is_valid[i] = False
* costs[i] = 9000 # <<<<<<<<<<<<<<
* if n_gold < 1:
* # Check projectivity --- leading cause
*/
(__pyx_v_costs[__pyx_v_i]) = 9000.0;
}
__pyx_L7:;
}
/* "spacy/syntax/arc_eager.pyx":608
* is_valid[i] = False
* costs[i] = 9000
* if n_gold < 1: # <<<<<<<<<<<<<<
* # Check projectivity --- leading cause
* if is_nonproj_tree(gold.heads):
*/
__pyx_t_12 = PyObject_RichCompare(__pyx_v_n_gold, __pyx_int_1, Py_LT); __Pyx_XGOTREF(__pyx_t_12); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 608, __pyx_L1_error)
__pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_t_12); if (unlikely(__pyx_t_8 < 0)) __PYX_ERR(0, 608, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
if (__pyx_t_8) {
/* "spacy/syntax/arc_eager.pyx":610
* if n_gold < 1:
* # Check projectivity --- leading cause
* if is_nonproj_tree(gold.heads): # <<<<<<<<<<<<<<
* raise ValueError(Errors.E020)
* else:
*/
__Pyx_GetModuleGlobalName(__pyx_t_11, __pyx_n_s_is_nonproj_tree); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 610, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_11);
__pyx_t_13 = NULL;
if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_11))) {
__pyx_t_13 = PyMethod_GET_SELF(__pyx_t_11);
if (likely(__pyx_t_13)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_11);
__Pyx_INCREF(__pyx_t_13);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_11, function);
}
}
__pyx_t_12 = (__pyx_t_13) ? __Pyx_PyObject_Call2Args(__pyx_t_11, __pyx_t_13, __pyx_v_gold->heads) : __Pyx_PyObject_CallOneArg(__pyx_t_11, __pyx_v_gold->heads);
__Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0;
if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 610, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_12);
__Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
__pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_t_12); if (unlikely(__pyx_t_8 < 0)) __PYX_ERR(0, 610, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
if (unlikely(__pyx_t_8)) {
/* "spacy/syntax/arc_eager.pyx":611
* # Check projectivity --- leading cause
* if is_nonproj_tree(gold.heads):
* raise ValueError(Errors.E020) # <<<<<<<<<<<<<<
* else:
* failure_state = stcls.print_state(gold.words)
*/
__Pyx_GetModuleGlobalName(__pyx_t_12, __pyx_n_s_Errors); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 611, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_12);
__pyx_t_11 = __Pyx_PyObject_GetAttrStr(__pyx_t_12, __pyx_n_s_E020); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 611, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_11);
__Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
__pyx_t_12 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_11); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 611, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_12);
__Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
__Pyx_Raise(__pyx_t_12, 0, 0, 0);
__Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
__PYX_ERR(0, 611, __pyx_L1_error)
/* "spacy/syntax/arc_eager.pyx":610
* if n_gold < 1:
* # Check projectivity --- leading cause
* if is_nonproj_tree(gold.heads): # <<<<<<<<<<<<<<
* raise ValueError(Errors.E020)
* else:
*/
}
/* "spacy/syntax/arc_eager.pyx":613
* raise ValueError(Errors.E020)
* else:
* failure_state = stcls.print_state(gold.words) # <<<<<<<<<<<<<<
* raise ValueError(Errors.E021.format(n_actions=self.n_moves,
* state=failure_state))
*/
/*else*/ {
__pyx_t_11 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_stcls), __pyx_n_s_print_state); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 613, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_11);
__pyx_t_13 = NULL;
if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_11))) {
__pyx_t_13 = PyMethod_GET_SELF(__pyx_t_11);
if (likely(__pyx_t_13)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_11);
__Pyx_INCREF(__pyx_t_13);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_11, function);
}
}
__pyx_t_12 = (__pyx_t_13) ? __Pyx_PyObject_Call2Args(__pyx_t_11, __pyx_t_13, __pyx_v_gold->words) : __Pyx_PyObject_CallOneArg(__pyx_t_11, __pyx_v_gold->words);
__Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0;
if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 613, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_12);
__Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
__pyx_v_failure_state = __pyx_t_12;
__pyx_t_12 = 0;
/* "spacy/syntax/arc_eager.pyx":614
* else:
* failure_state = stcls.print_state(gold.words)
* raise ValueError(Errors.E021.format(n_actions=self.n_moves, # <<<<<<<<<<<<<<
* state=failure_state))
*
*/
__Pyx_GetModuleGlobalName(__pyx_t_12, __pyx_n_s_Errors); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 614, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_12);
__pyx_t_11 = __Pyx_PyObject_GetAttrStr(__pyx_t_12, __pyx_n_s_E021); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 614, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_11);
__Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
__pyx_t_12 = __Pyx_PyObject_GetAttrStr(__pyx_t_11, __pyx_n_s_format); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 614, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_12);
__Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
__pyx_t_11 = __Pyx_PyDict_NewPresized(2); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 614, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_11);
__pyx_t_13 = __Pyx_PyInt_From_int(__pyx_v_self->__pyx_base.n_moves); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 614, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_13);
if (PyDict_SetItem(__pyx_t_11, __pyx_n_s_n_actions, __pyx_t_13) < 0) __PYX_ERR(0, 614, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
/* "spacy/syntax/arc_eager.pyx":615
* failure_state = stcls.print_state(gold.words)
* raise ValueError(Errors.E021.format(n_actions=self.n_moves,
* state=failure_state)) # <<<<<<<<<<<<<<
*
* def get_beam_annot(self, Beam beam):
*/
if (PyDict_SetItem(__pyx_t_11, __pyx_n_s_state, __pyx_v_failure_state) < 0) __PYX_ERR(0, 614, __pyx_L1_error)
/* "spacy/syntax/arc_eager.pyx":614
* else:
* failure_state = stcls.print_state(gold.words)
* raise ValueError(Errors.E021.format(n_actions=self.n_moves, # <<<<<<<<<<<<<<
* state=failure_state))
*
*/
__pyx_t_13 = __Pyx_PyObject_Call(__pyx_t_12, __pyx_empty_tuple, __pyx_t_11); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 614, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_13);
__Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
__Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
__pyx_t_11 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_13); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 614, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_11);
__Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
__Pyx_Raise(__pyx_t_11, 0, 0, 0);
__Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
__PYX_ERR(0, 614, __pyx_L1_error)
}
/* "spacy/syntax/arc_eager.pyx":608
* is_valid[i] = False
* costs[i] = 9000
* if n_gold < 1: # <<<<<<<<<<<<<<
* # Check projectivity --- leading cause
* if is_nonproj_tree(gold.heads):
*/
}
/* "spacy/syntax/arc_eager.pyx":571
* output[i] = is_valid[self.c[i].move]
*
* cdef int set_costs(self, int* is_valid, weight_t* costs, # <<<<<<<<<<<<<<
* StateClass stcls, GoldParse gold) except -1:
* cdef int i, move
*/
/* function exit code */
__pyx_r = 0;
goto __pyx_L0;
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_11);
__Pyx_XDECREF(__pyx_t_12);
__Pyx_XDECREF(__pyx_t_13);
__Pyx_AddTraceback("spacy.syntax.arc_eager.ArcEager.set_costs", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = -1;
__pyx_L0:;
__Pyx_XDECREF(__pyx_v_n_gold);
__Pyx_XDECREF(__pyx_v_failure_state);
__Pyx_TraceReturn(Py_None, 0);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "spacy/syntax/arc_eager.pyx":617
* state=failure_state))
*
* def get_beam_annot(self, Beam beam): # <<<<<<<<<<<<<<
* length = (<StateC*>beam.at(0)).length
* heads = [{} for _ in range(length)]
*/
/* Python wrapper */
static PyObject *__pyx_pw_5spacy_6syntax_9arc_eager_8ArcEager_23get_beam_annot(PyObject *__pyx_v_self, PyObject *__pyx_v_beam); /*proto*/
static PyObject *__pyx_pw_5spacy_6syntax_9arc_eager_8ArcEager_23get_beam_annot(PyObject *__pyx_v_self, PyObject *__pyx_v_beam) {
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
PyObject *__pyx_r = 0;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("get_beam_annot (wrapper)", 0);
if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_beam), __pyx_ptype_5thinc_5extra_6search_Beam, 1, "beam", 0))) __PYX_ERR(0, 617, __pyx_L1_error)
__pyx_r = __pyx_pf_5spacy_6syntax_9arc_eager_8ArcEager_22get_beam_annot(((struct __pyx_obj_5spacy_6syntax_9arc_eager_ArcEager *)__pyx_v_self), ((struct __pyx_obj_5thinc_5extra_6search_Beam *)__pyx_v_beam));
/* function exit code */
goto __pyx_L0;
__pyx_L1_error:;
__pyx_r = NULL;
__pyx_L0:;
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
static PyObject *__pyx_pf_5spacy_6syntax_9arc_eager_8ArcEager_22get_beam_annot(struct __pyx_obj_5spacy_6syntax_9arc_eager_ArcEager *__pyx_v_self, struct __pyx_obj_5thinc_5extra_6search_Beam *__pyx_v_beam) {
int __pyx_v_length;
PyObject *__pyx_v_heads = NULL;
PyObject *__pyx_v_deps = NULL;
PyObject *__pyx_v_probs = NULL;
__pyx_t_5thinc_8typedefs_class_t __pyx_v_i;
__pyx_t_5spacy_6syntax_6_state_StateC *__pyx_v_state;
PyObject *__pyx_v_prob = NULL;
int __pyx_v_j;
int __pyx_v_head;
__pyx_t_5spacy_8typedefs_attr_t __pyx_v_dep;
CYTHON_UNUSED int __pyx_v__;
PyObject *__pyx_r = NULL;
__Pyx_TraceDeclarations
__Pyx_RefNannyDeclarations
int __pyx_t_1;
PyObject *__pyx_t_2 = NULL;
int __pyx_t_3;
int __pyx_t_4;
PyObject *__pyx_t_5 = NULL;
__pyx_t_5thinc_8typedefs_class_t __pyx_t_6;
__pyx_t_5thinc_8typedefs_class_t __pyx_t_7;
__pyx_t_5thinc_8typedefs_class_t __pyx_t_8;
int __pyx_t_9;
__pyx_t_5spacy_8typedefs_attr_t __pyx_t_10;
PyObject *__pyx_t_11 = NULL;
PyObject *__pyx_t_12 = NULL;
int __pyx_t_13;
PyObject *__pyx_t_14 = NULL;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("get_beam_annot", 0);
__Pyx_TraceCall("get_beam_annot", __pyx_f[0], 617, 0, __PYX_ERR(0, 617, __pyx_L1_error));
/* "spacy/syntax/arc_eager.pyx":618
*
* def get_beam_annot(self, Beam beam):
* length = (<StateC*>beam.at(0)).length # <<<<<<<<<<<<<<
* heads = [{} for _ in range(length)]
* deps = [{} for _ in range(length)]
*/
__pyx_t_1 = ((__pyx_t_5spacy_6syntax_6_state_StateC *)__pyx_f_5thinc_5extra_6search_4Beam_at(__pyx_v_beam, 0))->length;
__pyx_v_length = __pyx_t_1;
/* "spacy/syntax/arc_eager.pyx":619
* def get_beam_annot(self, Beam beam):
* length = (<StateC*>beam.at(0)).length
* heads = [{} for _ in range(length)] # <<<<<<<<<<<<<<
* deps = [{} for _ in range(length)]
* probs = beam.probs
*/
__pyx_t_2 = PyList_New(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 619, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__pyx_t_1 = __pyx_v_length;
__pyx_t_3 = __pyx_t_1;
for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) {
__pyx_v__ = __pyx_t_4;
__pyx_t_5 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 619, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
if (unlikely(__Pyx_ListComp_Append(__pyx_t_2, (PyObject*)__pyx_t_5))) __PYX_ERR(0, 619, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
}
__pyx_v_heads = ((PyObject*)__pyx_t_2);
__pyx_t_2 = 0;
/* "spacy/syntax/arc_eager.pyx":620
* length = (<StateC*>beam.at(0)).length
* heads = [{} for _ in range(length)]
* deps = [{} for _ in range(length)] # <<<<<<<<<<<<<<
* probs = beam.probs
* for i in range(beam.size):
*/
__pyx_t_2 = PyList_New(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 620, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__pyx_t_1 = __pyx_v_length;
__pyx_t_3 = __pyx_t_1;
for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) {
__pyx_v__ = __pyx_t_4;
__pyx_t_5 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 620, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
if (unlikely(__Pyx_ListComp_Append(__pyx_t_2, (PyObject*)__pyx_t_5))) __PYX_ERR(0, 620, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
}
__pyx_v_deps = ((PyObject*)__pyx_t_2);
__pyx_t_2 = 0;
/* "spacy/syntax/arc_eager.pyx":621
* heads = [{} for _ in range(length)]
* deps = [{} for _ in range(length)]
* probs = beam.probs # <<<<<<<<<<<<<<
* for i in range(beam.size):
* state = <StateC*>beam.at(i)
*/
__pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_beam), __pyx_n_s_probs); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 621, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__pyx_v_probs = __pyx_t_2;
__pyx_t_2 = 0;
/* "spacy/syntax/arc_eager.pyx":622
* deps = [{} for _ in range(length)]
* probs = beam.probs
* for i in range(beam.size): # <<<<<<<<<<<<<<
* state = <StateC*>beam.at(i)
* self.finalize_state(state)
*/
__pyx_t_6 = __pyx_v_beam->size;
__pyx_t_7 = __pyx_t_6;
for (__pyx_t_8 = 0; __pyx_t_8 < __pyx_t_7; __pyx_t_8+=1) {
__pyx_v_i = __pyx_t_8;
/* "spacy/syntax/arc_eager.pyx":623
* probs = beam.probs
* for i in range(beam.size):
* state = <StateC*>beam.at(i) # <<<<<<<<<<<<<<
* self.finalize_state(state)
* if state.is_final():
*/
__pyx_v_state = ((__pyx_t_5spacy_6syntax_6_state_StateC *)__pyx_f_5thinc_5extra_6search_4Beam_at(__pyx_v_beam, __pyx_v_i));
/* "spacy/syntax/arc_eager.pyx":624
* for i in range(beam.size):
* state = <StateC*>beam.at(i)
* self.finalize_state(state) # <<<<<<<<<<<<<<
* if state.is_final():
* prob = probs[i]
*/
(void)(((struct __pyx_vtabstruct_5spacy_6syntax_9arc_eager_ArcEager *)__pyx_v_self->__pyx_base.__pyx_vtab)->__pyx_base.finalize_state(((struct __pyx_obj_5spacy_6syntax_17transition_system_TransitionSystem *)__pyx_v_self), __pyx_v_state));
/* "spacy/syntax/arc_eager.pyx":625
* state = <StateC*>beam.at(i)
* self.finalize_state(state)
* if state.is_final(): # <<<<<<<<<<<<<<
* prob = probs[i]
* for j in range(state.length):
*/
__pyx_t_9 = (__pyx_v_state->is_final() != 0);
if (__pyx_t_9) {
/* "spacy/syntax/arc_eager.pyx":626
* self.finalize_state(state)
* if state.is_final():
* prob = probs[i] # <<<<<<<<<<<<<<
* for j in range(state.length):
* head = j + state._sent[j].head
*/
__pyx_t_2 = __Pyx_GetItemInt(__pyx_v_probs, __pyx_v_i, __pyx_t_5thinc_8typedefs_class_t, 1, __Pyx_PyInt_From_int32_t, 0, 1, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 626, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_XDECREF_SET(__pyx_v_prob, __pyx_t_2);
__pyx_t_2 = 0;
/* "spacy/syntax/arc_eager.pyx":627
* if state.is_final():
* prob = probs[i]
* for j in range(state.length): # <<<<<<<<<<<<<<
* head = j + state._sent[j].head
* dep = state._sent[j].dep
*/
__pyx_t_1 = __pyx_v_state->length;
__pyx_t_3 = __pyx_t_1;
for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) {
__pyx_v_j = __pyx_t_4;
/* "spacy/syntax/arc_eager.pyx":628
* prob = probs[i]
* for j in range(state.length):
* head = j + state._sent[j].head # <<<<<<<<<<<<<<
* dep = state._sent[j].dep
* heads[j].setdefault(head, 0.0)
*/
__pyx_v_head = (__pyx_v_j + (__pyx_v_state->_sent[__pyx_v_j]).head);
/* "spacy/syntax/arc_eager.pyx":629
* for j in range(state.length):
* head = j + state._sent[j].head
* dep = state._sent[j].dep # <<<<<<<<<<<<<<
* heads[j].setdefault(head, 0.0)
* heads[j][head] += prob
*/
__pyx_t_10 = (__pyx_v_state->_sent[__pyx_v_j]).dep;
__pyx_v_dep = __pyx_t_10;
/* "spacy/syntax/arc_eager.pyx":630
* head = j + state._sent[j].head
* dep = state._sent[j].dep
* heads[j].setdefault(head, 0.0) # <<<<<<<<<<<<<<
* heads[j][head] += prob
* deps[j].setdefault(dep, 0.0)
*/
__pyx_t_5 = __Pyx_GetItemInt_List(__pyx_v_heads, __pyx_v_j, int, 1, __Pyx_PyInt_From_int, 1, 1, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 630, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__pyx_t_11 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_setdefault); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 630, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_11);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
__pyx_t_5 = __Pyx_PyInt_From_int(__pyx_v_head); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 630, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__pyx_t_12 = NULL;
__pyx_t_13 = 0;
if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_11))) {
__pyx_t_12 = PyMethod_GET_SELF(__pyx_t_11);
if (likely(__pyx_t_12)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_11);
__Pyx_INCREF(__pyx_t_12);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_11, function);
__pyx_t_13 = 1;
}
}
#if CYTHON_FAST_PYCALL
if (PyFunction_Check(__pyx_t_11)) {
PyObject *__pyx_temp[3] = {__pyx_t_12, __pyx_t_5, __pyx_float_0_0};
__pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_11, __pyx_temp+1-__pyx_t_13, 2+__pyx_t_13); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 630, __pyx_L1_error)
__Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0;
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
} else
#endif
#if CYTHON_FAST_PYCCALL
if (__Pyx_PyFastCFunction_Check(__pyx_t_11)) {
PyObject *__pyx_temp[3] = {__pyx_t_12, __pyx_t_5, __pyx_float_0_0};
__pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_11, __pyx_temp+1-__pyx_t_13, 2+__pyx_t_13); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 630, __pyx_L1_error)
__Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0;
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
} else
#endif
{
__pyx_t_14 = PyTuple_New(2+__pyx_t_13); if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 630, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_14);
if (__pyx_t_12) {
__Pyx_GIVEREF(__pyx_t_12); PyTuple_SET_ITEM(__pyx_t_14, 0, __pyx_t_12); __pyx_t_12 = NULL;
}
__Pyx_GIVEREF(__pyx_t_5);
PyTuple_SET_ITEM(__pyx_t_14, 0+__pyx_t_13, __pyx_t_5);
__Pyx_INCREF(__pyx_float_0_0);
__Pyx_GIVEREF(__pyx_float_0_0);
PyTuple_SET_ITEM(__pyx_t_14, 1+__pyx_t_13, __pyx_float_0_0);
__pyx_t_5 = 0;
__pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_11, __pyx_t_14, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 630, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0;
}
__Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
/* "spacy/syntax/arc_eager.pyx":631
* dep = state._sent[j].dep
* heads[j].setdefault(head, 0.0)
* heads[j][head] += prob # <<<<<<<<<<<<<<
* deps[j].setdefault(dep, 0.0)
* deps[j][dep] += prob
*/
__pyx_t_2 = __Pyx_GetItemInt_List(__pyx_v_heads, __pyx_v_j, int, 1, __Pyx_PyInt_From_int, 1, 1, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 631, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__pyx_t_13 = __pyx_v_head;
__pyx_t_11 = __Pyx_GetItemInt(__pyx_t_2, __pyx_t_13, int, 1, __Pyx_PyInt_From_int, 0, 1, 1); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 631, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_11);
__pyx_t_14 = PyNumber_InPlaceAdd(__pyx_t_11, __pyx_v_prob); if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 631, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_14);
__Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
if (unlikely(__Pyx_SetItemInt(__pyx_t_2, __pyx_t_13, __pyx_t_14, int, 1, __Pyx_PyInt_From_int, 0, 1, 1) < 0)) __PYX_ERR(0, 631, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0;
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
/* "spacy/syntax/arc_eager.pyx":632
* heads[j].setdefault(head, 0.0)
* heads[j][head] += prob
* deps[j].setdefault(dep, 0.0) # <<<<<<<<<<<<<<
* deps[j][dep] += prob
* return heads, deps
*/
__pyx_t_14 = __Pyx_GetItemInt_List(__pyx_v_deps, __pyx_v_j, int, 1, __Pyx_PyInt_From_int, 1, 1, 1); if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 632, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_14);
__pyx_t_11 = __Pyx_PyObject_GetAttrStr(__pyx_t_14, __pyx_n_s_setdefault); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 632, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_11);
__Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0;
__pyx_t_14 = __Pyx_PyInt_From_uint64_t(__pyx_v_dep); if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 632, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_14);
__pyx_t_5 = NULL;
__pyx_t_13 = 0;
if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_11))) {
__pyx_t_5 = PyMethod_GET_SELF(__pyx_t_11);
if (likely(__pyx_t_5)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_11);
__Pyx_INCREF(__pyx_t_5);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_11, function);
__pyx_t_13 = 1;
}
}
#if CYTHON_FAST_PYCALL
if (PyFunction_Check(__pyx_t_11)) {
PyObject *__pyx_temp[3] = {__pyx_t_5, __pyx_t_14, __pyx_float_0_0};
__pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_11, __pyx_temp+1-__pyx_t_13, 2+__pyx_t_13); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 632, __pyx_L1_error)
__Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0;
} else
#endif
#if CYTHON_FAST_PYCCALL
if (__Pyx_PyFastCFunction_Check(__pyx_t_11)) {
PyObject *__pyx_temp[3] = {__pyx_t_5, __pyx_t_14, __pyx_float_0_0};
__pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_11, __pyx_temp+1-__pyx_t_13, 2+__pyx_t_13); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 632, __pyx_L1_error)
__Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0;
} else
#endif
{
__pyx_t_12 = PyTuple_New(2+__pyx_t_13); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 632, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_12);
if (__pyx_t_5) {
__Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_12, 0, __pyx_t_5); __pyx_t_5 = NULL;
}
__Pyx_GIVEREF(__pyx_t_14);
PyTuple_SET_ITEM(__pyx_t_12, 0+__pyx_t_13, __pyx_t_14);
__Pyx_INCREF(__pyx_float_0_0);
__Pyx_GIVEREF(__pyx_float_0_0);
PyTuple_SET_ITEM(__pyx_t_12, 1+__pyx_t_13, __pyx_float_0_0);
__pyx_t_14 = 0;
__pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_11, __pyx_t_12, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 632, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
}
__Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
/* "spacy/syntax/arc_eager.pyx":633
* heads[j][head] += prob
* deps[j].setdefault(dep, 0.0)
* deps[j][dep] += prob # <<<<<<<<<<<<<<
* return heads, deps
*/
__pyx_t_2 = __Pyx_GetItemInt_List(__pyx_v_deps, __pyx_v_j, int, 1, __Pyx_PyInt_From_int, 1, 1, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 633, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__pyx_t_10 = __pyx_v_dep;
__pyx_t_11 = __Pyx_GetItemInt(__pyx_t_2, __pyx_t_10, __pyx_t_5spacy_8typedefs_attr_t, 0, __Pyx_PyInt_From_uint64_t, 0, 0, 1); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 633, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_11);
__pyx_t_12 = PyNumber_InPlaceAdd(__pyx_t_11, __pyx_v_prob); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 633, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_12);
__Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
if (unlikely(__Pyx_SetItemInt(__pyx_t_2, __pyx_t_10, __pyx_t_12, __pyx_t_5spacy_8typedefs_attr_t, 0, __Pyx_PyInt_From_uint64_t, 0, 0, 1) < 0)) __PYX_ERR(0, 633, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
}
/* "spacy/syntax/arc_eager.pyx":625
* state = <StateC*>beam.at(i)
* self.finalize_state(state)
* if state.is_final(): # <<<<<<<<<<<<<<
* prob = probs[i]
* for j in range(state.length):
*/
}
}
/* "spacy/syntax/arc_eager.pyx":634
* deps[j].setdefault(dep, 0.0)
* deps[j][dep] += prob
* return heads, deps # <<<<<<<<<<<<<<
*/
__Pyx_XDECREF(__pyx_r);
__pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 634, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_INCREF(__pyx_v_heads);
__Pyx_GIVEREF(__pyx_v_heads);
PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_v_heads);
__Pyx_INCREF(__pyx_v_deps);
__Pyx_GIVEREF(__pyx_v_deps);
PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_v_deps);
__pyx_r = __pyx_t_2;
__pyx_t_2 = 0;
goto __pyx_L0;
/* "spacy/syntax/arc_eager.pyx":617
* state=failure_state))
*
* def get_beam_annot(self, Beam beam): # <<<<<<<<<<<<<<
* length = (<StateC*>beam.at(0)).length
* heads = [{} for _ in range(length)]
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_2);
__Pyx_XDECREF(__pyx_t_5);
__Pyx_XDECREF(__pyx_t_11);
__Pyx_XDECREF(__pyx_t_12);
__Pyx_XDECREF(__pyx_t_14);
__Pyx_AddTraceback("spacy.syntax.arc_eager.ArcEager.get_beam_annot", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = NULL;
__pyx_L0:;
__Pyx_XDECREF(__pyx_v_heads);
__Pyx_XDECREF(__pyx_v_deps);
__Pyx_XDECREF(__pyx_v_probs);
__Pyx_XDECREF(__pyx_v_prob);
__Pyx_XGIVEREF(__pyx_r);
__Pyx_TraceReturn(__pyx_r, 0);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "(tree fragment)":1
* def __reduce_cython__(self): # <<<<<<<<<<<<<<
* raise TypeError("self.c,self.del_beam_state,self.init_beam_state cannot be converted to a Python object for pickling")
* def __setstate_cython__(self, __pyx_state):
*/
/* Python wrapper */
static PyObject *__pyx_pw_5spacy_6syntax_9arc_eager_8ArcEager_25__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
static PyObject *__pyx_pw_5spacy_6syntax_9arc_eager_8ArcEager_25__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
PyObject *__pyx_r = 0;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0);
__pyx_r = __pyx_pf_5spacy_6syntax_9arc_eager_8ArcEager_24__reduce_cython__(((struct __pyx_obj_5spacy_6syntax_9arc_eager_ArcEager *)__pyx_v_self));
/* function exit code */
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
static PyObject *__pyx_pf_5spacy_6syntax_9arc_eager_8ArcEager_24__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_5spacy_6syntax_9arc_eager_ArcEager *__pyx_v_self) {
PyObject *__pyx_r = NULL;
__Pyx_TraceDeclarations
__Pyx_RefNannyDeclarations
PyObject *__pyx_t_1 = NULL;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("__reduce_cython__", 0);
__Pyx_TraceCall("__reduce_cython__", __pyx_f[1], 1, 0, __PYX_ERR(1, 1, __pyx_L1_error));
/* "(tree fragment)":2
* def __reduce_cython__(self):
* raise TypeError("self.c,self.del_beam_state,self.init_beam_state cannot be converted to a Python object for pickling") # <<<<<<<<<<<<<<
* def __setstate_cython__(self, __pyx_state):
* raise TypeError("self.c,self.del_beam_state,self.init_beam_state cannot be converted to a Python object for pickling")
*/
__pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__7, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_Raise(__pyx_t_1, 0, 0, 0);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__PYX_ERR(1, 2, __pyx_L1_error)
/* "(tree fragment)":1
* def __reduce_cython__(self): # <<<<<<<<<<<<<<
* raise TypeError("self.c,self.del_beam_state,self.init_beam_state cannot be converted to a Python object for pickling")
* def __setstate_cython__(self, __pyx_state):
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_1);
__Pyx_AddTraceback("spacy.syntax.arc_eager.ArcEager.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = NULL;
__Pyx_XGIVEREF(__pyx_r);
__Pyx_TraceReturn(__pyx_r, 0);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "(tree fragment)":3
* def __reduce_cython__(self):
* raise TypeError("self.c,self.del_beam_state,self.init_beam_state cannot be converted to a Python object for pickling")
* def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<<
* raise TypeError("self.c,self.del_beam_state,self.init_beam_state cannot be converted to a Python object for pickling")
*/
/* Python wrapper */
static PyObject *__pyx_pw_5spacy_6syntax_9arc_eager_8ArcEager_27__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state); /*proto*/
static PyObject *__pyx_pw_5spacy_6syntax_9arc_eager_8ArcEager_27__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state) {
PyObject *__pyx_r = 0;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0);
__pyx_r = __pyx_pf_5spacy_6syntax_9arc_eager_8ArcEager_26__setstate_cython__(((struct __pyx_obj_5spacy_6syntax_9arc_eager_ArcEager *)__pyx_v_self), ((PyObject *)__pyx_v___pyx_state));
/* function exit code */
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
static PyObject *__pyx_pf_5spacy_6syntax_9arc_eager_8ArcEager_26__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_5spacy_6syntax_9arc_eager_ArcEager *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) {
PyObject *__pyx_r = NULL;
__Pyx_TraceDeclarations
__Pyx_RefNannyDeclarations
PyObject *__pyx_t_1 = NULL;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("__setstate_cython__", 0);
__Pyx_TraceCall("__setstate_cython__", __pyx_f[1], 3, 0, __PYX_ERR(1, 3, __pyx_L1_error));
/* "(tree fragment)":4
* raise TypeError("self.c,self.del_beam_state,self.init_beam_state cannot be converted to a Python object for pickling")
* def __setstate_cython__(self, __pyx_state):
* raise TypeError("self.c,self.del_beam_state,self.init_beam_state cannot be converted to a Python object for pickling") # <<<<<<<<<<<<<<
*/
__pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__8, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 4, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_Raise(__pyx_t_1, 0, 0, 0);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__PYX_ERR(1, 4, __pyx_L1_error)
/* "(tree fragment)":3
* def __reduce_cython__(self):
* raise TypeError("self.c,self.del_beam_state,self.init_beam_state cannot be converted to a Python object for pickling")
* def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<<
* raise TypeError("self.c,self.del_beam_state,self.init_beam_state cannot be converted to a Python object for pickling")
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_1);
__Pyx_AddTraceback("spacy.syntax.arc_eager.ArcEager.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = NULL;
__Pyx_XGIVEREF(__pyx_r);
__Pyx_TraceReturn(__pyx_r, 0);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "(tree fragment)":1
* def __pyx_unpickle_Shift(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<<
* cdef object __pyx_PickleError
* cdef object __pyx_result
*/
/* Python wrapper */
static PyObject *__pyx_pw_5spacy_6syntax_9arc_eager_1__pyx_unpickle_Shift(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static PyMethodDef __pyx_mdef_5spacy_6syntax_9arc_eager_1__pyx_unpickle_Shift = {"__pyx_unpickle_Shift", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5spacy_6syntax_9arc_eager_1__pyx_unpickle_Shift, METH_VARARGS|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_5spacy_6syntax_9arc_eager_1__pyx_unpickle_Shift(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
PyObject *__pyx_v___pyx_type = 0;
long __pyx_v___pyx_checksum;
PyObject *__pyx_v___pyx_state = 0;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
PyObject *__pyx_r = 0;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("__pyx_unpickle_Shift (wrapper)", 0);
{
static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_type,&__pyx_n_s_pyx_checksum,&__pyx_n_s_pyx_state,0};
PyObject* values[3] = {0,0,0};
if (unlikely(__pyx_kwds)) {
Py_ssize_t kw_args;
const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
switch (pos_args) {
case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
CYTHON_FALLTHROUGH;
case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
CYTHON_FALLTHROUGH;
case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
CYTHON_FALLTHROUGH;
case 0: break;
default: goto __pyx_L5_argtuple_error;
}
kw_args = PyDict_Size(__pyx_kwds);
switch (pos_args) {
case 0:
if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_pyx_type)) != 0)) kw_args--;
else goto __pyx_L5_argtuple_error;
CYTHON_FALLTHROUGH;
case 1:
if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_pyx_checksum)) != 0)) kw_args--;
else {
__Pyx_RaiseArgtupleInvalid("__pyx_unpickle_Shift", 1, 3, 3, 1); __PYX_ERR(1, 1, __pyx_L3_error)
}
CYTHON_FALLTHROUGH;
case 2:
if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_pyx_state)) != 0)) kw_args--;
else {
__Pyx_RaiseArgtupleInvalid("__pyx_unpickle_Shift", 1, 3, 3, 2); __PYX_ERR(1, 1, __pyx_L3_error)
}
}
if (unlikely(kw_args > 0)) {
if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__pyx_unpickle_Shift") < 0)) __PYX_ERR(1, 1, __pyx_L3_error)
}
} else if (PyTuple_GET_SIZE(__pyx_args) != 3) {
goto __pyx_L5_argtuple_error;
} else {
values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
}
__pyx_v___pyx_type = values[0];
__pyx_v___pyx_checksum = __Pyx_PyInt_As_long(values[1]); if (unlikely((__pyx_v___pyx_checksum == (long)-1) && PyErr_Occurred())) __PYX_ERR(1, 1, __pyx_L3_error)
__pyx_v___pyx_state = values[2];
}
goto __pyx_L4_argument_unpacking_done;
__pyx_L5_argtuple_error:;
__Pyx_RaiseArgtupleInvalid("__pyx_unpickle_Shift", 1, 3, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 1, __pyx_L3_error)
__pyx_L3_error:;
__Pyx_AddTraceback("spacy.syntax.arc_eager.__pyx_unpickle_Shift", __pyx_clineno, __pyx_lineno, __pyx_filename);
__Pyx_RefNannyFinishContext();
return NULL;
__pyx_L4_argument_unpacking_done:;
__pyx_r = __pyx_pf_5spacy_6syntax_9arc_eager___pyx_unpickle_Shift(__pyx_self, __pyx_v___pyx_type, __pyx_v___pyx_checksum, __pyx_v___pyx_state);
/* function exit code */
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
static PyObject *__pyx_pf_5spacy_6syntax_9arc_eager___pyx_unpickle_Shift(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v___pyx_type, long __pyx_v___pyx_checksum, PyObject *__pyx_v___pyx_state) {
PyObject *__pyx_v___pyx_PickleError = 0;
PyObject *__pyx_v___pyx_result = 0;
PyObject *__pyx_r = NULL;
__Pyx_TraceDeclarations
__Pyx_RefNannyDeclarations
int __pyx_t_1;
PyObject *__pyx_t_2 = NULL;
PyObject *__pyx_t_3 = NULL;
PyObject *__pyx_t_4 = NULL;
PyObject *__pyx_t_5 = NULL;
int __pyx_t_6;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_TraceFrameInit(__pyx_codeobj__9)
__Pyx_RefNannySetupContext("__pyx_unpickle_Shift", 0);
__Pyx_TraceCall("__pyx_unpickle_Shift", __pyx_f[1], 1, 0, __PYX_ERR(1, 1, __pyx_L1_error));
/* "(tree fragment)":4
* cdef object __pyx_PickleError
* cdef object __pyx_result
* if __pyx_checksum != 0xd41d8cd: # <<<<<<<<<<<<<<
* from pickle import PickleError as __pyx_PickleError
* raise __pyx_PickleError("Incompatible checksums (%s vs 0xd41d8cd = ())" % __pyx_checksum)
*/
__pyx_t_1 = ((__pyx_v___pyx_checksum != 0xd41d8cd) != 0);
if (__pyx_t_1) {
/* "(tree fragment)":5
* cdef object __pyx_result
* if __pyx_checksum != 0xd41d8cd:
* from pickle import PickleError as __pyx_PickleError # <<<<<<<<<<<<<<
* raise __pyx_PickleError("Incompatible checksums (%s vs 0xd41d8cd = ())" % __pyx_checksum)
* __pyx_result = Shift.__new__(__pyx_type)
*/
__pyx_t_2 = PyList_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 5, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_INCREF(__pyx_n_s_PickleError);
__Pyx_GIVEREF(__pyx_n_s_PickleError);
PyList_SET_ITEM(__pyx_t_2, 0, __pyx_n_s_PickleError);
__pyx_t_3 = __Pyx_Import(__pyx_n_s_pickle, __pyx_t_2, -1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 5, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__pyx_t_2 = __Pyx_ImportFrom(__pyx_t_3, __pyx_n_s_PickleError); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 5, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_INCREF(__pyx_t_2);
__pyx_v___pyx_PickleError = __pyx_t_2;
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
/* "(tree fragment)":6
* if __pyx_checksum != 0xd41d8cd:
* from pickle import PickleError as __pyx_PickleError
* raise __pyx_PickleError("Incompatible checksums (%s vs 0xd41d8cd = ())" % __pyx_checksum) # <<<<<<<<<<<<<<
* __pyx_result = Shift.__new__(__pyx_type)
* if __pyx_state is not None:
*/
__pyx_t_2 = __Pyx_PyInt_From_long(__pyx_v___pyx_checksum); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 6, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__pyx_t_4 = __Pyx_PyString_Format(__pyx_kp_s_Incompatible_checksums_s_vs_0xd4, __pyx_t_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 6, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__Pyx_INCREF(__pyx_v___pyx_PickleError);
__pyx_t_2 = __pyx_v___pyx_PickleError; __pyx_t_5 = NULL;
if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) {
__pyx_t_5 = PyMethod_GET_SELF(__pyx_t_2);
if (likely(__pyx_t_5)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
__Pyx_INCREF(__pyx_t_5);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_2, function);
}
}
__pyx_t_3 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_5, __pyx_t_4) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_4);
__Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 6, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__Pyx_Raise(__pyx_t_3, 0, 0, 0);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__PYX_ERR(1, 6, __pyx_L1_error)
/* "(tree fragment)":4
* cdef object __pyx_PickleError
* cdef object __pyx_result
* if __pyx_checksum != 0xd41d8cd: # <<<<<<<<<<<<<<
* from pickle import PickleError as __pyx_PickleError
* raise __pyx_PickleError("Incompatible checksums (%s vs 0xd41d8cd = ())" % __pyx_checksum)
*/
}
/* "(tree fragment)":7
* from pickle import PickleError as __pyx_PickleError
* raise __pyx_PickleError("Incompatible checksums (%s vs 0xd41d8cd = ())" % __pyx_checksum)
* __pyx_result = Shift.__new__(__pyx_type) # <<<<<<<<<<<<<<
* if __pyx_state is not None:
* __pyx_unpickle_Shift__set_state(<Shift> __pyx_result, __pyx_state)
*/
__pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_ptype_5spacy_6syntax_9arc_eager_Shift), __pyx_n_s_new); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 7, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__pyx_t_4 = NULL;
if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
__pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2);
if (likely(__pyx_t_4)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
__Pyx_INCREF(__pyx_t_4);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_2, function);
}
}
__pyx_t_3 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_4, __pyx_v___pyx_type) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_v___pyx_type);
__Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 7, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__pyx_v___pyx_result = __pyx_t_3;
__pyx_t_3 = 0;
/* "(tree fragment)":8
* raise __pyx_PickleError("Incompatible checksums (%s vs 0xd41d8cd = ())" % __pyx_checksum)
* __pyx_result = Shift.__new__(__pyx_type)
* if __pyx_state is not None: # <<<<<<<<<<<<<<
* __pyx_unpickle_Shift__set_state(<Shift> __pyx_result, __pyx_state)
* return __pyx_result
*/
__pyx_t_1 = (__pyx_v___pyx_state != Py_None);
__pyx_t_6 = (__pyx_t_1 != 0);
if (__pyx_t_6) {
/* "(tree fragment)":9
* __pyx_result = Shift.__new__(__pyx_type)
* if __pyx_state is not None:
* __pyx_unpickle_Shift__set_state(<Shift> __pyx_result, __pyx_state) # <<<<<<<<<<<<<<
* return __pyx_result
* cdef __pyx_unpickle_Shift__set_state(Shift __pyx_result, tuple __pyx_state):
*/
if (!(likely(PyTuple_CheckExact(__pyx_v___pyx_state))||((__pyx_v___pyx_state) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "tuple", Py_TYPE(__pyx_v___pyx_state)->tp_name), 0))) __PYX_ERR(1, 9, __pyx_L1_error)
__pyx_t_3 = __pyx_f_5spacy_6syntax_9arc_eager___pyx_unpickle_Shift__set_state(((struct __pyx_obj_5spacy_6syntax_9arc_eager_Shift *)__pyx_v___pyx_result), ((PyObject*)__pyx_v___pyx_state)); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 9, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
/* "(tree fragment)":8
* raise __pyx_PickleError("Incompatible checksums (%s vs 0xd41d8cd = ())" % __pyx_checksum)
* __pyx_result = Shift.__new__(__pyx_type)
* if __pyx_state is not None: # <<<<<<<<<<<<<<
* __pyx_unpickle_Shift__set_state(<Shift> __pyx_result, __pyx_state)
* return __pyx_result
*/
}
/* "(tree fragment)":10
* if __pyx_state is not None:
* __pyx_unpickle_Shift__set_state(<Shift> __pyx_result, __pyx_state)
* return __pyx_result # <<<<<<<<<<<<<<
* cdef __pyx_unpickle_Shift__set_state(Shift __pyx_result, tuple __pyx_state):
* if len(__pyx_state) > 0 and hasattr(__pyx_result, '__dict__'):
*/
__Pyx_XDECREF(__pyx_r);
__Pyx_INCREF(__pyx_v___pyx_result);
__pyx_r = __pyx_v___pyx_result;
goto __pyx_L0;
/* "(tree fragment)":1
* def __pyx_unpickle_Shift(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<<
* cdef object __pyx_PickleError
* cdef object __pyx_result
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_2);
__Pyx_XDECREF(__pyx_t_3);
__Pyx_XDECREF(__pyx_t_4);
__Pyx_XDECREF(__pyx_t_5);
__Pyx_AddTraceback("spacy.syntax.arc_eager.__pyx_unpickle_Shift", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = NULL;
__pyx_L0:;
__Pyx_XDECREF(__pyx_v___pyx_PickleError);
__Pyx_XDECREF(__pyx_v___pyx_result);
__Pyx_XGIVEREF(__pyx_r);
__Pyx_TraceReturn(__pyx_r, 0);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "(tree fragment)":11
* __pyx_unpickle_Shift__set_state(<Shift> __pyx_result, __pyx_state)
* return __pyx_result
* cdef __pyx_unpickle_Shift__set_state(Shift __pyx_result, tuple __pyx_state): # <<<<<<<<<<<<<<
* if len(__pyx_state) > 0 and hasattr(__pyx_result, '__dict__'):
* __pyx_result.__dict__.update(__pyx_state[0])
*/
static PyObject *__pyx_f_5spacy_6syntax_9arc_eager___pyx_unpickle_Shift__set_state(struct __pyx_obj_5spacy_6syntax_9arc_eager_Shift *__pyx_v___pyx_result, PyObject *__pyx_v___pyx_state) {
PyObject *__pyx_r = NULL;
__Pyx_TraceDeclarations
__Pyx_RefNannyDeclarations
int __pyx_t_1;
Py_ssize_t __pyx_t_2;
int __pyx_t_3;
int __pyx_t_4;
PyObject *__pyx_t_5 = NULL;
PyObject *__pyx_t_6 = NULL;
PyObject *__pyx_t_7 = NULL;
PyObject *__pyx_t_8 = NULL;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("__pyx_unpickle_Shift__set_state", 0);
__Pyx_TraceCall("__pyx_unpickle_Shift__set_state", __pyx_f[1], 11, 0, __PYX_ERR(1, 11, __pyx_L1_error));
/* "(tree fragment)":12
* return __pyx_result
* cdef __pyx_unpickle_Shift__set_state(Shift __pyx_result, tuple __pyx_state):
* if len(__pyx_state) > 0 and hasattr(__pyx_result, '__dict__'): # <<<<<<<<<<<<<<
* __pyx_result.__dict__.update(__pyx_state[0])
*/
if (unlikely(__pyx_v___pyx_state == Py_None)) {
PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()");
__PYX_ERR(1, 12, __pyx_L1_error)
}
__pyx_t_2 = PyTuple_GET_SIZE(__pyx_v___pyx_state); if (unlikely(__pyx_t_2 == ((Py_ssize_t)-1))) __PYX_ERR(1, 12, __pyx_L1_error)
__pyx_t_3 = ((__pyx_t_2 > 0) != 0);
if (__pyx_t_3) {
} else {
__pyx_t_1 = __pyx_t_3;
goto __pyx_L4_bool_binop_done;
}
__pyx_t_3 = __Pyx_HasAttr(((PyObject *)__pyx_v___pyx_result), __pyx_n_s_dict); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(1, 12, __pyx_L1_error)
__pyx_t_4 = (__pyx_t_3 != 0);
__pyx_t_1 = __pyx_t_4;
__pyx_L4_bool_binop_done:;
if (__pyx_t_1) {
/* "(tree fragment)":13
* cdef __pyx_unpickle_Shift__set_state(Shift __pyx_result, tuple __pyx_state):
* if len(__pyx_state) > 0 and hasattr(__pyx_result, '__dict__'):
* __pyx_result.__dict__.update(__pyx_state[0]) # <<<<<<<<<<<<<<
*/
__pyx_t_6 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v___pyx_result), __pyx_n_s_dict); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 13, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_update); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 13, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
if (unlikely(__pyx_v___pyx_state == Py_None)) {
PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable");
__PYX_ERR(1, 13, __pyx_L1_error)
}
__pyx_t_6 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 13, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__pyx_t_8 = NULL;
if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_7))) {
__pyx_t_8 = PyMethod_GET_SELF(__pyx_t_7);
if (likely(__pyx_t_8)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7);
__Pyx_INCREF(__pyx_t_8);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_7, function);
}
}
__pyx_t_5 = (__pyx_t_8) ? __Pyx_PyObject_Call2Args(__pyx_t_7, __pyx_t_8, __pyx_t_6) : __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_6);
__Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 13, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
/* "(tree fragment)":12
* return __pyx_result
* cdef __pyx_unpickle_Shift__set_state(Shift __pyx_result, tuple __pyx_state):
* if len(__pyx_state) > 0 and hasattr(__pyx_result, '__dict__'): # <<<<<<<<<<<<<<
* __pyx_result.__dict__.update(__pyx_state[0])
*/
}
/* "(tree fragment)":11
* __pyx_unpickle_Shift__set_state(<Shift> __pyx_result, __pyx_state)
* return __pyx_result
* cdef __pyx_unpickle_Shift__set_state(Shift __pyx_result, tuple __pyx_state): # <<<<<<<<<<<<<<
* if len(__pyx_state) > 0 and hasattr(__pyx_result, '__dict__'):
* __pyx_result.__dict__.update(__pyx_state[0])
*/
/* function exit code */
__pyx_r = Py_None; __Pyx_INCREF(Py_None);
goto __pyx_L0;
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_5);
__Pyx_XDECREF(__pyx_t_6);
__Pyx_XDECREF(__pyx_t_7);
__Pyx_XDECREF(__pyx_t_8);
__Pyx_AddTraceback("spacy.syntax.arc_eager.__pyx_unpickle_Shift__set_state", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = 0;
__pyx_L0:;
__Pyx_XGIVEREF(__pyx_r);
__Pyx_TraceReturn(__pyx_r, 0);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "(tree fragment)":1
* def __pyx_unpickle_Reduce(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<<
* cdef object __pyx_PickleError
* cdef object __pyx_result
*/
/* Python wrapper */
static PyObject *__pyx_pw_5spacy_6syntax_9arc_eager_3__pyx_unpickle_Reduce(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static PyMethodDef __pyx_mdef_5spacy_6syntax_9arc_eager_3__pyx_unpickle_Reduce = {"__pyx_unpickle_Reduce", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5spacy_6syntax_9arc_eager_3__pyx_unpickle_Reduce, METH_VARARGS|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_5spacy_6syntax_9arc_eager_3__pyx_unpickle_Reduce(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
PyObject *__pyx_v___pyx_type = 0;
long __pyx_v___pyx_checksum;
PyObject *__pyx_v___pyx_state = 0;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
PyObject *__pyx_r = 0;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("__pyx_unpickle_Reduce (wrapper)", 0);
{
static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_type,&__pyx_n_s_pyx_checksum,&__pyx_n_s_pyx_state,0};
PyObject* values[3] = {0,0,0};
if (unlikely(__pyx_kwds)) {
Py_ssize_t kw_args;
const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
switch (pos_args) {
case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
CYTHON_FALLTHROUGH;
case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
CYTHON_FALLTHROUGH;
case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
CYTHON_FALLTHROUGH;
case 0: break;
default: goto __pyx_L5_argtuple_error;
}
kw_args = PyDict_Size(__pyx_kwds);
switch (pos_args) {
case 0:
if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_pyx_type)) != 0)) kw_args--;
else goto __pyx_L5_argtuple_error;
CYTHON_FALLTHROUGH;
case 1:
if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_pyx_checksum)) != 0)) kw_args--;
else {
__Pyx_RaiseArgtupleInvalid("__pyx_unpickle_Reduce", 1, 3, 3, 1); __PYX_ERR(1, 1, __pyx_L3_error)
}
CYTHON_FALLTHROUGH;
case 2:
if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_pyx_state)) != 0)) kw_args--;
else {
__Pyx_RaiseArgtupleInvalid("__pyx_unpickle_Reduce", 1, 3, 3, 2); __PYX_ERR(1, 1, __pyx_L3_error)
}
}
if (unlikely(kw_args > 0)) {
if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__pyx_unpickle_Reduce") < 0)) __PYX_ERR(1, 1, __pyx_L3_error)
}
} else if (PyTuple_GET_SIZE(__pyx_args) != 3) {
goto __pyx_L5_argtuple_error;
} else {
values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
}
__pyx_v___pyx_type = values[0];
__pyx_v___pyx_checksum = __Pyx_PyInt_As_long(values[1]); if (unlikely((__pyx_v___pyx_checksum == (long)-1) && PyErr_Occurred())) __PYX_ERR(1, 1, __pyx_L3_error)
__pyx_v___pyx_state = values[2];
}
goto __pyx_L4_argument_unpacking_done;
__pyx_L5_argtuple_error:;
__Pyx_RaiseArgtupleInvalid("__pyx_unpickle_Reduce", 1, 3, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 1, __pyx_L3_error)
__pyx_L3_error:;
__Pyx_AddTraceback("spacy.syntax.arc_eager.__pyx_unpickle_Reduce", __pyx_clineno, __pyx_lineno, __pyx_filename);
__Pyx_RefNannyFinishContext();
return NULL;
__pyx_L4_argument_unpacking_done:;
__pyx_r = __pyx_pf_5spacy_6syntax_9arc_eager_2__pyx_unpickle_Reduce(__pyx_self, __pyx_v___pyx_type, __pyx_v___pyx_checksum, __pyx_v___pyx_state);
/* function exit code */
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
static PyObject *__pyx_pf_5spacy_6syntax_9arc_eager_2__pyx_unpickle_Reduce(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v___pyx_type, long __pyx_v___pyx_checksum, PyObject *__pyx_v___pyx_state) {
PyObject *__pyx_v___pyx_PickleError = 0;
PyObject *__pyx_v___pyx_result = 0;
PyObject *__pyx_r = NULL;
__Pyx_TraceDeclarations
__Pyx_RefNannyDeclarations
int __pyx_t_1;
PyObject *__pyx_t_2 = NULL;
PyObject *__pyx_t_3 = NULL;
PyObject *__pyx_t_4 = NULL;
PyObject *__pyx_t_5 = NULL;
int __pyx_t_6;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_TraceFrameInit(__pyx_codeobj__10)
__Pyx_RefNannySetupContext("__pyx_unpickle_Reduce", 0);
__Pyx_TraceCall("__pyx_unpickle_Reduce", __pyx_f[1], 1, 0, __PYX_ERR(1, 1, __pyx_L1_error));
/* "(tree fragment)":4
* cdef object __pyx_PickleError
* cdef object __pyx_result
* if __pyx_checksum != 0xd41d8cd: # <<<<<<<<<<<<<<
* from pickle import PickleError as __pyx_PickleError
* raise __pyx_PickleError("Incompatible checksums (%s vs 0xd41d8cd = ())" % __pyx_checksum)
*/
__pyx_t_1 = ((__pyx_v___pyx_checksum != 0xd41d8cd) != 0);
if (__pyx_t_1) {
/* "(tree fragment)":5
* cdef object __pyx_result
* if __pyx_checksum != 0xd41d8cd:
* from pickle import PickleError as __pyx_PickleError # <<<<<<<<<<<<<<
* raise __pyx_PickleError("Incompatible checksums (%s vs 0xd41d8cd = ())" % __pyx_checksum)
* __pyx_result = Reduce.__new__(__pyx_type)
*/
__pyx_t_2 = PyList_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 5, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_INCREF(__pyx_n_s_PickleError);
__Pyx_GIVEREF(__pyx_n_s_PickleError);
PyList_SET_ITEM(__pyx_t_2, 0, __pyx_n_s_PickleError);
__pyx_t_3 = __Pyx_Import(__pyx_n_s_pickle, __pyx_t_2, -1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 5, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__pyx_t_2 = __Pyx_ImportFrom(__pyx_t_3, __pyx_n_s_PickleError); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 5, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_INCREF(__pyx_t_2);
__pyx_v___pyx_PickleError = __pyx_t_2;
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
/* "(tree fragment)":6
* if __pyx_checksum != 0xd41d8cd:
* from pickle import PickleError as __pyx_PickleError
* raise __pyx_PickleError("Incompatible checksums (%s vs 0xd41d8cd = ())" % __pyx_checksum) # <<<<<<<<<<<<<<
* __pyx_result = Reduce.__new__(__pyx_type)
* if __pyx_state is not None:
*/
__pyx_t_2 = __Pyx_PyInt_From_long(__pyx_v___pyx_checksum); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 6, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__pyx_t_4 = __Pyx_PyString_Format(__pyx_kp_s_Incompatible_checksums_s_vs_0xd4, __pyx_t_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 6, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__Pyx_INCREF(__pyx_v___pyx_PickleError);
__pyx_t_2 = __pyx_v___pyx_PickleError; __pyx_t_5 = NULL;
if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) {
__pyx_t_5 = PyMethod_GET_SELF(__pyx_t_2);
if (likely(__pyx_t_5)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
__Pyx_INCREF(__pyx_t_5);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_2, function);
}
}
__pyx_t_3 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_5, __pyx_t_4) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_4);
__Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 6, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__Pyx_Raise(__pyx_t_3, 0, 0, 0);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__PYX_ERR(1, 6, __pyx_L1_error)
/* "(tree fragment)":4
* cdef object __pyx_PickleError
* cdef object __pyx_result
* if __pyx_checksum != 0xd41d8cd: # <<<<<<<<<<<<<<
* from pickle import PickleError as __pyx_PickleError
* raise __pyx_PickleError("Incompatible checksums (%s vs 0xd41d8cd = ())" % __pyx_checksum)
*/
}
/* "(tree fragment)":7
* from pickle import PickleError as __pyx_PickleError
* raise __pyx_PickleError("Incompatible checksums (%s vs 0xd41d8cd = ())" % __pyx_checksum)
* __pyx_result = Reduce.__new__(__pyx_type) # <<<<<<<<<<<<<<
* if __pyx_state is not None:
* __pyx_unpickle_Reduce__set_state(<Reduce> __pyx_result, __pyx_state)
*/
__pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_ptype_5spacy_6syntax_9arc_eager_Reduce), __pyx_n_s_new); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 7, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__pyx_t_4 = NULL;
if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
__pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2);
if (likely(__pyx_t_4)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
__Pyx_INCREF(__pyx_t_4);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_2, function);
}
}
__pyx_t_3 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_4, __pyx_v___pyx_type) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_v___pyx_type);
__Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 7, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__pyx_v___pyx_result = __pyx_t_3;
__pyx_t_3 = 0;
/* "(tree fragment)":8
* raise __pyx_PickleError("Incompatible checksums (%s vs 0xd41d8cd = ())" % __pyx_checksum)
* __pyx_result = Reduce.__new__(__pyx_type)
* if __pyx_state is not None: # <<<<<<<<<<<<<<
* __pyx_unpickle_Reduce__set_state(<Reduce> __pyx_result, __pyx_state)
* return __pyx_result
*/
__pyx_t_1 = (__pyx_v___pyx_state != Py_None);
__pyx_t_6 = (__pyx_t_1 != 0);
if (__pyx_t_6) {
/* "(tree fragment)":9
* __pyx_result = Reduce.__new__(__pyx_type)
* if __pyx_state is not None:
* __pyx_unpickle_Reduce__set_state(<Reduce> __pyx_result, __pyx_state) # <<<<<<<<<<<<<<
* return __pyx_result
* cdef __pyx_unpickle_Reduce__set_state(Reduce __pyx_result, tuple __pyx_state):
*/
if (!(likely(PyTuple_CheckExact(__pyx_v___pyx_state))||((__pyx_v___pyx_state) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "tuple", Py_TYPE(__pyx_v___pyx_state)->tp_name), 0))) __PYX_ERR(1, 9, __pyx_L1_error)
__pyx_t_3 = __pyx_f_5spacy_6syntax_9arc_eager___pyx_unpickle_Reduce__set_state(((struct __pyx_obj_5spacy_6syntax_9arc_eager_Reduce *)__pyx_v___pyx_result), ((PyObject*)__pyx_v___pyx_state)); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 9, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
/* "(tree fragment)":8
* raise __pyx_PickleError("Incompatible checksums (%s vs 0xd41d8cd = ())" % __pyx_checksum)
* __pyx_result = Reduce.__new__(__pyx_type)
* if __pyx_state is not None: # <<<<<<<<<<<<<<
* __pyx_unpickle_Reduce__set_state(<Reduce> __pyx_result, __pyx_state)
* return __pyx_result
*/
}
/* "(tree fragment)":10
* if __pyx_state is not None:
* __pyx_unpickle_Reduce__set_state(<Reduce> __pyx_result, __pyx_state)
* return __pyx_result # <<<<<<<<<<<<<<
* cdef __pyx_unpickle_Reduce__set_state(Reduce __pyx_result, tuple __pyx_state):
* if len(__pyx_state) > 0 and hasattr(__pyx_result, '__dict__'):
*/
__Pyx_XDECREF(__pyx_r);
__Pyx_INCREF(__pyx_v___pyx_result);
__pyx_r = __pyx_v___pyx_result;
goto __pyx_L0;
/* "(tree fragment)":1
* def __pyx_unpickle_Reduce(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<<
* cdef object __pyx_PickleError
* cdef object __pyx_result
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_2);
__Pyx_XDECREF(__pyx_t_3);
__Pyx_XDECREF(__pyx_t_4);
__Pyx_XDECREF(__pyx_t_5);
__Pyx_AddTraceback("spacy.syntax.arc_eager.__pyx_unpickle_Reduce", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = NULL;
__pyx_L0:;
__Pyx_XDECREF(__pyx_v___pyx_PickleError);
__Pyx_XDECREF(__pyx_v___pyx_result);
__Pyx_XGIVEREF(__pyx_r);
__Pyx_TraceReturn(__pyx_r, 0);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "(tree fragment)":11
* __pyx_unpickle_Reduce__set_state(<Reduce> __pyx_result, __pyx_state)
* return __pyx_result
* cdef __pyx_unpickle_Reduce__set_state(Reduce __pyx_result, tuple __pyx_state): # <<<<<<<<<<<<<<
* if len(__pyx_state) > 0 and hasattr(__pyx_result, '__dict__'):
* __pyx_result.__dict__.update(__pyx_state[0])
*/
static PyObject *__pyx_f_5spacy_6syntax_9arc_eager___pyx_unpickle_Reduce__set_state(struct __pyx_obj_5spacy_6syntax_9arc_eager_Reduce *__pyx_v___pyx_result, PyObject *__pyx_v___pyx_state) {
PyObject *__pyx_r = NULL;
__Pyx_TraceDeclarations
__Pyx_RefNannyDeclarations
int __pyx_t_1;
Py_ssize_t __pyx_t_2;
int __pyx_t_3;
int __pyx_t_4;
PyObject *__pyx_t_5 = NULL;
PyObject *__pyx_t_6 = NULL;
PyObject *__pyx_t_7 = NULL;
PyObject *__pyx_t_8 = NULL;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("__pyx_unpickle_Reduce__set_state", 0);
__Pyx_TraceCall("__pyx_unpickle_Reduce__set_state", __pyx_f[1], 11, 0, __PYX_ERR(1, 11, __pyx_L1_error));
/* "(tree fragment)":12
* return __pyx_result
* cdef __pyx_unpickle_Reduce__set_state(Reduce __pyx_result, tuple __pyx_state):
* if len(__pyx_state) > 0 and hasattr(__pyx_result, '__dict__'): # <<<<<<<<<<<<<<
* __pyx_result.__dict__.update(__pyx_state[0])
*/
if (unlikely(__pyx_v___pyx_state == Py_None)) {
PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()");
__PYX_ERR(1, 12, __pyx_L1_error)
}
__pyx_t_2 = PyTuple_GET_SIZE(__pyx_v___pyx_state); if (unlikely(__pyx_t_2 == ((Py_ssize_t)-1))) __PYX_ERR(1, 12, __pyx_L1_error)
__pyx_t_3 = ((__pyx_t_2 > 0) != 0);
if (__pyx_t_3) {
} else {
__pyx_t_1 = __pyx_t_3;
goto __pyx_L4_bool_binop_done;
}
__pyx_t_3 = __Pyx_HasAttr(((PyObject *)__pyx_v___pyx_result), __pyx_n_s_dict); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(1, 12, __pyx_L1_error)
__pyx_t_4 = (__pyx_t_3 != 0);
__pyx_t_1 = __pyx_t_4;
__pyx_L4_bool_binop_done:;
if (__pyx_t_1) {
/* "(tree fragment)":13
* cdef __pyx_unpickle_Reduce__set_state(Reduce __pyx_result, tuple __pyx_state):
* if len(__pyx_state) > 0 and hasattr(__pyx_result, '__dict__'):
* __pyx_result.__dict__.update(__pyx_state[0]) # <<<<<<<<<<<<<<
*/
__pyx_t_6 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v___pyx_result), __pyx_n_s_dict); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 13, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_update); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 13, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
if (unlikely(__pyx_v___pyx_state == Py_None)) {
PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable");
__PYX_ERR(1, 13, __pyx_L1_error)
}
__pyx_t_6 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 13, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__pyx_t_8 = NULL;
if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_7))) {
__pyx_t_8 = PyMethod_GET_SELF(__pyx_t_7);
if (likely(__pyx_t_8)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7);
__Pyx_INCREF(__pyx_t_8);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_7, function);
}
}
__pyx_t_5 = (__pyx_t_8) ? __Pyx_PyObject_Call2Args(__pyx_t_7, __pyx_t_8, __pyx_t_6) : __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_6);
__Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 13, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
/* "(tree fragment)":12
* return __pyx_result
* cdef __pyx_unpickle_Reduce__set_state(Reduce __pyx_result, tuple __pyx_state):
* if len(__pyx_state) > 0 and hasattr(__pyx_result, '__dict__'): # <<<<<<<<<<<<<<
* __pyx_result.__dict__.update(__pyx_state[0])
*/
}
/* "(tree fragment)":11
* __pyx_unpickle_Reduce__set_state(<Reduce> __pyx_result, __pyx_state)
* return __pyx_result
* cdef __pyx_unpickle_Reduce__set_state(Reduce __pyx_result, tuple __pyx_state): # <<<<<<<<<<<<<<
* if len(__pyx_state) > 0 and hasattr(__pyx_result, '__dict__'):
* __pyx_result.__dict__.update(__pyx_state[0])
*/
/* function exit code */
__pyx_r = Py_None; __Pyx_INCREF(Py_None);
goto __pyx_L0;
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_5);
__Pyx_XDECREF(__pyx_t_6);
__Pyx_XDECREF(__pyx_t_7);
__Pyx_XDECREF(__pyx_t_8);
__Pyx_AddTraceback("spacy.syntax.arc_eager.__pyx_unpickle_Reduce__set_state", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = 0;
__pyx_L0:;
__Pyx_XGIVEREF(__pyx_r);
__Pyx_TraceReturn(__pyx_r, 0);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "(tree fragment)":1
* def __pyx_unpickle_LeftArc(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<<
* cdef object __pyx_PickleError
* cdef object __pyx_result
*/
/* Python wrapper */
static PyObject *__pyx_pw_5spacy_6syntax_9arc_eager_5__pyx_unpickle_LeftArc(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static PyMethodDef __pyx_mdef_5spacy_6syntax_9arc_eager_5__pyx_unpickle_LeftArc = {"__pyx_unpickle_LeftArc", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5spacy_6syntax_9arc_eager_5__pyx_unpickle_LeftArc, METH_VARARGS|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_5spacy_6syntax_9arc_eager_5__pyx_unpickle_LeftArc(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
PyObject *__pyx_v___pyx_type = 0;
long __pyx_v___pyx_checksum;
PyObject *__pyx_v___pyx_state = 0;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
PyObject *__pyx_r = 0;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("__pyx_unpickle_LeftArc (wrapper)", 0);
{
static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_type,&__pyx_n_s_pyx_checksum,&__pyx_n_s_pyx_state,0};
PyObject* values[3] = {0,0,0};
if (unlikely(__pyx_kwds)) {
Py_ssize_t kw_args;
const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
switch (pos_args) {
case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
CYTHON_FALLTHROUGH;
case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
CYTHON_FALLTHROUGH;
case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
CYTHON_FALLTHROUGH;
case 0: break;
default: goto __pyx_L5_argtuple_error;
}
kw_args = PyDict_Size(__pyx_kwds);
switch (pos_args) {
case 0:
if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_pyx_type)) != 0)) kw_args--;
else goto __pyx_L5_argtuple_error;
CYTHON_FALLTHROUGH;
case 1:
if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_pyx_checksum)) != 0)) kw_args--;
else {
__Pyx_RaiseArgtupleInvalid("__pyx_unpickle_LeftArc", 1, 3, 3, 1); __PYX_ERR(1, 1, __pyx_L3_error)
}
CYTHON_FALLTHROUGH;
case 2:
if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_pyx_state)) != 0)) kw_args--;
else {
__Pyx_RaiseArgtupleInvalid("__pyx_unpickle_LeftArc", 1, 3, 3, 2); __PYX_ERR(1, 1, __pyx_L3_error)
}
}
if (unlikely(kw_args > 0)) {
if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__pyx_unpickle_LeftArc") < 0)) __PYX_ERR(1, 1, __pyx_L3_error)
}
} else if (PyTuple_GET_SIZE(__pyx_args) != 3) {
goto __pyx_L5_argtuple_error;
} else {
values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
}
__pyx_v___pyx_type = values[0];
__pyx_v___pyx_checksum = __Pyx_PyInt_As_long(values[1]); if (unlikely((__pyx_v___pyx_checksum == (long)-1) && PyErr_Occurred())) __PYX_ERR(1, 1, __pyx_L3_error)
__pyx_v___pyx_state = values[2];
}
goto __pyx_L4_argument_unpacking_done;
__pyx_L5_argtuple_error:;
__Pyx_RaiseArgtupleInvalid("__pyx_unpickle_LeftArc", 1, 3, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 1, __pyx_L3_error)
__pyx_L3_error:;
__Pyx_AddTraceback("spacy.syntax.arc_eager.__pyx_unpickle_LeftArc", __pyx_clineno, __pyx_lineno, __pyx_filename);
__Pyx_RefNannyFinishContext();
return NULL;
__pyx_L4_argument_unpacking_done:;
__pyx_r = __pyx_pf_5spacy_6syntax_9arc_eager_4__pyx_unpickle_LeftArc(__pyx_self, __pyx_v___pyx_type, __pyx_v___pyx_checksum, __pyx_v___pyx_state);
/* function exit code */
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
static PyObject *__pyx_pf_5spacy_6syntax_9arc_eager_4__pyx_unpickle_LeftArc(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v___pyx_type, long __pyx_v___pyx_checksum, PyObject *__pyx_v___pyx_state) {
PyObject *__pyx_v___pyx_PickleError = 0;
PyObject *__pyx_v___pyx_result = 0;
PyObject *__pyx_r = NULL;
__Pyx_TraceDeclarations
__Pyx_RefNannyDeclarations
int __pyx_t_1;
PyObject *__pyx_t_2 = NULL;
PyObject *__pyx_t_3 = NULL;
PyObject *__pyx_t_4 = NULL;
PyObject *__pyx_t_5 = NULL;
int __pyx_t_6;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_TraceFrameInit(__pyx_codeobj__11)
__Pyx_RefNannySetupContext("__pyx_unpickle_LeftArc", 0);
__Pyx_TraceCall("__pyx_unpickle_LeftArc", __pyx_f[1], 1, 0, __PYX_ERR(1, 1, __pyx_L1_error));
/* "(tree fragment)":4
* cdef object __pyx_PickleError
* cdef object __pyx_result
* if __pyx_checksum != 0xd41d8cd: # <<<<<<<<<<<<<<
* from pickle import PickleError as __pyx_PickleError
* raise __pyx_PickleError("Incompatible checksums (%s vs 0xd41d8cd = ())" % __pyx_checksum)
*/
__pyx_t_1 = ((__pyx_v___pyx_checksum != 0xd41d8cd) != 0);
if (__pyx_t_1) {
/* "(tree fragment)":5
* cdef object __pyx_result
* if __pyx_checksum != 0xd41d8cd:
* from pickle import PickleError as __pyx_PickleError # <<<<<<<<<<<<<<
* raise __pyx_PickleError("Incompatible checksums (%s vs 0xd41d8cd = ())" % __pyx_checksum)
* __pyx_result = LeftArc.__new__(__pyx_type)
*/
__pyx_t_2 = PyList_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 5, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_INCREF(__pyx_n_s_PickleError);
__Pyx_GIVEREF(__pyx_n_s_PickleError);
PyList_SET_ITEM(__pyx_t_2, 0, __pyx_n_s_PickleError);
__pyx_t_3 = __Pyx_Import(__pyx_n_s_pickle, __pyx_t_2, -1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 5, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__pyx_t_2 = __Pyx_ImportFrom(__pyx_t_3, __pyx_n_s_PickleError); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 5, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_INCREF(__pyx_t_2);
__pyx_v___pyx_PickleError = __pyx_t_2;
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
/* "(tree fragment)":6
* if __pyx_checksum != 0xd41d8cd:
* from pickle import PickleError as __pyx_PickleError
* raise __pyx_PickleError("Incompatible checksums (%s vs 0xd41d8cd = ())" % __pyx_checksum) # <<<<<<<<<<<<<<
* __pyx_result = LeftArc.__new__(__pyx_type)
* if __pyx_state is not None:
*/
__pyx_t_2 = __Pyx_PyInt_From_long(__pyx_v___pyx_checksum); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 6, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__pyx_t_4 = __Pyx_PyString_Format(__pyx_kp_s_Incompatible_checksums_s_vs_0xd4, __pyx_t_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 6, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__Pyx_INCREF(__pyx_v___pyx_PickleError);
__pyx_t_2 = __pyx_v___pyx_PickleError; __pyx_t_5 = NULL;
if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) {
__pyx_t_5 = PyMethod_GET_SELF(__pyx_t_2);
if (likely(__pyx_t_5)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
__Pyx_INCREF(__pyx_t_5);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_2, function);
}
}
__pyx_t_3 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_5, __pyx_t_4) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_4);
__Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 6, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__Pyx_Raise(__pyx_t_3, 0, 0, 0);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__PYX_ERR(1, 6, __pyx_L1_error)
/* "(tree fragment)":4
* cdef object __pyx_PickleError
* cdef object __pyx_result
* if __pyx_checksum != 0xd41d8cd: # <<<<<<<<<<<<<<
* from pickle import PickleError as __pyx_PickleError
* raise __pyx_PickleError("Incompatible checksums (%s vs 0xd41d8cd = ())" % __pyx_checksum)
*/
}
/* "(tree fragment)":7
* from pickle import PickleError as __pyx_PickleError
* raise __pyx_PickleError("Incompatible checksums (%s vs 0xd41d8cd = ())" % __pyx_checksum)
* __pyx_result = LeftArc.__new__(__pyx_type) # <<<<<<<<<<<<<<
* if __pyx_state is not None:
* __pyx_unpickle_LeftArc__set_state(<LeftArc> __pyx_result, __pyx_state)
*/
__pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_ptype_5spacy_6syntax_9arc_eager_LeftArc), __pyx_n_s_new); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 7, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__pyx_t_4 = NULL;
if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
__pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2);
if (likely(__pyx_t_4)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
__Pyx_INCREF(__pyx_t_4);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_2, function);
}
}
__pyx_t_3 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_4, __pyx_v___pyx_type) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_v___pyx_type);
__Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 7, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__pyx_v___pyx_result = __pyx_t_3;
__pyx_t_3 = 0;
/* "(tree fragment)":8
* raise __pyx_PickleError("Incompatible checksums (%s vs 0xd41d8cd = ())" % __pyx_checksum)
* __pyx_result = LeftArc.__new__(__pyx_type)
* if __pyx_state is not None: # <<<<<<<<<<<<<<
* __pyx_unpickle_LeftArc__set_state(<LeftArc> __pyx_result, __pyx_state)
* return __pyx_result
*/
__pyx_t_1 = (__pyx_v___pyx_state != Py_None);
__pyx_t_6 = (__pyx_t_1 != 0);
if (__pyx_t_6) {
/* "(tree fragment)":9
* __pyx_result = LeftArc.__new__(__pyx_type)
* if __pyx_state is not None:
* __pyx_unpickle_LeftArc__set_state(<LeftArc> __pyx_result, __pyx_state) # <<<<<<<<<<<<<<
* return __pyx_result
* cdef __pyx_unpickle_LeftArc__set_state(LeftArc __pyx_result, tuple __pyx_state):
*/
if (!(likely(PyTuple_CheckExact(__pyx_v___pyx_state))||((__pyx_v___pyx_state) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "tuple", Py_TYPE(__pyx_v___pyx_state)->tp_name), 0))) __PYX_ERR(1, 9, __pyx_L1_error)
__pyx_t_3 = __pyx_f_5spacy_6syntax_9arc_eager___pyx_unpickle_LeftArc__set_state(((struct __pyx_obj_5spacy_6syntax_9arc_eager_LeftArc *)__pyx_v___pyx_result), ((PyObject*)__pyx_v___pyx_state)); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 9, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
/* "(tree fragment)":8
* raise __pyx_PickleError("Incompatible checksums (%s vs 0xd41d8cd = ())" % __pyx_checksum)
* __pyx_result = LeftArc.__new__(__pyx_type)
* if __pyx_state is not None: # <<<<<<<<<<<<<<
* __pyx_unpickle_LeftArc__set_state(<LeftArc> __pyx_result, __pyx_state)
* return __pyx_result
*/
}
/* "(tree fragment)":10
* if __pyx_state is not None:
* __pyx_unpickle_LeftArc__set_state(<LeftArc> __pyx_result, __pyx_state)
* return __pyx_result # <<<<<<<<<<<<<<
* cdef __pyx_unpickle_LeftArc__set_state(LeftArc __pyx_result, tuple __pyx_state):
* if len(__pyx_state) > 0 and hasattr(__pyx_result, '__dict__'):
*/
__Pyx_XDECREF(__pyx_r);
__Pyx_INCREF(__pyx_v___pyx_result);
__pyx_r = __pyx_v___pyx_result;
goto __pyx_L0;
/* "(tree fragment)":1
* def __pyx_unpickle_LeftArc(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<<
* cdef object __pyx_PickleError
* cdef object __pyx_result
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_2);
__Pyx_XDECREF(__pyx_t_3);
__Pyx_XDECREF(__pyx_t_4);
__Pyx_XDECREF(__pyx_t_5);
__Pyx_AddTraceback("spacy.syntax.arc_eager.__pyx_unpickle_LeftArc", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = NULL;
__pyx_L0:;
__Pyx_XDECREF(__pyx_v___pyx_PickleError);
__Pyx_XDECREF(__pyx_v___pyx_result);
__Pyx_XGIVEREF(__pyx_r);
__Pyx_TraceReturn(__pyx_r, 0);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "(tree fragment)":11
* __pyx_unpickle_LeftArc__set_state(<LeftArc> __pyx_result, __pyx_state)
* return __pyx_result
* cdef __pyx_unpickle_LeftArc__set_state(LeftArc __pyx_result, tuple __pyx_state): # <<<<<<<<<<<<<<
* if len(__pyx_state) > 0 and hasattr(__pyx_result, '__dict__'):
* __pyx_result.__dict__.update(__pyx_state[0])
*/
static PyObject *__pyx_f_5spacy_6syntax_9arc_eager___pyx_unpickle_LeftArc__set_state(struct __pyx_obj_5spacy_6syntax_9arc_eager_LeftArc *__pyx_v___pyx_result, PyObject *__pyx_v___pyx_state) {
PyObject *__pyx_r = NULL;
__Pyx_TraceDeclarations
__Pyx_RefNannyDeclarations
int __pyx_t_1;
Py_ssize_t __pyx_t_2;
int __pyx_t_3;
int __pyx_t_4;
PyObject *__pyx_t_5 = NULL;
PyObject *__pyx_t_6 = NULL;
PyObject *__pyx_t_7 = NULL;
PyObject *__pyx_t_8 = NULL;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("__pyx_unpickle_LeftArc__set_state", 0);
__Pyx_TraceCall("__pyx_unpickle_LeftArc__set_state", __pyx_f[1], 11, 0, __PYX_ERR(1, 11, __pyx_L1_error));
/* "(tree fragment)":12
* return __pyx_result
* cdef __pyx_unpickle_LeftArc__set_state(LeftArc __pyx_result, tuple __pyx_state):
* if len(__pyx_state) > 0 and hasattr(__pyx_result, '__dict__'): # <<<<<<<<<<<<<<
* __pyx_result.__dict__.update(__pyx_state[0])
*/
if (unlikely(__pyx_v___pyx_state == Py_None)) {
PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()");
__PYX_ERR(1, 12, __pyx_L1_error)
}
__pyx_t_2 = PyTuple_GET_SIZE(__pyx_v___pyx_state); if (unlikely(__pyx_t_2 == ((Py_ssize_t)-1))) __PYX_ERR(1, 12, __pyx_L1_error)
__pyx_t_3 = ((__pyx_t_2 > 0) != 0);
if (__pyx_t_3) {
} else {
__pyx_t_1 = __pyx_t_3;
goto __pyx_L4_bool_binop_done;
}
__pyx_t_3 = __Pyx_HasAttr(((PyObject *)__pyx_v___pyx_result), __pyx_n_s_dict); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(1, 12, __pyx_L1_error)
__pyx_t_4 = (__pyx_t_3 != 0);
__pyx_t_1 = __pyx_t_4;
__pyx_L4_bool_binop_done:;
if (__pyx_t_1) {
/* "(tree fragment)":13
* cdef __pyx_unpickle_LeftArc__set_state(LeftArc __pyx_result, tuple __pyx_state):
* if len(__pyx_state) > 0 and hasattr(__pyx_result, '__dict__'):
* __pyx_result.__dict__.update(__pyx_state[0]) # <<<<<<<<<<<<<<
*/
__pyx_t_6 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v___pyx_result), __pyx_n_s_dict); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 13, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_update); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 13, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
if (unlikely(__pyx_v___pyx_state == Py_None)) {
PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable");
__PYX_ERR(1, 13, __pyx_L1_error)
}
__pyx_t_6 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 13, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__pyx_t_8 = NULL;
if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_7))) {
__pyx_t_8 = PyMethod_GET_SELF(__pyx_t_7);
if (likely(__pyx_t_8)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7);
__Pyx_INCREF(__pyx_t_8);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_7, function);
}
}
__pyx_t_5 = (__pyx_t_8) ? __Pyx_PyObject_Call2Args(__pyx_t_7, __pyx_t_8, __pyx_t_6) : __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_6);
__Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 13, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
/* "(tree fragment)":12
* return __pyx_result
* cdef __pyx_unpickle_LeftArc__set_state(LeftArc __pyx_result, tuple __pyx_state):
* if len(__pyx_state) > 0 and hasattr(__pyx_result, '__dict__'): # <<<<<<<<<<<<<<
* __pyx_result.__dict__.update(__pyx_state[0])
*/
}
/* "(tree fragment)":11
* __pyx_unpickle_LeftArc__set_state(<LeftArc> __pyx_result, __pyx_state)
* return __pyx_result
* cdef __pyx_unpickle_LeftArc__set_state(LeftArc __pyx_result, tuple __pyx_state): # <<<<<<<<<<<<<<
* if len(__pyx_state) > 0 and hasattr(__pyx_result, '__dict__'):
* __pyx_result.__dict__.update(__pyx_state[0])
*/
/* function exit code */
__pyx_r = Py_None; __Pyx_INCREF(Py_None);
goto __pyx_L0;
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_5);
__Pyx_XDECREF(__pyx_t_6);
__Pyx_XDECREF(__pyx_t_7);
__Pyx_XDECREF(__pyx_t_8);
__Pyx_AddTraceback("spacy.syntax.arc_eager.__pyx_unpickle_LeftArc__set_state", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = 0;
__pyx_L0:;
__Pyx_XGIVEREF(__pyx_r);
__Pyx_TraceReturn(__pyx_r, 0);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "(tree fragment)":1
* def __pyx_unpickle_RightArc(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<<
* cdef object __pyx_PickleError
* cdef object __pyx_result
*/
/* Python wrapper */
static PyObject *__pyx_pw_5spacy_6syntax_9arc_eager_7__pyx_unpickle_RightArc(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static PyMethodDef __pyx_mdef_5spacy_6syntax_9arc_eager_7__pyx_unpickle_RightArc = {"__pyx_unpickle_RightArc", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5spacy_6syntax_9arc_eager_7__pyx_unpickle_RightArc, METH_VARARGS|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_5spacy_6syntax_9arc_eager_7__pyx_unpickle_RightArc(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
PyObject *__pyx_v___pyx_type = 0;
long __pyx_v___pyx_checksum;
PyObject *__pyx_v___pyx_state = 0;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
PyObject *__pyx_r = 0;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("__pyx_unpickle_RightArc (wrapper)", 0);
{
static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_type,&__pyx_n_s_pyx_checksum,&__pyx_n_s_pyx_state,0};
PyObject* values[3] = {0,0,0};
if (unlikely(__pyx_kwds)) {
Py_ssize_t kw_args;
const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
switch (pos_args) {
case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
CYTHON_FALLTHROUGH;
case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
CYTHON_FALLTHROUGH;
case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
CYTHON_FALLTHROUGH;
case 0: break;
default: goto __pyx_L5_argtuple_error;
}
kw_args = PyDict_Size(__pyx_kwds);
switch (pos_args) {
case 0:
if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_pyx_type)) != 0)) kw_args--;
else goto __pyx_L5_argtuple_error;
CYTHON_FALLTHROUGH;
case 1:
if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_pyx_checksum)) != 0)) kw_args--;
else {
__Pyx_RaiseArgtupleInvalid("__pyx_unpickle_RightArc", 1, 3, 3, 1); __PYX_ERR(1, 1, __pyx_L3_error)
}
CYTHON_FALLTHROUGH;
case 2:
if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_pyx_state)) != 0)) kw_args--;
else {
__Pyx_RaiseArgtupleInvalid("__pyx_unpickle_RightArc", 1, 3, 3, 2); __PYX_ERR(1, 1, __pyx_L3_error)
}
}
if (unlikely(kw_args > 0)) {
if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__pyx_unpickle_RightArc") < 0)) __PYX_ERR(1, 1, __pyx_L3_error)
}
} else if (PyTuple_GET_SIZE(__pyx_args) != 3) {
goto __pyx_L5_argtuple_error;
} else {
values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
}
__pyx_v___pyx_type = values[0];
__pyx_v___pyx_checksum = __Pyx_PyInt_As_long(values[1]); if (unlikely((__pyx_v___pyx_checksum == (long)-1) && PyErr_Occurred())) __PYX_ERR(1, 1, __pyx_L3_error)
__pyx_v___pyx_state = values[2];
}
goto __pyx_L4_argument_unpacking_done;
__pyx_L5_argtuple_error:;
__Pyx_RaiseArgtupleInvalid("__pyx_unpickle_RightArc", 1, 3, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 1, __pyx_L3_error)
__pyx_L3_error:;
__Pyx_AddTraceback("spacy.syntax.arc_eager.__pyx_unpickle_RightArc", __pyx_clineno, __pyx_lineno, __pyx_filename);
__Pyx_RefNannyFinishContext();
return NULL;
__pyx_L4_argument_unpacking_done:;
__pyx_r = __pyx_pf_5spacy_6syntax_9arc_eager_6__pyx_unpickle_RightArc(__pyx_self, __pyx_v___pyx_type, __pyx_v___pyx_checksum, __pyx_v___pyx_state);
/* function exit code */
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
static PyObject *__pyx_pf_5spacy_6syntax_9arc_eager_6__pyx_unpickle_RightArc(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v___pyx_type, long __pyx_v___pyx_checksum, PyObject *__pyx_v___pyx_state) {
PyObject *__pyx_v___pyx_PickleError = 0;
PyObject *__pyx_v___pyx_result = 0;
PyObject *__pyx_r = NULL;
__Pyx_TraceDeclarations
__Pyx_RefNannyDeclarations
int __pyx_t_1;
PyObject *__pyx_t_2 = NULL;
PyObject *__pyx_t_3 = NULL;
PyObject *__pyx_t_4 = NULL;
PyObject *__pyx_t_5 = NULL;
int __pyx_t_6;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_TraceFrameInit(__pyx_codeobj__12)
__Pyx_RefNannySetupContext("__pyx_unpickle_RightArc", 0);
__Pyx_TraceCall("__pyx_unpickle_RightArc", __pyx_f[1], 1, 0, __PYX_ERR(1, 1, __pyx_L1_error));
/* "(tree fragment)":4
* cdef object __pyx_PickleError
* cdef object __pyx_result
* if __pyx_checksum != 0xd41d8cd: # <<<<<<<<<<<<<<
* from pickle import PickleError as __pyx_PickleError
* raise __pyx_PickleError("Incompatible checksums (%s vs 0xd41d8cd = ())" % __pyx_checksum)
*/
__pyx_t_1 = ((__pyx_v___pyx_checksum != 0xd41d8cd) != 0);
if (__pyx_t_1) {
/* "(tree fragment)":5
* cdef object __pyx_result
* if __pyx_checksum != 0xd41d8cd:
* from pickle import PickleError as __pyx_PickleError # <<<<<<<<<<<<<<
* raise __pyx_PickleError("Incompatible checksums (%s vs 0xd41d8cd = ())" % __pyx_checksum)
* __pyx_result = RightArc.__new__(__pyx_type)
*/
__pyx_t_2 = PyList_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 5, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_INCREF(__pyx_n_s_PickleError);
__Pyx_GIVEREF(__pyx_n_s_PickleError);
PyList_SET_ITEM(__pyx_t_2, 0, __pyx_n_s_PickleError);
__pyx_t_3 = __Pyx_Import(__pyx_n_s_pickle, __pyx_t_2, -1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 5, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__pyx_t_2 = __Pyx_ImportFrom(__pyx_t_3, __pyx_n_s_PickleError); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 5, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_INCREF(__pyx_t_2);
__pyx_v___pyx_PickleError = __pyx_t_2;
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
/* "(tree fragment)":6
* if __pyx_checksum != 0xd41d8cd:
* from pickle import PickleError as __pyx_PickleError
* raise __pyx_PickleError("Incompatible checksums (%s vs 0xd41d8cd = ())" % __pyx_checksum) # <<<<<<<<<<<<<<
* __pyx_result = RightArc.__new__(__pyx_type)
* if __pyx_state is not None:
*/
__pyx_t_2 = __Pyx_PyInt_From_long(__pyx_v___pyx_checksum); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 6, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__pyx_t_4 = __Pyx_PyString_Format(__pyx_kp_s_Incompatible_checksums_s_vs_0xd4, __pyx_t_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 6, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__Pyx_INCREF(__pyx_v___pyx_PickleError);
__pyx_t_2 = __pyx_v___pyx_PickleError; __pyx_t_5 = NULL;
if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) {
__pyx_t_5 = PyMethod_GET_SELF(__pyx_t_2);
if (likely(__pyx_t_5)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
__Pyx_INCREF(__pyx_t_5);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_2, function);
}
}
__pyx_t_3 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_5, __pyx_t_4) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_4);
__Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 6, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__Pyx_Raise(__pyx_t_3, 0, 0, 0);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__PYX_ERR(1, 6, __pyx_L1_error)
/* "(tree fragment)":4
* cdef object __pyx_PickleError
* cdef object __pyx_result
* if __pyx_checksum != 0xd41d8cd: # <<<<<<<<<<<<<<
* from pickle import PickleError as __pyx_PickleError
* raise __pyx_PickleError("Incompatible checksums (%s vs 0xd41d8cd = ())" % __pyx_checksum)
*/
}
/* "(tree fragment)":7
* from pickle import PickleError as __pyx_PickleError
* raise __pyx_PickleError("Incompatible checksums (%s vs 0xd41d8cd = ())" % __pyx_checksum)
* __pyx_result = RightArc.__new__(__pyx_type) # <<<<<<<<<<<<<<
* if __pyx_state is not None:
* __pyx_unpickle_RightArc__set_state(<RightArc> __pyx_result, __pyx_state)
*/
__pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_ptype_5spacy_6syntax_9arc_eager_RightArc), __pyx_n_s_new); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 7, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__pyx_t_4 = NULL;
if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
__pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2);
if (likely(__pyx_t_4)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
__Pyx_INCREF(__pyx_t_4);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_2, function);
}
}
__pyx_t_3 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_4, __pyx_v___pyx_type) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_v___pyx_type);
__Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 7, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__pyx_v___pyx_result = __pyx_t_3;
__pyx_t_3 = 0;
/* "(tree fragment)":8
* raise __pyx_PickleError("Incompatible checksums (%s vs 0xd41d8cd = ())" % __pyx_checksum)
* __pyx_result = RightArc.__new__(__pyx_type)
* if __pyx_state is not None: # <<<<<<<<<<<<<<
* __pyx_unpickle_RightArc__set_state(<RightArc> __pyx_result, __pyx_state)
* return __pyx_result
*/
__pyx_t_1 = (__pyx_v___pyx_state != Py_None);
__pyx_t_6 = (__pyx_t_1 != 0);
if (__pyx_t_6) {
/* "(tree fragment)":9
* __pyx_result = RightArc.__new__(__pyx_type)
* if __pyx_state is not None:
* __pyx_unpickle_RightArc__set_state(<RightArc> __pyx_result, __pyx_state) # <<<<<<<<<<<<<<
* return __pyx_result
* cdef __pyx_unpickle_RightArc__set_state(RightArc __pyx_result, tuple __pyx_state):
*/
if (!(likely(PyTuple_CheckExact(__pyx_v___pyx_state))||((__pyx_v___pyx_state) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "tuple", Py_TYPE(__pyx_v___pyx_state)->tp_name), 0))) __PYX_ERR(1, 9, __pyx_L1_error)
__pyx_t_3 = __pyx_f_5spacy_6syntax_9arc_eager___pyx_unpickle_RightArc__set_state(((struct __pyx_obj_5spacy_6syntax_9arc_eager_RightArc *)__pyx_v___pyx_result), ((PyObject*)__pyx_v___pyx_state)); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 9, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
/* "(tree fragment)":8
* raise __pyx_PickleError("Incompatible checksums (%s vs 0xd41d8cd = ())" % __pyx_checksum)
* __pyx_result = RightArc.__new__(__pyx_type)
* if __pyx_state is not None: # <<<<<<<<<<<<<<
* __pyx_unpickle_RightArc__set_state(<RightArc> __pyx_result, __pyx_state)
* return __pyx_result
*/
}
/* "(tree fragment)":10
* if __pyx_state is not None:
* __pyx_unpickle_RightArc__set_state(<RightArc> __pyx_result, __pyx_state)
* return __pyx_result # <<<<<<<<<<<<<<
* cdef __pyx_unpickle_RightArc__set_state(RightArc __pyx_result, tuple __pyx_state):
* if len(__pyx_state) > 0 and hasattr(__pyx_result, '__dict__'):
*/
__Pyx_XDECREF(__pyx_r);
__Pyx_INCREF(__pyx_v___pyx_result);
__pyx_r = __pyx_v___pyx_result;
goto __pyx_L0;
/* "(tree fragment)":1
* def __pyx_unpickle_RightArc(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<<
* cdef object __pyx_PickleError
* cdef object __pyx_result
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_2);
__Pyx_XDECREF(__pyx_t_3);
__Pyx_XDECREF(__pyx_t_4);
__Pyx_XDECREF(__pyx_t_5);
__Pyx_AddTraceback("spacy.syntax.arc_eager.__pyx_unpickle_RightArc", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = NULL;
__pyx_L0:;
__Pyx_XDECREF(__pyx_v___pyx_PickleError);
__Pyx_XDECREF(__pyx_v___pyx_result);
__Pyx_XGIVEREF(__pyx_r);
__Pyx_TraceReturn(__pyx_r, 0);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "(tree fragment)":11
* __pyx_unpickle_RightArc__set_state(<RightArc> __pyx_result, __pyx_state)
* return __pyx_result
* cdef __pyx_unpickle_RightArc__set_state(RightArc __pyx_result, tuple __pyx_state): # <<<<<<<<<<<<<<
* if len(__pyx_state) > 0 and hasattr(__pyx_result, '__dict__'):
* __pyx_result.__dict__.update(__pyx_state[0])
*/
static PyObject *__pyx_f_5spacy_6syntax_9arc_eager___pyx_unpickle_RightArc__set_state(struct __pyx_obj_5spacy_6syntax_9arc_eager_RightArc *__pyx_v___pyx_result, PyObject *__pyx_v___pyx_state) {
PyObject *__pyx_r = NULL;
__Pyx_TraceDeclarations
__Pyx_RefNannyDeclarations
int __pyx_t_1;
Py_ssize_t __pyx_t_2;
int __pyx_t_3;
int __pyx_t_4;
PyObject *__pyx_t_5 = NULL;
PyObject *__pyx_t_6 = NULL;
PyObject *__pyx_t_7 = NULL;
PyObject *__pyx_t_8 = NULL;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("__pyx_unpickle_RightArc__set_state", 0);
__Pyx_TraceCall("__pyx_unpickle_RightArc__set_state", __pyx_f[1], 11, 0, __PYX_ERR(1, 11, __pyx_L1_error));
/* "(tree fragment)":12
* return __pyx_result
* cdef __pyx_unpickle_RightArc__set_state(RightArc __pyx_result, tuple __pyx_state):
* if len(__pyx_state) > 0 and hasattr(__pyx_result, '__dict__'): # <<<<<<<<<<<<<<
* __pyx_result.__dict__.update(__pyx_state[0])
*/
if (unlikely(__pyx_v___pyx_state == Py_None)) {
PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()");
__PYX_ERR(1, 12, __pyx_L1_error)
}
__pyx_t_2 = PyTuple_GET_SIZE(__pyx_v___pyx_state); if (unlikely(__pyx_t_2 == ((Py_ssize_t)-1))) __PYX_ERR(1, 12, __pyx_L1_error)
__pyx_t_3 = ((__pyx_t_2 > 0) != 0);
if (__pyx_t_3) {
} else {
__pyx_t_1 = __pyx_t_3;
goto __pyx_L4_bool_binop_done;
}
__pyx_t_3 = __Pyx_HasAttr(((PyObject *)__pyx_v___pyx_result), __pyx_n_s_dict); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(1, 12, __pyx_L1_error)
__pyx_t_4 = (__pyx_t_3 != 0);
__pyx_t_1 = __pyx_t_4;
__pyx_L4_bool_binop_done:;
if (__pyx_t_1) {
/* "(tree fragment)":13
* cdef __pyx_unpickle_RightArc__set_state(RightArc __pyx_result, tuple __pyx_state):
* if len(__pyx_state) > 0 and hasattr(__pyx_result, '__dict__'):
* __pyx_result.__dict__.update(__pyx_state[0]) # <<<<<<<<<<<<<<
*/
__pyx_t_6 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v___pyx_result), __pyx_n_s_dict); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 13, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_update); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 13, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
if (unlikely(__pyx_v___pyx_state == Py_None)) {
PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable");
__PYX_ERR(1, 13, __pyx_L1_error)
}
__pyx_t_6 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 13, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__pyx_t_8 = NULL;
if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_7))) {
__pyx_t_8 = PyMethod_GET_SELF(__pyx_t_7);
if (likely(__pyx_t_8)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7);
__Pyx_INCREF(__pyx_t_8);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_7, function);
}
}
__pyx_t_5 = (__pyx_t_8) ? __Pyx_PyObject_Call2Args(__pyx_t_7, __pyx_t_8, __pyx_t_6) : __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_6);
__Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 13, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
/* "(tree fragment)":12
* return __pyx_result
* cdef __pyx_unpickle_RightArc__set_state(RightArc __pyx_result, tuple __pyx_state):
* if len(__pyx_state) > 0 and hasattr(__pyx_result, '__dict__'): # <<<<<<<<<<<<<<
* __pyx_result.__dict__.update(__pyx_state[0])
*/
}
/* "(tree fragment)":11
* __pyx_unpickle_RightArc__set_state(<RightArc> __pyx_result, __pyx_state)
* return __pyx_result
* cdef __pyx_unpickle_RightArc__set_state(RightArc __pyx_result, tuple __pyx_state): # <<<<<<<<<<<<<<
* if len(__pyx_state) > 0 and hasattr(__pyx_result, '__dict__'):
* __pyx_result.__dict__.update(__pyx_state[0])
*/
/* function exit code */
__pyx_r = Py_None; __Pyx_INCREF(Py_None);
goto __pyx_L0;
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_5);
__Pyx_XDECREF(__pyx_t_6);
__Pyx_XDECREF(__pyx_t_7);
__Pyx_XDECREF(__pyx_t_8);
__Pyx_AddTraceback("spacy.syntax.arc_eager.__pyx_unpickle_RightArc__set_state", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = 0;
__pyx_L0:;
__Pyx_XGIVEREF(__pyx_r);
__Pyx_TraceReturn(__pyx_r, 0);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "(tree fragment)":1
* def __pyx_unpickle_Break(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<<
* cdef object __pyx_PickleError
* cdef object __pyx_result
*/
/* Python wrapper */
static PyObject *__pyx_pw_5spacy_6syntax_9arc_eager_9__pyx_unpickle_Break(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static PyMethodDef __pyx_mdef_5spacy_6syntax_9arc_eager_9__pyx_unpickle_Break = {"__pyx_unpickle_Break", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5spacy_6syntax_9arc_eager_9__pyx_unpickle_Break, METH_VARARGS|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_5spacy_6syntax_9arc_eager_9__pyx_unpickle_Break(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
PyObject *__pyx_v___pyx_type = 0;
long __pyx_v___pyx_checksum;
PyObject *__pyx_v___pyx_state = 0;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
PyObject *__pyx_r = 0;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("__pyx_unpickle_Break (wrapper)", 0);
{
static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_type,&__pyx_n_s_pyx_checksum,&__pyx_n_s_pyx_state,0};
PyObject* values[3] = {0,0,0};
if (unlikely(__pyx_kwds)) {
Py_ssize_t kw_args;
const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
switch (pos_args) {
case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
CYTHON_FALLTHROUGH;
case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
CYTHON_FALLTHROUGH;
case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
CYTHON_FALLTHROUGH;
case 0: break;
default: goto __pyx_L5_argtuple_error;
}
kw_args = PyDict_Size(__pyx_kwds);
switch (pos_args) {
case 0:
if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_pyx_type)) != 0)) kw_args--;
else goto __pyx_L5_argtuple_error;
CYTHON_FALLTHROUGH;
case 1:
if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_pyx_checksum)) != 0)) kw_args--;
else {
__Pyx_RaiseArgtupleInvalid("__pyx_unpickle_Break", 1, 3, 3, 1); __PYX_ERR(1, 1, __pyx_L3_error)
}
CYTHON_FALLTHROUGH;
case 2:
if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_pyx_state)) != 0)) kw_args--;
else {
__Pyx_RaiseArgtupleInvalid("__pyx_unpickle_Break", 1, 3, 3, 2); __PYX_ERR(1, 1, __pyx_L3_error)
}
}
if (unlikely(kw_args > 0)) {
if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__pyx_unpickle_Break") < 0)) __PYX_ERR(1, 1, __pyx_L3_error)
}
} else if (PyTuple_GET_SIZE(__pyx_args) != 3) {
goto __pyx_L5_argtuple_error;
} else {
values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
}
__pyx_v___pyx_type = values[0];
__pyx_v___pyx_checksum = __Pyx_PyInt_As_long(values[1]); if (unlikely((__pyx_v___pyx_checksum == (long)-1) && PyErr_Occurred())) __PYX_ERR(1, 1, __pyx_L3_error)
__pyx_v___pyx_state = values[2];
}
goto __pyx_L4_argument_unpacking_done;
__pyx_L5_argtuple_error:;
__Pyx_RaiseArgtupleInvalid("__pyx_unpickle_Break", 1, 3, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 1, __pyx_L3_error)
__pyx_L3_error:;
__Pyx_AddTraceback("spacy.syntax.arc_eager.__pyx_unpickle_Break", __pyx_clineno, __pyx_lineno, __pyx_filename);
__Pyx_RefNannyFinishContext();
return NULL;
__pyx_L4_argument_unpacking_done:;
__pyx_r = __pyx_pf_5spacy_6syntax_9arc_eager_8__pyx_unpickle_Break(__pyx_self, __pyx_v___pyx_type, __pyx_v___pyx_checksum, __pyx_v___pyx_state);
/* function exit code */
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
static PyObject *__pyx_pf_5spacy_6syntax_9arc_eager_8__pyx_unpickle_Break(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v___pyx_type, long __pyx_v___pyx_checksum, PyObject *__pyx_v___pyx_state) {
PyObject *__pyx_v___pyx_PickleError = 0;
PyObject *__pyx_v___pyx_result = 0;
PyObject *__pyx_r = NULL;
__Pyx_TraceDeclarations
__Pyx_RefNannyDeclarations
int __pyx_t_1;
PyObject *__pyx_t_2 = NULL;
PyObject *__pyx_t_3 = NULL;
PyObject *__pyx_t_4 = NULL;
PyObject *__pyx_t_5 = NULL;
int __pyx_t_6;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_TraceFrameInit(__pyx_codeobj__13)
__Pyx_RefNannySetupContext("__pyx_unpickle_Break", 0);
__Pyx_TraceCall("__pyx_unpickle_Break", __pyx_f[1], 1, 0, __PYX_ERR(1, 1, __pyx_L1_error));
/* "(tree fragment)":4
* cdef object __pyx_PickleError
* cdef object __pyx_result
* if __pyx_checksum != 0xd41d8cd: # <<<<<<<<<<<<<<
* from pickle import PickleError as __pyx_PickleError
* raise __pyx_PickleError("Incompatible checksums (%s vs 0xd41d8cd = ())" % __pyx_checksum)
*/
__pyx_t_1 = ((__pyx_v___pyx_checksum != 0xd41d8cd) != 0);
if (__pyx_t_1) {
/* "(tree fragment)":5
* cdef object __pyx_result
* if __pyx_checksum != 0xd41d8cd:
* from pickle import PickleError as __pyx_PickleError # <<<<<<<<<<<<<<
* raise __pyx_PickleError("Incompatible checksums (%s vs 0xd41d8cd = ())" % __pyx_checksum)
* __pyx_result = Break.__new__(__pyx_type)
*/
__pyx_t_2 = PyList_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 5, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_INCREF(__pyx_n_s_PickleError);
__Pyx_GIVEREF(__pyx_n_s_PickleError);
PyList_SET_ITEM(__pyx_t_2, 0, __pyx_n_s_PickleError);
__pyx_t_3 = __Pyx_Import(__pyx_n_s_pickle, __pyx_t_2, -1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 5, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__pyx_t_2 = __Pyx_ImportFrom(__pyx_t_3, __pyx_n_s_PickleError); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 5, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_INCREF(__pyx_t_2);
__pyx_v___pyx_PickleError = __pyx_t_2;
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
/* "(tree fragment)":6
* if __pyx_checksum != 0xd41d8cd:
* from pickle import PickleError as __pyx_PickleError
* raise __pyx_PickleError("Incompatible checksums (%s vs 0xd41d8cd = ())" % __pyx_checksum) # <<<<<<<<<<<<<<
* __pyx_result = Break.__new__(__pyx_type)
* if __pyx_state is not None:
*/
__pyx_t_2 = __Pyx_PyInt_From_long(__pyx_v___pyx_checksum); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 6, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__pyx_t_4 = __Pyx_PyString_Format(__pyx_kp_s_Incompatible_checksums_s_vs_0xd4, __pyx_t_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 6, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__Pyx_INCREF(__pyx_v___pyx_PickleError);
__pyx_t_2 = __pyx_v___pyx_PickleError; __pyx_t_5 = NULL;
if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) {
__pyx_t_5 = PyMethod_GET_SELF(__pyx_t_2);
if (likely(__pyx_t_5)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
__Pyx_INCREF(__pyx_t_5);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_2, function);
}
}
__pyx_t_3 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_5, __pyx_t_4) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_4);
__Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 6, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__Pyx_Raise(__pyx_t_3, 0, 0, 0);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__PYX_ERR(1, 6, __pyx_L1_error)
/* "(tree fragment)":4
* cdef object __pyx_PickleError
* cdef object __pyx_result
* if __pyx_checksum != 0xd41d8cd: # <<<<<<<<<<<<<<
* from pickle import PickleError as __pyx_PickleError
* raise __pyx_PickleError("Incompatible checksums (%s vs 0xd41d8cd = ())" % __pyx_checksum)
*/
}
/* "(tree fragment)":7
* from pickle import PickleError as __pyx_PickleError
* raise __pyx_PickleError("Incompatible checksums (%s vs 0xd41d8cd = ())" % __pyx_checksum)
* __pyx_result = Break.__new__(__pyx_type) # <<<<<<<<<<<<<<
* if __pyx_state is not None:
* __pyx_unpickle_Break__set_state(<Break> __pyx_result, __pyx_state)
*/
__pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_ptype_5spacy_6syntax_9arc_eager_Break), __pyx_n_s_new); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 7, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__pyx_t_4 = NULL;
if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
__pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2);
if (likely(__pyx_t_4)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
__Pyx_INCREF(__pyx_t_4);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_2, function);
}
}
__pyx_t_3 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_4, __pyx_v___pyx_type) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_v___pyx_type);
__Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 7, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__pyx_v___pyx_result = __pyx_t_3;
__pyx_t_3 = 0;
/* "(tree fragment)":8
* raise __pyx_PickleError("Incompatible checksums (%s vs 0xd41d8cd = ())" % __pyx_checksum)
* __pyx_result = Break.__new__(__pyx_type)
* if __pyx_state is not None: # <<<<<<<<<<<<<<
* __pyx_unpickle_Break__set_state(<Break> __pyx_result, __pyx_state)
* return __pyx_result
*/
__pyx_t_1 = (__pyx_v___pyx_state != Py_None);
__pyx_t_6 = (__pyx_t_1 != 0);
if (__pyx_t_6) {
/* "(tree fragment)":9
* __pyx_result = Break.__new__(__pyx_type)
* if __pyx_state is not None:
* __pyx_unpickle_Break__set_state(<Break> __pyx_result, __pyx_state) # <<<<<<<<<<<<<<
* return __pyx_result
* cdef __pyx_unpickle_Break__set_state(Break __pyx_result, tuple __pyx_state):
*/
if (!(likely(PyTuple_CheckExact(__pyx_v___pyx_state))||((__pyx_v___pyx_state) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "tuple", Py_TYPE(__pyx_v___pyx_state)->tp_name), 0))) __PYX_ERR(1, 9, __pyx_L1_error)
__pyx_t_3 = __pyx_f_5spacy_6syntax_9arc_eager___pyx_unpickle_Break__set_state(((struct __pyx_obj_5spacy_6syntax_9arc_eager_Break *)__pyx_v___pyx_result), ((PyObject*)__pyx_v___pyx_state)); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 9, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
/* "(tree fragment)":8
* raise __pyx_PickleError("Incompatible checksums (%s vs 0xd41d8cd = ())" % __pyx_checksum)
* __pyx_result = Break.__new__(__pyx_type)
* if __pyx_state is not None: # <<<<<<<<<<<<<<
* __pyx_unpickle_Break__set_state(<Break> __pyx_result, __pyx_state)
* return __pyx_result
*/
}
/* "(tree fragment)":10
* if __pyx_state is not None:
* __pyx_unpickle_Break__set_state(<Break> __pyx_result, __pyx_state)
* return __pyx_result # <<<<<<<<<<<<<<
* cdef __pyx_unpickle_Break__set_state(Break __pyx_result, tuple __pyx_state):
* if len(__pyx_state) > 0 and hasattr(__pyx_result, '__dict__'):
*/
__Pyx_XDECREF(__pyx_r);
__Pyx_INCREF(__pyx_v___pyx_result);
__pyx_r = __pyx_v___pyx_result;
goto __pyx_L0;
/* "(tree fragment)":1
* def __pyx_unpickle_Break(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<<
* cdef object __pyx_PickleError
* cdef object __pyx_result
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_2);
__Pyx_XDECREF(__pyx_t_3);
__Pyx_XDECREF(__pyx_t_4);
__Pyx_XDECREF(__pyx_t_5);
__Pyx_AddTraceback("spacy.syntax.arc_eager.__pyx_unpickle_Break", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = NULL;
__pyx_L0:;
__Pyx_XDECREF(__pyx_v___pyx_PickleError);
__Pyx_XDECREF(__pyx_v___pyx_result);
__Pyx_XGIVEREF(__pyx_r);
__Pyx_TraceReturn(__pyx_r, 0);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "(tree fragment)":11
* __pyx_unpickle_Break__set_state(<Break> __pyx_result, __pyx_state)
* return __pyx_result
* cdef __pyx_unpickle_Break__set_state(Break __pyx_result, tuple __pyx_state): # <<<<<<<<<<<<<<
* if len(__pyx_state) > 0 and hasattr(__pyx_result, '__dict__'):
* __pyx_result.__dict__.update(__pyx_state[0])
*/
static PyObject *__pyx_f_5spacy_6syntax_9arc_eager___pyx_unpickle_Break__set_state(struct __pyx_obj_5spacy_6syntax_9arc_eager_Break *__pyx_v___pyx_result, PyObject *__pyx_v___pyx_state) {
PyObject *__pyx_r = NULL;
__Pyx_TraceDeclarations
__Pyx_RefNannyDeclarations
int __pyx_t_1;
Py_ssize_t __pyx_t_2;
int __pyx_t_3;
int __pyx_t_4;
PyObject *__pyx_t_5 = NULL;
PyObject *__pyx_t_6 = NULL;
PyObject *__pyx_t_7 = NULL;
PyObject *__pyx_t_8 = NULL;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("__pyx_unpickle_Break__set_state", 0);
__Pyx_TraceCall("__pyx_unpickle_Break__set_state", __pyx_f[1], 11, 0, __PYX_ERR(1, 11, __pyx_L1_error));
/* "(tree fragment)":12
* return __pyx_result
* cdef __pyx_unpickle_Break__set_state(Break __pyx_result, tuple __pyx_state):
* if len(__pyx_state) > 0 and hasattr(__pyx_result, '__dict__'): # <<<<<<<<<<<<<<
* __pyx_result.__dict__.update(__pyx_state[0])
*/
if (unlikely(__pyx_v___pyx_state == Py_None)) {
PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()");
__PYX_ERR(1, 12, __pyx_L1_error)
}
__pyx_t_2 = PyTuple_GET_SIZE(__pyx_v___pyx_state); if (unlikely(__pyx_t_2 == ((Py_ssize_t)-1))) __PYX_ERR(1, 12, __pyx_L1_error)
__pyx_t_3 = ((__pyx_t_2 > 0) != 0);
if (__pyx_t_3) {
} else {
__pyx_t_1 = __pyx_t_3;
goto __pyx_L4_bool_binop_done;
}
__pyx_t_3 = __Pyx_HasAttr(((PyObject *)__pyx_v___pyx_result), __pyx_n_s_dict); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(1, 12, __pyx_L1_error)
__pyx_t_4 = (__pyx_t_3 != 0);
__pyx_t_1 = __pyx_t_4;
__pyx_L4_bool_binop_done:;
if (__pyx_t_1) {
/* "(tree fragment)":13
* cdef __pyx_unpickle_Break__set_state(Break __pyx_result, tuple __pyx_state):
* if len(__pyx_state) > 0 and hasattr(__pyx_result, '__dict__'):
* __pyx_result.__dict__.update(__pyx_state[0]) # <<<<<<<<<<<<<<
*/
__pyx_t_6 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v___pyx_result), __pyx_n_s_dict); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 13, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_update); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 13, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
if (unlikely(__pyx_v___pyx_state == Py_None)) {
PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable");
__PYX_ERR(1, 13, __pyx_L1_error)
}
__pyx_t_6 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 13, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__pyx_t_8 = NULL;
if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_7))) {
__pyx_t_8 = PyMethod_GET_SELF(__pyx_t_7);
if (likely(__pyx_t_8)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7);
__Pyx_INCREF(__pyx_t_8);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_7, function);
}
}
__pyx_t_5 = (__pyx_t_8) ? __Pyx_PyObject_Call2Args(__pyx_t_7, __pyx_t_8, __pyx_t_6) : __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_6);
__Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 13, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
/* "(tree fragment)":12
* return __pyx_result
* cdef __pyx_unpickle_Break__set_state(Break __pyx_result, tuple __pyx_state):
* if len(__pyx_state) > 0 and hasattr(__pyx_result, '__dict__'): # <<<<<<<<<<<<<<
* __pyx_result.__dict__.update(__pyx_state[0])
*/
}
/* "(tree fragment)":11
* __pyx_unpickle_Break__set_state(<Break> __pyx_result, __pyx_state)
* return __pyx_result
* cdef __pyx_unpickle_Break__set_state(Break __pyx_result, tuple __pyx_state): # <<<<<<<<<<<<<<
* if len(__pyx_state) > 0 and hasattr(__pyx_result, '__dict__'):
* __pyx_result.__dict__.update(__pyx_state[0])
*/
/* function exit code */
__pyx_r = Py_None; __Pyx_INCREF(Py_None);
goto __pyx_L0;
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_5);
__Pyx_XDECREF(__pyx_t_6);
__Pyx_XDECREF(__pyx_t_7);
__Pyx_XDECREF(__pyx_t_8);
__Pyx_AddTraceback("spacy.syntax.arc_eager.__pyx_unpickle_Break__set_state", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = 0;
__pyx_L0:;
__Pyx_XGIVEREF(__pyx_r);
__Pyx_TraceReturn(__pyx_r, 0);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "../../../../opt/python/cp37-cp37m/lib/python3.7/site-packages/numpy/__init__.pxd":742
* ctypedef npy_cdouble complex_t
*
* cdef inline object PyArray_MultiIterNew1(a): # <<<<<<<<<<<<<<
* return PyArray_MultiIterNew(1, <void*>a)
*
*/
static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew1(PyObject *__pyx_v_a) {
PyObject *__pyx_r = NULL;
__Pyx_TraceDeclarations
__Pyx_RefNannyDeclarations
PyObject *__pyx_t_1 = NULL;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("PyArray_MultiIterNew1", 0);
__Pyx_TraceCall("PyArray_MultiIterNew1", __pyx_f[2], 742, 0, __PYX_ERR(2, 742, __pyx_L1_error));
/* "../../../../opt/python/cp37-cp37m/lib/python3.7/site-packages/numpy/__init__.pxd":743
*
* cdef inline object PyArray_MultiIterNew1(a):
* return PyArray_MultiIterNew(1, <void*>a) # <<<<<<<<<<<<<<
*
* cdef inline object PyArray_MultiIterNew2(a, b):
*/
__Pyx_XDECREF(__pyx_r);
__pyx_t_1 = PyArray_MultiIterNew(1, ((void *)__pyx_v_a)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 743, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_r = __pyx_t_1;
__pyx_t_1 = 0;
goto __pyx_L0;
/* "../../../../opt/python/cp37-cp37m/lib/python3.7/site-packages/numpy/__init__.pxd":742
* ctypedef npy_cdouble complex_t
*
* cdef inline object PyArray_MultiIterNew1(a): # <<<<<<<<<<<<<<
* return PyArray_MultiIterNew(1, <void*>a)
*
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_1);
__Pyx_AddTraceback("numpy.PyArray_MultiIterNew1", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = 0;
__pyx_L0:;
__Pyx_XGIVEREF(__pyx_r);
__Pyx_TraceReturn(__pyx_r, 0);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "../../../../opt/python/cp37-cp37m/lib/python3.7/site-packages/numpy/__init__.pxd":745
* return PyArray_MultiIterNew(1, <void*>a)
*
* cdef inline object PyArray_MultiIterNew2(a, b): # <<<<<<<<<<<<<<
* return PyArray_MultiIterNew(2, <void*>a, <void*>b)
*
*/
static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew2(PyObject *__pyx_v_a, PyObject *__pyx_v_b) {
PyObject *__pyx_r = NULL;
__Pyx_TraceDeclarations
__Pyx_RefNannyDeclarations
PyObject *__pyx_t_1 = NULL;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("PyArray_MultiIterNew2", 0);
__Pyx_TraceCall("PyArray_MultiIterNew2", __pyx_f[2], 745, 0, __PYX_ERR(2, 745, __pyx_L1_error));
/* "../../../../opt/python/cp37-cp37m/lib/python3.7/site-packages/numpy/__init__.pxd":746
*
* cdef inline object PyArray_MultiIterNew2(a, b):
* return PyArray_MultiIterNew(2, <void*>a, <void*>b) # <<<<<<<<<<<<<<
*
* cdef inline object PyArray_MultiIterNew3(a, b, c):
*/
__Pyx_XDECREF(__pyx_r);
__pyx_t_1 = PyArray_MultiIterNew(2, ((void *)__pyx_v_a), ((void *)__pyx_v_b)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 746, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_r = __pyx_t_1;
__pyx_t_1 = 0;
goto __pyx_L0;
/* "../../../../opt/python/cp37-cp37m/lib/python3.7/site-packages/numpy/__init__.pxd":745
* return PyArray_MultiIterNew(1, <void*>a)
*
* cdef inline object PyArray_MultiIterNew2(a, b): # <<<<<<<<<<<<<<
* return PyArray_MultiIterNew(2, <void*>a, <void*>b)
*
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_1);
__Pyx_AddTraceback("numpy.PyArray_MultiIterNew2", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = 0;
__pyx_L0:;
__Pyx_XGIVEREF(__pyx_r);
__Pyx_TraceReturn(__pyx_r, 0);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "../../../../opt/python/cp37-cp37m/lib/python3.7/site-packages/numpy/__init__.pxd":748
* return PyArray_MultiIterNew(2, <void*>a, <void*>b)
*
* cdef inline object PyArray_MultiIterNew3(a, b, c): # <<<<<<<<<<<<<<
* return PyArray_MultiIterNew(3, <void*>a, <void*>b, <void*> c)
*
*/
static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew3(PyObject *__pyx_v_a, PyObject *__pyx_v_b, PyObject *__pyx_v_c) {
PyObject *__pyx_r = NULL;
__Pyx_TraceDeclarations
__Pyx_RefNannyDeclarations
PyObject *__pyx_t_1 = NULL;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("PyArray_MultiIterNew3", 0);
__Pyx_TraceCall("PyArray_MultiIterNew3", __pyx_f[2], 748, 0, __PYX_ERR(2, 748, __pyx_L1_error));
/* "../../../../opt/python/cp37-cp37m/lib/python3.7/site-packages/numpy/__init__.pxd":749
*
* cdef inline object PyArray_MultiIterNew3(a, b, c):
* return PyArray_MultiIterNew(3, <void*>a, <void*>b, <void*> c) # <<<<<<<<<<<<<<
*
* cdef inline object PyArray_MultiIterNew4(a, b, c, d):
*/
__Pyx_XDECREF(__pyx_r);
__pyx_t_1 = PyArray_MultiIterNew(3, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 749, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_r = __pyx_t_1;
__pyx_t_1 = 0;
goto __pyx_L0;
/* "../../../../opt/python/cp37-cp37m/lib/python3.7/site-packages/numpy/__init__.pxd":748
* return PyArray_MultiIterNew(2, <void*>a, <void*>b)
*
* cdef inline object PyArray_MultiIterNew3(a, b, c): # <<<<<<<<<<<<<<
* return PyArray_MultiIterNew(3, <void*>a, <void*>b, <void*> c)
*
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_1);
__Pyx_AddTraceback("numpy.PyArray_MultiIterNew3", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = 0;
__pyx_L0:;
__Pyx_XGIVEREF(__pyx_r);
__Pyx_TraceReturn(__pyx_r, 0);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "../../../../opt/python/cp37-cp37m/lib/python3.7/site-packages/numpy/__init__.pxd":751
* return PyArray_MultiIterNew(3, <void*>a, <void*>b, <void*> c)
*
* cdef inline object PyArray_MultiIterNew4(a, b, c, d): # <<<<<<<<<<<<<<
* return PyArray_MultiIterNew(4, <void*>a, <void*>b, <void*>c, <void*> d)
*
*/
static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew4(PyObject *__pyx_v_a, PyObject *__pyx_v_b, PyObject *__pyx_v_c, PyObject *__pyx_v_d) {
PyObject *__pyx_r = NULL;
__Pyx_TraceDeclarations
__Pyx_RefNannyDeclarations
PyObject *__pyx_t_1 = NULL;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("PyArray_MultiIterNew4", 0);
__Pyx_TraceCall("PyArray_MultiIterNew4", __pyx_f[2], 751, 0, __PYX_ERR(2, 751, __pyx_L1_error));
/* "../../../../opt/python/cp37-cp37m/lib/python3.7/site-packages/numpy/__init__.pxd":752
*
* cdef inline object PyArray_MultiIterNew4(a, b, c, d):
* return PyArray_MultiIterNew(4, <void*>a, <void*>b, <void*>c, <void*> d) # <<<<<<<<<<<<<<
*
* cdef inline object PyArray_MultiIterNew5(a, b, c, d, e):
*/
__Pyx_XDECREF(__pyx_r);
__pyx_t_1 = PyArray_MultiIterNew(4, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c), ((void *)__pyx_v_d)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 752, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_r = __pyx_t_1;
__pyx_t_1 = 0;
goto __pyx_L0;
/* "../../../../opt/python/cp37-cp37m/lib/python3.7/site-packages/numpy/__init__.pxd":751
* return PyArray_MultiIterNew(3, <void*>a, <void*>b, <void*> c)
*
* cdef inline object PyArray_MultiIterNew4(a, b, c, d): # <<<<<<<<<<<<<<
* return PyArray_MultiIterNew(4, <void*>a, <void*>b, <void*>c, <void*> d)
*
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_1);
__Pyx_AddTraceback("numpy.PyArray_MultiIterNew4", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = 0;
__pyx_L0:;
__Pyx_XGIVEREF(__pyx_r);
__Pyx_TraceReturn(__pyx_r, 0);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "../../../../opt/python/cp37-cp37m/lib/python3.7/site-packages/numpy/__init__.pxd":754
* return PyArray_MultiIterNew(4, <void*>a, <void*>b, <void*>c, <void*> d)
*
* cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): # <<<<<<<<<<<<<<
* return PyArray_MultiIterNew(5, <void*>a, <void*>b, <void*>c, <void*> d, <void*> e)
*
*/
static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew5(PyObject *__pyx_v_a, PyObject *__pyx_v_b, PyObject *__pyx_v_c, PyObject *__pyx_v_d, PyObject *__pyx_v_e) {
PyObject *__pyx_r = NULL;
__Pyx_TraceDeclarations
__Pyx_RefNannyDeclarations
PyObject *__pyx_t_1 = NULL;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("PyArray_MultiIterNew5", 0);
__Pyx_TraceCall("PyArray_MultiIterNew5", __pyx_f[2], 754, 0, __PYX_ERR(2, 754, __pyx_L1_error));
/* "../../../../opt/python/cp37-cp37m/lib/python3.7/site-packages/numpy/__init__.pxd":755
*
* cdef inline object PyArray_MultiIterNew5(a, b, c, d, e):
* return PyArray_MultiIterNew(5, <void*>a, <void*>b, <void*>c, <void*> d, <void*> e) # <<<<<<<<<<<<<<
*
* cdef inline tuple PyDataType_SHAPE(dtype d):
*/
__Pyx_XDECREF(__pyx_r);
__pyx_t_1 = PyArray_MultiIterNew(5, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c), ((void *)__pyx_v_d), ((void *)__pyx_v_e)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 755, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_r = __pyx_t_1;
__pyx_t_1 = 0;
goto __pyx_L0;
/* "../../../../opt/python/cp37-cp37m/lib/python3.7/site-packages/numpy/__init__.pxd":754
* return PyArray_MultiIterNew(4, <void*>a, <void*>b, <void*>c, <void*> d)
*
* cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): # <<<<<<<<<<<<<<
* return PyArray_MultiIterNew(5, <void*>a, <void*>b, <void*>c, <void*> d, <void*> e)
*
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_1);
__Pyx_AddTraceback("numpy.PyArray_MultiIterNew5", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = 0;
__pyx_L0:;
__Pyx_XGIVEREF(__pyx_r);
__Pyx_TraceReturn(__pyx_r, 0);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "../../../../opt/python/cp37-cp37m/lib/python3.7/site-packages/numpy/__init__.pxd":757
* return PyArray_MultiIterNew(5, <void*>a, <void*>b, <void*>c, <void*> d, <void*> e)
*
* cdef inline tuple PyDataType_SHAPE(dtype d): # <<<<<<<<<<<<<<
* if PyDataType_HASSUBARRAY(d):
* return <tuple>d.subarray.shape
*/
static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyDataType_SHAPE(PyArray_Descr *__pyx_v_d) {
PyObject *__pyx_r = NULL;
__Pyx_TraceDeclarations
__Pyx_RefNannyDeclarations
int __pyx_t_1;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("PyDataType_SHAPE", 0);
__Pyx_TraceCall("PyDataType_SHAPE", __pyx_f[2], 757, 0, __PYX_ERR(2, 757, __pyx_L1_error));
/* "../../../../opt/python/cp37-cp37m/lib/python3.7/site-packages/numpy/__init__.pxd":758
*
* cdef inline tuple PyDataType_SHAPE(dtype d):
* if PyDataType_HASSUBARRAY(d): # <<<<<<<<<<<<<<
* return <tuple>d.subarray.shape
* else:
*/
__pyx_t_1 = (PyDataType_HASSUBARRAY(__pyx_v_d) != 0);
if (__pyx_t_1) {
/* "../../../../opt/python/cp37-cp37m/lib/python3.7/site-packages/numpy/__init__.pxd":759
* cdef inline tuple PyDataType_SHAPE(dtype d):
* if PyDataType_HASSUBARRAY(d):
* return <tuple>d.subarray.shape # <<<<<<<<<<<<<<
* else:
* return ()
*/
__Pyx_XDECREF(__pyx_r);
__Pyx_INCREF(((PyObject*)__pyx_v_d->subarray->shape));
__pyx_r = ((PyObject*)__pyx_v_d->subarray->shape);
goto __pyx_L0;
/* "../../../../opt/python/cp37-cp37m/lib/python3.7/site-packages/numpy/__init__.pxd":758
*
* cdef inline tuple PyDataType_SHAPE(dtype d):
* if PyDataType_HASSUBARRAY(d): # <<<<<<<<<<<<<<
* return <tuple>d.subarray.shape
* else:
*/
}
/* "../../../../opt/python/cp37-cp37m/lib/python3.7/site-packages/numpy/__init__.pxd":761
* return <tuple>d.subarray.shape
* else:
* return () # <<<<<<<<<<<<<<
*
* cdef inline char* _util_dtypestring(dtype descr, char* f, char* end, int* offset) except NULL:
*/
/*else*/ {
__Pyx_XDECREF(__pyx_r);
__Pyx_INCREF(__pyx_empty_tuple);
__pyx_r = __pyx_empty_tuple;
goto __pyx_L0;
}
/* "../../../../opt/python/cp37-cp37m/lib/python3.7/site-packages/numpy/__init__.pxd":757
* return PyArray_MultiIterNew(5, <void*>a, <void*>b, <void*>c, <void*> d, <void*> e)
*
* cdef inline tuple PyDataType_SHAPE(dtype d): # <<<<<<<<<<<<<<
* if PyDataType_HASSUBARRAY(d):
* return <tuple>d.subarray.shape
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_AddTraceback("numpy.PyDataType_SHAPE", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = 0;
__pyx_L0:;
__Pyx_XGIVEREF(__pyx_r);
__Pyx_TraceReturn(__pyx_r, 0);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "../../../../opt/python/cp37-cp37m/lib/python3.7/site-packages/numpy/__init__.pxd":763
* return ()
*
* cdef inline char* _util_dtypestring(dtype descr, char* f, char* end, int* offset) except NULL: # <<<<<<<<<<<<<<
* # Recursive utility function used in __getbuffer__ to get format
* # string. The new location in the format string is returned.
*/
static CYTHON_INLINE char *__pyx_f_5numpy__util_dtypestring(PyArray_Descr *__pyx_v_descr, char *__pyx_v_f, char *__pyx_v_end, int *__pyx_v_offset) {
PyArray_Descr *__pyx_v_child = 0;
int __pyx_v_endian_detector;
int __pyx_v_little_endian;
PyObject *__pyx_v_fields = 0;
PyObject *__pyx_v_childname = NULL;
PyObject *__pyx_v_new_offset = NULL;
PyObject *__pyx_v_t = NULL;
char *__pyx_r;
__Pyx_TraceDeclarations
__Pyx_RefNannyDeclarations
PyObject *__pyx_t_1 = NULL;
Py_ssize_t __pyx_t_2;
PyObject *__pyx_t_3 = NULL;
PyObject *__pyx_t_4 = NULL;
int __pyx_t_5;
int __pyx_t_6;
int __pyx_t_7;
long __pyx_t_8;
char *__pyx_t_9;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("_util_dtypestring", 0);
__Pyx_TraceCall("_util_dtypestring", __pyx_f[2], 763, 0, __PYX_ERR(2, 763, __pyx_L1_error));
/* "../../../../opt/python/cp37-cp37m/lib/python3.7/site-packages/numpy/__init__.pxd":768
*
* cdef dtype child
* cdef int endian_detector = 1 # <<<<<<<<<<<<<<
* cdef bint little_endian = ((<char*>&endian_detector)[0] != 0)
* cdef tuple fields
*/
__pyx_v_endian_detector = 1;
/* "../../../../opt/python/cp37-cp37m/lib/python3.7/site-packages/numpy/__init__.pxd":769
* cdef dtype child
* cdef int endian_detector = 1
* cdef bint little_endian = ((<char*>&endian_detector)[0] != 0) # <<<<<<<<<<<<<<
* cdef tuple fields
*
*/
__pyx_v_little_endian = ((((char *)(&__pyx_v_endian_detector))[0]) != 0);
/* "../../../../opt/python/cp37-cp37m/lib/python3.7/site-packages/numpy/__init__.pxd":772
* cdef tuple fields
*
* for childname in descr.names: # <<<<<<<<<<<<<<
* fields = descr.fields[childname]
* child, new_offset = fields
*/
if (unlikely(__pyx_v_descr->names == Py_None)) {
PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable");
__PYX_ERR(2, 772, __pyx_L1_error)
}
__pyx_t_1 = __pyx_v_descr->names; __Pyx_INCREF(__pyx_t_1); __pyx_t_2 = 0;
for (;;) {
if (__pyx_t_2 >= PyTuple_GET_SIZE(__pyx_t_1)) break;
#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
__pyx_t_3 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_2); __Pyx_INCREF(__pyx_t_3); __pyx_t_2++; if (unlikely(0 < 0)) __PYX_ERR(2, 772, __pyx_L1_error)
#else
__pyx_t_3 = PySequence_ITEM(__pyx_t_1, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 772, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
#endif
__Pyx_XDECREF_SET(__pyx_v_childname, __pyx_t_3);
__pyx_t_3 = 0;
/* "../../../../opt/python/cp37-cp37m/lib/python3.7/site-packages/numpy/__init__.pxd":773
*
* for childname in descr.names:
* fields = descr.fields[childname] # <<<<<<<<<<<<<<
* child, new_offset = fields
*
*/
if (unlikely(__pyx_v_descr->fields == Py_None)) {
PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable");
__PYX_ERR(2, 773, __pyx_L1_error)
}
__pyx_t_3 = __Pyx_PyDict_GetItem(__pyx_v_descr->fields, __pyx_v_childname); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 773, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
if (!(likely(PyTuple_CheckExact(__pyx_t_3))||((__pyx_t_3) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "tuple", Py_TYPE(__pyx_t_3)->tp_name), 0))) __PYX_ERR(2, 773, __pyx_L1_error)
__Pyx_XDECREF_SET(__pyx_v_fields, ((PyObject*)__pyx_t_3));
__pyx_t_3 = 0;
/* "../../../../opt/python/cp37-cp37m/lib/python3.7/site-packages/numpy/__init__.pxd":774
* for childname in descr.names:
* fields = descr.fields[childname]
* child, new_offset = fields # <<<<<<<<<<<<<<
*
* if (end - f) - <int>(new_offset - offset[0]) < 15:
*/
if (likely(__pyx_v_fields != Py_None)) {
PyObject* sequence = __pyx_v_fields;
Py_ssize_t size = __Pyx_PySequence_SIZE(sequence);
if (unlikely(size != 2)) {
if (size > 2) __Pyx_RaiseTooManyValuesError(2);
else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
__PYX_ERR(2, 774, __pyx_L1_error)
}
#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
__pyx_t_3 = PyTuple_GET_ITEM(sequence, 0);
__pyx_t_4 = PyTuple_GET_ITEM(sequence, 1);
__Pyx_INCREF(__pyx_t_3);
__Pyx_INCREF(__pyx_t_4);
#else
__pyx_t_3 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 774, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__pyx_t_4 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 774, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
#endif
} else {
__Pyx_RaiseNoneNotIterableError(); __PYX_ERR(2, 774, __pyx_L1_error)
}
if (!(likely(((__pyx_t_3) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_3, __pyx_ptype_5numpy_dtype))))) __PYX_ERR(2, 774, __pyx_L1_error)
__Pyx_XDECREF_SET(__pyx_v_child, ((PyArray_Descr *)__pyx_t_3));
__pyx_t_3 = 0;
__Pyx_XDECREF_SET(__pyx_v_new_offset, __pyx_t_4);
__pyx_t_4 = 0;
/* "../../../../opt/python/cp37-cp37m/lib/python3.7/site-packages/numpy/__init__.pxd":776
* child, new_offset = fields
*
* if (end - f) - <int>(new_offset - offset[0]) < 15: # <<<<<<<<<<<<<<
* raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd")
*
*/
__pyx_t_4 = __Pyx_PyInt_From_int((__pyx_v_offset[0])); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 776, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__pyx_t_3 = PyNumber_Subtract(__pyx_v_new_offset, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 776, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__pyx_t_5 = __Pyx_PyInt_As_int(__pyx_t_3); if (unlikely((__pyx_t_5 == (int)-1) && PyErr_Occurred())) __PYX_ERR(2, 776, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__pyx_t_6 = ((((__pyx_v_end - __pyx_v_f) - ((int)__pyx_t_5)) < 15) != 0);
if (unlikely(__pyx_t_6)) {
/* "../../../../opt/python/cp37-cp37m/lib/python3.7/site-packages/numpy/__init__.pxd":777
*
* if (end - f) - <int>(new_offset - offset[0]) < 15:
* raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd") # <<<<<<<<<<<<<<
*
* if ((child.byteorder == c'>' and little_endian) or
*/
__pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__14, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 777, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_Raise(__pyx_t_3, 0, 0, 0);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__PYX_ERR(2, 777, __pyx_L1_error)
/* "../../../../opt/python/cp37-cp37m/lib/python3.7/site-packages/numpy/__init__.pxd":776
* child, new_offset = fields
*
* if (end - f) - <int>(new_offset - offset[0]) < 15: # <<<<<<<<<<<<<<
* raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd")
*
*/
}
/* "../../../../opt/python/cp37-cp37m/lib/python3.7/site-packages/numpy/__init__.pxd":779
* raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd")
*
* if ((child.byteorder == c'>' and little_endian) or # <<<<<<<<<<<<<<
* (child.byteorder == c'<' and not little_endian)):
* raise ValueError(u"Non-native byte order not supported")
*/
__pyx_t_7 = ((__pyx_v_child->byteorder == '>') != 0);
if (!__pyx_t_7) {
goto __pyx_L8_next_or;
} else {
}
__pyx_t_7 = (__pyx_v_little_endian != 0);
if (!__pyx_t_7) {
} else {
__pyx_t_6 = __pyx_t_7;
goto __pyx_L7_bool_binop_done;
}
__pyx_L8_next_or:;
/* "../../../../opt/python/cp37-cp37m/lib/python3.7/site-packages/numpy/__init__.pxd":780
*
* if ((child.byteorder == c'>' and little_endian) or
* (child.byteorder == c'<' and not little_endian)): # <<<<<<<<<<<<<<
* raise ValueError(u"Non-native byte order not supported")
* # One could encode it in the format string and have Cython
*/
__pyx_t_7 = ((__pyx_v_child->byteorder == '<') != 0);
if (__pyx_t_7) {
} else {
__pyx_t_6 = __pyx_t_7;
goto __pyx_L7_bool_binop_done;
}
__pyx_t_7 = ((!(__pyx_v_little_endian != 0)) != 0);
__pyx_t_6 = __pyx_t_7;
__pyx_L7_bool_binop_done:;
/* "../../../../opt/python/cp37-cp37m/lib/python3.7/site-packages/numpy/__init__.pxd":779
* raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd")
*
* if ((child.byteorder == c'>' and little_endian) or # <<<<<<<<<<<<<<
* (child.byteorder == c'<' and not little_endian)):
* raise ValueError(u"Non-native byte order not supported")
*/
if (unlikely(__pyx_t_6)) {
/* "../../../../opt/python/cp37-cp37m/lib/python3.7/site-packages/numpy/__init__.pxd":781
* if ((child.byteorder == c'>' and little_endian) or
* (child.byteorder == c'<' and not little_endian)):
* raise ValueError(u"Non-native byte order not supported") # <<<<<<<<<<<<<<
* # One could encode it in the format string and have Cython
* # complain instead, BUT: < and > in format strings also imply
*/
__pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__15, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 781, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_Raise(__pyx_t_3, 0, 0, 0);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__PYX_ERR(2, 781, __pyx_L1_error)
/* "../../../../opt/python/cp37-cp37m/lib/python3.7/site-packages/numpy/__init__.pxd":779
* raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd")
*
* if ((child.byteorder == c'>' and little_endian) or # <<<<<<<<<<<<<<
* (child.byteorder == c'<' and not little_endian)):
* raise ValueError(u"Non-native byte order not supported")
*/
}
/* "../../../../opt/python/cp37-cp37m/lib/python3.7/site-packages/numpy/__init__.pxd":791
*
* # Output padding bytes
* while offset[0] < new_offset: # <<<<<<<<<<<<<<
* f[0] = 120 # "x"; pad byte
* f += 1
*/
while (1) {
__pyx_t_3 = __Pyx_PyInt_From_int((__pyx_v_offset[0])); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 791, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__pyx_t_4 = PyObject_RichCompare(__pyx_t_3, __pyx_v_new_offset, Py_LT); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 791, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(2, 791, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
if (!__pyx_t_6) break;
/* "../../../../opt/python/cp37-cp37m/lib/python3.7/site-packages/numpy/__init__.pxd":792
* # Output padding bytes
* while offset[0] < new_offset:
* f[0] = 120 # "x"; pad byte # <<<<<<<<<<<<<<
* f += 1
* offset[0] += 1
*/
(__pyx_v_f[0]) = 0x78;
/* "../../../../opt/python/cp37-cp37m/lib/python3.7/site-packages/numpy/__init__.pxd":793
* while offset[0] < new_offset:
* f[0] = 120 # "x"; pad byte
* f += 1 # <<<<<<<<<<<<<<
* offset[0] += 1
*
*/
__pyx_v_f = (__pyx_v_f + 1);
/* "../../../../opt/python/cp37-cp37m/lib/python3.7/site-packages/numpy/__init__.pxd":794
* f[0] = 120 # "x"; pad byte
* f += 1
* offset[0] += 1 # <<<<<<<<<<<<<<
*
* offset[0] += child.itemsize
*/
__pyx_t_8 = 0;
(__pyx_v_offset[__pyx_t_8]) = ((__pyx_v_offset[__pyx_t_8]) + 1);
}
/* "../../../../opt/python/cp37-cp37m/lib/python3.7/site-packages/numpy/__init__.pxd":796
* offset[0] += 1
*
* offset[0] += child.itemsize # <<<<<<<<<<<<<<
*
* if not PyDataType_HASFIELDS(child):
*/
__pyx_t_8 = 0;
(__pyx_v_offset[__pyx_t_8]) = ((__pyx_v_offset[__pyx_t_8]) + __pyx_v_child->elsize);
/* "../../../../opt/python/cp37-cp37m/lib/python3.7/site-packages/numpy/__init__.pxd":798
* offset[0] += child.itemsize
*
* if not PyDataType_HASFIELDS(child): # <<<<<<<<<<<<<<
* t = child.type_num
* if end - f < 5:
*/
__pyx_t_6 = ((!(PyDataType_HASFIELDS(__pyx_v_child) != 0)) != 0);
if (__pyx_t_6) {
/* "../../../../opt/python/cp37-cp37m/lib/python3.7/site-packages/numpy/__init__.pxd":799
*
* if not PyDataType_HASFIELDS(child):
* t = child.type_num # <<<<<<<<<<<<<<
* if end - f < 5:
* raise RuntimeError(u"Format string allocated too short.")
*/
__pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_child->type_num); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 799, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_XDECREF_SET(__pyx_v_t, __pyx_t_4);
__pyx_t_4 = 0;
/* "../../../../opt/python/cp37-cp37m/lib/python3.7/site-packages/numpy/__init__.pxd":800
* if not PyDataType_HASFIELDS(child):
* t = child.type_num
* if end - f < 5: # <<<<<<<<<<<<<<
* raise RuntimeError(u"Format string allocated too short.")
*
*/
__pyx_t_6 = (((__pyx_v_end - __pyx_v_f) < 5) != 0);
if (unlikely(__pyx_t_6)) {
/* "../../../../opt/python/cp37-cp37m/lib/python3.7/site-packages/numpy/__init__.pxd":801
* t = child.type_num
* if end - f < 5:
* raise RuntimeError(u"Format string allocated too short.") # <<<<<<<<<<<<<<
*
* # Until ticket #99 is fixed, use integers to avoid warnings
*/
__pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__16, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 801, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_Raise(__pyx_t_4, 0, 0, 0);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__PYX_ERR(2, 801, __pyx_L1_error)
/* "../../../../opt/python/cp37-cp37m/lib/python3.7/site-packages/numpy/__init__.pxd":800
* if not PyDataType_HASFIELDS(child):
* t = child.type_num
* if end - f < 5: # <<<<<<<<<<<<<<
* raise RuntimeError(u"Format string allocated too short.")
*
*/
}
/* "../../../../opt/python/cp37-cp37m/lib/python3.7/site-packages/numpy/__init__.pxd":804
*
* # Until ticket #99 is fixed, use integers to avoid warnings
* if t == NPY_BYTE: f[0] = 98 #"b" # <<<<<<<<<<<<<<
* elif t == NPY_UBYTE: f[0] = 66 #"B"
* elif t == NPY_SHORT: f[0] = 104 #"h"
*/
__pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_BYTE); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 804, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 804, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(2, 804, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
if (__pyx_t_6) {
(__pyx_v_f[0]) = 98;
goto __pyx_L15;
}
/* "../../../../opt/python/cp37-cp37m/lib/python3.7/site-packages/numpy/__init__.pxd":805
* # Until ticket #99 is fixed, use integers to avoid warnings
* if t == NPY_BYTE: f[0] = 98 #"b"
* elif t == NPY_UBYTE: f[0] = 66 #"B" # <<<<<<<<<<<<<<
* elif t == NPY_SHORT: f[0] = 104 #"h"
* elif t == NPY_USHORT: f[0] = 72 #"H"
*/
__pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_UBYTE); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 805, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 805, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(2, 805, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
if (__pyx_t_6) {
(__pyx_v_f[0]) = 66;
goto __pyx_L15;
}
/* "../../../../opt/python/cp37-cp37m/lib/python3.7/site-packages/numpy/__init__.pxd":806
* if t == NPY_BYTE: f[0] = 98 #"b"
* elif t == NPY_UBYTE: f[0] = 66 #"B"
* elif t == NPY_SHORT: f[0] = 104 #"h" # <<<<<<<<<<<<<<
* elif t == NPY_USHORT: f[0] = 72 #"H"
* elif t == NPY_INT: f[0] = 105 #"i"
*/
__pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_SHORT); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 806, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 806, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(2, 806, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
if (__pyx_t_6) {
(__pyx_v_f[0]) = 0x68;
goto __pyx_L15;
}
/* "../../../../opt/python/cp37-cp37m/lib/python3.7/site-packages/numpy/__init__.pxd":807
* elif t == NPY_UBYTE: f[0] = 66 #"B"
* elif t == NPY_SHORT: f[0] = 104 #"h"
* elif t == NPY_USHORT: f[0] = 72 #"H" # <<<<<<<<<<<<<<
* elif t == NPY_INT: f[0] = 105 #"i"
* elif t == NPY_UINT: f[0] = 73 #"I"
*/
__pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_USHORT); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 807, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 807, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(2, 807, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
if (__pyx_t_6) {
(__pyx_v_f[0]) = 72;
goto __pyx_L15;
}
/* "../../../../opt/python/cp37-cp37m/lib/python3.7/site-packages/numpy/__init__.pxd":808
* elif t == NPY_SHORT: f[0] = 104 #"h"
* elif t == NPY_USHORT: f[0] = 72 #"H"
* elif t == NPY_INT: f[0] = 105 #"i" # <<<<<<<<<<<<<<
* elif t == NPY_UINT: f[0] = 73 #"I"
* elif t == NPY_LONG: f[0] = 108 #"l"
*/
__pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_INT); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 808, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 808, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(2, 808, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
if (__pyx_t_6) {
(__pyx_v_f[0]) = 0x69;
goto __pyx_L15;
}
/* "../../../../opt/python/cp37-cp37m/lib/python3.7/site-packages/numpy/__init__.pxd":809
* elif t == NPY_USHORT: f[0] = 72 #"H"
* elif t == NPY_INT: f[0] = 105 #"i"
* elif t == NPY_UINT: f[0] = 73 #"I" # <<<<<<<<<<<<<<
* elif t == NPY_LONG: f[0] = 108 #"l"
* elif t == NPY_ULONG: f[0] = 76 #"L"
*/
__pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_UINT); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 809, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 809, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(2, 809, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
if (__pyx_t_6) {
(__pyx_v_f[0]) = 73;
goto __pyx_L15;
}
/* "../../../../opt/python/cp37-cp37m/lib/python3.7/site-packages/numpy/__init__.pxd":810
* elif t == NPY_INT: f[0] = 105 #"i"
* elif t == NPY_UINT: f[0] = 73 #"I"
* elif t == NPY_LONG: f[0] = 108 #"l" # <<<<<<<<<<<<<<
* elif t == NPY_ULONG: f[0] = 76 #"L"
* elif t == NPY_LONGLONG: f[0] = 113 #"q"
*/
__pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_LONG); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 810, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 810, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(2, 810, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
if (__pyx_t_6) {
(__pyx_v_f[0]) = 0x6C;
goto __pyx_L15;
}
/* "../../../../opt/python/cp37-cp37m/lib/python3.7/site-packages/numpy/__init__.pxd":811
* elif t == NPY_UINT: f[0] = 73 #"I"
* elif t == NPY_LONG: f[0] = 108 #"l"
* elif t == NPY_ULONG: f[0] = 76 #"L" # <<<<<<<<<<<<<<
* elif t == NPY_LONGLONG: f[0] = 113 #"q"
* elif t == NPY_ULONGLONG: f[0] = 81 #"Q"
*/
__pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_ULONG); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 811, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 811, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(2, 811, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
if (__pyx_t_6) {
(__pyx_v_f[0]) = 76;
goto __pyx_L15;
}
/* "../../../../opt/python/cp37-cp37m/lib/python3.7/site-packages/numpy/__init__.pxd":812
* elif t == NPY_LONG: f[0] = 108 #"l"
* elif t == NPY_ULONG: f[0] = 76 #"L"
* elif t == NPY_LONGLONG: f[0] = 113 #"q" # <<<<<<<<<<<<<<
* elif t == NPY_ULONGLONG: f[0] = 81 #"Q"
* elif t == NPY_FLOAT: f[0] = 102 #"f"
*/
__pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_LONGLONG); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 812, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 812, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(2, 812, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
if (__pyx_t_6) {
(__pyx_v_f[0]) = 0x71;
goto __pyx_L15;
}
/* "../../../../opt/python/cp37-cp37m/lib/python3.7/site-packages/numpy/__init__.pxd":813
* elif t == NPY_ULONG: f[0] = 76 #"L"
* elif t == NPY_LONGLONG: f[0] = 113 #"q"
* elif t == NPY_ULONGLONG: f[0] = 81 #"Q" # <<<<<<<<<<<<<<
* elif t == NPY_FLOAT: f[0] = 102 #"f"
* elif t == NPY_DOUBLE: f[0] = 100 #"d"
*/
__pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_ULONGLONG); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 813, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 813, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(2, 813, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
if (__pyx_t_6) {
(__pyx_v_f[0]) = 81;
goto __pyx_L15;
}
/* "../../../../opt/python/cp37-cp37m/lib/python3.7/site-packages/numpy/__init__.pxd":814
* elif t == NPY_LONGLONG: f[0] = 113 #"q"
* elif t == NPY_ULONGLONG: f[0] = 81 #"Q"
* elif t == NPY_FLOAT: f[0] = 102 #"f" # <<<<<<<<<<<<<<
* elif t == NPY_DOUBLE: f[0] = 100 #"d"
* elif t == NPY_LONGDOUBLE: f[0] = 103 #"g"
*/
__pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_FLOAT); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 814, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 814, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(2, 814, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
if (__pyx_t_6) {
(__pyx_v_f[0]) = 0x66;
goto __pyx_L15;
}
/* "../../../../opt/python/cp37-cp37m/lib/python3.7/site-packages/numpy/__init__.pxd":815
* elif t == NPY_ULONGLONG: f[0] = 81 #"Q"
* elif t == NPY_FLOAT: f[0] = 102 #"f"
* elif t == NPY_DOUBLE: f[0] = 100 #"d" # <<<<<<<<<<<<<<
* elif t == NPY_LONGDOUBLE: f[0] = 103 #"g"
* elif t == NPY_CFLOAT: f[0] = 90; f[1] = 102; f += 1 # Zf
*/
__pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_DOUBLE); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 815, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 815, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(2, 815, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
if (__pyx_t_6) {
(__pyx_v_f[0]) = 0x64;
goto __pyx_L15;
}
/* "../../../../opt/python/cp37-cp37m/lib/python3.7/site-packages/numpy/__init__.pxd":816
* elif t == NPY_FLOAT: f[0] = 102 #"f"
* elif t == NPY_DOUBLE: f[0] = 100 #"d"
* elif t == NPY_LONGDOUBLE: f[0] = 103 #"g" # <<<<<<<<<<<<<<
* elif t == NPY_CFLOAT: f[0] = 90; f[1] = 102; f += 1 # Zf
* elif t == NPY_CDOUBLE: f[0] = 90; f[1] = 100; f += 1 # Zd
*/
__pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_LONGDOUBLE); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 816, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 816, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(2, 816, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
if (__pyx_t_6) {
(__pyx_v_f[0]) = 0x67;
goto __pyx_L15;
}
/* "../../../../opt/python/cp37-cp37m/lib/python3.7/site-packages/numpy/__init__.pxd":817
* elif t == NPY_DOUBLE: f[0] = 100 #"d"
* elif t == NPY_LONGDOUBLE: f[0] = 103 #"g"
* elif t == NPY_CFLOAT: f[0] = 90; f[1] = 102; f += 1 # Zf # <<<<<<<<<<<<<<
* elif t == NPY_CDOUBLE: f[0] = 90; f[1] = 100; f += 1 # Zd
* elif t == NPY_CLONGDOUBLE: f[0] = 90; f[1] = 103; f += 1 # Zg
*/
__pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_CFLOAT); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 817, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 817, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(2, 817, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
if (__pyx_t_6) {
(__pyx_v_f[0]) = 90;
(__pyx_v_f[1]) = 0x66;
__pyx_v_f = (__pyx_v_f + 1);
goto __pyx_L15;
}
/* "../../../../opt/python/cp37-cp37m/lib/python3.7/site-packages/numpy/__init__.pxd":818
* elif t == NPY_LONGDOUBLE: f[0] = 103 #"g"
* elif t == NPY_CFLOAT: f[0] = 90; f[1] = 102; f += 1 # Zf
* elif t == NPY_CDOUBLE: f[0] = 90; f[1] = 100; f += 1 # Zd # <<<<<<<<<<<<<<
* elif t == NPY_CLONGDOUBLE: f[0] = 90; f[1] = 103; f += 1 # Zg
* elif t == NPY_OBJECT: f[0] = 79 #"O"
*/
__pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_CDOUBLE); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 818, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 818, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(2, 818, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
if (__pyx_t_6) {
(__pyx_v_f[0]) = 90;
(__pyx_v_f[1]) = 0x64;
__pyx_v_f = (__pyx_v_f + 1);
goto __pyx_L15;
}
/* "../../../../opt/python/cp37-cp37m/lib/python3.7/site-packages/numpy/__init__.pxd":819
* elif t == NPY_CFLOAT: f[0] = 90; f[1] = 102; f += 1 # Zf
* elif t == NPY_CDOUBLE: f[0] = 90; f[1] = 100; f += 1 # Zd
* elif t == NPY_CLONGDOUBLE: f[0] = 90; f[1] = 103; f += 1 # Zg # <<<<<<<<<<<<<<
* elif t == NPY_OBJECT: f[0] = 79 #"O"
* else:
*/
__pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_CLONGDOUBLE); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 819, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 819, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(2, 819, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
if (__pyx_t_6) {
(__pyx_v_f[0]) = 90;
(__pyx_v_f[1]) = 0x67;
__pyx_v_f = (__pyx_v_f + 1);
goto __pyx_L15;
}
/* "../../../../opt/python/cp37-cp37m/lib/python3.7/site-packages/numpy/__init__.pxd":820
* elif t == NPY_CDOUBLE: f[0] = 90; f[1] = 100; f += 1 # Zd
* elif t == NPY_CLONGDOUBLE: f[0] = 90; f[1] = 103; f += 1 # Zg
* elif t == NPY_OBJECT: f[0] = 79 #"O" # <<<<<<<<<<<<<<
* else:
* raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t)
*/
__pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_OBJECT); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 820, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 820, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(2, 820, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
if (likely(__pyx_t_6)) {
(__pyx_v_f[0]) = 79;
goto __pyx_L15;
}
/* "../../../../opt/python/cp37-cp37m/lib/python3.7/site-packages/numpy/__init__.pxd":822
* elif t == NPY_OBJECT: f[0] = 79 #"O"
* else:
* raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t) # <<<<<<<<<<<<<<
* f += 1
* else:
*/
/*else*/ {
__pyx_t_3 = __Pyx_PyUnicode_FormatSafe(__pyx_kp_u_unknown_dtype_code_in_numpy_pxd, __pyx_v_t); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 822, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 822, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__Pyx_Raise(__pyx_t_4, 0, 0, 0);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__PYX_ERR(2, 822, __pyx_L1_error)
}
__pyx_L15:;
/* "../../../../opt/python/cp37-cp37m/lib/python3.7/site-packages/numpy/__init__.pxd":823
* else:
* raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t)
* f += 1 # <<<<<<<<<<<<<<
* else:
* # Cython ignores struct boundary information ("T{...}"),
*/
__pyx_v_f = (__pyx_v_f + 1);
/* "../../../../opt/python/cp37-cp37m/lib/python3.7/site-packages/numpy/__init__.pxd":798
* offset[0] += child.itemsize
*
* if not PyDataType_HASFIELDS(child): # <<<<<<<<<<<<<<
* t = child.type_num
* if end - f < 5:
*/
goto __pyx_L13;
}
/* "../../../../opt/python/cp37-cp37m/lib/python3.7/site-packages/numpy/__init__.pxd":827
* # Cython ignores struct boundary information ("T{...}"),
* # so don't output it
* f = _util_dtypestring(child, f, end, offset) # <<<<<<<<<<<<<<
* return f
*
*/
/*else*/ {
__pyx_t_9 = __pyx_f_5numpy__util_dtypestring(__pyx_v_child, __pyx_v_f, __pyx_v_end, __pyx_v_offset); if (unlikely(__pyx_t_9 == ((char *)NULL))) __PYX_ERR(2, 827, __pyx_L1_error)
__pyx_v_f = __pyx_t_9;
}
__pyx_L13:;
/* "../../../../opt/python/cp37-cp37m/lib/python3.7/site-packages/numpy/__init__.pxd":772
* cdef tuple fields
*
* for childname in descr.names: # <<<<<<<<<<<<<<
* fields = descr.fields[childname]
* child, new_offset = fields
*/
}
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
/* "../../../../opt/python/cp37-cp37m/lib/python3.7/site-packages/numpy/__init__.pxd":828
* # so don't output it
* f = _util_dtypestring(child, f, end, offset)
* return f # <<<<<<<<<<<<<<
*
*
*/
__pyx_r = __pyx_v_f;
goto __pyx_L0;
/* "../../../../opt/python/cp37-cp37m/lib/python3.7/site-packages/numpy/__init__.pxd":763
* return ()
*
* cdef inline char* _util_dtypestring(dtype descr, char* f, char* end, int* offset) except NULL: # <<<<<<<<<<<<<<
* # Recursive utility function used in __getbuffer__ to get format
* # string. The new location in the format string is returned.
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_1);
__Pyx_XDECREF(__pyx_t_3);
__Pyx_XDECREF(__pyx_t_4);
__Pyx_AddTraceback("numpy._util_dtypestring", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = NULL;
__pyx_L0:;
__Pyx_XDECREF((PyObject *)__pyx_v_child);
__Pyx_XDECREF(__pyx_v_fields);
__Pyx_XDECREF(__pyx_v_childname);
__Pyx_XDECREF(__pyx_v_new_offset);
__Pyx_XDECREF(__pyx_v_t);
__Pyx_TraceReturn(Py_None, 0);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "../../../../opt/python/cp37-cp37m/lib/python3.7/site-packages/numpy/__init__.pxd":943
* int _import_umath() except -1
*
* cdef inline void set_array_base(ndarray arr, object base): # <<<<<<<<<<<<<<
* Py_INCREF(base) # important to do this before stealing the reference below!
* PyArray_SetBaseObject(arr, base)
*/
static CYTHON_INLINE void __pyx_f_5numpy_set_array_base(PyArrayObject *__pyx_v_arr, PyObject *__pyx_v_base) {
__Pyx_TraceDeclarations
__Pyx_RefNannyDeclarations
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("set_array_base", 0);
__Pyx_TraceCall("set_array_base", __pyx_f[2], 943, 0, __PYX_ERR(2, 943, __pyx_L1_error));
/* "../../../../opt/python/cp37-cp37m/lib/python3.7/site-packages/numpy/__init__.pxd":944
*
* cdef inline void set_array_base(ndarray arr, object base):
* Py_INCREF(base) # important to do this before stealing the reference below! # <<<<<<<<<<<<<<
* PyArray_SetBaseObject(arr, base)
*
*/
Py_INCREF(__pyx_v_base);
/* "../../../../opt/python/cp37-cp37m/lib/python3.7/site-packages/numpy/__init__.pxd":945
* cdef inline void set_array_base(ndarray arr, object base):
* Py_INCREF(base) # important to do this before stealing the reference below!
* PyArray_SetBaseObject(arr, base) # <<<<<<<<<<<<<<
*
* cdef inline object get_array_base(ndarray arr):
*/
(void)(PyArray_SetBaseObject(__pyx_v_arr, __pyx_v_base));
/* "../../../../opt/python/cp37-cp37m/lib/python3.7/site-packages/numpy/__init__.pxd":943
* int _import_umath() except -1
*
* cdef inline void set_array_base(ndarray arr, object base): # <<<<<<<<<<<<<<
* Py_INCREF(base) # important to do this before stealing the reference below!
* PyArray_SetBaseObject(arr, base)
*/
/* function exit code */
goto __pyx_L0;
__pyx_L1_error:;
__Pyx_WriteUnraisable("numpy.set_array_base", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0);
__pyx_L0:;
__Pyx_TraceReturn(Py_None, 0);
__Pyx_RefNannyFinishContext();
}
/* "../../../../opt/python/cp37-cp37m/lib/python3.7/site-packages/numpy/__init__.pxd":947
* PyArray_SetBaseObject(arr, base)
*
* cdef inline object get_array_base(ndarray arr): # <<<<<<<<<<<<<<
* base = PyArray_BASE(arr)
* if base is NULL:
*/
static CYTHON_INLINE PyObject *__pyx_f_5numpy_get_array_base(PyArrayObject *__pyx_v_arr) {
PyObject *__pyx_v_base;
PyObject *__pyx_r = NULL;
__Pyx_TraceDeclarations
__Pyx_RefNannyDeclarations
int __pyx_t_1;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("get_array_base", 0);
__Pyx_TraceCall("get_array_base", __pyx_f[2], 947, 0, __PYX_ERR(2, 947, __pyx_L1_error));
/* "../../../../opt/python/cp37-cp37m/lib/python3.7/site-packages/numpy/__init__.pxd":948
*
* cdef inline object get_array_base(ndarray arr):
* base = PyArray_BASE(arr) # <<<<<<<<<<<<<<
* if base is NULL:
* return None
*/
__pyx_v_base = PyArray_BASE(__pyx_v_arr);
/* "../../../../opt/python/cp37-cp37m/lib/python3.7/site-packages/numpy/__init__.pxd":949
* cdef inline object get_array_base(ndarray arr):
* base = PyArray_BASE(arr)
* if base is NULL: # <<<<<<<<<<<<<<
* return None
* return <object>base
*/
__pyx_t_1 = ((__pyx_v_base == NULL) != 0);
if (__pyx_t_1) {
/* "../../../../opt/python/cp37-cp37m/lib/python3.7/site-packages/numpy/__init__.pxd":950
* base = PyArray_BASE(arr)
* if base is NULL:
* return None # <<<<<<<<<<<<<<
* return <object>base
*
*/
__Pyx_XDECREF(__pyx_r);
__pyx_r = Py_None; __Pyx_INCREF(Py_None);
goto __pyx_L0;
/* "../../../../opt/python/cp37-cp37m/lib/python3.7/site-packages/numpy/__init__.pxd":949
* cdef inline object get_array_base(ndarray arr):
* base = PyArray_BASE(arr)
* if base is NULL: # <<<<<<<<<<<<<<
* return None
* return <object>base
*/
}
/* "../../../../opt/python/cp37-cp37m/lib/python3.7/site-packages/numpy/__init__.pxd":951
* if base is NULL:
* return None
* return <object>base # <<<<<<<<<<<<<<
*
* # Versions of the import_* functions which are more suitable for
*/
__Pyx_XDECREF(__pyx_r);
__Pyx_INCREF(((PyObject *)__pyx_v_base));
__pyx_r = ((PyObject *)__pyx_v_base);
goto __pyx_L0;
/* "../../../../opt/python/cp37-cp37m/lib/python3.7/site-packages/numpy/__init__.pxd":947
* PyArray_SetBaseObject(arr, base)
*
* cdef inline object get_array_base(ndarray arr): # <<<<<<<<<<<<<<
* base = PyArray_BASE(arr)
* if base is NULL:
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_AddTraceback("numpy.get_array_base", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = 0;
__pyx_L0:;
__Pyx_XGIVEREF(__pyx_r);
__Pyx_TraceReturn(__pyx_r, 0);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "../../../../opt/python/cp37-cp37m/lib/python3.7/site-packages/numpy/__init__.pxd":955
* # Versions of the import_* functions which are more suitable for
* # Cython code.
* cdef inline int import_array() except -1: # <<<<<<<<<<<<<<
* try:
* __pyx_import_array()
*/
static CYTHON_INLINE int __pyx_f_5numpy_import_array(void) {
int __pyx_r;
__Pyx_TraceDeclarations
__Pyx_RefNannyDeclarations
PyObject *__pyx_t_1 = NULL;
PyObject *__pyx_t_2 = NULL;
PyObject *__pyx_t_3 = NULL;
int __pyx_t_4;
PyObject *__pyx_t_5 = NULL;
PyObject *__pyx_t_6 = NULL;
PyObject *__pyx_t_7 = NULL;
PyObject *__pyx_t_8 = NULL;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("import_array", 0);
__Pyx_TraceCall("import_array", __pyx_f[2], 955, 0, __PYX_ERR(2, 955, __pyx_L1_error));
/* "../../../../opt/python/cp37-cp37m/lib/python3.7/site-packages/numpy/__init__.pxd":956
* # Cython code.
* cdef inline int import_array() except -1:
* try: # <<<<<<<<<<<<<<
* __pyx_import_array()
* except Exception:
*/
{
__Pyx_PyThreadState_declare
__Pyx_PyThreadState_assign
__Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3);
__Pyx_XGOTREF(__pyx_t_1);
__Pyx_XGOTREF(__pyx_t_2);
__Pyx_XGOTREF(__pyx_t_3);
/*try:*/ {
/* "../../../../opt/python/cp37-cp37m/lib/python3.7/site-packages/numpy/__init__.pxd":957
* cdef inline int import_array() except -1:
* try:
* __pyx_import_array() # <<<<<<<<<<<<<<
* except Exception:
* raise ImportError("numpy.core.multiarray failed to import")
*/
__pyx_t_4 = _import_array(); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(2, 957, __pyx_L3_error)
/* "../../../../opt/python/cp37-cp37m/lib/python3.7/site-packages/numpy/__init__.pxd":956
* # Cython code.
* cdef inline int import_array() except -1:
* try: # <<<<<<<<<<<<<<
* __pyx_import_array()
* except Exception:
*/
}
__Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
__Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
__Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
goto __pyx_L8_try_end;
__pyx_L3_error:;
/* "../../../../opt/python/cp37-cp37m/lib/python3.7/site-packages/numpy/__init__.pxd":958
* try:
* __pyx_import_array()
* except Exception: # <<<<<<<<<<<<<<
* raise ImportError("numpy.core.multiarray failed to import")
*
*/
__pyx_t_4 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])));
if (__pyx_t_4) {
__Pyx_AddTraceback("numpy.import_array", __pyx_clineno, __pyx_lineno, __pyx_filename);
if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7) < 0) __PYX_ERR(2, 958, __pyx_L5_except_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_GOTREF(__pyx_t_6);
__Pyx_GOTREF(__pyx_t_7);
/* "../../../../opt/python/cp37-cp37m/lib/python3.7/site-packages/numpy/__init__.pxd":959
* __pyx_import_array()
* except Exception:
* raise ImportError("numpy.core.multiarray failed to import") # <<<<<<<<<<<<<<
*
* cdef inline int import_umath() except -1:
*/
__pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_ImportError, __pyx_tuple__17, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 959, __pyx_L5_except_error)
__Pyx_GOTREF(__pyx_t_8);
__Pyx_Raise(__pyx_t_8, 0, 0, 0);
__Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
__PYX_ERR(2, 959, __pyx_L5_except_error)
}
goto __pyx_L5_except_error;
__pyx_L5_except_error:;
/* "../../../../opt/python/cp37-cp37m/lib/python3.7/site-packages/numpy/__init__.pxd":956
* # Cython code.
* cdef inline int import_array() except -1:
* try: # <<<<<<<<<<<<<<
* __pyx_import_array()
* except Exception:
*/
__Pyx_XGIVEREF(__pyx_t_1);
__Pyx_XGIVEREF(__pyx_t_2);
__Pyx_XGIVEREF(__pyx_t_3);
__Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3);
goto __pyx_L1_error;
__pyx_L8_try_end:;
}
/* "../../../../opt/python/cp37-cp37m/lib/python3.7/site-packages/numpy/__init__.pxd":955
* # Versions of the import_* functions which are more suitable for
* # Cython code.
* cdef inline int import_array() except -1: # <<<<<<<<<<<<<<
* try:
* __pyx_import_array()
*/
/* function exit code */
__pyx_r = 0;
goto __pyx_L0;
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_5);
__Pyx_XDECREF(__pyx_t_6);
__Pyx_XDECREF(__pyx_t_7);
__Pyx_XDECREF(__pyx_t_8);
__Pyx_AddTraceback("numpy.import_array", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = -1;
__pyx_L0:;
__Pyx_TraceReturn(Py_None, 0);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "../../../../opt/python/cp37-cp37m/lib/python3.7/site-packages/numpy/__init__.pxd":961
* raise ImportError("numpy.core.multiarray failed to import")
*
* cdef inline int import_umath() except -1: # <<<<<<<<<<<<<<
* try:
* _import_umath()
*/
static CYTHON_INLINE int __pyx_f_5numpy_import_umath(void) {
int __pyx_r;
__Pyx_TraceDeclarations
__Pyx_RefNannyDeclarations
PyObject *__pyx_t_1 = NULL;
PyObject *__pyx_t_2 = NULL;
PyObject *__pyx_t_3 = NULL;
int __pyx_t_4;
PyObject *__pyx_t_5 = NULL;
PyObject *__pyx_t_6 = NULL;
PyObject *__pyx_t_7 = NULL;
PyObject *__pyx_t_8 = NULL;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("import_umath", 0);
__Pyx_TraceCall("import_umath", __pyx_f[2], 961, 0, __PYX_ERR(2, 961, __pyx_L1_error));
/* "../../../../opt/python/cp37-cp37m/lib/python3.7/site-packages/numpy/__init__.pxd":962
*
* cdef inline int import_umath() except -1:
* try: # <<<<<<<<<<<<<<
* _import_umath()
* except Exception:
*/
{
__Pyx_PyThreadState_declare
__Pyx_PyThreadState_assign
__Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3);
__Pyx_XGOTREF(__pyx_t_1);
__Pyx_XGOTREF(__pyx_t_2);
__Pyx_XGOTREF(__pyx_t_3);
/*try:*/ {
/* "../../../../opt/python/cp37-cp37m/lib/python3.7/site-packages/numpy/__init__.pxd":963
* cdef inline int import_umath() except -1:
* try:
* _import_umath() # <<<<<<<<<<<<<<
* except Exception:
* raise ImportError("numpy.core.umath failed to import")
*/
__pyx_t_4 = _import_umath(); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(2, 963, __pyx_L3_error)
/* "../../../../opt/python/cp37-cp37m/lib/python3.7/site-packages/numpy/__init__.pxd":962
*
* cdef inline int import_umath() except -1:
* try: # <<<<<<<<<<<<<<
* _import_umath()
* except Exception:
*/
}
__Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
__Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
__Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
goto __pyx_L8_try_end;
__pyx_L3_error:;
/* "../../../../opt/python/cp37-cp37m/lib/python3.7/site-packages/numpy/__init__.pxd":964
* try:
* _import_umath()
* except Exception: # <<<<<<<<<<<<<<
* raise ImportError("numpy.core.umath failed to import")
*
*/
__pyx_t_4 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])));
if (__pyx_t_4) {
__Pyx_AddTraceback("numpy.import_umath", __pyx_clineno, __pyx_lineno, __pyx_filename);
if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7) < 0) __PYX_ERR(2, 964, __pyx_L5_except_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_GOTREF(__pyx_t_6);
__Pyx_GOTREF(__pyx_t_7);
/* "../../../../opt/python/cp37-cp37m/lib/python3.7/site-packages/numpy/__init__.pxd":965
* _import_umath()
* except Exception:
* raise ImportError("numpy.core.umath failed to import") # <<<<<<<<<<<<<<
*
* cdef inline int import_ufunc() except -1:
*/
__pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_ImportError, __pyx_tuple__18, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 965, __pyx_L5_except_error)
__Pyx_GOTREF(__pyx_t_8);
__Pyx_Raise(__pyx_t_8, 0, 0, 0);
__Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
__PYX_ERR(2, 965, __pyx_L5_except_error)
}
goto __pyx_L5_except_error;
__pyx_L5_except_error:;
/* "../../../../opt/python/cp37-cp37m/lib/python3.7/site-packages/numpy/__init__.pxd":962
*
* cdef inline int import_umath() except -1:
* try: # <<<<<<<<<<<<<<
* _import_umath()
* except Exception:
*/
__Pyx_XGIVEREF(__pyx_t_1);
__Pyx_XGIVEREF(__pyx_t_2);
__Pyx_XGIVEREF(__pyx_t_3);
__Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3);
goto __pyx_L1_error;
__pyx_L8_try_end:;
}
/* "../../../../opt/python/cp37-cp37m/lib/python3.7/site-packages/numpy/__init__.pxd":961
* raise ImportError("numpy.core.multiarray failed to import")
*
* cdef inline int import_umath() except -1: # <<<<<<<<<<<<<<
* try:
* _import_umath()
*/
/* function exit code */
__pyx_r = 0;
goto __pyx_L0;
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_5);
__Pyx_XDECREF(__pyx_t_6);
__Pyx_XDECREF(__pyx_t_7);
__Pyx_XDECREF(__pyx_t_8);
__Pyx_AddTraceback("numpy.import_umath", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = -1;
__pyx_L0:;
__Pyx_TraceReturn(Py_None, 0);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "../../../../opt/python/cp37-cp37m/lib/python3.7/site-packages/numpy/__init__.pxd":967
* raise ImportError("numpy.core.umath failed to import")
*
* cdef inline int import_ufunc() except -1: # <<<<<<<<<<<<<<
* try:
* _import_umath()
*/
static CYTHON_INLINE int __pyx_f_5numpy_import_ufunc(void) {
int __pyx_r;
__Pyx_TraceDeclarations
__Pyx_RefNannyDeclarations
PyObject *__pyx_t_1 = NULL;
PyObject *__pyx_t_2 = NULL;
PyObject *__pyx_t_3 = NULL;
int __pyx_t_4;
PyObject *__pyx_t_5 = NULL;
PyObject *__pyx_t_6 = NULL;
PyObject *__pyx_t_7 = NULL;
PyObject *__pyx_t_8 = NULL;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("import_ufunc", 0);
__Pyx_TraceCall("import_ufunc", __pyx_f[2], 967, 0, __PYX_ERR(2, 967, __pyx_L1_error));
/* "../../../../opt/python/cp37-cp37m/lib/python3.7/site-packages/numpy/__init__.pxd":968
*
* cdef inline int import_ufunc() except -1:
* try: # <<<<<<<<<<<<<<
* _import_umath()
* except Exception:
*/
{
__Pyx_PyThreadState_declare
__Pyx_PyThreadState_assign
__Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3);
__Pyx_XGOTREF(__pyx_t_1);
__Pyx_XGOTREF(__pyx_t_2);
__Pyx_XGOTREF(__pyx_t_3);
/*try:*/ {
/* "../../../../opt/python/cp37-cp37m/lib/python3.7/site-packages/numpy/__init__.pxd":969
* cdef inline int import_ufunc() except -1:
* try:
* _import_umath() # <<<<<<<<<<<<<<
* except Exception:
* raise ImportError("numpy.core.umath failed to import")
*/
__pyx_t_4 = _import_umath(); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(2, 969, __pyx_L3_error)
/* "../../../../opt/python/cp37-cp37m/lib/python3.7/site-packages/numpy/__init__.pxd":968
*
* cdef inline int import_ufunc() except -1:
* try: # <<<<<<<<<<<<<<
* _import_umath()
* except Exception:
*/
}
__Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
__Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
__Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
goto __pyx_L8_try_end;
__pyx_L3_error:;
/* "../../../../opt/python/cp37-cp37m/lib/python3.7/site-packages/numpy/__init__.pxd":970
* try:
* _import_umath()
* except Exception: # <<<<<<<<<<<<<<
* raise ImportError("numpy.core.umath failed to import")
*
*/
__pyx_t_4 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])));
if (__pyx_t_4) {
__Pyx_AddTraceback("numpy.import_ufunc", __pyx_clineno, __pyx_lineno, __pyx_filename);
if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7) < 0) __PYX_ERR(2, 970, __pyx_L5_except_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_GOTREF(__pyx_t_6);
__Pyx_GOTREF(__pyx_t_7);
/* "../../../../opt/python/cp37-cp37m/lib/python3.7/site-packages/numpy/__init__.pxd":971
* _import_umath()
* except Exception:
* raise ImportError("numpy.core.umath failed to import") # <<<<<<<<<<<<<<
*
* cdef extern from *:
*/
__pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_ImportError, __pyx_tuple__18, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 971, __pyx_L5_except_error)
__Pyx_GOTREF(__pyx_t_8);
__Pyx_Raise(__pyx_t_8, 0, 0, 0);
__Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
__PYX_ERR(2, 971, __pyx_L5_except_error)
}
goto __pyx_L5_except_error;
__pyx_L5_except_error:;
/* "../../../../opt/python/cp37-cp37m/lib/python3.7/site-packages/numpy/__init__.pxd":968
*
* cdef inline int import_ufunc() except -1:
* try: # <<<<<<<<<<<<<<
* _import_umath()
* except Exception:
*/
__Pyx_XGIVEREF(__pyx_t_1);
__Pyx_XGIVEREF(__pyx_t_2);
__Pyx_XGIVEREF(__pyx_t_3);
__Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3);
goto __pyx_L1_error;
__pyx_L8_try_end:;
}
/* "../../../../opt/python/cp37-cp37m/lib/python3.7/site-packages/numpy/__init__.pxd":967
* raise ImportError("numpy.core.umath failed to import")
*
* cdef inline int import_ufunc() except -1: # <<<<<<<<<<<<<<
* try:
* _import_umath()
*/
/* function exit code */
__pyx_r = 0;
goto __pyx_L0;
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_5);
__Pyx_XDECREF(__pyx_t_6);
__Pyx_XDECREF(__pyx_t_7);
__Pyx_XDECREF(__pyx_t_8);
__Pyx_AddTraceback("numpy.import_ufunc", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = -1;
__pyx_L0:;
__Pyx_TraceReturn(Py_None, 0);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "lexeme.pxd":21
*
* @staticmethod
* cdef inline Lexeme from_ptr(LexemeC* lex, Vocab vocab, int vector_length): # <<<<<<<<<<<<<<
* cdef Lexeme self = Lexeme.__new__(Lexeme, vocab, lex.orth)
* self.c = lex
*/
static CYTHON_INLINE struct __pyx_obj_5spacy_6lexeme_Lexeme *__pyx_f_5spacy_6lexeme_6Lexeme_from_ptr(struct __pyx_t_5spacy_7structs_LexemeC *__pyx_v_lex, struct __pyx_obj_5spacy_5vocab_Vocab *__pyx_v_vocab, CYTHON_UNUSED int __pyx_v_vector_length) {
struct __pyx_obj_5spacy_6lexeme_Lexeme *__pyx_v_self = 0;
struct __pyx_obj_5spacy_6lexeme_Lexeme *__pyx_r = NULL;
__Pyx_TraceDeclarations
__Pyx_RefNannyDeclarations
PyObject *__pyx_t_1 = NULL;
PyObject *__pyx_t_2 = NULL;
__pyx_t_5spacy_8typedefs_attr_t __pyx_t_3;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("from_ptr", 0);
__Pyx_TraceCall("from_ptr", __pyx_f[3], 21, 0, __PYX_ERR(3, 21, __pyx_L1_error));
/* "lexeme.pxd":22
* @staticmethod
* cdef inline Lexeme from_ptr(LexemeC* lex, Vocab vocab, int vector_length):
* cdef Lexeme self = Lexeme.__new__(Lexeme, vocab, lex.orth) # <<<<<<<<<<<<<<
* self.c = lex
* self.vocab = vocab
*/
__pyx_t_1 = __Pyx_PyInt_From_uint64_t(__pyx_v_lex->orth); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 22, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 22, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_INCREF(((PyObject *)__pyx_v_vocab));
__Pyx_GIVEREF(((PyObject *)__pyx_v_vocab));
PyTuple_SET_ITEM(__pyx_t_2, 0, ((PyObject *)__pyx_v_vocab));
__Pyx_GIVEREF(__pyx_t_1);
PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_t_1);
__pyx_t_1 = 0;
__pyx_t_1 = __Pyx_tp_new(((PyObject *)__pyx_ptype_5spacy_6lexeme_Lexeme), ((PyObject*)__pyx_t_2)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 22, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
if (!(likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_5spacy_6lexeme_Lexeme)))) __PYX_ERR(3, 22, __pyx_L1_error)
__pyx_v_self = ((struct __pyx_obj_5spacy_6lexeme_Lexeme *)__pyx_t_1);
__pyx_t_1 = 0;
/* "lexeme.pxd":23
* cdef inline Lexeme from_ptr(LexemeC* lex, Vocab vocab, int vector_length):
* cdef Lexeme self = Lexeme.__new__(Lexeme, vocab, lex.orth)
* self.c = lex # <<<<<<<<<<<<<<
* self.vocab = vocab
* self.orth = lex.orth
*/
__pyx_v_self->c = __pyx_v_lex;
/* "lexeme.pxd":24
* cdef Lexeme self = Lexeme.__new__(Lexeme, vocab, lex.orth)
* self.c = lex
* self.vocab = vocab # <<<<<<<<<<<<<<
* self.orth = lex.orth
*
*/
__Pyx_INCREF(((PyObject *)__pyx_v_vocab));
__Pyx_GIVEREF(((PyObject *)__pyx_v_vocab));
__Pyx_GOTREF(__pyx_v_self->vocab);
__Pyx_DECREF(((PyObject *)__pyx_v_self->vocab));
__pyx_v_self->vocab = __pyx_v_vocab;
/* "lexeme.pxd":25
* self.c = lex
* self.vocab = vocab
* self.orth = lex.orth # <<<<<<<<<<<<<<
*
* @staticmethod
*/
__pyx_t_3 = __pyx_v_lex->orth;
__pyx_v_self->orth = __pyx_t_3;
/* "lexeme.pxd":21
*
* @staticmethod
* cdef inline Lexeme from_ptr(LexemeC* lex, Vocab vocab, int vector_length): # <<<<<<<<<<<<<<
* cdef Lexeme self = Lexeme.__new__(Lexeme, vocab, lex.orth)
* self.c = lex
*/
/* function exit code */
__pyx_r = ((struct __pyx_obj_5spacy_6lexeme_Lexeme *)Py_None); __Pyx_INCREF(Py_None);
goto __pyx_L0;
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_1);
__Pyx_XDECREF(__pyx_t_2);
__Pyx_AddTraceback("spacy.lexeme.Lexeme.from_ptr", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = 0;
__pyx_L0:;
__Pyx_XDECREF((PyObject *)__pyx_v_self);
__Pyx_XGIVEREF((PyObject *)__pyx_r);
__Pyx_TraceReturn(__pyx_r, 0);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "lexeme.pxd":28
*
* @staticmethod
* cdef inline void set_struct_attr(LexemeC* lex, attr_id_t name, attr_t value) nogil: # <<<<<<<<<<<<<<
* if name < (sizeof(flags_t) * 8):
* Lexeme.c_set_flag(lex, name, value)
*/
static CYTHON_INLINE void __pyx_f_5spacy_6lexeme_6Lexeme_set_struct_attr(struct __pyx_t_5spacy_7structs_LexemeC *__pyx_v_lex, enum __pyx_t_5spacy_5attrs_attr_id_t __pyx_v_name, __pyx_t_5spacy_8typedefs_attr_t __pyx_v_value) {
__Pyx_TraceDeclarations
int __pyx_t_1;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_TraceCall("set_struct_attr", __pyx_f[3], 28, 1, __PYX_ERR(3, 28, __pyx_L1_error));
/* "lexeme.pxd":29
* @staticmethod
* cdef inline void set_struct_attr(LexemeC* lex, attr_id_t name, attr_t value) nogil:
* if name < (sizeof(flags_t) * 8): # <<<<<<<<<<<<<<
* Lexeme.c_set_flag(lex, name, value)
* elif name == ID:
*/
__pyx_t_1 = ((__pyx_v_name < ((sizeof(__pyx_t_5spacy_8typedefs_flags_t)) * 8)) != 0);
if (__pyx_t_1) {
/* "lexeme.pxd":30
* cdef inline void set_struct_attr(LexemeC* lex, attr_id_t name, attr_t value) nogil:
* if name < (sizeof(flags_t) * 8):
* Lexeme.c_set_flag(lex, name, value) # <<<<<<<<<<<<<<
* elif name == ID:
* lex.id = value
*/
(void)(__pyx_f_5spacy_6lexeme_6Lexeme_c_set_flag(__pyx_v_lex, __pyx_v_name, __pyx_v_value));
/* "lexeme.pxd":29
* @staticmethod
* cdef inline void set_struct_attr(LexemeC* lex, attr_id_t name, attr_t value) nogil:
* if name < (sizeof(flags_t) * 8): # <<<<<<<<<<<<<<
* Lexeme.c_set_flag(lex, name, value)
* elif name == ID:
*/
goto __pyx_L3;
}
/* "lexeme.pxd":31
* if name < (sizeof(flags_t) * 8):
* Lexeme.c_set_flag(lex, name, value)
* elif name == ID: # <<<<<<<<<<<<<<
* lex.id = value
* elif name == LOWER:
*/
__pyx_t_1 = ((__pyx_v_name == __pyx_e_5spacy_5attrs_ID) != 0);
if (__pyx_t_1) {
/* "lexeme.pxd":32
* Lexeme.c_set_flag(lex, name, value)
* elif name == ID:
* lex.id = value # <<<<<<<<<<<<<<
* elif name == LOWER:
* lex.lower = value
*/
__pyx_v_lex->id = __pyx_v_value;
/* "lexeme.pxd":31
* if name < (sizeof(flags_t) * 8):
* Lexeme.c_set_flag(lex, name, value)
* elif name == ID: # <<<<<<<<<<<<<<
* lex.id = value
* elif name == LOWER:
*/
goto __pyx_L3;
}
/* "lexeme.pxd":33
* elif name == ID:
* lex.id = value
* elif name == LOWER: # <<<<<<<<<<<<<<
* lex.lower = value
* elif name == NORM:
*/
__pyx_t_1 = ((__pyx_v_name == __pyx_e_5spacy_5attrs_LOWER) != 0);
if (__pyx_t_1) {
/* "lexeme.pxd":34
* lex.id = value
* elif name == LOWER:
* lex.lower = value # <<<<<<<<<<<<<<
* elif name == NORM:
* lex.norm = value
*/
__pyx_v_lex->lower = __pyx_v_value;
/* "lexeme.pxd":33
* elif name == ID:
* lex.id = value
* elif name == LOWER: # <<<<<<<<<<<<<<
* lex.lower = value
* elif name == NORM:
*/
goto __pyx_L3;
}
/* "lexeme.pxd":35
* elif name == LOWER:
* lex.lower = value
* elif name == NORM: # <<<<<<<<<<<<<<
* lex.norm = value
* elif name == SHAPE:
*/
__pyx_t_1 = ((__pyx_v_name == __pyx_e_5spacy_5attrs_NORM) != 0);
if (__pyx_t_1) {
/* "lexeme.pxd":36
* lex.lower = value
* elif name == NORM:
* lex.norm = value # <<<<<<<<<<<<<<
* elif name == SHAPE:
* lex.shape = value
*/
__pyx_v_lex->norm = __pyx_v_value;
/* "lexeme.pxd":35
* elif name == LOWER:
* lex.lower = value
* elif name == NORM: # <<<<<<<<<<<<<<
* lex.norm = value
* elif name == SHAPE:
*/
goto __pyx_L3;
}
/* "lexeme.pxd":37
* elif name == NORM:
* lex.norm = value
* elif name == SHAPE: # <<<<<<<<<<<<<<
* lex.shape = value
* elif name == PREFIX:
*/
__pyx_t_1 = ((__pyx_v_name == __pyx_e_5spacy_5attrs_SHAPE) != 0);
if (__pyx_t_1) {
/* "lexeme.pxd":38
* lex.norm = value
* elif name == SHAPE:
* lex.shape = value # <<<<<<<<<<<<<<
* elif name == PREFIX:
* lex.prefix = value
*/
__pyx_v_lex->shape = __pyx_v_value;
/* "lexeme.pxd":37
* elif name == NORM:
* lex.norm = value
* elif name == SHAPE: # <<<<<<<<<<<<<<
* lex.shape = value
* elif name == PREFIX:
*/
goto __pyx_L3;
}
/* "lexeme.pxd":39
* elif name == SHAPE:
* lex.shape = value
* elif name == PREFIX: # <<<<<<<<<<<<<<
* lex.prefix = value
* elif name == SUFFIX:
*/
__pyx_t_1 = ((__pyx_v_name == __pyx_e_5spacy_5attrs_PREFIX) != 0);
if (__pyx_t_1) {
/* "lexeme.pxd":40
* lex.shape = value
* elif name == PREFIX:
* lex.prefix = value # <<<<<<<<<<<<<<
* elif name == SUFFIX:
* lex.suffix = value
*/
__pyx_v_lex->prefix = __pyx_v_value;
/* "lexeme.pxd":39
* elif name == SHAPE:
* lex.shape = value
* elif name == PREFIX: # <<<<<<<<<<<<<<
* lex.prefix = value
* elif name == SUFFIX:
*/
goto __pyx_L3;
}
/* "lexeme.pxd":41
* elif name == PREFIX:
* lex.prefix = value
* elif name == SUFFIX: # <<<<<<<<<<<<<<
* lex.suffix = value
* elif name == LANG:
*/
__pyx_t_1 = ((__pyx_v_name == __pyx_e_5spacy_5attrs_SUFFIX) != 0);
if (__pyx_t_1) {
/* "lexeme.pxd":42
* lex.prefix = value
* elif name == SUFFIX:
* lex.suffix = value # <<<<<<<<<<<<<<
* elif name == LANG:
* lex.lang = value
*/
__pyx_v_lex->suffix = __pyx_v_value;
/* "lexeme.pxd":41
* elif name == PREFIX:
* lex.prefix = value
* elif name == SUFFIX: # <<<<<<<<<<<<<<
* lex.suffix = value
* elif name == LANG:
*/
goto __pyx_L3;
}
/* "lexeme.pxd":43
* elif name == SUFFIX:
* lex.suffix = value
* elif name == LANG: # <<<<<<<<<<<<<<
* lex.lang = value
*
*/
__pyx_t_1 = ((__pyx_v_name == __pyx_e_5spacy_5attrs_LANG) != 0);
if (__pyx_t_1) {
/* "lexeme.pxd":44
* lex.suffix = value
* elif name == LANG:
* lex.lang = value # <<<<<<<<<<<<<<
*
* @staticmethod
*/
__pyx_v_lex->lang = __pyx_v_value;
/* "lexeme.pxd":43
* elif name == SUFFIX:
* lex.suffix = value
* elif name == LANG: # <<<<<<<<<<<<<<
* lex.lang = value
*
*/
}
__pyx_L3:;
/* "lexeme.pxd":28
*
* @staticmethod
* cdef inline void set_struct_attr(LexemeC* lex, attr_id_t name, attr_t value) nogil: # <<<<<<<<<<<<<<
* if name < (sizeof(flags_t) * 8):
* Lexeme.c_set_flag(lex, name, value)
*/
/* function exit code */
goto __pyx_L0;
__pyx_L1_error:;
__Pyx_WriteUnraisable("spacy.lexeme.Lexeme.set_struct_attr", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 1);
__pyx_L0:;
__Pyx_TraceReturn(Py_None, 1);
}
/* "lexeme.pxd":47
*
* @staticmethod
* cdef inline attr_t get_struct_attr(const LexemeC* lex, attr_id_t feat_name) nogil: # <<<<<<<<<<<<<<
* if feat_name < (sizeof(flags_t) * 8):
* if Lexeme.c_check_flag(lex, feat_name):
*/
static CYTHON_INLINE __pyx_t_5spacy_8typedefs_attr_t __pyx_f_5spacy_6lexeme_6Lexeme_get_struct_attr(struct __pyx_t_5spacy_7structs_LexemeC const *__pyx_v_lex, enum __pyx_t_5spacy_5attrs_attr_id_t __pyx_v_feat_name) {
__pyx_t_5spacy_8typedefs_attr_t __pyx_r;
__Pyx_TraceDeclarations
int __pyx_t_1;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_TraceCall("get_struct_attr", __pyx_f[3], 47, 1, __PYX_ERR(3, 47, __pyx_L1_error));
/* "lexeme.pxd":48
* @staticmethod
* cdef inline attr_t get_struct_attr(const LexemeC* lex, attr_id_t feat_name) nogil:
* if feat_name < (sizeof(flags_t) * 8): # <<<<<<<<<<<<<<
* if Lexeme.c_check_flag(lex, feat_name):
* return 1
*/
__pyx_t_1 = ((__pyx_v_feat_name < ((sizeof(__pyx_t_5spacy_8typedefs_flags_t)) * 8)) != 0);
if (__pyx_t_1) {
/* "lexeme.pxd":49
* cdef inline attr_t get_struct_attr(const LexemeC* lex, attr_id_t feat_name) nogil:
* if feat_name < (sizeof(flags_t) * 8):
* if Lexeme.c_check_flag(lex, feat_name): # <<<<<<<<<<<<<<
* return 1
* else:
*/
__pyx_t_1 = (__pyx_f_5spacy_6lexeme_6Lexeme_c_check_flag(__pyx_v_lex, __pyx_v_feat_name) != 0);
if (__pyx_t_1) {
/* "lexeme.pxd":50
* if feat_name < (sizeof(flags_t) * 8):
* if Lexeme.c_check_flag(lex, feat_name):
* return 1 # <<<<<<<<<<<<<<
* else:
* return 0
*/
__pyx_r = 1;
goto __pyx_L0;
/* "lexeme.pxd":49
* cdef inline attr_t get_struct_attr(const LexemeC* lex, attr_id_t feat_name) nogil:
* if feat_name < (sizeof(flags_t) * 8):
* if Lexeme.c_check_flag(lex, feat_name): # <<<<<<<<<<<<<<
* return 1
* else:
*/
}
/* "lexeme.pxd":52
* return 1
* else:
* return 0 # <<<<<<<<<<<<<<
* elif feat_name == ID:
* return lex.id
*/
/*else*/ {
__pyx_r = 0;
goto __pyx_L0;
}
/* "lexeme.pxd":48
* @staticmethod
* cdef inline attr_t get_struct_attr(const LexemeC* lex, attr_id_t feat_name) nogil:
* if feat_name < (sizeof(flags_t) * 8): # <<<<<<<<<<<<<<
* if Lexeme.c_check_flag(lex, feat_name):
* return 1
*/
}
/* "lexeme.pxd":53
* else:
* return 0
* elif feat_name == ID: # <<<<<<<<<<<<<<
* return lex.id
* elif feat_name == ORTH:
*/
__pyx_t_1 = ((__pyx_v_feat_name == __pyx_e_5spacy_5attrs_ID) != 0);
if (__pyx_t_1) {
/* "lexeme.pxd":54
* return 0
* elif feat_name == ID:
* return lex.id # <<<<<<<<<<<<<<
* elif feat_name == ORTH:
* return lex.orth
*/
__pyx_r = __pyx_v_lex->id;
goto __pyx_L0;
/* "lexeme.pxd":53
* else:
* return 0
* elif feat_name == ID: # <<<<<<<<<<<<<<
* return lex.id
* elif feat_name == ORTH:
*/
}
/* "lexeme.pxd":55
* elif feat_name == ID:
* return lex.id
* elif feat_name == ORTH: # <<<<<<<<<<<<<<
* return lex.orth
* elif feat_name == LOWER:
*/
__pyx_t_1 = ((__pyx_v_feat_name == __pyx_e_5spacy_5attrs_ORTH) != 0);
if (__pyx_t_1) {
/* "lexeme.pxd":56
* return lex.id
* elif feat_name == ORTH:
* return lex.orth # <<<<<<<<<<<<<<
* elif feat_name == LOWER:
* return lex.lower
*/
__pyx_r = __pyx_v_lex->orth;
goto __pyx_L0;
/* "lexeme.pxd":55
* elif feat_name == ID:
* return lex.id
* elif feat_name == ORTH: # <<<<<<<<<<<<<<
* return lex.orth
* elif feat_name == LOWER:
*/
}
/* "lexeme.pxd":57
* elif feat_name == ORTH:
* return lex.orth
* elif feat_name == LOWER: # <<<<<<<<<<<<<<
* return lex.lower
* elif feat_name == NORM:
*/
__pyx_t_1 = ((__pyx_v_feat_name == __pyx_e_5spacy_5attrs_LOWER) != 0);
if (__pyx_t_1) {
/* "lexeme.pxd":58
* return lex.orth
* elif feat_name == LOWER:
* return lex.lower # <<<<<<<<<<<<<<
* elif feat_name == NORM:
* return lex.norm
*/
__pyx_r = __pyx_v_lex->lower;
goto __pyx_L0;
/* "lexeme.pxd":57
* elif feat_name == ORTH:
* return lex.orth
* elif feat_name == LOWER: # <<<<<<<<<<<<<<
* return lex.lower
* elif feat_name == NORM:
*/
}
/* "lexeme.pxd":59
* elif feat_name == LOWER:
* return lex.lower
* elif feat_name == NORM: # <<<<<<<<<<<<<<
* return lex.norm
* elif feat_name == SHAPE:
*/
__pyx_t_1 = ((__pyx_v_feat_name == __pyx_e_5spacy_5attrs_NORM) != 0);
if (__pyx_t_1) {
/* "lexeme.pxd":60
* return lex.lower
* elif feat_name == NORM:
* return lex.norm # <<<<<<<<<<<<<<
* elif feat_name == SHAPE:
* return lex.shape
*/
__pyx_r = __pyx_v_lex->norm;
goto __pyx_L0;
/* "lexeme.pxd":59
* elif feat_name == LOWER:
* return lex.lower
* elif feat_name == NORM: # <<<<<<<<<<<<<<
* return lex.norm
* elif feat_name == SHAPE:
*/
}
/* "lexeme.pxd":61
* elif feat_name == NORM:
* return lex.norm
* elif feat_name == SHAPE: # <<<<<<<<<<<<<<
* return lex.shape
* elif feat_name == PREFIX:
*/
__pyx_t_1 = ((__pyx_v_feat_name == __pyx_e_5spacy_5attrs_SHAPE) != 0);
if (__pyx_t_1) {
/* "lexeme.pxd":62
* return lex.norm
* elif feat_name == SHAPE:
* return lex.shape # <<<<<<<<<<<<<<
* elif feat_name == PREFIX:
* return lex.prefix
*/
__pyx_r = __pyx_v_lex->shape;
goto __pyx_L0;
/* "lexeme.pxd":61
* elif feat_name == NORM:
* return lex.norm
* elif feat_name == SHAPE: # <<<<<<<<<<<<<<
* return lex.shape
* elif feat_name == PREFIX:
*/
}
/* "lexeme.pxd":63
* elif feat_name == SHAPE:
* return lex.shape
* elif feat_name == PREFIX: # <<<<<<<<<<<<<<
* return lex.prefix
* elif feat_name == SUFFIX:
*/
__pyx_t_1 = ((__pyx_v_feat_name == __pyx_e_5spacy_5attrs_PREFIX) != 0);
if (__pyx_t_1) {
/* "lexeme.pxd":64
* return lex.shape
* elif feat_name == PREFIX:
* return lex.prefix # <<<<<<<<<<<<<<
* elif feat_name == SUFFIX:
* return lex.suffix
*/
__pyx_r = __pyx_v_lex->prefix;
goto __pyx_L0;
/* "lexeme.pxd":63
* elif feat_name == SHAPE:
* return lex.shape
* elif feat_name == PREFIX: # <<<<<<<<<<<<<<
* return lex.prefix
* elif feat_name == SUFFIX:
*/
}
/* "lexeme.pxd":65
* elif feat_name == PREFIX:
* return lex.prefix
* elif feat_name == SUFFIX: # <<<<<<<<<<<<<<
* return lex.suffix
* elif feat_name == LENGTH:
*/
__pyx_t_1 = ((__pyx_v_feat_name == __pyx_e_5spacy_5attrs_SUFFIX) != 0);
if (__pyx_t_1) {
/* "lexeme.pxd":66
* return lex.prefix
* elif feat_name == SUFFIX:
* return lex.suffix # <<<<<<<<<<<<<<
* elif feat_name == LENGTH:
* return lex.length
*/
__pyx_r = __pyx_v_lex->suffix;
goto __pyx_L0;
/* "lexeme.pxd":65
* elif feat_name == PREFIX:
* return lex.prefix
* elif feat_name == SUFFIX: # <<<<<<<<<<<<<<
* return lex.suffix
* elif feat_name == LENGTH:
*/
}
/* "lexeme.pxd":67
* elif feat_name == SUFFIX:
* return lex.suffix
* elif feat_name == LENGTH: # <<<<<<<<<<<<<<
* return lex.length
* elif feat_name == LANG:
*/
__pyx_t_1 = ((__pyx_v_feat_name == __pyx_e_5spacy_5attrs_LENGTH) != 0);
if (__pyx_t_1) {
/* "lexeme.pxd":68
* return lex.suffix
* elif feat_name == LENGTH:
* return lex.length # <<<<<<<<<<<<<<
* elif feat_name == LANG:
* return lex.lang
*/
__pyx_r = __pyx_v_lex->length;
goto __pyx_L0;
/* "lexeme.pxd":67
* elif feat_name == SUFFIX:
* return lex.suffix
* elif feat_name == LENGTH: # <<<<<<<<<<<<<<
* return lex.length
* elif feat_name == LANG:
*/
}
/* "lexeme.pxd":69
* elif feat_name == LENGTH:
* return lex.length
* elif feat_name == LANG: # <<<<<<<<<<<<<<
* return lex.lang
* else:
*/
__pyx_t_1 = ((__pyx_v_feat_name == __pyx_e_5spacy_5attrs_LANG) != 0);
if (__pyx_t_1) {
/* "lexeme.pxd":70
* return lex.length
* elif feat_name == LANG:
* return lex.lang # <<<<<<<<<<<<<<
* else:
* return 0
*/
__pyx_r = __pyx_v_lex->lang;
goto __pyx_L0;
/* "lexeme.pxd":69
* elif feat_name == LENGTH:
* return lex.length
* elif feat_name == LANG: # <<<<<<<<<<<<<<
* return lex.lang
* else:
*/
}
/* "lexeme.pxd":72
* return lex.lang
* else:
* return 0 # <<<<<<<<<<<<<<
*
* @staticmethod
*/
/*else*/ {
__pyx_r = 0;
goto __pyx_L0;
}
/* "lexeme.pxd":47
*
* @staticmethod
* cdef inline attr_t get_struct_attr(const LexemeC* lex, attr_id_t feat_name) nogil: # <<<<<<<<<<<<<<
* if feat_name < (sizeof(flags_t) * 8):
* if Lexeme.c_check_flag(lex, feat_name):
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_WriteUnraisable("spacy.lexeme.Lexeme.get_struct_attr", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 1);
__pyx_r = 0;
__pyx_L0:;
__Pyx_TraceReturn(Py_None, 1);
return __pyx_r;
}
/* "lexeme.pxd":75
*
* @staticmethod
* cdef inline bint c_check_flag(const LexemeC* lexeme, attr_id_t flag_id) nogil: # <<<<<<<<<<<<<<
* cdef flags_t one = 1
* if lexeme.flags & (one << flag_id):
*/
static CYTHON_INLINE int __pyx_f_5spacy_6lexeme_6Lexeme_c_check_flag(struct __pyx_t_5spacy_7structs_LexemeC const *__pyx_v_lexeme, enum __pyx_t_5spacy_5attrs_attr_id_t __pyx_v_flag_id) {
__pyx_t_5spacy_8typedefs_flags_t __pyx_v_one;
int __pyx_r;
__Pyx_TraceDeclarations
int __pyx_t_1;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_TraceCall("c_check_flag", __pyx_f[3], 75, 1, __PYX_ERR(3, 75, __pyx_L1_error));
/* "lexeme.pxd":76
* @staticmethod
* cdef inline bint c_check_flag(const LexemeC* lexeme, attr_id_t flag_id) nogil:
* cdef flags_t one = 1 # <<<<<<<<<<<<<<
* if lexeme.flags & (one << flag_id):
* return True
*/
__pyx_v_one = 1;
/* "lexeme.pxd":77
* cdef inline bint c_check_flag(const LexemeC* lexeme, attr_id_t flag_id) nogil:
* cdef flags_t one = 1
* if lexeme.flags & (one << flag_id): # <<<<<<<<<<<<<<
* return True
* else:
*/
__pyx_t_1 = ((__pyx_v_lexeme->flags & (__pyx_v_one << __pyx_v_flag_id)) != 0);
if (__pyx_t_1) {
/* "lexeme.pxd":78
* cdef flags_t one = 1
* if lexeme.flags & (one << flag_id):
* return True # <<<<<<<<<<<<<<
* else:
* return False
*/
__pyx_r = 1;
goto __pyx_L0;
/* "lexeme.pxd":77
* cdef inline bint c_check_flag(const LexemeC* lexeme, attr_id_t flag_id) nogil:
* cdef flags_t one = 1
* if lexeme.flags & (one << flag_id): # <<<<<<<<<<<<<<
* return True
* else:
*/
}
/* "lexeme.pxd":80
* return True
* else:
* return False # <<<<<<<<<<<<<<
*
* @staticmethod
*/
/*else*/ {
__pyx_r = 0;
goto __pyx_L0;
}
/* "lexeme.pxd":75
*
* @staticmethod
* cdef inline bint c_check_flag(const LexemeC* lexeme, attr_id_t flag_id) nogil: # <<<<<<<<<<<<<<
* cdef flags_t one = 1
* if lexeme.flags & (one << flag_id):
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_WriteUnraisable("spacy.lexeme.Lexeme.c_check_flag", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 1);
__pyx_r = 0;
__pyx_L0:;
__Pyx_TraceReturn(Py_None, 1);
return __pyx_r;
}
/* "lexeme.pxd":83
*
* @staticmethod
* cdef inline bint c_set_flag(LexemeC* lex, attr_id_t flag_id, bint value) nogil: # <<<<<<<<<<<<<<
* cdef flags_t one = 1
* if value:
*/
static CYTHON_INLINE int __pyx_f_5spacy_6lexeme_6Lexeme_c_set_flag(struct __pyx_t_5spacy_7structs_LexemeC *__pyx_v_lex, enum __pyx_t_5spacy_5attrs_attr_id_t __pyx_v_flag_id, int __pyx_v_value) {
__pyx_t_5spacy_8typedefs_flags_t __pyx_v_one;
int __pyx_r;
__Pyx_TraceDeclarations
int __pyx_t_1;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_TraceCall("c_set_flag", __pyx_f[3], 83, 1, __PYX_ERR(3, 83, __pyx_L1_error));
/* "lexeme.pxd":84
* @staticmethod
* cdef inline bint c_set_flag(LexemeC* lex, attr_id_t flag_id, bint value) nogil:
* cdef flags_t one = 1 # <<<<<<<<<<<<<<
* if value:
* lex.flags |= one << flag_id
*/
__pyx_v_one = 1;
/* "lexeme.pxd":85
* cdef inline bint c_set_flag(LexemeC* lex, attr_id_t flag_id, bint value) nogil:
* cdef flags_t one = 1
* if value: # <<<<<<<<<<<<<<
* lex.flags |= one << flag_id
* else:
*/
__pyx_t_1 = (__pyx_v_value != 0);
if (__pyx_t_1) {
/* "lexeme.pxd":86
* cdef flags_t one = 1
* if value:
* lex.flags |= one << flag_id # <<<<<<<<<<<<<<
* else:
* lex.flags &= ~(one << flag_id)
*/
__pyx_v_lex->flags = (__pyx_v_lex->flags | (__pyx_v_one << __pyx_v_flag_id));
/* "lexeme.pxd":85
* cdef inline bint c_set_flag(LexemeC* lex, attr_id_t flag_id, bint value) nogil:
* cdef flags_t one = 1
* if value: # <<<<<<<<<<<<<<
* lex.flags |= one << flag_id
* else:
*/
goto __pyx_L3;
}
/* "lexeme.pxd":88
* lex.flags |= one << flag_id
* else:
* lex.flags &= ~(one << flag_id) # <<<<<<<<<<<<<<
*/
/*else*/ {
__pyx_v_lex->flags = (__pyx_v_lex->flags & (~(__pyx_v_one << __pyx_v_flag_id)));
}
__pyx_L3:;
/* "lexeme.pxd":83
*
* @staticmethod
* cdef inline bint c_set_flag(LexemeC* lex, attr_id_t flag_id, bint value) nogil: # <<<<<<<<<<<<<<
* cdef flags_t one = 1
* if value:
*/
/* function exit code */
__pyx_r = 0;
goto __pyx_L0;
__pyx_L1_error:;
__Pyx_WriteUnraisable("spacy.lexeme.Lexeme.c_set_flag", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 1);
__pyx_r = 0;
__pyx_L0:;
__Pyx_TraceReturn(Py_None, 1);
return __pyx_r;
}
/* "_state.pxd":17
*
*
* cdef inline bint is_space_token(const TokenC* token) nogil: # <<<<<<<<<<<<<<
* return Lexeme.c_check_flag(token.lex, IS_SPACE)
*
*/
static CYTHON_INLINE int __pyx_f_5spacy_6syntax_6_state_is_space_token(struct __pyx_t_5spacy_7structs_TokenC const *__pyx_v_token) {
int __pyx_r;
__Pyx_TraceDeclarations
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_TraceCall("is_space_token", __pyx_f[4], 17, 1, __PYX_ERR(4, 17, __pyx_L1_error));
/* "_state.pxd":18
*
* cdef inline bint is_space_token(const TokenC* token) nogil:
* return Lexeme.c_check_flag(token.lex, IS_SPACE) # <<<<<<<<<<<<<<
*
* cdef struct RingBufferC:
*/
__pyx_r = __pyx_f_5spacy_6lexeme_6Lexeme_c_check_flag(__pyx_v_token->lex, __pyx_e_5spacy_5attrs_IS_SPACE);
goto __pyx_L0;
/* "_state.pxd":17
*
*
* cdef inline bint is_space_token(const TokenC* token) nogil: # <<<<<<<<<<<<<<
* return Lexeme.c_check_flag(token.lex, IS_SPACE)
*
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_WriteUnraisable("spacy.syntax._state.is_space_token", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 1);
__pyx_r = 0;
__pyx_L0:;
__Pyx_TraceReturn(Py_None, 1);
return __pyx_r;
}
/* "_state.pxd":25
* int default
*
* cdef inline int ring_push(RingBufferC* ring, int value) nogil: # <<<<<<<<<<<<<<
* ring.data[ring.i] = value
* ring.i += 1
*/
static CYTHON_INLINE int __pyx_f_5spacy_6syntax_6_state_ring_push(struct __pyx_t_5spacy_6syntax_6_state_RingBufferC *__pyx_v_ring, int __pyx_v_value) {
int __pyx_r;
__Pyx_TraceDeclarations
int __pyx_t_1;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_TraceCall("ring_push", __pyx_f[4], 25, 1, __PYX_ERR(4, 25, __pyx_L1_error));
/* "_state.pxd":26
*
* cdef inline int ring_push(RingBufferC* ring, int value) nogil:
* ring.data[ring.i] = value # <<<<<<<<<<<<<<
* ring.i += 1
* if ring.i >= 8:
*/
(__pyx_v_ring->data[__pyx_v_ring->i]) = __pyx_v_value;
/* "_state.pxd":27
* cdef inline int ring_push(RingBufferC* ring, int value) nogil:
* ring.data[ring.i] = value
* ring.i += 1 # <<<<<<<<<<<<<<
* if ring.i >= 8:
* ring.i = 0
*/
__pyx_v_ring->i = (__pyx_v_ring->i + 1);
/* "_state.pxd":28
* ring.data[ring.i] = value
* ring.i += 1
* if ring.i >= 8: # <<<<<<<<<<<<<<
* ring.i = 0
*
*/
__pyx_t_1 = ((__pyx_v_ring->i >= 8) != 0);
if (__pyx_t_1) {
/* "_state.pxd":29
* ring.i += 1
* if ring.i >= 8:
* ring.i = 0 # <<<<<<<<<<<<<<
*
* cdef inline int ring_get(RingBufferC* ring, int i) nogil:
*/
__pyx_v_ring->i = 0;
/* "_state.pxd":28
* ring.data[ring.i] = value
* ring.i += 1
* if ring.i >= 8: # <<<<<<<<<<<<<<
* ring.i = 0
*
*/
}
/* "_state.pxd":25
* int default
*
* cdef inline int ring_push(RingBufferC* ring, int value) nogil: # <<<<<<<<<<<<<<
* ring.data[ring.i] = value
* ring.i += 1
*/
/* function exit code */
__pyx_r = 0;
goto __pyx_L0;
__pyx_L1_error:;
__Pyx_WriteUnraisable("spacy.syntax._state.ring_push", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 1);
__pyx_r = 0;
__pyx_L0:;
__Pyx_TraceReturn(Py_None, 1);
return __pyx_r;
}
/* "_state.pxd":31
* ring.i = 0
*
* cdef inline int ring_get(RingBufferC* ring, int i) nogil: # <<<<<<<<<<<<<<
* if i >= ring.i:
* return ring.default
*/
static CYTHON_INLINE int __pyx_f_5spacy_6syntax_6_state_ring_get(struct __pyx_t_5spacy_6syntax_6_state_RingBufferC *__pyx_v_ring, int __pyx_v_i) {
int __pyx_r;
__Pyx_TraceDeclarations
int __pyx_t_1;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_TraceCall("ring_get", __pyx_f[4], 31, 1, __PYX_ERR(4, 31, __pyx_L1_error));
/* "_state.pxd":32
*
* cdef inline int ring_get(RingBufferC* ring, int i) nogil:
* if i >= ring.i: # <<<<<<<<<<<<<<
* return ring.default
* else:
*/
__pyx_t_1 = ((__pyx_v_i >= __pyx_v_ring->i) != 0);
if (__pyx_t_1) {
/* "_state.pxd":33
* cdef inline int ring_get(RingBufferC* ring, int i) nogil:
* if i >= ring.i:
* return ring.default # <<<<<<<<<<<<<<
* else:
* return ring.data[ring.i-i]
*/
__pyx_r = __pyx_v_ring->__pyx_default;
goto __pyx_L0;
/* "_state.pxd":32
*
* cdef inline int ring_get(RingBufferC* ring, int i) nogil:
* if i >= ring.i: # <<<<<<<<<<<<<<
* return ring.default
* else:
*/
}
/* "_state.pxd":35
* return ring.default
* else:
* return ring.data[ring.i-i] # <<<<<<<<<<<<<<
*
*
*/
/*else*/ {
__pyx_r = (__pyx_v_ring->data[(__pyx_v_ring->i - __pyx_v_i)]);
goto __pyx_L0;
}
/* "_state.pxd":31
* ring.i = 0
*
* cdef inline int ring_get(RingBufferC* ring, int i) nogil: # <<<<<<<<<<<<<<
* if i >= ring.i:
* return ring.default
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_WriteUnraisable("spacy.syntax._state.ring_get", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 1);
__pyx_r = 0;
__pyx_L0:;
__Pyx_TraceReturn(Py_None, 1);
return __pyx_r;
}
/* "_state.pxd":53
* int _break
*
* __init__(const TokenC* sent, int length) nogil: # <<<<<<<<<<<<<<
* cdef int PADDING = 5
* this._buffer = <int*>calloc(length + (PADDING * 2), sizeof(int))
*/
void __pyx_t_5spacy_6syntax_6_state_StateC::__pyx_f___init__StateC(struct __pyx_t_5spacy_7structs_TokenC const *__pyx_v_sent, int __pyx_v_length) {
int __pyx_v_PADDING;
int __pyx_v_i;
__Pyx_TraceDeclarations
__Pyx_RefNannyDeclarations
int __pyx_t_1;
int __pyx_t_2;
PyObject *__pyx_t_3;
int __pyx_t_4;
long __pyx_t_5;
long __pyx_t_6;
int __pyx_t_7;
int __pyx_t_8;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
#ifdef WITH_THREAD
PyGILState_STATE __pyx_gilstate_save;
#endif
__Pyx_RefNannySetupContext("<init>", 1);
__Pyx_TraceCall("<init>", __pyx_f[4], 53, 1, __PYX_ERR(4, 53, __pyx_L1_error));
/* "_state.pxd":54
*
* __init__(const TokenC* sent, int length) nogil:
* cdef int PADDING = 5 # <<<<<<<<<<<<<<
* this._buffer = <int*>calloc(length + (PADDING * 2), sizeof(int))
* this._stack = <int*>calloc(length + (PADDING * 2), sizeof(int))
*/
/*try:*/ {
__pyx_v_PADDING = 5;
/* "_state.pxd":55
* __init__(const TokenC* sent, int length) nogil:
* cdef int PADDING = 5
* this._buffer = <int*>calloc(length + (PADDING * 2), sizeof(int)) # <<<<<<<<<<<<<<
* this._stack = <int*>calloc(length + (PADDING * 2), sizeof(int))
* this.shifted = <bint*>calloc(length + (PADDING * 2), sizeof(bint))
*/
this->_buffer = ((int *)calloc((__pyx_v_length + (__pyx_v_PADDING * 2)), (sizeof(int))));
/* "_state.pxd":56
* cdef int PADDING = 5
* this._buffer = <int*>calloc(length + (PADDING * 2), sizeof(int))
* this._stack = <int*>calloc(length + (PADDING * 2), sizeof(int)) # <<<<<<<<<<<<<<
* this.shifted = <bint*>calloc(length + (PADDING * 2), sizeof(bint))
* this._sent = <TokenC*>calloc(length + (PADDING * 2), sizeof(TokenC))
*/
this->_stack = ((int *)calloc((__pyx_v_length + (__pyx_v_PADDING * 2)), (sizeof(int))));
/* "_state.pxd":57
* this._buffer = <int*>calloc(length + (PADDING * 2), sizeof(int))
* this._stack = <int*>calloc(length + (PADDING * 2), sizeof(int))
* this.shifted = <bint*>calloc(length + (PADDING * 2), sizeof(bint)) # <<<<<<<<<<<<<<
* this._sent = <TokenC*>calloc(length + (PADDING * 2), sizeof(TokenC))
* this._ents = <SpanC*>calloc(length + (PADDING * 2), sizeof(SpanC))
*/
this->shifted = ((int *)calloc((__pyx_v_length + (__pyx_v_PADDING * 2)), (sizeof(int))));
/* "_state.pxd":58
* this._stack = <int*>calloc(length + (PADDING * 2), sizeof(int))
* this.shifted = <bint*>calloc(length + (PADDING * 2), sizeof(bint))
* this._sent = <TokenC*>calloc(length + (PADDING * 2), sizeof(TokenC)) # <<<<<<<<<<<<<<
* this._ents = <SpanC*>calloc(length + (PADDING * 2), sizeof(SpanC))
* if not (this._buffer and this._stack and this.shifted
*/
this->_sent = ((struct __pyx_t_5spacy_7structs_TokenC *)calloc((__pyx_v_length + (__pyx_v_PADDING * 2)), (sizeof(struct __pyx_t_5spacy_7structs_TokenC))));
/* "_state.pxd":59
* this.shifted = <bint*>calloc(length + (PADDING * 2), sizeof(bint))
* this._sent = <TokenC*>calloc(length + (PADDING * 2), sizeof(TokenC))
* this._ents = <SpanC*>calloc(length + (PADDING * 2), sizeof(SpanC)) # <<<<<<<<<<<<<<
* if not (this._buffer and this._stack and this.shifted
* and this._sent and this._ents):
*/
this->_ents = ((struct __pyx_t_5spacy_7structs_SpanC *)calloc((__pyx_v_length + (__pyx_v_PADDING * 2)), (sizeof(struct __pyx_t_5spacy_7structs_SpanC))));
/* "_state.pxd":60
* this._sent = <TokenC*>calloc(length + (PADDING * 2), sizeof(TokenC))
* this._ents = <SpanC*>calloc(length + (PADDING * 2), sizeof(SpanC))
* if not (this._buffer and this._stack and this.shifted # <<<<<<<<<<<<<<
* and this._sent and this._ents):
* with gil:
*/
__pyx_t_2 = (this->_buffer != 0);
if (__pyx_t_2) {
} else {
__pyx_t_1 = __pyx_t_2;
goto __pyx_L7_bool_binop_done;
}
__pyx_t_2 = (this->_stack != 0);
if (__pyx_t_2) {
} else {
__pyx_t_1 = __pyx_t_2;
goto __pyx_L7_bool_binop_done;
}
/* "_state.pxd":61
* this._ents = <SpanC*>calloc(length + (PADDING * 2), sizeof(SpanC))
* if not (this._buffer and this._stack and this.shifted
* and this._sent and this._ents): # <<<<<<<<<<<<<<
* with gil:
* PyErr_SetFromErrno(MemoryError)
*/
__pyx_t_2 = (this->shifted != 0);
if (__pyx_t_2) {
} else {
__pyx_t_1 = __pyx_t_2;
goto __pyx_L7_bool_binop_done;
}
__pyx_t_2 = (this->_sent != 0);
if (__pyx_t_2) {
} else {
__pyx_t_1 = __pyx_t_2;
goto __pyx_L7_bool_binop_done;
}
__pyx_t_2 = (this->_ents != 0);
__pyx_t_1 = __pyx_t_2;
__pyx_L7_bool_binop_done:;
/* "_state.pxd":60
* this._sent = <TokenC*>calloc(length + (PADDING * 2), sizeof(TokenC))
* this._ents = <SpanC*>calloc(length + (PADDING * 2), sizeof(SpanC))
* if not (this._buffer and this._stack and this.shifted # <<<<<<<<<<<<<<
* and this._sent and this._ents):
* with gil:
*/
__pyx_t_2 = ((!__pyx_t_1) != 0);
if (__pyx_t_2) {
/* "_state.pxd":62
* if not (this._buffer and this._stack and this.shifted
* and this._sent and this._ents):
* with gil: # <<<<<<<<<<<<<<
* PyErr_SetFromErrno(MemoryError)
* PyErr_CheckSignals()
*/
{
#ifdef WITH_THREAD
PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
#endif
/*try:*/ {
/* "_state.pxd":63
* and this._sent and this._ents):
* with gil:
* PyErr_SetFromErrno(MemoryError) # <<<<<<<<<<<<<<
* PyErr_CheckSignals()
* memset(&this._hist, 0, sizeof(this._hist))
*/
__pyx_t_3 = PyErr_SetFromErrno(__pyx_builtin_MemoryError); if (unlikely(__pyx_t_3 == ((PyObject *)NULL))) __PYX_ERR(4, 63, __pyx_L13_error)
/* "_state.pxd":64
* with gil:
* PyErr_SetFromErrno(MemoryError)
* PyErr_CheckSignals() # <<<<<<<<<<<<<<
* memset(&this._hist, 0, sizeof(this._hist))
* this.offset = 0
*/
__pyx_t_4 = PyErr_CheckSignals(); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(4, 64, __pyx_L13_error)
}
/* "_state.pxd":62
* if not (this._buffer and this._stack and this.shifted
* and this._sent and this._ents):
* with gil: # <<<<<<<<<<<<<<
* PyErr_SetFromErrno(MemoryError)
* PyErr_CheckSignals()
*/
/*finally:*/ {
/*normal exit:*/{
#ifdef WITH_THREAD
__Pyx_PyGILState_Release(__pyx_gilstate_save);
#endif
goto __pyx_L14;
}
__pyx_L13_error: {
#ifdef WITH_THREAD
__Pyx_PyGILState_Release(__pyx_gilstate_save);
#endif
goto __pyx_L4_error;
}
__pyx_L14:;
}
}
/* "_state.pxd":60
* this._sent = <TokenC*>calloc(length + (PADDING * 2), sizeof(TokenC))
* this._ents = <SpanC*>calloc(length + (PADDING * 2), sizeof(SpanC))
* if not (this._buffer and this._stack and this.shifted # <<<<<<<<<<<<<<
* and this._sent and this._ents):
* with gil:
*/
}
/* "_state.pxd":65
* PyErr_SetFromErrno(MemoryError)
* PyErr_CheckSignals()
* memset(&this._hist, 0, sizeof(this._hist)) # <<<<<<<<<<<<<<
* this.offset = 0
* cdef int i
*/
(void)(memset((&this->_hist), 0, (sizeof(this->_hist))));
/* "_state.pxd":66
* PyErr_CheckSignals()
* memset(&this._hist, 0, sizeof(this._hist))
* this.offset = 0 # <<<<<<<<<<<<<<
* cdef int i
* for i in range(length + (PADDING * 2)):
*/
this->offset = 0;
/* "_state.pxd":68
* this.offset = 0
* cdef int i
* for i in range(length + (PADDING * 2)): # <<<<<<<<<<<<<<
* this._ents[i].end = -1
* this._sent[i].l_edge = i
*/
__pyx_t_5 = (__pyx_v_length + (__pyx_v_PADDING * 2));
__pyx_t_6 = __pyx_t_5;
for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_6; __pyx_t_4+=1) {
__pyx_v_i = __pyx_t_4;
/* "_state.pxd":69
* cdef int i
* for i in range(length + (PADDING * 2)):
* this._ents[i].end = -1 # <<<<<<<<<<<<<<
* this._sent[i].l_edge = i
* this._sent[i].r_edge = i
*/
(this->_ents[__pyx_v_i]).end = -1;
/* "_state.pxd":70
* for i in range(length + (PADDING * 2)):
* this._ents[i].end = -1
* this._sent[i].l_edge = i # <<<<<<<<<<<<<<
* this._sent[i].r_edge = i
* for i in range(PADDING):
*/
(this->_sent[__pyx_v_i]).l_edge = __pyx_v_i;
/* "_state.pxd":71
* this._ents[i].end = -1
* this._sent[i].l_edge = i
* this._sent[i].r_edge = i # <<<<<<<<<<<<<<
* for i in range(PADDING):
* this._sent[i].lex = &EMPTY_LEXEME
*/
(this->_sent[__pyx_v_i]).r_edge = __pyx_v_i;
}
/* "_state.pxd":72
* this._sent[i].l_edge = i
* this._sent[i].r_edge = i
* for i in range(PADDING): # <<<<<<<<<<<<<<
* this._sent[i].lex = &EMPTY_LEXEME
* this._sent += PADDING
*/
__pyx_t_4 = __pyx_v_PADDING;
__pyx_t_7 = __pyx_t_4;
for (__pyx_t_8 = 0; __pyx_t_8 < __pyx_t_7; __pyx_t_8+=1) {
__pyx_v_i = __pyx_t_8;
/* "_state.pxd":73
* this._sent[i].r_edge = i
* for i in range(PADDING):
* this._sent[i].lex = &EMPTY_LEXEME # <<<<<<<<<<<<<<
* this._sent += PADDING
* this._ents += PADDING
*/
(this->_sent[__pyx_v_i]).lex = (&__pyx_v_5spacy_5vocab_EMPTY_LEXEME);
}
/* "_state.pxd":74
* for i in range(PADDING):
* this._sent[i].lex = &EMPTY_LEXEME
* this._sent += PADDING # <<<<<<<<<<<<<<
* this._ents += PADDING
* this._buffer += PADDING
*/
this->_sent = (this->_sent + __pyx_v_PADDING);
/* "_state.pxd":75
* this._sent[i].lex = &EMPTY_LEXEME
* this._sent += PADDING
* this._ents += PADDING # <<<<<<<<<<<<<<
* this._buffer += PADDING
* this._stack += PADDING
*/
this->_ents = (this->_ents + __pyx_v_PADDING);
/* "_state.pxd":76
* this._sent += PADDING
* this._ents += PADDING
* this._buffer += PADDING # <<<<<<<<<<<<<<
* this._stack += PADDING
* this.shifted += PADDING
*/
this->_buffer = (this->_buffer + __pyx_v_PADDING);
/* "_state.pxd":77
* this._ents += PADDING
* this._buffer += PADDING
* this._stack += PADDING # <<<<<<<<<<<<<<
* this.shifted += PADDING
* this.length = length
*/
this->_stack = (this->_stack + __pyx_v_PADDING);
/* "_state.pxd":78
* this._buffer += PADDING
* this._stack += PADDING
* this.shifted += PADDING # <<<<<<<<<<<<<<
* this.length = length
* this._break = -1
*/
this->shifted = (this->shifted + __pyx_v_PADDING);
/* "_state.pxd":79
* this._stack += PADDING
* this.shifted += PADDING
* this.length = length # <<<<<<<<<<<<<<
* this._break = -1
* this._s_i = 0
*/
this->length = __pyx_v_length;
/* "_state.pxd":80
* this.shifted += PADDING
* this.length = length
* this._break = -1 # <<<<<<<<<<<<<<
* this._s_i = 0
* this._b_i = 0
*/
this->_break = -1;
/* "_state.pxd":81
* this.length = length
* this._break = -1
* this._s_i = 0 # <<<<<<<<<<<<<<
* this._b_i = 0
* this._e_i = 0
*/
this->_s_i = 0;
/* "_state.pxd":82
* this._break = -1
* this._s_i = 0
* this._b_i = 0 # <<<<<<<<<<<<<<
* this._e_i = 0
* for i in range(length):
*/
this->_b_i = 0;
/* "_state.pxd":83
* this._s_i = 0
* this._b_i = 0
* this._e_i = 0 # <<<<<<<<<<<<<<
* for i in range(length):
* this._buffer[i] = i
*/
this->_e_i = 0;
/* "_state.pxd":84
* this._b_i = 0
* this._e_i = 0
* for i in range(length): # <<<<<<<<<<<<<<
* this._buffer[i] = i
* memset(&this._empty_token, 0, sizeof(TokenC))
*/
__pyx_t_4 = __pyx_v_length;
__pyx_t_7 = __pyx_t_4;
for (__pyx_t_8 = 0; __pyx_t_8 < __pyx_t_7; __pyx_t_8+=1) {
__pyx_v_i = __pyx_t_8;
/* "_state.pxd":85
* this._e_i = 0
* for i in range(length):
* this._buffer[i] = i # <<<<<<<<<<<<<<
* memset(&this._empty_token, 0, sizeof(TokenC))
* this._empty_token.lex = &EMPTY_LEXEME
*/
(this->_buffer[__pyx_v_i]) = __pyx_v_i;
}
/* "_state.pxd":86
* for i in range(length):
* this._buffer[i] = i
* memset(&this._empty_token, 0, sizeof(TokenC)) # <<<<<<<<<<<<<<
* this._empty_token.lex = &EMPTY_LEXEME
* for i in range(length):
*/
(void)(memset((&this->_empty_token), 0, (sizeof(struct __pyx_t_5spacy_7structs_TokenC))));
/* "_state.pxd":87
* this._buffer[i] = i
* memset(&this._empty_token, 0, sizeof(TokenC))
* this._empty_token.lex = &EMPTY_LEXEME # <<<<<<<<<<<<<<
* for i in range(length):
* this._sent[i] = sent[i]
*/
this->_empty_token.lex = (&__pyx_v_5spacy_5vocab_EMPTY_LEXEME);
/* "_state.pxd":88
* memset(&this._empty_token, 0, sizeof(TokenC))
* this._empty_token.lex = &EMPTY_LEXEME
* for i in range(length): # <<<<<<<<<<<<<<
* this._sent[i] = sent[i]
* this._buffer[i] = i
*/
__pyx_t_4 = __pyx_v_length;
__pyx_t_7 = __pyx_t_4;
for (__pyx_t_8 = 0; __pyx_t_8 < __pyx_t_7; __pyx_t_8+=1) {
__pyx_v_i = __pyx_t_8;
/* "_state.pxd":89
* this._empty_token.lex = &EMPTY_LEXEME
* for i in range(length):
* this._sent[i] = sent[i] # <<<<<<<<<<<<<<
* this._buffer[i] = i
* for i in range(length, length+PADDING):
*/
(this->_sent[__pyx_v_i]) = (__pyx_v_sent[__pyx_v_i]);
/* "_state.pxd":90
* for i in range(length):
* this._sent[i] = sent[i]
* this._buffer[i] = i # <<<<<<<<<<<<<<
* for i in range(length, length+PADDING):
* this._sent[i].lex = &EMPTY_LEXEME
*/
(this->_buffer[__pyx_v_i]) = __pyx_v_i;
}
/* "_state.pxd":91
* this._sent[i] = sent[i]
* this._buffer[i] = i
* for i in range(length, length+PADDING): # <<<<<<<<<<<<<<
* this._sent[i].lex = &EMPTY_LEXEME
*
*/
__pyx_t_4 = (__pyx_v_length + __pyx_v_PADDING);
__pyx_t_7 = __pyx_t_4;
for (__pyx_t_8 = __pyx_v_length; __pyx_t_8 < __pyx_t_7; __pyx_t_8+=1) {
__pyx_v_i = __pyx_t_8;
/* "_state.pxd":92
* this._buffer[i] = i
* for i in range(length, length+PADDING):
* this._sent[i].lex = &EMPTY_LEXEME # <<<<<<<<<<<<<<
*
* __dealloc__():
*/
(this->_sent[__pyx_v_i]).lex = (&__pyx_v_5spacy_5vocab_EMPTY_LEXEME);
}
}
/* "_state.pxd":54
*
* __init__(const TokenC* sent, int length) nogil:
* cdef int PADDING = 5 # <<<<<<<<<<<<<<
* this._buffer = <int*>calloc(length + (PADDING * 2), sizeof(int))
* this._stack = <int*>calloc(length + (PADDING * 2), sizeof(int))
*/
/*finally:*/ {
/*normal exit:*/{
#ifdef WITH_THREAD
__pyx_gilstate_save = __Pyx_PyGILState_Ensure();
#endif
goto __pyx_L5;
}
__pyx_L4_error: {
#ifdef WITH_THREAD
__pyx_gilstate_save = __Pyx_PyGILState_Ensure();
#endif
goto __pyx_L1_error;
}
__pyx_L5:;
}
/* "_state.pxd":53
* int _break
*
* __init__(const TokenC* sent, int length) nogil: # <<<<<<<<<<<<<<
* cdef int PADDING = 5
* this._buffer = <int*>calloc(length + (PADDING * 2), sizeof(int))
*/
/* function exit code */
goto __pyx_L0;
__pyx_L1_error:;
__Pyx_WriteUnraisable("StateC.<init>", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 1);
__pyx_L0:;
__Pyx_TraceReturn(Py_None, 1);
#ifdef WITH_THREAD
__Pyx_PyGILState_Release(__pyx_gilstate_save);
#endif
}
/* "_state.pxd":94
* this._sent[i].lex = &EMPTY_LEXEME
*
* __dealloc__(): # <<<<<<<<<<<<<<
* cdef int PADDING = 5
* free(this._sent - PADDING)
*/
void __pyx_t_5spacy_6syntax_6_state_StateC::__pyx_f___dealloc__StateC(void) {
int __pyx_v_PADDING;
__Pyx_TraceDeclarations
__Pyx_RefNannyDeclarations
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("<del>", 0);
__Pyx_TraceCall("<del>", __pyx_f[4], 94, 0, __PYX_ERR(4, 94, __pyx_L1_error));
/* "_state.pxd":95
*
* __dealloc__():
* cdef int PADDING = 5 # <<<<<<<<<<<<<<
* free(this._sent - PADDING)
* free(this._ents - PADDING)
*/
__pyx_v_PADDING = 5;
/* "_state.pxd":96
* __dealloc__():
* cdef int PADDING = 5
* free(this._sent - PADDING) # <<<<<<<<<<<<<<
* free(this._ents - PADDING)
* free(this._buffer - PADDING)
*/
free((this->_sent - __pyx_v_PADDING));
/* "_state.pxd":97
* cdef int PADDING = 5
* free(this._sent - PADDING)
* free(this._ents - PADDING) # <<<<<<<<<<<<<<
* free(this._buffer - PADDING)
* free(this._stack - PADDING)
*/
free((this->_ents - __pyx_v_PADDING));
/* "_state.pxd":98
* free(this._sent - PADDING)
* free(this._ents - PADDING)
* free(this._buffer - PADDING) # <<<<<<<<<<<<<<
* free(this._stack - PADDING)
* free(this.shifted - PADDING)
*/
free((this->_buffer - __pyx_v_PADDING));
/* "_state.pxd":99
* free(this._ents - PADDING)
* free(this._buffer - PADDING)
* free(this._stack - PADDING) # <<<<<<<<<<<<<<
* free(this.shifted - PADDING)
*
*/
free((this->_stack - __pyx_v_PADDING));
/* "_state.pxd":100
* free(this._buffer - PADDING)
* free(this._stack - PADDING)
* free(this.shifted - PADDING) # <<<<<<<<<<<<<<
*
* void set_context_tokens(int* ids, int n) nogil:
*/
free((this->shifted - __pyx_v_PADDING));
/* "_state.pxd":94
* this._sent[i].lex = &EMPTY_LEXEME
*
* __dealloc__(): # <<<<<<<<<<<<<<
* cdef int PADDING = 5
* free(this._sent - PADDING)
*/
/* function exit code */
goto __pyx_L0;
__pyx_L1_error:;
__Pyx_WriteUnraisable("StateC.<del>", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0);
__pyx_L0:;
__Pyx_TraceReturn(Py_None, 0);
__Pyx_RefNannyFinishContext();
}
/* "_state.pxd":102
* free(this.shifted - PADDING)
*
* void set_context_tokens(int* ids, int n) nogil: # <<<<<<<<<<<<<<
* if n == 1:
* if this.B(0) >= 0:
*/
void __pyx_t_5spacy_6syntax_6_state_StateC::set_context_tokens(int *__pyx_v_ids, int __pyx_v_n) {
int __pyx_v_i;
__Pyx_TraceDeclarations
int __pyx_t_1;
int __pyx_t_2;
int __pyx_t_3;
int __pyx_t_4;
int __pyx_t_5;
int __pyx_t_6;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_TraceCall("set_context_tokens", __pyx_f[4], 102, 1, __PYX_ERR(4, 102, __pyx_L1_error));
/* "_state.pxd":103
*
* void set_context_tokens(int* ids, int n) nogil:
* if n == 1: # <<<<<<<<<<<<<<
* if this.B(0) >= 0:
* ids[0] = this.B(0)
*/
switch (__pyx_v_n) {
case 1:
/* "_state.pxd":104
* void set_context_tokens(int* ids, int n) nogil:
* if n == 1:
* if this.B(0) >= 0: # <<<<<<<<<<<<<<
* ids[0] = this.B(0)
* else:
*/
__pyx_t_1 = ((this->B(0) >= 0) != 0);
if (__pyx_t_1) {
/* "_state.pxd":105
* if n == 1:
* if this.B(0) >= 0:
* ids[0] = this.B(0) # <<<<<<<<<<<<<<
* else:
* ids[0] = -1
*/
(__pyx_v_ids[0]) = this->B(0);
/* "_state.pxd":104
* void set_context_tokens(int* ids, int n) nogil:
* if n == 1:
* if this.B(0) >= 0: # <<<<<<<<<<<<<<
* ids[0] = this.B(0)
* else:
*/
goto __pyx_L3;
}
/* "_state.pxd":107
* ids[0] = this.B(0)
* else:
* ids[0] = -1 # <<<<<<<<<<<<<<
* elif n == 2:
* ids[0] = this.B(0)
*/
/*else*/ {
(__pyx_v_ids[0]) = -1;
}
__pyx_L3:;
/* "_state.pxd":103
*
* void set_context_tokens(int* ids, int n) nogil:
* if n == 1: # <<<<<<<<<<<<<<
* if this.B(0) >= 0:
* ids[0] = this.B(0)
*/
break;
case 2:
/* "_state.pxd":109
* ids[0] = -1
* elif n == 2:
* ids[0] = this.B(0) # <<<<<<<<<<<<<<
* ids[1] = this.S(0)
* elif n == 3:
*/
(__pyx_v_ids[0]) = this->B(0);
/* "_state.pxd":110
* elif n == 2:
* ids[0] = this.B(0)
* ids[1] = this.S(0) # <<<<<<<<<<<<<<
* elif n == 3:
* if this.B(0) >= 0:
*/
(__pyx_v_ids[1]) = this->S(0);
/* "_state.pxd":108
* else:
* ids[0] = -1
* elif n == 2: # <<<<<<<<<<<<<<
* ids[0] = this.B(0)
* ids[1] = this.S(0)
*/
break;
case 3:
/* "_state.pxd":112
* ids[1] = this.S(0)
* elif n == 3:
* if this.B(0) >= 0: # <<<<<<<<<<<<<<
* ids[0] = this.B(0)
* else:
*/
__pyx_t_1 = ((this->B(0) >= 0) != 0);
if (__pyx_t_1) {
/* "_state.pxd":113
* elif n == 3:
* if this.B(0) >= 0:
* ids[0] = this.B(0) # <<<<<<<<<<<<<<
* else:
* ids[0] = -1
*/
(__pyx_v_ids[0]) = this->B(0);
/* "_state.pxd":112
* ids[1] = this.S(0)
* elif n == 3:
* if this.B(0) >= 0: # <<<<<<<<<<<<<<
* ids[0] = this.B(0)
* else:
*/
goto __pyx_L4;
}
/* "_state.pxd":115
* ids[0] = this.B(0)
* else:
* ids[0] = -1 # <<<<<<<<<<<<<<
* # First word of entity, if any
* if this.entity_is_open():
*/
/*else*/ {
(__pyx_v_ids[0]) = -1;
}
__pyx_L4:;
/* "_state.pxd":117
* ids[0] = -1
* # First word of entity, if any
* if this.entity_is_open(): # <<<<<<<<<<<<<<
* ids[1] = this.E(0)
* else:
*/
__pyx_t_1 = (this->entity_is_open() != 0);
if (__pyx_t_1) {
/* "_state.pxd":118
* # First word of entity, if any
* if this.entity_is_open():
* ids[1] = this.E(0) # <<<<<<<<<<<<<<
* else:
* ids[1] = -1
*/
(__pyx_v_ids[1]) = this->E(0);
/* "_state.pxd":117
* ids[0] = -1
* # First word of entity, if any
* if this.entity_is_open(): # <<<<<<<<<<<<<<
* ids[1] = this.E(0)
* else:
*/
goto __pyx_L5;
}
/* "_state.pxd":120
* ids[1] = this.E(0)
* else:
* ids[1] = -1 # <<<<<<<<<<<<<<
* # Last word of entity, if within entity
* if ids[0] == -1 or ids[1] == -1:
*/
/*else*/ {
(__pyx_v_ids[1]) = -1;
}
__pyx_L5:;
/* "_state.pxd":122
* ids[1] = -1
* # Last word of entity, if within entity
* if ids[0] == -1 or ids[1] == -1: # <<<<<<<<<<<<<<
* ids[2] = -1
* else:
*/
__pyx_t_2 = (((__pyx_v_ids[0]) == -1L) != 0);
if (!__pyx_t_2) {
} else {
__pyx_t_1 = __pyx_t_2;
goto __pyx_L7_bool_binop_done;
}
__pyx_t_2 = (((__pyx_v_ids[1]) == -1L) != 0);
__pyx_t_1 = __pyx_t_2;
__pyx_L7_bool_binop_done:;
if (__pyx_t_1) {
/* "_state.pxd":123
* # Last word of entity, if within entity
* if ids[0] == -1 or ids[1] == -1:
* ids[2] = -1 # <<<<<<<<<<<<<<
* else:
* ids[2] = ids[0] - 1
*/
(__pyx_v_ids[2]) = -1;
/* "_state.pxd":122
* ids[1] = -1
* # Last word of entity, if within entity
* if ids[0] == -1 or ids[1] == -1: # <<<<<<<<<<<<<<
* ids[2] = -1
* else:
*/
goto __pyx_L6;
}
/* "_state.pxd":125
* ids[2] = -1
* else:
* ids[2] = ids[0] - 1 # <<<<<<<<<<<<<<
* elif n == 8:
* ids[0] = this.B(0)
*/
/*else*/ {
(__pyx_v_ids[2]) = ((__pyx_v_ids[0]) - 1);
}
__pyx_L6:;
/* "_state.pxd":111
* ids[0] = this.B(0)
* ids[1] = this.S(0)
* elif n == 3: # <<<<<<<<<<<<<<
* if this.B(0) >= 0:
* ids[0] = this.B(0)
*/
break;
case 8:
/* "_state.pxd":127
* ids[2] = ids[0] - 1
* elif n == 8:
* ids[0] = this.B(0) # <<<<<<<<<<<<<<
* ids[1] = this.B(1)
* ids[2] = this.S(0)
*/
(__pyx_v_ids[0]) = this->B(0);
/* "_state.pxd":128
* elif n == 8:
* ids[0] = this.B(0)
* ids[1] = this.B(1) # <<<<<<<<<<<<<<
* ids[2] = this.S(0)
* ids[3] = this.S(1)
*/
(__pyx_v_ids[1]) = this->B(1);
/* "_state.pxd":129
* ids[0] = this.B(0)
* ids[1] = this.B(1)
* ids[2] = this.S(0) # <<<<<<<<<<<<<<
* ids[3] = this.S(1)
* ids[4] = this.S(2)
*/
(__pyx_v_ids[2]) = this->S(0);
/* "_state.pxd":130
* ids[1] = this.B(1)
* ids[2] = this.S(0)
* ids[3] = this.S(1) # <<<<<<<<<<<<<<
* ids[4] = this.S(2)
* ids[5] = this.L(this.B(0), 1)
*/
(__pyx_v_ids[3]) = this->S(1);
/* "_state.pxd":131
* ids[2] = this.S(0)
* ids[3] = this.S(1)
* ids[4] = this.S(2) # <<<<<<<<<<<<<<
* ids[5] = this.L(this.B(0), 1)
* ids[6] = this.L(this.S(0), 1)
*/
(__pyx_v_ids[4]) = this->S(2);
/* "_state.pxd":132
* ids[3] = this.S(1)
* ids[4] = this.S(2)
* ids[5] = this.L(this.B(0), 1) # <<<<<<<<<<<<<<
* ids[6] = this.L(this.S(0), 1)
* ids[7] = this.R(this.S(0), 1)
*/
(__pyx_v_ids[5]) = this->L(this->B(0), 1);
/* "_state.pxd":133
* ids[4] = this.S(2)
* ids[5] = this.L(this.B(0), 1)
* ids[6] = this.L(this.S(0), 1) # <<<<<<<<<<<<<<
* ids[7] = this.R(this.S(0), 1)
* elif n == 13:
*/
(__pyx_v_ids[6]) = this->L(this->S(0), 1);
/* "_state.pxd":134
* ids[5] = this.L(this.B(0), 1)
* ids[6] = this.L(this.S(0), 1)
* ids[7] = this.R(this.S(0), 1) # <<<<<<<<<<<<<<
* elif n == 13:
* ids[0] = this.B(0)
*/
(__pyx_v_ids[7]) = this->R(this->S(0), 1);
/* "_state.pxd":126
* else:
* ids[2] = ids[0] - 1
* elif n == 8: # <<<<<<<<<<<<<<
* ids[0] = this.B(0)
* ids[1] = this.B(1)
*/
break;
case 13:
/* "_state.pxd":136
* ids[7] = this.R(this.S(0), 1)
* elif n == 13:
* ids[0] = this.B(0) # <<<<<<<<<<<<<<
* ids[1] = this.B(1)
* ids[2] = this.S(0)
*/
(__pyx_v_ids[0]) = this->B(0);
/* "_state.pxd":137
* elif n == 13:
* ids[0] = this.B(0)
* ids[1] = this.B(1) # <<<<<<<<<<<<<<
* ids[2] = this.S(0)
* ids[3] = this.S(1)
*/
(__pyx_v_ids[1]) = this->B(1);
/* "_state.pxd":138
* ids[0] = this.B(0)
* ids[1] = this.B(1)
* ids[2] = this.S(0) # <<<<<<<<<<<<<<
* ids[3] = this.S(1)
* ids[4] = this.S(2)
*/
(__pyx_v_ids[2]) = this->S(0);
/* "_state.pxd":139
* ids[1] = this.B(1)
* ids[2] = this.S(0)
* ids[3] = this.S(1) # <<<<<<<<<<<<<<
* ids[4] = this.S(2)
* ids[5] = this.L(this.S(0), 1)
*/
(__pyx_v_ids[3]) = this->S(1);
/* "_state.pxd":140
* ids[2] = this.S(0)
* ids[3] = this.S(1)
* ids[4] = this.S(2) # <<<<<<<<<<<<<<
* ids[5] = this.L(this.S(0), 1)
* ids[6] = this.L(this.S(0), 2)
*/
(__pyx_v_ids[4]) = this->S(2);
/* "_state.pxd":141
* ids[3] = this.S(1)
* ids[4] = this.S(2)
* ids[5] = this.L(this.S(0), 1) # <<<<<<<<<<<<<<
* ids[6] = this.L(this.S(0), 2)
* ids[6] = this.R(this.S(0), 1)
*/
(__pyx_v_ids[5]) = this->L(this->S(0), 1);
/* "_state.pxd":142
* ids[4] = this.S(2)
* ids[5] = this.L(this.S(0), 1)
* ids[6] = this.L(this.S(0), 2) # <<<<<<<<<<<<<<
* ids[6] = this.R(this.S(0), 1)
* ids[7] = this.L(this.B(0), 1)
*/
(__pyx_v_ids[6]) = this->L(this->S(0), 2);
/* "_state.pxd":143
* ids[5] = this.L(this.S(0), 1)
* ids[6] = this.L(this.S(0), 2)
* ids[6] = this.R(this.S(0), 1) # <<<<<<<<<<<<<<
* ids[7] = this.L(this.B(0), 1)
* ids[8] = this.R(this.S(0), 2)
*/
(__pyx_v_ids[6]) = this->R(this->S(0), 1);
/* "_state.pxd":144
* ids[6] = this.L(this.S(0), 2)
* ids[6] = this.R(this.S(0), 1)
* ids[7] = this.L(this.B(0), 1) # <<<<<<<<<<<<<<
* ids[8] = this.R(this.S(0), 2)
* ids[9] = this.L(this.S(1), 1)
*/
(__pyx_v_ids[7]) = this->L(this->B(0), 1);
/* "_state.pxd":145
* ids[6] = this.R(this.S(0), 1)
* ids[7] = this.L(this.B(0), 1)
* ids[8] = this.R(this.S(0), 2) # <<<<<<<<<<<<<<
* ids[9] = this.L(this.S(1), 1)
* ids[10] = this.L(this.S(1), 2)
*/
(__pyx_v_ids[8]) = this->R(this->S(0), 2);
/* "_state.pxd":146
* ids[7] = this.L(this.B(0), 1)
* ids[8] = this.R(this.S(0), 2)
* ids[9] = this.L(this.S(1), 1) # <<<<<<<<<<<<<<
* ids[10] = this.L(this.S(1), 2)
* ids[11] = this.R(this.S(1), 1)
*/
(__pyx_v_ids[9]) = this->L(this->S(1), 1);
/* "_state.pxd":147
* ids[8] = this.R(this.S(0), 2)
* ids[9] = this.L(this.S(1), 1)
* ids[10] = this.L(this.S(1), 2) # <<<<<<<<<<<<<<
* ids[11] = this.R(this.S(1), 1)
* ids[12] = this.R(this.S(1), 2)
*/
(__pyx_v_ids[10]) = this->L(this->S(1), 2);
/* "_state.pxd":148
* ids[9] = this.L(this.S(1), 1)
* ids[10] = this.L(this.S(1), 2)
* ids[11] = this.R(this.S(1), 1) # <<<<<<<<<<<<<<
* ids[12] = this.R(this.S(1), 2)
* elif n == 6:
*/
(__pyx_v_ids[11]) = this->R(this->S(1), 1);
/* "_state.pxd":149
* ids[10] = this.L(this.S(1), 2)
* ids[11] = this.R(this.S(1), 1)
* ids[12] = this.R(this.S(1), 2) # <<<<<<<<<<<<<<
* elif n == 6:
* if this.B(0) >= 0:
*/
(__pyx_v_ids[12]) = this->R(this->S(1), 2);
/* "_state.pxd":135
* ids[6] = this.L(this.S(0), 1)
* ids[7] = this.R(this.S(0), 1)
* elif n == 13: # <<<<<<<<<<<<<<
* ids[0] = this.B(0)
* ids[1] = this.B(1)
*/
break;
case 6:
/* "_state.pxd":151
* ids[12] = this.R(this.S(1), 2)
* elif n == 6:
* if this.B(0) >= 0: # <<<<<<<<<<<<<<
* ids[0] = this.B(0)
* ids[1] = this.B(0)-1
*/
__pyx_t_1 = ((this->B(0) >= 0) != 0);
if (__pyx_t_1) {
/* "_state.pxd":152
* elif n == 6:
* if this.B(0) >= 0:
* ids[0] = this.B(0) # <<<<<<<<<<<<<<
* ids[1] = this.B(0)-1
* else:
*/
(__pyx_v_ids[0]) = this->B(0);
/* "_state.pxd":153
* if this.B(0) >= 0:
* ids[0] = this.B(0)
* ids[1] = this.B(0)-1 # <<<<<<<<<<<<<<
* else:
* ids[0] = -1
*/
(__pyx_v_ids[1]) = (this->B(0) - 1);
/* "_state.pxd":151
* ids[12] = this.R(this.S(1), 2)
* elif n == 6:
* if this.B(0) >= 0: # <<<<<<<<<<<<<<
* ids[0] = this.B(0)
* ids[1] = this.B(0)-1
*/
goto __pyx_L9;
}
/* "_state.pxd":155
* ids[1] = this.B(0)-1
* else:
* ids[0] = -1 # <<<<<<<<<<<<<<
* ids[1] = -1
* ids[2] = this.B(1)
*/
/*else*/ {
(__pyx_v_ids[0]) = -1;
/* "_state.pxd":156
* else:
* ids[0] = -1
* ids[1] = -1 # <<<<<<<<<<<<<<
* ids[2] = this.B(1)
* ids[3] = this.E(0)
*/
(__pyx_v_ids[1]) = -1;
}
__pyx_L9:;
/* "_state.pxd":157
* ids[0] = -1
* ids[1] = -1
* ids[2] = this.B(1) # <<<<<<<<<<<<<<
* ids[3] = this.E(0)
* if ids[3] >= 1:
*/
(__pyx_v_ids[2]) = this->B(1);
/* "_state.pxd":158
* ids[1] = -1
* ids[2] = this.B(1)
* ids[3] = this.E(0) # <<<<<<<<<<<<<<
* if ids[3] >= 1:
* ids[4] = this.E(0)-1
*/
(__pyx_v_ids[3]) = this->E(0);
/* "_state.pxd":159
* ids[2] = this.B(1)
* ids[3] = this.E(0)
* if ids[3] >= 1: # <<<<<<<<<<<<<<
* ids[4] = this.E(0)-1
* else:
*/
__pyx_t_1 = (((__pyx_v_ids[3]) >= 1) != 0);
if (__pyx_t_1) {
/* "_state.pxd":160
* ids[3] = this.E(0)
* if ids[3] >= 1:
* ids[4] = this.E(0)-1 # <<<<<<<<<<<<<<
* else:
* ids[4] = -1
*/
(__pyx_v_ids[4]) = (this->E(0) - 1);
/* "_state.pxd":159
* ids[2] = this.B(1)
* ids[3] = this.E(0)
* if ids[3] >= 1: # <<<<<<<<<<<<<<
* ids[4] = this.E(0)-1
* else:
*/
goto __pyx_L10;
}
/* "_state.pxd":162
* ids[4] = this.E(0)-1
* else:
* ids[4] = -1 # <<<<<<<<<<<<<<
* if (ids[3]+1) < this.length:
* ids[5] = this.E(0)+1
*/
/*else*/ {
(__pyx_v_ids[4]) = -1;
}
__pyx_L10:;
/* "_state.pxd":163
* else:
* ids[4] = -1
* if (ids[3]+1) < this.length: # <<<<<<<<<<<<<<
* ids[5] = this.E(0)+1
* else:
*/
__pyx_t_1 = ((((__pyx_v_ids[3]) + 1) < this->length) != 0);
if (__pyx_t_1) {
/* "_state.pxd":164
* ids[4] = -1
* if (ids[3]+1) < this.length:
* ids[5] = this.E(0)+1 # <<<<<<<<<<<<<<
* else:
* ids[5] = -1
*/
(__pyx_v_ids[5]) = (this->E(0) + 1);
/* "_state.pxd":163
* else:
* ids[4] = -1
* if (ids[3]+1) < this.length: # <<<<<<<<<<<<<<
* ids[5] = this.E(0)+1
* else:
*/
goto __pyx_L11;
}
/* "_state.pxd":166
* ids[5] = this.E(0)+1
* else:
* ids[5] = -1 # <<<<<<<<<<<<<<
* else:
* # TODO error =/
*/
/*else*/ {
(__pyx_v_ids[5]) = -1;
}
__pyx_L11:;
/* "_state.pxd":150
* ids[11] = this.R(this.S(1), 1)
* ids[12] = this.R(this.S(1), 2)
* elif n == 6: # <<<<<<<<<<<<<<
* if this.B(0) >= 0:
* ids[0] = this.B(0)
*/
break;
default:
break;
}
/* "_state.pxd":170
* # TODO error =/
* pass
* for i in range(n): # <<<<<<<<<<<<<<
* if ids[i] >= 0:
* ids[i] += this.offset
*/
__pyx_t_3 = __pyx_v_n;
__pyx_t_4 = __pyx_t_3;
for (__pyx_t_5 = 0; __pyx_t_5 < __pyx_t_4; __pyx_t_5+=1) {
__pyx_v_i = __pyx_t_5;
/* "_state.pxd":171
* pass
* for i in range(n):
* if ids[i] >= 0: # <<<<<<<<<<<<<<
* ids[i] += this.offset
* else:
*/
__pyx_t_1 = (((__pyx_v_ids[__pyx_v_i]) >= 0) != 0);
if (__pyx_t_1) {
/* "_state.pxd":172
* for i in range(n):
* if ids[i] >= 0:
* ids[i] += this.offset # <<<<<<<<<<<<<<
* else:
* ids[i] = -1
*/
__pyx_t_6 = __pyx_v_i;
(__pyx_v_ids[__pyx_t_6]) = ((__pyx_v_ids[__pyx_t_6]) + this->offset);
/* "_state.pxd":171
* pass
* for i in range(n):
* if ids[i] >= 0: # <<<<<<<<<<<<<<
* ids[i] += this.offset
* else:
*/
goto __pyx_L14;
}
/* "_state.pxd":174
* ids[i] += this.offset
* else:
* ids[i] = -1 # <<<<<<<<<<<<<<
*
* int S(int i) nogil const:
*/
/*else*/ {
(__pyx_v_ids[__pyx_v_i]) = -1;
}
__pyx_L14:;
}
/* "_state.pxd":102
* free(this.shifted - PADDING)
*
* void set_context_tokens(int* ids, int n) nogil: # <<<<<<<<<<<<<<
* if n == 1:
* if this.B(0) >= 0:
*/
/* function exit code */
goto __pyx_L0;
__pyx_L1_error:;
__Pyx_WriteUnraisable("StateC.set_context_tokens", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 1);
__pyx_L0:;
__Pyx_TraceReturn(Py_None, 1);
}
/* "_state.pxd":176
* ids[i] = -1
*
* int S(int i) nogil const: # <<<<<<<<<<<<<<
* if i >= this._s_i:
* return -1
*/
int __pyx_t_5spacy_6syntax_6_state_StateC::S(int __pyx_v_i) const {
int __pyx_r;
__Pyx_TraceDeclarations
int __pyx_t_1;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_TraceCall("S", __pyx_f[4], 176, 1, __PYX_ERR(4, 176, __pyx_L1_error));
/* "_state.pxd":177
*
* int S(int i) nogil const:
* if i >= this._s_i: # <<<<<<<<<<<<<<
* return -1
* return this._stack[this._s_i - (i+1)]
*/
__pyx_t_1 = ((__pyx_v_i >= this->_s_i) != 0);
if (__pyx_t_1) {
/* "_state.pxd":178
* int S(int i) nogil const:
* if i >= this._s_i:
* return -1 # <<<<<<<<<<<<<<
* return this._stack[this._s_i - (i+1)]
*
*/
__pyx_r = -1;
goto __pyx_L0;
/* "_state.pxd":177
*
* int S(int i) nogil const:
* if i >= this._s_i: # <<<<<<<<<<<<<<
* return -1
* return this._stack[this._s_i - (i+1)]
*/
}
/* "_state.pxd":179
* if i >= this._s_i:
* return -1
* return this._stack[this._s_i - (i+1)] # <<<<<<<<<<<<<<
*
* int B(int i) nogil const:
*/
__pyx_r = (this->_stack[(this->_s_i - (__pyx_v_i + 1))]);
goto __pyx_L0;
/* "_state.pxd":176
* ids[i] = -1
*
* int S(int i) nogil const: # <<<<<<<<<<<<<<
* if i >= this._s_i:
* return -1
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_WriteUnraisable("StateC.S", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 1);
__pyx_r = 0;
__pyx_L0:;
__Pyx_TraceReturn(Py_None, 1);
return __pyx_r;
}
/* "_state.pxd":181
* return this._stack[this._s_i - (i+1)]
*
* int B(int i) nogil const: # <<<<<<<<<<<<<<
* if (i + this._b_i) >= this.length:
* return -1
*/
int __pyx_t_5spacy_6syntax_6_state_StateC::B(int __pyx_v_i) const {
int __pyx_r;
__Pyx_TraceDeclarations
int __pyx_t_1;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_TraceCall("B", __pyx_f[4], 181, 1, __PYX_ERR(4, 181, __pyx_L1_error));
/* "_state.pxd":182
*
* int B(int i) nogil const:
* if (i + this._b_i) >= this.length: # <<<<<<<<<<<<<<
* return -1
* return this._buffer[this._b_i + i]
*/
__pyx_t_1 = (((__pyx_v_i + this->_b_i) >= this->length) != 0);
if (__pyx_t_1) {
/* "_state.pxd":183
* int B(int i) nogil const:
* if (i + this._b_i) >= this.length:
* return -1 # <<<<<<<<<<<<<<
* return this._buffer[this._b_i + i]
*
*/
__pyx_r = -1;
goto __pyx_L0;
/* "_state.pxd":182
*
* int B(int i) nogil const:
* if (i + this._b_i) >= this.length: # <<<<<<<<<<<<<<
* return -1
* return this._buffer[this._b_i + i]
*/
}
/* "_state.pxd":184
* if (i + this._b_i) >= this.length:
* return -1
* return this._buffer[this._b_i + i] # <<<<<<<<<<<<<<
*
* const TokenC* S_(int i) nogil const:
*/
__pyx_r = (this->_buffer[(this->_b_i + __pyx_v_i)]);
goto __pyx_L0;
/* "_state.pxd":181
* return this._stack[this._s_i - (i+1)]
*
* int B(int i) nogil const: # <<<<<<<<<<<<<<
* if (i + this._b_i) >= this.length:
* return -1
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_WriteUnraisable("StateC.B", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 1);
__pyx_r = 0;
__pyx_L0:;
__Pyx_TraceReturn(Py_None, 1);
return __pyx_r;
}
/* "_state.pxd":186
* return this._buffer[this._b_i + i]
*
* const TokenC* S_(int i) nogil const: # <<<<<<<<<<<<<<
* return this.safe_get(this.S(i))
*
*/
struct __pyx_t_5spacy_7structs_TokenC const *__pyx_t_5spacy_6syntax_6_state_StateC::S_(int __pyx_v_i) const {
struct __pyx_t_5spacy_7structs_TokenC const *__pyx_r;
__Pyx_TraceDeclarations
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_TraceCall("S_", __pyx_f[4], 186, 1, __PYX_ERR(4, 186, __pyx_L1_error));
/* "_state.pxd":187
*
* const TokenC* S_(int i) nogil const:
* return this.safe_get(this.S(i)) # <<<<<<<<<<<<<<
*
* const TokenC* B_(int i) nogil const:
*/
__pyx_r = this->safe_get(this->S(__pyx_v_i));
goto __pyx_L0;
/* "_state.pxd":186
* return this._buffer[this._b_i + i]
*
* const TokenC* S_(int i) nogil const: # <<<<<<<<<<<<<<
* return this.safe_get(this.S(i))
*
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_WriteUnraisable("StateC.S_", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 1);
__pyx_r = 0;
__pyx_L0:;
__Pyx_TraceReturn(Py_None, 1);
return __pyx_r;
}
/* "_state.pxd":189
* return this.safe_get(this.S(i))
*
* const TokenC* B_(int i) nogil const: # <<<<<<<<<<<<<<
* return this.safe_get(this.B(i))
*
*/
struct __pyx_t_5spacy_7structs_TokenC const *__pyx_t_5spacy_6syntax_6_state_StateC::B_(int __pyx_v_i) const {
struct __pyx_t_5spacy_7structs_TokenC const *__pyx_r;
__Pyx_TraceDeclarations
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_TraceCall("B_", __pyx_f[4], 189, 1, __PYX_ERR(4, 189, __pyx_L1_error));
/* "_state.pxd":190
*
* const TokenC* B_(int i) nogil const:
* return this.safe_get(this.B(i)) # <<<<<<<<<<<<<<
*
* const TokenC* H_(int i) nogil const:
*/
__pyx_r = this->safe_get(this->B(__pyx_v_i));
goto __pyx_L0;
/* "_state.pxd":189
* return this.safe_get(this.S(i))
*
* const TokenC* B_(int i) nogil const: # <<<<<<<<<<<<<<
* return this.safe_get(this.B(i))
*
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_WriteUnraisable("StateC.B_", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 1);
__pyx_r = 0;
__pyx_L0:;
__Pyx_TraceReturn(Py_None, 1);
return __pyx_r;
}
/* "_state.pxd":192
* return this.safe_get(this.B(i))
*
* const TokenC* H_(int i) nogil const: # <<<<<<<<<<<<<<
* return this.safe_get(this.H(i))
*
*/
struct __pyx_t_5spacy_7structs_TokenC const *__pyx_t_5spacy_6syntax_6_state_StateC::H_(int __pyx_v_i) const {
struct __pyx_t_5spacy_7structs_TokenC const *__pyx_r;
__Pyx_TraceDeclarations
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_TraceCall("H_", __pyx_f[4], 192, 1, __PYX_ERR(4, 192, __pyx_L1_error));
/* "_state.pxd":193
*
* const TokenC* H_(int i) nogil const:
* return this.safe_get(this.H(i)) # <<<<<<<<<<<<<<
*
* const TokenC* E_(int i) nogil const:
*/
__pyx_r = this->safe_get(this->H(__pyx_v_i));
goto __pyx_L0;
/* "_state.pxd":192
* return this.safe_get(this.B(i))
*
* const TokenC* H_(int i) nogil const: # <<<<<<<<<<<<<<
* return this.safe_get(this.H(i))
*
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_WriteUnraisable("StateC.H_", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 1);
__pyx_r = 0;
__pyx_L0:;
__Pyx_TraceReturn(Py_None, 1);
return __pyx_r;
}
/* "_state.pxd":195
* return this.safe_get(this.H(i))
*
* const TokenC* E_(int i) nogil const: # <<<<<<<<<<<<<<
* return this.safe_get(this.E(i))
*
*/
struct __pyx_t_5spacy_7structs_TokenC const *__pyx_t_5spacy_6syntax_6_state_StateC::E_(int __pyx_v_i) const {
struct __pyx_t_5spacy_7structs_TokenC const *__pyx_r;
__Pyx_TraceDeclarations
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_TraceCall("E_", __pyx_f[4], 195, 1, __PYX_ERR(4, 195, __pyx_L1_error));
/* "_state.pxd":196
*
* const TokenC* E_(int i) nogil const:
* return this.safe_get(this.E(i)) # <<<<<<<<<<<<<<
*
* const TokenC* L_(int i, int idx) nogil const:
*/
__pyx_r = this->safe_get(this->E(__pyx_v_i));
goto __pyx_L0;
/* "_state.pxd":195
* return this.safe_get(this.H(i))
*
* const TokenC* E_(int i) nogil const: # <<<<<<<<<<<<<<
* return this.safe_get(this.E(i))
*
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_WriteUnraisable("StateC.E_", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 1);
__pyx_r = 0;
__pyx_L0:;
__Pyx_TraceReturn(Py_None, 1);
return __pyx_r;
}
/* "_state.pxd":198
* return this.safe_get(this.E(i))
*
* const TokenC* L_(int i, int idx) nogil const: # <<<<<<<<<<<<<<
* return this.safe_get(this.L(i, idx))
*
*/
struct __pyx_t_5spacy_7structs_TokenC const *__pyx_t_5spacy_6syntax_6_state_StateC::L_(int __pyx_v_i, int __pyx_v_idx) const {
struct __pyx_t_5spacy_7structs_TokenC const *__pyx_r;
__Pyx_TraceDeclarations
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_TraceCall("L_", __pyx_f[4], 198, 1, __PYX_ERR(4, 198, __pyx_L1_error));
/* "_state.pxd":199
*
* const TokenC* L_(int i, int idx) nogil const:
* return this.safe_get(this.L(i, idx)) # <<<<<<<<<<<<<<
*
* const TokenC* R_(int i, int idx) nogil const:
*/
__pyx_r = this->safe_get(this->L(__pyx_v_i, __pyx_v_idx));
goto __pyx_L0;
/* "_state.pxd":198
* return this.safe_get(this.E(i))
*
* const TokenC* L_(int i, int idx) nogil const: # <<<<<<<<<<<<<<
* return this.safe_get(this.L(i, idx))
*
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_WriteUnraisable("StateC.L_", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 1);
__pyx_r = 0;
__pyx_L0:;
__Pyx_TraceReturn(Py_None, 1);
return __pyx_r;
}
/* "_state.pxd":201
* return this.safe_get(this.L(i, idx))
*
* const TokenC* R_(int i, int idx) nogil const: # <<<<<<<<<<<<<<
* return this.safe_get(this.R(i, idx))
*
*/
struct __pyx_t_5spacy_7structs_TokenC const *__pyx_t_5spacy_6syntax_6_state_StateC::R_(int __pyx_v_i, int __pyx_v_idx) const {
struct __pyx_t_5spacy_7structs_TokenC const *__pyx_r;
__Pyx_TraceDeclarations
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_TraceCall("R_", __pyx_f[4], 201, 1, __PYX_ERR(4, 201, __pyx_L1_error));
/* "_state.pxd":202
*
* const TokenC* R_(int i, int idx) nogil const:
* return this.safe_get(this.R(i, idx)) # <<<<<<<<<<<<<<
*
* const TokenC* safe_get(int i) nogil const:
*/
__pyx_r = this->safe_get(this->R(__pyx_v_i, __pyx_v_idx));
goto __pyx_L0;
/* "_state.pxd":201
* return this.safe_get(this.L(i, idx))
*
* const TokenC* R_(int i, int idx) nogil const: # <<<<<<<<<<<<<<
* return this.safe_get(this.R(i, idx))
*
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_WriteUnraisable("StateC.R_", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 1);
__pyx_r = 0;
__pyx_L0:;
__Pyx_TraceReturn(Py_None, 1);
return __pyx_r;
}
/* "_state.pxd":204
* return this.safe_get(this.R(i, idx))
*
* const TokenC* safe_get(int i) nogil const: # <<<<<<<<<<<<<<
* if i < 0 or i >= this.length:
* return &this._empty_token
*/
struct __pyx_t_5spacy_7structs_TokenC const *__pyx_t_5spacy_6syntax_6_state_StateC::safe_get(int __pyx_v_i) const {
struct __pyx_t_5spacy_7structs_TokenC const *__pyx_r;
__Pyx_TraceDeclarations
int __pyx_t_1;
int __pyx_t_2;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_TraceCall("safe_get", __pyx_f[4], 204, 1, __PYX_ERR(4, 204, __pyx_L1_error));
/* "_state.pxd":205
*
* const TokenC* safe_get(int i) nogil const:
* if i < 0 or i >= this.length: # <<<<<<<<<<<<<<
* return &this._empty_token
* else:
*/
__pyx_t_2 = ((__pyx_v_i < 0) != 0);
if (!__pyx_t_2) {
} else {
__pyx_t_1 = __pyx_t_2;
goto __pyx_L4_bool_binop_done;
}
__pyx_t_2 = ((__pyx_v_i >= this->length) != 0);
__pyx_t_1 = __pyx_t_2;
__pyx_L4_bool_binop_done:;
if (__pyx_t_1) {
/* "_state.pxd":206
* const TokenC* safe_get(int i) nogil const:
* if i < 0 or i >= this.length:
* return &this._empty_token # <<<<<<<<<<<<<<
* else:
* return &this._sent[i]
*/
__pyx_r = (&this->_empty_token);
goto __pyx_L0;
/* "_state.pxd":205
*
* const TokenC* safe_get(int i) nogil const:
* if i < 0 or i >= this.length: # <<<<<<<<<<<<<<
* return &this._empty_token
* else:
*/
}
/* "_state.pxd":208
* return &this._empty_token
* else:
* return &this._sent[i] # <<<<<<<<<<<<<<
*
* int H(int i) nogil const:
*/
/*else*/ {
__pyx_r = (&(this->_sent[__pyx_v_i]));
goto __pyx_L0;
}
/* "_state.pxd":204
* return this.safe_get(this.R(i, idx))
*
* const TokenC* safe_get(int i) nogil const: # <<<<<<<<<<<<<<
* if i < 0 or i >= this.length:
* return &this._empty_token
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_WriteUnraisable("StateC.safe_get", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 1);
__pyx_r = 0;
__pyx_L0:;
__Pyx_TraceReturn(Py_None, 1);
return __pyx_r;
}
/* "_state.pxd":210
* return &this._sent[i]
*
* int H(int i) nogil const: # <<<<<<<<<<<<<<
* if i < 0 or i >= this.length:
* return -1
*/
int __pyx_t_5spacy_6syntax_6_state_StateC::H(int __pyx_v_i) const {
int __pyx_r;
__Pyx_TraceDeclarations
int __pyx_t_1;
int __pyx_t_2;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_TraceCall("H", __pyx_f[4], 210, 1, __PYX_ERR(4, 210, __pyx_L1_error));
/* "_state.pxd":211
*
* int H(int i) nogil const:
* if i < 0 or i >= this.length: # <<<<<<<<<<<<<<
* return -1
* return this._sent[i].head + i
*/
__pyx_t_2 = ((__pyx_v_i < 0) != 0);
if (!__pyx_t_2) {
} else {
__pyx_t_1 = __pyx_t_2;
goto __pyx_L4_bool_binop_done;
}
__pyx_t_2 = ((__pyx_v_i >= this->length) != 0);
__pyx_t_1 = __pyx_t_2;
__pyx_L4_bool_binop_done:;
if (__pyx_t_1) {
/* "_state.pxd":212
* int H(int i) nogil const:
* if i < 0 or i >= this.length:
* return -1 # <<<<<<<<<<<<<<
* return this._sent[i].head + i
*
*/
__pyx_r = -1;
goto __pyx_L0;
/* "_state.pxd":211
*
* int H(int i) nogil const:
* if i < 0 or i >= this.length: # <<<<<<<<<<<<<<
* return -1
* return this._sent[i].head + i
*/
}
/* "_state.pxd":213
* if i < 0 or i >= this.length:
* return -1
* return this._sent[i].head + i # <<<<<<<<<<<<<<
*
* int E(int i) nogil const:
*/
__pyx_r = ((this->_sent[__pyx_v_i]).head + __pyx_v_i);
goto __pyx_L0;
/* "_state.pxd":210
* return &this._sent[i]
*
* int H(int i) nogil const: # <<<<<<<<<<<<<<
* if i < 0 or i >= this.length:
* return -1
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_WriteUnraisable("StateC.H", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 1);
__pyx_r = 0;
__pyx_L0:;
__Pyx_TraceReturn(Py_None, 1);
return __pyx_r;
}
/* "_state.pxd":215
* return this._sent[i].head + i
*
* int E(int i) nogil const: # <<<<<<<<<<<<<<
* if this._e_i <= 0 or this._e_i >= this.length:
* return -1
*/
int __pyx_t_5spacy_6syntax_6_state_StateC::E(int __pyx_v_i) const {
int __pyx_r;
__Pyx_TraceDeclarations
int __pyx_t_1;
int __pyx_t_2;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_TraceCall("E", __pyx_f[4], 215, 1, __PYX_ERR(4, 215, __pyx_L1_error));
/* "_state.pxd":216
*
* int E(int i) nogil const:
* if this._e_i <= 0 or this._e_i >= this.length: # <<<<<<<<<<<<<<
* return -1
* if i < 0 or i >= this._e_i:
*/
__pyx_t_2 = ((this->_e_i <= 0) != 0);
if (!__pyx_t_2) {
} else {
__pyx_t_1 = __pyx_t_2;
goto __pyx_L4_bool_binop_done;
}
__pyx_t_2 = ((this->_e_i >= this->length) != 0);
__pyx_t_1 = __pyx_t_2;
__pyx_L4_bool_binop_done:;
if (__pyx_t_1) {
/* "_state.pxd":217
* int E(int i) nogil const:
* if this._e_i <= 0 or this._e_i >= this.length:
* return -1 # <<<<<<<<<<<<<<
* if i < 0 or i >= this._e_i:
* return -1
*/
__pyx_r = -1;
goto __pyx_L0;
/* "_state.pxd":216
*
* int E(int i) nogil const:
* if this._e_i <= 0 or this._e_i >= this.length: # <<<<<<<<<<<<<<
* return -1
* if i < 0 or i >= this._e_i:
*/
}
/* "_state.pxd":218
* if this._e_i <= 0 or this._e_i >= this.length:
* return -1
* if i < 0 or i >= this._e_i: # <<<<<<<<<<<<<<
* return -1
* return this._ents[this._e_i - (i+1)].start
*/
__pyx_t_2 = ((__pyx_v_i < 0) != 0);
if (!__pyx_t_2) {
} else {
__pyx_t_1 = __pyx_t_2;
goto __pyx_L7_bool_binop_done;
}
__pyx_t_2 = ((__pyx_v_i >= this->_e_i) != 0);
__pyx_t_1 = __pyx_t_2;
__pyx_L7_bool_binop_done:;
if (__pyx_t_1) {
/* "_state.pxd":219
* return -1
* if i < 0 or i >= this._e_i:
* return -1 # <<<<<<<<<<<<<<
* return this._ents[this._e_i - (i+1)].start
*
*/
__pyx_r = -1;
goto __pyx_L0;
/* "_state.pxd":218
* if this._e_i <= 0 or this._e_i >= this.length:
* return -1
* if i < 0 or i >= this._e_i: # <<<<<<<<<<<<<<
* return -1
* return this._ents[this._e_i - (i+1)].start
*/
}
/* "_state.pxd":220
* if i < 0 or i >= this._e_i:
* return -1
* return this._ents[this._e_i - (i+1)].start # <<<<<<<<<<<<<<
*
* int L(int i, int idx) nogil const:
*/
__pyx_r = (this->_ents[(this->_e_i - (__pyx_v_i + 1))]).start;
goto __pyx_L0;
/* "_state.pxd":215
* return this._sent[i].head + i
*
* int E(int i) nogil const: # <<<<<<<<<<<<<<
* if this._e_i <= 0 or this._e_i >= this.length:
* return -1
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_WriteUnraisable("StateC.E", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 1);
__pyx_r = 0;
__pyx_L0:;
__Pyx_TraceReturn(Py_None, 1);
return __pyx_r;
}
/* "_state.pxd":222
* return this._ents[this._e_i - (i+1)].start
*
* int L(int i, int idx) nogil const: # <<<<<<<<<<<<<<
* if idx < 1:
* return -1
*/
int __pyx_t_5spacy_6syntax_6_state_StateC::L(int __pyx_v_i, int __pyx_v_idx) const {
struct __pyx_t_5spacy_7structs_TokenC const *__pyx_v_target;
struct __pyx_t_5spacy_7structs_TokenC const *__pyx_v_ptr;
int __pyx_r;
__Pyx_TraceDeclarations
int __pyx_t_1;
int __pyx_t_2;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_TraceCall("L", __pyx_f[4], 222, 1, __PYX_ERR(4, 222, __pyx_L1_error));
/* "_state.pxd":223
*
* int L(int i, int idx) nogil const:
* if idx < 1: # <<<<<<<<<<<<<<
* return -1
* if i < 0 or i >= this.length:
*/
__pyx_t_1 = ((__pyx_v_idx < 1) != 0);
if (__pyx_t_1) {
/* "_state.pxd":224
* int L(int i, int idx) nogil const:
* if idx < 1:
* return -1 # <<<<<<<<<<<<<<
* if i < 0 or i >= this.length:
* return -1
*/
__pyx_r = -1;
goto __pyx_L0;
/* "_state.pxd":223
*
* int L(int i, int idx) nogil const:
* if idx < 1: # <<<<<<<<<<<<<<
* return -1
* if i < 0 or i >= this.length:
*/
}
/* "_state.pxd":225
* if idx < 1:
* return -1
* if i < 0 or i >= this.length: # <<<<<<<<<<<<<<
* return -1
* cdef const TokenC* target = &this._sent[i]
*/
__pyx_t_2 = ((__pyx_v_i < 0) != 0);
if (!__pyx_t_2) {
} else {
__pyx_t_1 = __pyx_t_2;
goto __pyx_L5_bool_binop_done;
}
__pyx_t_2 = ((__pyx_v_i >= this->length) != 0);
__pyx_t_1 = __pyx_t_2;
__pyx_L5_bool_binop_done:;
if (__pyx_t_1) {
/* "_state.pxd":226
* return -1
* if i < 0 or i >= this.length:
* return -1 # <<<<<<<<<<<<<<
* cdef const TokenC* target = &this._sent[i]
* if target.l_kids < <uint32_t>idx:
*/
__pyx_r = -1;
goto __pyx_L0;
/* "_state.pxd":225
* if idx < 1:
* return -1
* if i < 0 or i >= this.length: # <<<<<<<<<<<<<<
* return -1
* cdef const TokenC* target = &this._sent[i]
*/
}
/* "_state.pxd":227
* if i < 0 or i >= this.length:
* return -1
* cdef const TokenC* target = &this._sent[i] # <<<<<<<<<<<<<<
* if target.l_kids < <uint32_t>idx:
* return -1
*/
__pyx_v_target = (&(this->_sent[__pyx_v_i]));
/* "_state.pxd":228
* return -1
* cdef const TokenC* target = &this._sent[i]
* if target.l_kids < <uint32_t>idx: # <<<<<<<<<<<<<<
* return -1
* cdef const TokenC* ptr = &this._sent[target.l_edge]
*/
__pyx_t_1 = ((__pyx_v_target->l_kids < ((uint32_t)__pyx_v_idx)) != 0);
if (__pyx_t_1) {
/* "_state.pxd":229
* cdef const TokenC* target = &this._sent[i]
* if target.l_kids < <uint32_t>idx:
* return -1 # <<<<<<<<<<<<<<
* cdef const TokenC* ptr = &this._sent[target.l_edge]
*
*/
__pyx_r = -1;
goto __pyx_L0;
/* "_state.pxd":228
* return -1
* cdef const TokenC* target = &this._sent[i]
* if target.l_kids < <uint32_t>idx: # <<<<<<<<<<<<<<
* return -1
* cdef const TokenC* ptr = &this._sent[target.l_edge]
*/
}
/* "_state.pxd":230
* if target.l_kids < <uint32_t>idx:
* return -1
* cdef const TokenC* ptr = &this._sent[target.l_edge] # <<<<<<<<<<<<<<
*
* while ptr < target:
*/
__pyx_v_ptr = (&(this->_sent[__pyx_v_target->l_edge]));
/* "_state.pxd":232
* cdef const TokenC* ptr = &this._sent[target.l_edge]
*
* while ptr < target: # <<<<<<<<<<<<<<
* # If this head is still to the right of us, we can skip to it
* # No token that's between this token and this head could be our
*/
while (1) {
__pyx_t_1 = ((__pyx_v_ptr < __pyx_v_target) != 0);
if (!__pyx_t_1) break;
/* "_state.pxd":236
* # No token that's between this token and this head could be our
* # child.
* if (ptr.head >= 1) and (ptr + ptr.head) < target: # <<<<<<<<<<<<<<
* ptr += ptr.head
*
*/
__pyx_t_2 = ((__pyx_v_ptr->head >= 1) != 0);
if (__pyx_t_2) {
} else {
__pyx_t_1 = __pyx_t_2;
goto __pyx_L11_bool_binop_done;
}
__pyx_t_2 = (((__pyx_v_ptr + __pyx_v_ptr->head) < __pyx_v_target) != 0);
__pyx_t_1 = __pyx_t_2;
__pyx_L11_bool_binop_done:;
if (__pyx_t_1) {
/* "_state.pxd":237
* # child.
* if (ptr.head >= 1) and (ptr + ptr.head) < target:
* ptr += ptr.head # <<<<<<<<<<<<<<
*
* elif ptr + ptr.head == target:
*/
__pyx_v_ptr = (__pyx_v_ptr + __pyx_v_ptr->head);
/* "_state.pxd":236
* # No token that's between this token and this head could be our
* # child.
* if (ptr.head >= 1) and (ptr + ptr.head) < target: # <<<<<<<<<<<<<<
* ptr += ptr.head
*
*/
goto __pyx_L10;
}
/* "_state.pxd":239
* ptr += ptr.head
*
* elif ptr + ptr.head == target: # <<<<<<<<<<<<<<
* idx -= 1
* if idx == 0:
*/
__pyx_t_1 = (((__pyx_v_ptr + __pyx_v_ptr->head) == __pyx_v_target) != 0);
if (__pyx_t_1) {
/* "_state.pxd":240
*
* elif ptr + ptr.head == target:
* idx -= 1 # <<<<<<<<<<<<<<
* if idx == 0:
* return ptr - this._sent
*/
__pyx_v_idx = (__pyx_v_idx - 1);
/* "_state.pxd":241
* elif ptr + ptr.head == target:
* idx -= 1
* if idx == 0: # <<<<<<<<<<<<<<
* return ptr - this._sent
* ptr += 1
*/
__pyx_t_1 = ((__pyx_v_idx == 0) != 0);
if (__pyx_t_1) {
/* "_state.pxd":242
* idx -= 1
* if idx == 0:
* return ptr - this._sent # <<<<<<<<<<<<<<
* ptr += 1
* else:
*/
__pyx_r = (__pyx_v_ptr - this->_sent);
goto __pyx_L0;
/* "_state.pxd":241
* elif ptr + ptr.head == target:
* idx -= 1
* if idx == 0: # <<<<<<<<<<<<<<
* return ptr - this._sent
* ptr += 1
*/
}
/* "_state.pxd":243
* if idx == 0:
* return ptr - this._sent
* ptr += 1 # <<<<<<<<<<<<<<
* else:
* ptr += 1
*/
__pyx_v_ptr = (__pyx_v_ptr + 1);
/* "_state.pxd":239
* ptr += ptr.head
*
* elif ptr + ptr.head == target: # <<<<<<<<<<<<<<
* idx -= 1
* if idx == 0:
*/
goto __pyx_L10;
}
/* "_state.pxd":245
* ptr += 1
* else:
* ptr += 1 # <<<<<<<<<<<<<<
* return -1
*
*/
/*else*/ {
__pyx_v_ptr = (__pyx_v_ptr + 1);
}
__pyx_L10:;
}
/* "_state.pxd":246
* else:
* ptr += 1
* return -1 # <<<<<<<<<<<<<<
*
* int R(int i, int idx) nogil const:
*/
__pyx_r = -1;
goto __pyx_L0;
/* "_state.pxd":222
* return this._ents[this._e_i - (i+1)].start
*
* int L(int i, int idx) nogil const: # <<<<<<<<<<<<<<
* if idx < 1:
* return -1
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_WriteUnraisable("StateC.L", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 1);
__pyx_r = 0;
__pyx_L0:;
__Pyx_TraceReturn(Py_None, 1);
return __pyx_r;
}
/* "_state.pxd":248
* return -1
*
* int R(int i, int idx) nogil const: # <<<<<<<<<<<<<<
* if idx < 1:
* return -1
*/
int __pyx_t_5spacy_6syntax_6_state_StateC::R(int __pyx_v_i, int __pyx_v_idx) const {
struct __pyx_t_5spacy_7structs_TokenC const *__pyx_v_target;
struct __pyx_t_5spacy_7structs_TokenC const *__pyx_v_ptr;
int __pyx_r;
__Pyx_TraceDeclarations
int __pyx_t_1;
int __pyx_t_2;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_TraceCall("R", __pyx_f[4], 248, 1, __PYX_ERR(4, 248, __pyx_L1_error));
/* "_state.pxd":249
*
* int R(int i, int idx) nogil const:
* if idx < 1: # <<<<<<<<<<<<<<
* return -1
* if i < 0 or i >= this.length:
*/
__pyx_t_1 = ((__pyx_v_idx < 1) != 0);
if (__pyx_t_1) {
/* "_state.pxd":250
* int R(int i, int idx) nogil const:
* if idx < 1:
* return -1 # <<<<<<<<<<<<<<
* if i < 0 or i >= this.length:
* return -1
*/
__pyx_r = -1;
goto __pyx_L0;
/* "_state.pxd":249
*
* int R(int i, int idx) nogil const:
* if idx < 1: # <<<<<<<<<<<<<<
* return -1
* if i < 0 or i >= this.length:
*/
}
/* "_state.pxd":251
* if idx < 1:
* return -1
* if i < 0 or i >= this.length: # <<<<<<<<<<<<<<
* return -1
* cdef const TokenC* target = &this._sent[i]
*/
__pyx_t_2 = ((__pyx_v_i < 0) != 0);
if (!__pyx_t_2) {
} else {
__pyx_t_1 = __pyx_t_2;
goto __pyx_L5_bool_binop_done;
}
__pyx_t_2 = ((__pyx_v_i >= this->length) != 0);
__pyx_t_1 = __pyx_t_2;
__pyx_L5_bool_binop_done:;
if (__pyx_t_1) {
/* "_state.pxd":252
* return -1
* if i < 0 or i >= this.length:
* return -1 # <<<<<<<<<<<<<<
* cdef const TokenC* target = &this._sent[i]
* if target.r_kids < <uint32_t>idx:
*/
__pyx_r = -1;
goto __pyx_L0;
/* "_state.pxd":251
* if idx < 1:
* return -1
* if i < 0 or i >= this.length: # <<<<<<<<<<<<<<
* return -1
* cdef const TokenC* target = &this._sent[i]
*/
}
/* "_state.pxd":253
* if i < 0 or i >= this.length:
* return -1
* cdef const TokenC* target = &this._sent[i] # <<<<<<<<<<<<<<
* if target.r_kids < <uint32_t>idx:
* return -1
*/
__pyx_v_target = (&(this->_sent[__pyx_v_i]));
/* "_state.pxd":254
* return -1
* cdef const TokenC* target = &this._sent[i]
* if target.r_kids < <uint32_t>idx: # <<<<<<<<<<<<<<
* return -1
* cdef const TokenC* ptr = &this._sent[target.r_edge]
*/
__pyx_t_1 = ((__pyx_v_target->r_kids < ((uint32_t)__pyx_v_idx)) != 0);
if (__pyx_t_1) {
/* "_state.pxd":255
* cdef const TokenC* target = &this._sent[i]
* if target.r_kids < <uint32_t>idx:
* return -1 # <<<<<<<<<<<<<<
* cdef const TokenC* ptr = &this._sent[target.r_edge]
* while ptr > target:
*/
__pyx_r = -1;
goto __pyx_L0;
/* "_state.pxd":254
* return -1
* cdef const TokenC* target = &this._sent[i]
* if target.r_kids < <uint32_t>idx: # <<<<<<<<<<<<<<
* return -1
* cdef const TokenC* ptr = &this._sent[target.r_edge]
*/
}
/* "_state.pxd":256
* if target.r_kids < <uint32_t>idx:
* return -1
* cdef const TokenC* ptr = &this._sent[target.r_edge] # <<<<<<<<<<<<<<
* while ptr > target:
* # If this head is still to the right of us, we can skip to it
*/
__pyx_v_ptr = (&(this->_sent[__pyx_v_target->r_edge]));
/* "_state.pxd":257
* return -1
* cdef const TokenC* ptr = &this._sent[target.r_edge]
* while ptr > target: # <<<<<<<<<<<<<<
* # If this head is still to the right of us, we can skip to it
* # No token that's between this token and this head could be our
*/
while (1) {
__pyx_t_1 = ((__pyx_v_ptr > __pyx_v_target) != 0);
if (!__pyx_t_1) break;
/* "_state.pxd":261
* # No token that's between this token and this head could be our
* # child.
* if (ptr.head < 0) and ((ptr + ptr.head) > target): # <<<<<<<<<<<<<<
* ptr += ptr.head
* elif ptr + ptr.head == target:
*/
__pyx_t_2 = ((__pyx_v_ptr->head < 0) != 0);
if (__pyx_t_2) {
} else {
__pyx_t_1 = __pyx_t_2;
goto __pyx_L11_bool_binop_done;
}
__pyx_t_2 = (((__pyx_v_ptr + __pyx_v_ptr->head) > __pyx_v_target) != 0);
__pyx_t_1 = __pyx_t_2;
__pyx_L11_bool_binop_done:;
if (__pyx_t_1) {
/* "_state.pxd":262
* # child.
* if (ptr.head < 0) and ((ptr + ptr.head) > target):
* ptr += ptr.head # <<<<<<<<<<<<<<
* elif ptr + ptr.head == target:
* idx -= 1
*/
__pyx_v_ptr = (__pyx_v_ptr + __pyx_v_ptr->head);
/* "_state.pxd":261
* # No token that's between this token and this head could be our
* # child.
* if (ptr.head < 0) and ((ptr + ptr.head) > target): # <<<<<<<<<<<<<<
* ptr += ptr.head
* elif ptr + ptr.head == target:
*/
goto __pyx_L10;
}
/* "_state.pxd":263
* if (ptr.head < 0) and ((ptr + ptr.head) > target):
* ptr += ptr.head
* elif ptr + ptr.head == target: # <<<<<<<<<<<<<<
* idx -= 1
* if idx == 0:
*/
__pyx_t_1 = (((__pyx_v_ptr + __pyx_v_ptr->head) == __pyx_v_target) != 0);
if (__pyx_t_1) {
/* "_state.pxd":264
* ptr += ptr.head
* elif ptr + ptr.head == target:
* idx -= 1 # <<<<<<<<<<<<<<
* if idx == 0:
* return ptr - this._sent
*/
__pyx_v_idx = (__pyx_v_idx - 1);
/* "_state.pxd":265
* elif ptr + ptr.head == target:
* idx -= 1
* if idx == 0: # <<<<<<<<<<<<<<
* return ptr - this._sent
* ptr -= 1
*/
__pyx_t_1 = ((__pyx_v_idx == 0) != 0);
if (__pyx_t_1) {
/* "_state.pxd":266
* idx -= 1
* if idx == 0:
* return ptr - this._sent # <<<<<<<<<<<<<<
* ptr -= 1
* else:
*/
__pyx_r = (__pyx_v_ptr - this->_sent);
goto __pyx_L0;
/* "_state.pxd":265
* elif ptr + ptr.head == target:
* idx -= 1
* if idx == 0: # <<<<<<<<<<<<<<
* return ptr - this._sent
* ptr -= 1
*/
}
/* "_state.pxd":267
* if idx == 0:
* return ptr - this._sent
* ptr -= 1 # <<<<<<<<<<<<<<
* else:
* ptr -= 1
*/
__pyx_v_ptr = (__pyx_v_ptr - 1);
/* "_state.pxd":263
* if (ptr.head < 0) and ((ptr + ptr.head) > target):
* ptr += ptr.head
* elif ptr + ptr.head == target: # <<<<<<<<<<<<<<
* idx -= 1
* if idx == 0:
*/
goto __pyx_L10;
}
/* "_state.pxd":269
* ptr -= 1
* else:
* ptr -= 1 # <<<<<<<<<<<<<<
* return -1
*
*/
/*else*/ {
__pyx_v_ptr = (__pyx_v_ptr - 1);
}
__pyx_L10:;
}
/* "_state.pxd":270
* else:
* ptr -= 1
* return -1 # <<<<<<<<<<<<<<
*
* bint empty() nogil const:
*/
__pyx_r = -1;
goto __pyx_L0;
/* "_state.pxd":248
* return -1
*
* int R(int i, int idx) nogil const: # <<<<<<<<<<<<<<
* if idx < 1:
* return -1
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_WriteUnraisable("StateC.R", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 1);
__pyx_r = 0;
__pyx_L0:;
__Pyx_TraceReturn(Py_None, 1);
return __pyx_r;
}
/* "_state.pxd":272
* return -1
*
* bint empty() nogil const: # <<<<<<<<<<<<<<
* return this._s_i <= 0
*
*/
int __pyx_t_5spacy_6syntax_6_state_StateC::empty(void) const {
int __pyx_r;
__Pyx_TraceDeclarations
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_TraceCall("empty", __pyx_f[4], 272, 1, __PYX_ERR(4, 272, __pyx_L1_error));
/* "_state.pxd":273
*
* bint empty() nogil const:
* return this._s_i <= 0 # <<<<<<<<<<<<<<
*
* bint eol() nogil const:
*/
__pyx_r = (this->_s_i <= 0);
goto __pyx_L0;
/* "_state.pxd":272
* return -1
*
* bint empty() nogil const: # <<<<<<<<<<<<<<
* return this._s_i <= 0
*
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_WriteUnraisable("StateC.empty", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 1);
__pyx_r = 0;
__pyx_L0:;
__Pyx_TraceReturn(Py_None, 1);
return __pyx_r;
}
/* "_state.pxd":275
* return this._s_i <= 0
*
* bint eol() nogil const: # <<<<<<<<<<<<<<
* return this.buffer_length() == 0
*
*/
int __pyx_t_5spacy_6syntax_6_state_StateC::eol(void) const {
int __pyx_r;
__Pyx_TraceDeclarations
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_TraceCall("eol", __pyx_f[4], 275, 1, __PYX_ERR(4, 275, __pyx_L1_error));
/* "_state.pxd":276
*
* bint eol() nogil const:
* return this.buffer_length() == 0 # <<<<<<<<<<<<<<
*
* bint at_break() nogil const:
*/
__pyx_r = (this->buffer_length() == 0);
goto __pyx_L0;
/* "_state.pxd":275
* return this._s_i <= 0
*
* bint eol() nogil const: # <<<<<<<<<<<<<<
* return this.buffer_length() == 0
*
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_WriteUnraisable("StateC.eol", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 1);
__pyx_r = 0;
__pyx_L0:;
__Pyx_TraceReturn(Py_None, 1);
return __pyx_r;
}
/* "_state.pxd":278
* return this.buffer_length() == 0
*
* bint at_break() nogil const: # <<<<<<<<<<<<<<
* return this._break != -1
*
*/
int __pyx_t_5spacy_6syntax_6_state_StateC::at_break(void) const {
int __pyx_r;
__Pyx_TraceDeclarations
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_TraceCall("at_break", __pyx_f[4], 278, 1, __PYX_ERR(4, 278, __pyx_L1_error));
/* "_state.pxd":279
*
* bint at_break() nogil const:
* return this._break != -1 # <<<<<<<<<<<<<<
*
* bint is_final() nogil const:
*/
__pyx_r = (this->_break != -1L);
goto __pyx_L0;
/* "_state.pxd":278
* return this.buffer_length() == 0
*
* bint at_break() nogil const: # <<<<<<<<<<<<<<
* return this._break != -1
*
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_WriteUnraisable("StateC.at_break", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 1);
__pyx_r = 0;
__pyx_L0:;
__Pyx_TraceReturn(Py_None, 1);
return __pyx_r;
}
/* "_state.pxd":281
* return this._break != -1
*
* bint is_final() nogil const: # <<<<<<<<<<<<<<
* return this.stack_depth() <= 0 and this._b_i >= this.length
*
*/
int __pyx_t_5spacy_6syntax_6_state_StateC::is_final(void) const {
int __pyx_r;
__Pyx_TraceDeclarations
int __pyx_t_1;
int __pyx_t_2;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_TraceCall("is_final", __pyx_f[4], 281, 1, __PYX_ERR(4, 281, __pyx_L1_error));
/* "_state.pxd":282
*
* bint is_final() nogil const:
* return this.stack_depth() <= 0 and this._b_i >= this.length # <<<<<<<<<<<<<<
*
* bint has_head(int i) nogil const:
*/
__pyx_t_2 = ((this->stack_depth() <= 0) != 0);
if (__pyx_t_2) {
} else {
__pyx_t_1 = __pyx_t_2;
goto __pyx_L3_bool_binop_done;
}
__pyx_t_2 = ((this->_b_i >= this->length) != 0);
__pyx_t_1 = __pyx_t_2;
__pyx_L3_bool_binop_done:;
__pyx_r = __pyx_t_1;
goto __pyx_L0;
/* "_state.pxd":281
* return this._break != -1
*
* bint is_final() nogil const: # <<<<<<<<<<<<<<
* return this.stack_depth() <= 0 and this._b_i >= this.length
*
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_WriteUnraisable("StateC.is_final", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 1);
__pyx_r = 0;
__pyx_L0:;
__Pyx_TraceReturn(Py_None, 1);
return __pyx_r;
}
/* "_state.pxd":284
* return this.stack_depth() <= 0 and this._b_i >= this.length
*
* bint has_head(int i) nogil const: # <<<<<<<<<<<<<<
* return this.safe_get(i).head != 0
*
*/
int __pyx_t_5spacy_6syntax_6_state_StateC::has_head(int __pyx_v_i) const {
int __pyx_r;
__Pyx_TraceDeclarations
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_TraceCall("has_head", __pyx_f[4], 284, 1, __PYX_ERR(4, 284, __pyx_L1_error));
/* "_state.pxd":285
*
* bint has_head(int i) nogil const:
* return this.safe_get(i).head != 0 # <<<<<<<<<<<<<<
*
* int n_L(int i) nogil const:
*/
__pyx_r = (this->safe_get(__pyx_v_i)->head != 0);
goto __pyx_L0;
/* "_state.pxd":284
* return this.stack_depth() <= 0 and this._b_i >= this.length
*
* bint has_head(int i) nogil const: # <<<<<<<<<<<<<<
* return this.safe_get(i).head != 0
*
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_WriteUnraisable("StateC.has_head", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 1);
__pyx_r = 0;
__pyx_L0:;
__Pyx_TraceReturn(Py_None, 1);
return __pyx_r;
}
/* "_state.pxd":287
* return this.safe_get(i).head != 0
*
* int n_L(int i) nogil const: # <<<<<<<<<<<<<<
* return this.safe_get(i).l_kids
*
*/
int __pyx_t_5spacy_6syntax_6_state_StateC::n_L(int __pyx_v_i) const {
int __pyx_r;
__Pyx_TraceDeclarations
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_TraceCall("n_L", __pyx_f[4], 287, 1, __PYX_ERR(4, 287, __pyx_L1_error));
/* "_state.pxd":288
*
* int n_L(int i) nogil const:
* return this.safe_get(i).l_kids # <<<<<<<<<<<<<<
*
* int n_R(int i) nogil const:
*/
__pyx_r = this->safe_get(__pyx_v_i)->l_kids;
goto __pyx_L0;
/* "_state.pxd":287
* return this.safe_get(i).head != 0
*
* int n_L(int i) nogil const: # <<<<<<<<<<<<<<
* return this.safe_get(i).l_kids
*
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_WriteUnraisable("StateC.n_L", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 1);
__pyx_r = 0;
__pyx_L0:;
__Pyx_TraceReturn(Py_None, 1);
return __pyx_r;
}
/* "_state.pxd":290
* return this.safe_get(i).l_kids
*
* int n_R(int i) nogil const: # <<<<<<<<<<<<<<
* return this.safe_get(i).r_kids
*
*/
int __pyx_t_5spacy_6syntax_6_state_StateC::n_R(int __pyx_v_i) const {
int __pyx_r;
__Pyx_TraceDeclarations
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_TraceCall("n_R", __pyx_f[4], 290, 1, __PYX_ERR(4, 290, __pyx_L1_error));
/* "_state.pxd":291
*
* int n_R(int i) nogil const:
* return this.safe_get(i).r_kids # <<<<<<<<<<<<<<
*
* bint stack_is_connected() nogil const:
*/
__pyx_r = this->safe_get(__pyx_v_i)->r_kids;
goto __pyx_L0;
/* "_state.pxd":290
* return this.safe_get(i).l_kids
*
* int n_R(int i) nogil const: # <<<<<<<<<<<<<<
* return this.safe_get(i).r_kids
*
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_WriteUnraisable("StateC.n_R", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 1);
__pyx_r = 0;
__pyx_L0:;
__Pyx_TraceReturn(Py_None, 1);
return __pyx_r;
}
/* "_state.pxd":293
* return this.safe_get(i).r_kids
*
* bint stack_is_connected() nogil const: # <<<<<<<<<<<<<<
* return False
*
*/
int __pyx_t_5spacy_6syntax_6_state_StateC::stack_is_connected(void) const {
int __pyx_r;
__Pyx_TraceDeclarations
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_TraceCall("stack_is_connected", __pyx_f[4], 293, 1, __PYX_ERR(4, 293, __pyx_L1_error));
/* "_state.pxd":294
*
* bint stack_is_connected() nogil const:
* return False # <<<<<<<<<<<<<<
*
* bint entity_is_open() nogil const:
*/
__pyx_r = 0;
goto __pyx_L0;
/* "_state.pxd":293
* return this.safe_get(i).r_kids
*
* bint stack_is_connected() nogil const: # <<<<<<<<<<<<<<
* return False
*
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_WriteUnraisable("StateC.stack_is_connected", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 1);
__pyx_r = 0;
__pyx_L0:;
__Pyx_TraceReturn(Py_None, 1);
return __pyx_r;
}
/* "_state.pxd":296
* return False
*
* bint entity_is_open() nogil const: # <<<<<<<<<<<<<<
* if this._e_i < 1:
* return False
*/
int __pyx_t_5spacy_6syntax_6_state_StateC::entity_is_open(void) const {
int __pyx_r;
__Pyx_TraceDeclarations
int __pyx_t_1;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_TraceCall("entity_is_open", __pyx_f[4], 296, 1, __PYX_ERR(4, 296, __pyx_L1_error));
/* "_state.pxd":297
*
* bint entity_is_open() nogil const:
* if this._e_i < 1: # <<<<<<<<<<<<<<
* return False
* return this._ents[this._e_i-1].end == -1
*/
__pyx_t_1 = ((this->_e_i < 1) != 0);
if (__pyx_t_1) {
/* "_state.pxd":298
* bint entity_is_open() nogil const:
* if this._e_i < 1:
* return False # <<<<<<<<<<<<<<
* return this._ents[this._e_i-1].end == -1
*
*/
__pyx_r = 0;
goto __pyx_L0;
/* "_state.pxd":297
*
* bint entity_is_open() nogil const:
* if this._e_i < 1: # <<<<<<<<<<<<<<
* return False
* return this._ents[this._e_i-1].end == -1
*/
}
/* "_state.pxd":299
* if this._e_i < 1:
* return False
* return this._ents[this._e_i-1].end == -1 # <<<<<<<<<<<<<<
*
* int stack_depth() nogil const:
*/
__pyx_r = ((this->_ents[(this->_e_i - 1)]).end == -1L);
goto __pyx_L0;
/* "_state.pxd":296
* return False
*
* bint entity_is_open() nogil const: # <<<<<<<<<<<<<<
* if this._e_i < 1:
* return False
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_WriteUnraisable("StateC.entity_is_open", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 1);
__pyx_r = 0;
__pyx_L0:;
__Pyx_TraceReturn(Py_None, 1);
return __pyx_r;
}
/* "_state.pxd":301
* return this._ents[this._e_i-1].end == -1
*
* int stack_depth() nogil const: # <<<<<<<<<<<<<<
* return this._s_i
*
*/
int __pyx_t_5spacy_6syntax_6_state_StateC::stack_depth(void) const {
int __pyx_r;
__Pyx_TraceDeclarations
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_TraceCall("stack_depth", __pyx_f[4], 301, 1, __PYX_ERR(4, 301, __pyx_L1_error));
/* "_state.pxd":302
*
* int stack_depth() nogil const:
* return this._s_i # <<<<<<<<<<<<<<
*
* int buffer_length() nogil const:
*/
__pyx_r = this->_s_i;
goto __pyx_L0;
/* "_state.pxd":301
* return this._ents[this._e_i-1].end == -1
*
* int stack_depth() nogil const: # <<<<<<<<<<<<<<
* return this._s_i
*
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_WriteUnraisable("StateC.stack_depth", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 1);
__pyx_r = 0;
__pyx_L0:;
__Pyx_TraceReturn(Py_None, 1);
return __pyx_r;
}
/* "_state.pxd":304
* return this._s_i
*
* int buffer_length() nogil const: # <<<<<<<<<<<<<<
* if this._break != -1:
* return this._break - this._b_i
*/
int __pyx_t_5spacy_6syntax_6_state_StateC::buffer_length(void) const {
int __pyx_r;
__Pyx_TraceDeclarations
int __pyx_t_1;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_TraceCall("buffer_length", __pyx_f[4], 304, 1, __PYX_ERR(4, 304, __pyx_L1_error));
/* "_state.pxd":305
*
* int buffer_length() nogil const:
* if this._break != -1: # <<<<<<<<<<<<<<
* return this._break - this._b_i
* else:
*/
__pyx_t_1 = ((this->_break != -1L) != 0);
if (__pyx_t_1) {
/* "_state.pxd":306
* int buffer_length() nogil const:
* if this._break != -1:
* return this._break - this._b_i # <<<<<<<<<<<<<<
* else:
* return this.length - this._b_i
*/
__pyx_r = (this->_break - this->_b_i);
goto __pyx_L0;
/* "_state.pxd":305
*
* int buffer_length() nogil const:
* if this._break != -1: # <<<<<<<<<<<<<<
* return this._break - this._b_i
* else:
*/
}
/* "_state.pxd":308
* return this._break - this._b_i
* else:
* return this.length - this._b_i # <<<<<<<<<<<<<<
*
* uint64_t hash() nogil const:
*/
/*else*/ {
__pyx_r = (this->length - this->_b_i);
goto __pyx_L0;
}
/* "_state.pxd":304
* return this._s_i
*
* int buffer_length() nogil const: # <<<<<<<<<<<<<<
* if this._break != -1:
* return this._break - this._b_i
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_WriteUnraisable("StateC.buffer_length", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 1);
__pyx_r = 0;
__pyx_L0:;
__Pyx_TraceReturn(Py_None, 1);
return __pyx_r;
}
/* "_state.pxd":310
* return this.length - this._b_i
*
* uint64_t hash() nogil const: # <<<<<<<<<<<<<<
* cdef TokenC[11] sig
* sig[0] = this.S_(2)[0]
*/
uint64_t __pyx_t_5spacy_6syntax_6_state_StateC::hash(void) const {
struct __pyx_t_5spacy_7structs_TokenC __pyx_v_sig[11];
uint64_t __pyx_r;
__Pyx_TraceDeclarations
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_TraceCall("hash", __pyx_f[4], 310, 1, __PYX_ERR(4, 310, __pyx_L1_error));
/* "_state.pxd":312
* uint64_t hash() nogil const:
* cdef TokenC[11] sig
* sig[0] = this.S_(2)[0] # <<<<<<<<<<<<<<
* sig[1] = this.S_(1)[0]
* sig[2] = this.R_(this.S(1), 1)[0]
*/
(__pyx_v_sig[0]) = (this->S_(2)[0]);
/* "_state.pxd":313
* cdef TokenC[11] sig
* sig[0] = this.S_(2)[0]
* sig[1] = this.S_(1)[0] # <<<<<<<<<<<<<<
* sig[2] = this.R_(this.S(1), 1)[0]
* sig[3] = this.L_(this.S(0), 1)[0]
*/
(__pyx_v_sig[1]) = (this->S_(1)[0]);
/* "_state.pxd":314
* sig[0] = this.S_(2)[0]
* sig[1] = this.S_(1)[0]
* sig[2] = this.R_(this.S(1), 1)[0] # <<<<<<<<<<<<<<
* sig[3] = this.L_(this.S(0), 1)[0]
* sig[4] = this.L_(this.S(0), 2)[0]
*/
(__pyx_v_sig[2]) = (this->R_(this->S(1), 1)[0]);
/* "_state.pxd":315
* sig[1] = this.S_(1)[0]
* sig[2] = this.R_(this.S(1), 1)[0]
* sig[3] = this.L_(this.S(0), 1)[0] # <<<<<<<<<<<<<<
* sig[4] = this.L_(this.S(0), 2)[0]
* sig[5] = this.S_(0)[0]
*/
(__pyx_v_sig[3]) = (this->L_(this->S(0), 1)[0]);
/* "_state.pxd":316
* sig[2] = this.R_(this.S(1), 1)[0]
* sig[3] = this.L_(this.S(0), 1)[0]
* sig[4] = this.L_(this.S(0), 2)[0] # <<<<<<<<<<<<<<
* sig[5] = this.S_(0)[0]
* sig[6] = this.R_(this.S(0), 2)[0]
*/
(__pyx_v_sig[4]) = (this->L_(this->S(0), 2)[0]);
/* "_state.pxd":317
* sig[3] = this.L_(this.S(0), 1)[0]
* sig[4] = this.L_(this.S(0), 2)[0]
* sig[5] = this.S_(0)[0] # <<<<<<<<<<<<<<
* sig[6] = this.R_(this.S(0), 2)[0]
* sig[7] = this.R_(this.S(0), 1)[0]
*/
(__pyx_v_sig[5]) = (this->S_(0)[0]);
/* "_state.pxd":318
* sig[4] = this.L_(this.S(0), 2)[0]
* sig[5] = this.S_(0)[0]
* sig[6] = this.R_(this.S(0), 2)[0] # <<<<<<<<<<<<<<
* sig[7] = this.R_(this.S(0), 1)[0]
* sig[8] = this.B_(0)[0]
*/
(__pyx_v_sig[6]) = (this->R_(this->S(0), 2)[0]);
/* "_state.pxd":319
* sig[5] = this.S_(0)[0]
* sig[6] = this.R_(this.S(0), 2)[0]
* sig[7] = this.R_(this.S(0), 1)[0] # <<<<<<<<<<<<<<
* sig[8] = this.B_(0)[0]
* sig[9] = this.E_(0)[0]
*/
(__pyx_v_sig[7]) = (this->R_(this->S(0), 1)[0]);
/* "_state.pxd":320
* sig[6] = this.R_(this.S(0), 2)[0]
* sig[7] = this.R_(this.S(0), 1)[0]
* sig[8] = this.B_(0)[0] # <<<<<<<<<<<<<<
* sig[9] = this.E_(0)[0]
* sig[10] = this.E_(1)[0]
*/
(__pyx_v_sig[8]) = (this->B_(0)[0]);
/* "_state.pxd":321
* sig[7] = this.R_(this.S(0), 1)[0]
* sig[8] = this.B_(0)[0]
* sig[9] = this.E_(0)[0] # <<<<<<<<<<<<<<
* sig[10] = this.E_(1)[0]
* return hash64(sig, sizeof(sig), this._s_i) \
*/
(__pyx_v_sig[9]) = (this->E_(0)[0]);
/* "_state.pxd":322
* sig[8] = this.B_(0)[0]
* sig[9] = this.E_(0)[0]
* sig[10] = this.E_(1)[0] # <<<<<<<<<<<<<<
* return hash64(sig, sizeof(sig), this._s_i) \
* + hash64(<void*>&this._hist, sizeof(RingBufferC), 1)
*/
(__pyx_v_sig[10]) = (this->E_(1)[0]);
/* "_state.pxd":324
* sig[10] = this.E_(1)[0]
* return hash64(sig, sizeof(sig), this._s_i) \
* + hash64(<void*>&this._hist, sizeof(RingBufferC), 1) # <<<<<<<<<<<<<<
*
* void push_hist(int act) nogil:
*/
__pyx_r = (__pyx_f_10murmurhash_4mrmr_hash64(__pyx_v_sig, (sizeof(__pyx_v_sig)), this->_s_i) + __pyx_f_10murmurhash_4mrmr_hash64(((void *)(&this->_hist)), (sizeof(struct __pyx_t_5spacy_6syntax_6_state_RingBufferC)), 1));
goto __pyx_L0;
/* "_state.pxd":310
* return this.length - this._b_i
*
* uint64_t hash() nogil const: # <<<<<<<<<<<<<<
* cdef TokenC[11] sig
* sig[0] = this.S_(2)[0]
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_WriteUnraisable("StateC.hash", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 1);
__pyx_r = 0;
__pyx_L0:;
__Pyx_TraceReturn(Py_None, 1);
return __pyx_r;
}
/* "_state.pxd":326
* + hash64(<void*>&this._hist, sizeof(RingBufferC), 1)
*
* void push_hist(int act) nogil: # <<<<<<<<<<<<<<
* ring_push(&this._hist, act+1)
*
*/
void __pyx_t_5spacy_6syntax_6_state_StateC::push_hist(int __pyx_v_act) {
__Pyx_TraceDeclarations
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_TraceCall("push_hist", __pyx_f[4], 326, 1, __PYX_ERR(4, 326, __pyx_L1_error));
/* "_state.pxd":327
*
* void push_hist(int act) nogil:
* ring_push(&this._hist, act+1) # <<<<<<<<<<<<<<
*
* int get_hist(int i) nogil:
*/
(void)(__pyx_f_5spacy_6syntax_6_state_ring_push((&this->_hist), (__pyx_v_act + 1)));
/* "_state.pxd":326
* + hash64(<void*>&this._hist, sizeof(RingBufferC), 1)
*
* void push_hist(int act) nogil: # <<<<<<<<<<<<<<
* ring_push(&this._hist, act+1)
*
*/
/* function exit code */
goto __pyx_L0;
__pyx_L1_error:;
__Pyx_WriteUnraisable("StateC.push_hist", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 1);
__pyx_L0:;
__Pyx_TraceReturn(Py_None, 1);
}
/* "_state.pxd":329
* ring_push(&this._hist, act+1)
*
* int get_hist(int i) nogil: # <<<<<<<<<<<<<<
* return ring_get(&this._hist, i)
*
*/
int __pyx_t_5spacy_6syntax_6_state_StateC::get_hist(int __pyx_v_i) {
int __pyx_r;
__Pyx_TraceDeclarations
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_TraceCall("get_hist", __pyx_f[4], 329, 1, __PYX_ERR(4, 329, __pyx_L1_error));
/* "_state.pxd":330
*
* int get_hist(int i) nogil:
* return ring_get(&this._hist, i) # <<<<<<<<<<<<<<
*
* void push() nogil:
*/
__pyx_r = __pyx_f_5spacy_6syntax_6_state_ring_get((&this->_hist), __pyx_v_i);
goto __pyx_L0;
/* "_state.pxd":329
* ring_push(&this._hist, act+1)
*
* int get_hist(int i) nogil: # <<<<<<<<<<<<<<
* return ring_get(&this._hist, i)
*
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_WriteUnraisable("StateC.get_hist", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 1);
__pyx_r = 0;
__pyx_L0:;
__Pyx_TraceReturn(Py_None, 1);
return __pyx_r;
}
/* "_state.pxd":332
* return ring_get(&this._hist, i)
*
* void push() nogil: # <<<<<<<<<<<<<<
* if this.B(0) != -1:
* this._stack[this._s_i] = this.B(0)
*/
void __pyx_t_5spacy_6syntax_6_state_StateC::push(void) {
__Pyx_TraceDeclarations
int __pyx_t_1;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_TraceCall("push", __pyx_f[4], 332, 1, __PYX_ERR(4, 332, __pyx_L1_error));
/* "_state.pxd":333
*
* void push() nogil:
* if this.B(0) != -1: # <<<<<<<<<<<<<<
* this._stack[this._s_i] = this.B(0)
* this._s_i += 1
*/
__pyx_t_1 = ((this->B(0) != -1L) != 0);
if (__pyx_t_1) {
/* "_state.pxd":334
* void push() nogil:
* if this.B(0) != -1:
* this._stack[this._s_i] = this.B(0) # <<<<<<<<<<<<<<
* this._s_i += 1
* this._b_i += 1
*/
(this->_stack[this->_s_i]) = this->B(0);
/* "_state.pxd":333
*
* void push() nogil:
* if this.B(0) != -1: # <<<<<<<<<<<<<<
* this._stack[this._s_i] = this.B(0)
* this._s_i += 1
*/
}
/* "_state.pxd":335
* if this.B(0) != -1:
* this._stack[this._s_i] = this.B(0)
* this._s_i += 1 # <<<<<<<<<<<<<<
* this._b_i += 1
* if this.safe_get(this.B_(0).l_edge).sent_start == 1:
*/
this->_s_i = (this->_s_i + 1);
/* "_state.pxd":336
* this._stack[this._s_i] = this.B(0)
* this._s_i += 1
* this._b_i += 1 # <<<<<<<<<<<<<<
* if this.safe_get(this.B_(0).l_edge).sent_start == 1:
* this.set_break(this.B_(0).l_edge)
*/
this->_b_i = (this->_b_i + 1);
/* "_state.pxd":337
* this._s_i += 1
* this._b_i += 1
* if this.safe_get(this.B_(0).l_edge).sent_start == 1: # <<<<<<<<<<<<<<
* this.set_break(this.B_(0).l_edge)
* if this._b_i > this._break:
*/
__pyx_t_1 = ((this->safe_get(this->B_(0)->l_edge)->sent_start == 1) != 0);
if (__pyx_t_1) {
/* "_state.pxd":338
* this._b_i += 1
* if this.safe_get(this.B_(0).l_edge).sent_start == 1:
* this.set_break(this.B_(0).l_edge) # <<<<<<<<<<<<<<
* if this._b_i > this._break:
* this._break = -1
*/
this->set_break(this->B_(0)->l_edge);
/* "_state.pxd":337
* this._s_i += 1
* this._b_i += 1
* if this.safe_get(this.B_(0).l_edge).sent_start == 1: # <<<<<<<<<<<<<<
* this.set_break(this.B_(0).l_edge)
* if this._b_i > this._break:
*/
}
/* "_state.pxd":339
* if this.safe_get(this.B_(0).l_edge).sent_start == 1:
* this.set_break(this.B_(0).l_edge)
* if this._b_i > this._break: # <<<<<<<<<<<<<<
* this._break = -1
*
*/
__pyx_t_1 = ((this->_b_i > this->_break) != 0);
if (__pyx_t_1) {
/* "_state.pxd":340
* this.set_break(this.B_(0).l_edge)
* if this._b_i > this._break:
* this._break = -1 # <<<<<<<<<<<<<<
*
* void pop() nogil:
*/
this->_break = -1;
/* "_state.pxd":339
* if this.safe_get(this.B_(0).l_edge).sent_start == 1:
* this.set_break(this.B_(0).l_edge)
* if this._b_i > this._break: # <<<<<<<<<<<<<<
* this._break = -1
*
*/
}
/* "_state.pxd":332
* return ring_get(&this._hist, i)
*
* void push() nogil: # <<<<<<<<<<<<<<
* if this.B(0) != -1:
* this._stack[this._s_i] = this.B(0)
*/
/* function exit code */
goto __pyx_L0;
__pyx_L1_error:;
__Pyx_WriteUnraisable("StateC.push", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 1);
__pyx_L0:;
__Pyx_TraceReturn(Py_None, 1);
}
/* "_state.pxd":342
* this._break = -1
*
* void pop() nogil: # <<<<<<<<<<<<<<
* if this._s_i >= 1:
* this._s_i -= 1
*/
void __pyx_t_5spacy_6syntax_6_state_StateC::pop(void) {
__Pyx_TraceDeclarations
int __pyx_t_1;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_TraceCall("pop", __pyx_f[4], 342, 1, __PYX_ERR(4, 342, __pyx_L1_error));
/* "_state.pxd":343
*
* void pop() nogil:
* if this._s_i >= 1: # <<<<<<<<<<<<<<
* this._s_i -= 1
*
*/
__pyx_t_1 = ((this->_s_i >= 1) != 0);
if (__pyx_t_1) {
/* "_state.pxd":344
* void pop() nogil:
* if this._s_i >= 1:
* this._s_i -= 1 # <<<<<<<<<<<<<<
*
* void force_final() nogil:
*/
this->_s_i = (this->_s_i - 1);
/* "_state.pxd":343
*
* void pop() nogil:
* if this._s_i >= 1: # <<<<<<<<<<<<<<
* this._s_i -= 1
*
*/
}
/* "_state.pxd":342
* this._break = -1
*
* void pop() nogil: # <<<<<<<<<<<<<<
* if this._s_i >= 1:
* this._s_i -= 1
*/
/* function exit code */
goto __pyx_L0;
__pyx_L1_error:;
__Pyx_WriteUnraisable("StateC.pop", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 1);
__pyx_L0:;
__Pyx_TraceReturn(Py_None, 1);
}
/* "_state.pxd":346
* this._s_i -= 1
*
* void force_final() nogil: # <<<<<<<<<<<<<<
* # This should only be used in desperate situations, as it may leave
* # the analysis in an unexpected state.
*/
void __pyx_t_5spacy_6syntax_6_state_StateC::force_final(void) {
__Pyx_TraceDeclarations
int __pyx_t_1;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_TraceCall("force_final", __pyx_f[4], 346, 1, __PYX_ERR(4, 346, __pyx_L1_error));
/* "_state.pxd":349
* # This should only be used in desperate situations, as it may leave
* # the analysis in an unexpected state.
* this._s_i = 0 # <<<<<<<<<<<<<<
* this._b_i = this.length
*
*/
this->_s_i = 0;
/* "_state.pxd":350
* # the analysis in an unexpected state.
* this._s_i = 0
* this._b_i = this.length # <<<<<<<<<<<<<<
*
* void unshift() nogil:
*/
__pyx_t_1 = this->length;
this->_b_i = __pyx_t_1;
/* "_state.pxd":346
* this._s_i -= 1
*
* void force_final() nogil: # <<<<<<<<<<<<<<
* # This should only be used in desperate situations, as it may leave
* # the analysis in an unexpected state.
*/
/* function exit code */
goto __pyx_L0;
__pyx_L1_error:;
__Pyx_WriteUnraisable("StateC.force_final", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 1);
__pyx_L0:;
__Pyx_TraceReturn(Py_None, 1);
}
/* "_state.pxd":352
* this._b_i = this.length
*
* void unshift() nogil: # <<<<<<<<<<<<<<
* this._b_i -= 1
* this._buffer[this._b_i] = this.S(0)
*/
void __pyx_t_5spacy_6syntax_6_state_StateC::unshift(void) {
__Pyx_TraceDeclarations
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_TraceCall("unshift", __pyx_f[4], 352, 1, __PYX_ERR(4, 352, __pyx_L1_error));
/* "_state.pxd":353
*
* void unshift() nogil:
* this._b_i -= 1 # <<<<<<<<<<<<<<
* this._buffer[this._b_i] = this.S(0)
* this._s_i -= 1
*/
this->_b_i = (this->_b_i - 1);
/* "_state.pxd":354
* void unshift() nogil:
* this._b_i -= 1
* this._buffer[this._b_i] = this.S(0) # <<<<<<<<<<<<<<
* this._s_i -= 1
* this.shifted[this.B(0)] = True
*/
(this->_buffer[this->_b_i]) = this->S(0);
/* "_state.pxd":355
* this._b_i -= 1
* this._buffer[this._b_i] = this.S(0)
* this._s_i -= 1 # <<<<<<<<<<<<<<
* this.shifted[this.B(0)] = True
*
*/
this->_s_i = (this->_s_i - 1);
/* "_state.pxd":356
* this._buffer[this._b_i] = this.S(0)
* this._s_i -= 1
* this.shifted[this.B(0)] = True # <<<<<<<<<<<<<<
*
* void add_arc(int head, int child, attr_t label) nogil:
*/
(this->shifted[this->B(0)]) = 1;
/* "_state.pxd":352
* this._b_i = this.length
*
* void unshift() nogil: # <<<<<<<<<<<<<<
* this._b_i -= 1
* this._buffer[this._b_i] = this.S(0)
*/
/* function exit code */
goto __pyx_L0;
__pyx_L1_error:;
__Pyx_WriteUnraisable("StateC.unshift", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 1);
__pyx_L0:;
__Pyx_TraceReturn(Py_None, 1);
}
/* "_state.pxd":358
* this.shifted[this.B(0)] = True
*
* void add_arc(int head, int child, attr_t label) nogil: # <<<<<<<<<<<<<<
* if this.has_head(child):
* this.del_arc(this.H(child), child)
*/
void __pyx_t_5spacy_6syntax_6_state_StateC::add_arc(int __pyx_v_head, int __pyx_v_child, __pyx_t_5spacy_8typedefs_attr_t __pyx_v_label) {
int __pyx_v_dist;
int __pyx_v_i;
__Pyx_TraceDeclarations
int __pyx_t_1;
int __pyx_t_2;
uint32_t __pyx_t_3;
int __pyx_t_4;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_TraceCall("add_arc", __pyx_f[4], 358, 1, __PYX_ERR(4, 358, __pyx_L1_error));
/* "_state.pxd":359
*
* void add_arc(int head, int child, attr_t label) nogil:
* if this.has_head(child): # <<<<<<<<<<<<<<
* this.del_arc(this.H(child), child)
*
*/
__pyx_t_1 = (this->has_head(__pyx_v_child) != 0);
if (__pyx_t_1) {
/* "_state.pxd":360
* void add_arc(int head, int child, attr_t label) nogil:
* if this.has_head(child):
* this.del_arc(this.H(child), child) # <<<<<<<<<<<<<<
*
* cdef int dist = head - child
*/
this->del_arc(this->H(__pyx_v_child), __pyx_v_child);
/* "_state.pxd":359
*
* void add_arc(int head, int child, attr_t label) nogil:
* if this.has_head(child): # <<<<<<<<<<<<<<
* this.del_arc(this.H(child), child)
*
*/
}
/* "_state.pxd":362
* this.del_arc(this.H(child), child)
*
* cdef int dist = head - child # <<<<<<<<<<<<<<
* this._sent[child].head = dist
* this._sent[child].dep = label
*/
__pyx_v_dist = (__pyx_v_head - __pyx_v_child);
/* "_state.pxd":363
*
* cdef int dist = head - child
* this._sent[child].head = dist # <<<<<<<<<<<<<<
* this._sent[child].dep = label
* cdef int i
*/
(this->_sent[__pyx_v_child]).head = __pyx_v_dist;
/* "_state.pxd":364
* cdef int dist = head - child
* this._sent[child].head = dist
* this._sent[child].dep = label # <<<<<<<<<<<<<<
* cdef int i
* if child > head:
*/
(this->_sent[__pyx_v_child]).dep = __pyx_v_label;
/* "_state.pxd":366
* this._sent[child].dep = label
* cdef int i
* if child > head: # <<<<<<<<<<<<<<
* this._sent[head].r_kids += 1
* # Some transition systems can have a word in the buffer have a
*/
__pyx_t_1 = ((__pyx_v_child > __pyx_v_head) != 0);
if (__pyx_t_1) {
/* "_state.pxd":367
* cdef int i
* if child > head:
* this._sent[head].r_kids += 1 # <<<<<<<<<<<<<<
* # Some transition systems can have a word in the buffer have a
* # rightward child, e.g. from Unshift.
*/
__pyx_t_2 = __pyx_v_head;
(this->_sent[__pyx_t_2]).r_kids = ((this->_sent[__pyx_t_2]).r_kids + 1);
/* "_state.pxd":370
* # Some transition systems can have a word in the buffer have a
* # rightward child, e.g. from Unshift.
* this._sent[head].r_edge = this._sent[child].r_edge # <<<<<<<<<<<<<<
* i = 0
* while this.has_head(head) and i < this.length:
*/
__pyx_t_3 = (this->_sent[__pyx_v_child]).r_edge;
(this->_sent[__pyx_v_head]).r_edge = __pyx_t_3;
/* "_state.pxd":371
* # rightward child, e.g. from Unshift.
* this._sent[head].r_edge = this._sent[child].r_edge
* i = 0 # <<<<<<<<<<<<<<
* while this.has_head(head) and i < this.length:
* head = this.H(head)
*/
__pyx_v_i = 0;
/* "_state.pxd":372
* this._sent[head].r_edge = this._sent[child].r_edge
* i = 0
* while this.has_head(head) and i < this.length: # <<<<<<<<<<<<<<
* head = this.H(head)
* this._sent[head].r_edge = this._sent[child].r_edge
*/
while (1) {
__pyx_t_4 = (this->has_head(__pyx_v_head) != 0);
if (__pyx_t_4) {
} else {
__pyx_t_1 = __pyx_t_4;
goto __pyx_L7_bool_binop_done;
}
__pyx_t_4 = ((__pyx_v_i < this->length) != 0);
__pyx_t_1 = __pyx_t_4;
__pyx_L7_bool_binop_done:;
if (!__pyx_t_1) break;
/* "_state.pxd":373
* i = 0
* while this.has_head(head) and i < this.length:
* head = this.H(head) # <<<<<<<<<<<<<<
* this._sent[head].r_edge = this._sent[child].r_edge
* i += 1 # Guard against infinite loops
*/
__pyx_v_head = this->H(__pyx_v_head);
/* "_state.pxd":374
* while this.has_head(head) and i < this.length:
* head = this.H(head)
* this._sent[head].r_edge = this._sent[child].r_edge # <<<<<<<<<<<<<<
* i += 1 # Guard against infinite loops
* else:
*/
__pyx_t_3 = (this->_sent[__pyx_v_child]).r_edge;
(this->_sent[__pyx_v_head]).r_edge = __pyx_t_3;
/* "_state.pxd":375
* head = this.H(head)
* this._sent[head].r_edge = this._sent[child].r_edge
* i += 1 # Guard against infinite loops # <<<<<<<<<<<<<<
* else:
* this._sent[head].l_kids += 1
*/
__pyx_v_i = (__pyx_v_i + 1);
}
/* "_state.pxd":366
* this._sent[child].dep = label
* cdef int i
* if child > head: # <<<<<<<<<<<<<<
* this._sent[head].r_kids += 1
* # Some transition systems can have a word in the buffer have a
*/
goto __pyx_L4;
}
/* "_state.pxd":377
* i += 1 # Guard against infinite loops
* else:
* this._sent[head].l_kids += 1 # <<<<<<<<<<<<<<
* this._sent[head].l_edge = this._sent[child].l_edge
*
*/
/*else*/ {
__pyx_t_2 = __pyx_v_head;
(this->_sent[__pyx_t_2]).l_kids = ((this->_sent[__pyx_t_2]).l_kids + 1);
/* "_state.pxd":378
* else:
* this._sent[head].l_kids += 1
* this._sent[head].l_edge = this._sent[child].l_edge # <<<<<<<<<<<<<<
*
* void del_arc(int h_i, int c_i) nogil:
*/
__pyx_t_3 = (this->_sent[__pyx_v_child]).l_edge;
(this->_sent[__pyx_v_head]).l_edge = __pyx_t_3;
}
__pyx_L4:;
/* "_state.pxd":358
* this.shifted[this.B(0)] = True
*
* void add_arc(int head, int child, attr_t label) nogil: # <<<<<<<<<<<<<<
* if this.has_head(child):
* this.del_arc(this.H(child), child)
*/
/* function exit code */
goto __pyx_L0;
__pyx_L1_error:;
__Pyx_WriteUnraisable("StateC.add_arc", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 1);
__pyx_L0:;
__Pyx_TraceReturn(Py_None, 1);
}
/* "_state.pxd":380
* this._sent[head].l_edge = this._sent[child].l_edge
*
* void del_arc(int h_i, int c_i) nogil: # <<<<<<<<<<<<<<
* cdef int dist = h_i - c_i
* cdef TokenC* h = &this._sent[h_i]
*/
void __pyx_t_5spacy_6syntax_6_state_StateC::del_arc(int __pyx_v_h_i, int __pyx_v_c_i) {
CYTHON_UNUSED int __pyx_v_dist;
struct __pyx_t_5spacy_7structs_TokenC *__pyx_v_h;
int __pyx_v_i;
uint32_t __pyx_v_new_edge;
__Pyx_TraceDeclarations
int __pyx_t_1;
uint32_t __pyx_t_2;
int __pyx_t_3;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_TraceCall("del_arc", __pyx_f[4], 380, 1, __PYX_ERR(4, 380, __pyx_L1_error));
/* "_state.pxd":381
*
* void del_arc(int h_i, int c_i) nogil:
* cdef int dist = h_i - c_i # <<<<<<<<<<<<<<
* cdef TokenC* h = &this._sent[h_i]
* cdef int i = 0
*/
__pyx_v_dist = (__pyx_v_h_i - __pyx_v_c_i);
/* "_state.pxd":382
* void del_arc(int h_i, int c_i) nogil:
* cdef int dist = h_i - c_i
* cdef TokenC* h = &this._sent[h_i] # <<<<<<<<<<<<<<
* cdef int i = 0
* if c_i > h_i:
*/
__pyx_v_h = (&(this->_sent[__pyx_v_h_i]));
/* "_state.pxd":383
* cdef int dist = h_i - c_i
* cdef TokenC* h = &this._sent[h_i]
* cdef int i = 0 # <<<<<<<<<<<<<<
* if c_i > h_i:
* # this.R_(h_i, 2) returns the second-rightmost child token of h_i
*/
__pyx_v_i = 0;
/* "_state.pxd":384
* cdef TokenC* h = &this._sent[h_i]
* cdef int i = 0
* if c_i > h_i: # <<<<<<<<<<<<<<
* # this.R_(h_i, 2) returns the second-rightmost child token of h_i
* # If we have more than 2 rightmost children, our 2nd rightmost child's
*/
__pyx_t_1 = ((__pyx_v_c_i > __pyx_v_h_i) != 0);
if (__pyx_t_1) {
/* "_state.pxd":388
* # If we have more than 2 rightmost children, our 2nd rightmost child's
* # rightmost edge is going to be our new rightmost edge.
* h.r_edge = this.R_(h_i, 2).r_edge if h.r_kids >= 2 else h_i # <<<<<<<<<<<<<<
* h.r_kids -= 1
* new_edge = h.r_edge
*/
if (((__pyx_v_h->r_kids >= 2) != 0)) {
__pyx_t_2 = this->R_(__pyx_v_h_i, 2)->r_edge;
} else {
__pyx_t_2 = __pyx_v_h_i;
}
__pyx_v_h->r_edge = __pyx_t_2;
/* "_state.pxd":389
* # rightmost edge is going to be our new rightmost edge.
* h.r_edge = this.R_(h_i, 2).r_edge if h.r_kids >= 2 else h_i
* h.r_kids -= 1 # <<<<<<<<<<<<<<
* new_edge = h.r_edge
* # Correct upwards in the tree --- see Issue #251
*/
__pyx_v_h->r_kids = (__pyx_v_h->r_kids - 1);
/* "_state.pxd":390
* h.r_edge = this.R_(h_i, 2).r_edge if h.r_kids >= 2 else h_i
* h.r_kids -= 1
* new_edge = h.r_edge # <<<<<<<<<<<<<<
* # Correct upwards in the tree --- see Issue #251
* while h.head < 0 and i < this.length: # Guard infinite loop
*/
__pyx_t_2 = __pyx_v_h->r_edge;
__pyx_v_new_edge = __pyx_t_2;
/* "_state.pxd":392
* new_edge = h.r_edge
* # Correct upwards in the tree --- see Issue #251
* while h.head < 0 and i < this.length: # Guard infinite loop # <<<<<<<<<<<<<<
* h += h.head
* h.r_edge = new_edge
*/
while (1) {
__pyx_t_3 = ((__pyx_v_h->head < 0) != 0);
if (__pyx_t_3) {
} else {
__pyx_t_1 = __pyx_t_3;
goto __pyx_L6_bool_binop_done;
}
__pyx_t_3 = ((__pyx_v_i < this->length) != 0);
__pyx_t_1 = __pyx_t_3;
__pyx_L6_bool_binop_done:;
if (!__pyx_t_1) break;
/* "_state.pxd":393
* # Correct upwards in the tree --- see Issue #251
* while h.head < 0 and i < this.length: # Guard infinite loop
* h += h.head # <<<<<<<<<<<<<<
* h.r_edge = new_edge
* i += 1
*/
__pyx_v_h = (__pyx_v_h + __pyx_v_h->head);
/* "_state.pxd":394
* while h.head < 0 and i < this.length: # Guard infinite loop
* h += h.head
* h.r_edge = new_edge # <<<<<<<<<<<<<<
* i += 1
* else:
*/
__pyx_v_h->r_edge = __pyx_v_new_edge;
/* "_state.pxd":395
* h += h.head
* h.r_edge = new_edge
* i += 1 # <<<<<<<<<<<<<<
* else:
* # Same logic applies for left edge, but we don't need to walk up
*/
__pyx_v_i = (__pyx_v_i + 1);
}
/* "_state.pxd":384
* cdef TokenC* h = &this._sent[h_i]
* cdef int i = 0
* if c_i > h_i: # <<<<<<<<<<<<<<
* # this.R_(h_i, 2) returns the second-rightmost child token of h_i
* # If we have more than 2 rightmost children, our 2nd rightmost child's
*/
goto __pyx_L3;
}
/* "_state.pxd":399
* # Same logic applies for left edge, but we don't need to walk up
* # the tree, as the head is off the stack.
* h.l_edge = this.L_(h_i, 2).l_edge if h.l_kids >= 2 else h_i # <<<<<<<<<<<<<<
* h.l_kids -= 1
*
*/
/*else*/ {
if (((__pyx_v_h->l_kids >= 2) != 0)) {
__pyx_t_2 = this->L_(__pyx_v_h_i, 2)->l_edge;
} else {
__pyx_t_2 = __pyx_v_h_i;
}
__pyx_v_h->l_edge = __pyx_t_2;
/* "_state.pxd":400
* # the tree, as the head is off the stack.
* h.l_edge = this.L_(h_i, 2).l_edge if h.l_kids >= 2 else h_i
* h.l_kids -= 1 # <<<<<<<<<<<<<<
*
* void open_ent(attr_t label) nogil:
*/
__pyx_v_h->l_kids = (__pyx_v_h->l_kids - 1);
}
__pyx_L3:;
/* "_state.pxd":380
* this._sent[head].l_edge = this._sent[child].l_edge
*
* void del_arc(int h_i, int c_i) nogil: # <<<<<<<<<<<<<<
* cdef int dist = h_i - c_i
* cdef TokenC* h = &this._sent[h_i]
*/
/* function exit code */
goto __pyx_L0;
__pyx_L1_error:;
__Pyx_WriteUnraisable("StateC.del_arc", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 1);
__pyx_L0:;
__Pyx_TraceReturn(Py_None, 1);
}
/* "_state.pxd":402
* h.l_kids -= 1
*
* void open_ent(attr_t label) nogil: # <<<<<<<<<<<<<<
* this._ents[this._e_i].start = this.B(0)
* this._ents[this._e_i].label = label
*/
void __pyx_t_5spacy_6syntax_6_state_StateC::open_ent(__pyx_t_5spacy_8typedefs_attr_t __pyx_v_label) {
__Pyx_TraceDeclarations
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_TraceCall("open_ent", __pyx_f[4], 402, 1, __PYX_ERR(4, 402, __pyx_L1_error));
/* "_state.pxd":403
*
* void open_ent(attr_t label) nogil:
* this._ents[this._e_i].start = this.B(0) # <<<<<<<<<<<<<<
* this._ents[this._e_i].label = label
* this._ents[this._e_i].end = -1
*/
(this->_ents[this->_e_i]).start = this->B(0);
/* "_state.pxd":404
* void open_ent(attr_t label) nogil:
* this._ents[this._e_i].start = this.B(0)
* this._ents[this._e_i].label = label # <<<<<<<<<<<<<<
* this._ents[this._e_i].end = -1
* this._e_i += 1
*/
(this->_ents[this->_e_i]).label = __pyx_v_label;
/* "_state.pxd":405
* this._ents[this._e_i].start = this.B(0)
* this._ents[this._e_i].label = label
* this._ents[this._e_i].end = -1 # <<<<<<<<<<<<<<
* this._e_i += 1
*
*/
(this->_ents[this->_e_i]).end = -1;
/* "_state.pxd":406
* this._ents[this._e_i].label = label
* this._ents[this._e_i].end = -1
* this._e_i += 1 # <<<<<<<<<<<<<<
*
* void close_ent() nogil:
*/
this->_e_i = (this->_e_i + 1);
/* "_state.pxd":402
* h.l_kids -= 1
*
* void open_ent(attr_t label) nogil: # <<<<<<<<<<<<<<
* this._ents[this._e_i].start = this.B(0)
* this._ents[this._e_i].label = label
*/
/* function exit code */
goto __pyx_L0;
__pyx_L1_error:;
__Pyx_WriteUnraisable("StateC.open_ent", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 1);
__pyx_L0:;
__Pyx_TraceReturn(Py_None, 1);
}
/* "_state.pxd":408
* this._e_i += 1
*
* void close_ent() nogil: # <<<<<<<<<<<<<<
* # Note that we don't decrement _e_i here! We want to maintain all
* # entities, not over-write them...
*/
void __pyx_t_5spacy_6syntax_6_state_StateC::close_ent(void) {
__Pyx_TraceDeclarations
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_TraceCall("close_ent", __pyx_f[4], 408, 1, __PYX_ERR(4, 408, __pyx_L1_error));
/* "_state.pxd":411
* # Note that we don't decrement _e_i here! We want to maintain all
* # entities, not over-write them...
* this._ents[this._e_i-1].end = this.B(0)+1 # <<<<<<<<<<<<<<
* this._sent[this.B(0)].ent_iob = 1
*
*/
(this->_ents[(this->_e_i - 1)]).end = (this->B(0) + 1);
/* "_state.pxd":412
* # entities, not over-write them...
* this._ents[this._e_i-1].end = this.B(0)+1
* this._sent[this.B(0)].ent_iob = 1 # <<<<<<<<<<<<<<
*
* void set_ent_tag(int i, int ent_iob, attr_t ent_type) nogil:
*/
(this->_sent[this->B(0)]).ent_iob = 1;
/* "_state.pxd":408
* this._e_i += 1
*
* void close_ent() nogil: # <<<<<<<<<<<<<<
* # Note that we don't decrement _e_i here! We want to maintain all
* # entities, not over-write them...
*/
/* function exit code */
goto __pyx_L0;
__pyx_L1_error:;
__Pyx_WriteUnraisable("StateC.close_ent", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 1);
__pyx_L0:;
__Pyx_TraceReturn(Py_None, 1);
}
/* "_state.pxd":414
* this._sent[this.B(0)].ent_iob = 1
*
* void set_ent_tag(int i, int ent_iob, attr_t ent_type) nogil: # <<<<<<<<<<<<<<
* if 0 <= i < this.length:
* this._sent[i].ent_iob = ent_iob
*/
void __pyx_t_5spacy_6syntax_6_state_StateC::set_ent_tag(int __pyx_v_i, int __pyx_v_ent_iob, __pyx_t_5spacy_8typedefs_attr_t __pyx_v_ent_type) {
__Pyx_TraceDeclarations
int __pyx_t_1;
int __pyx_t_2;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_TraceCall("set_ent_tag", __pyx_f[4], 414, 1, __PYX_ERR(4, 414, __pyx_L1_error));
/* "_state.pxd":415
*
* void set_ent_tag(int i, int ent_iob, attr_t ent_type) nogil:
* if 0 <= i < this.length: # <<<<<<<<<<<<<<
* this._sent[i].ent_iob = ent_iob
* this._sent[i].ent_type = ent_type
*/
__pyx_t_1 = (0 <= __pyx_v_i);
if (__pyx_t_1) {
__pyx_t_1 = (__pyx_v_i < this->length);
}
__pyx_t_2 = (__pyx_t_1 != 0);
if (__pyx_t_2) {
/* "_state.pxd":416
* void set_ent_tag(int i, int ent_iob, attr_t ent_type) nogil:
* if 0 <= i < this.length:
* this._sent[i].ent_iob = ent_iob # <<<<<<<<<<<<<<
* this._sent[i].ent_type = ent_type
*
*/
(this->_sent[__pyx_v_i]).ent_iob = __pyx_v_ent_iob;
/* "_state.pxd":417
* if 0 <= i < this.length:
* this._sent[i].ent_iob = ent_iob
* this._sent[i].ent_type = ent_type # <<<<<<<<<<<<<<
*
* void set_break(int i) nogil:
*/
(this->_sent[__pyx_v_i]).ent_type = __pyx_v_ent_type;
/* "_state.pxd":415
*
* void set_ent_tag(int i, int ent_iob, attr_t ent_type) nogil:
* if 0 <= i < this.length: # <<<<<<<<<<<<<<
* this._sent[i].ent_iob = ent_iob
* this._sent[i].ent_type = ent_type
*/
}
/* "_state.pxd":414
* this._sent[this.B(0)].ent_iob = 1
*
* void set_ent_tag(int i, int ent_iob, attr_t ent_type) nogil: # <<<<<<<<<<<<<<
* if 0 <= i < this.length:
* this._sent[i].ent_iob = ent_iob
*/
/* function exit code */
goto __pyx_L0;
__pyx_L1_error:;
__Pyx_WriteUnraisable("StateC.set_ent_tag", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 1);
__pyx_L0:;
__Pyx_TraceReturn(Py_None, 1);
}
/* "_state.pxd":419
* this._sent[i].ent_type = ent_type
*
* void set_break(int i) nogil: # <<<<<<<<<<<<<<
* if 0 <= i < this.length:
* this._sent[i].sent_start = 1
*/
void __pyx_t_5spacy_6syntax_6_state_StateC::set_break(int __pyx_v_i) {
__Pyx_TraceDeclarations
int __pyx_t_1;
int __pyx_t_2;
int __pyx_t_3;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_TraceCall("set_break", __pyx_f[4], 419, 1, __PYX_ERR(4, 419, __pyx_L1_error));
/* "_state.pxd":420
*
* void set_break(int i) nogil:
* if 0 <= i < this.length: # <<<<<<<<<<<<<<
* this._sent[i].sent_start = 1
* this._break = this._b_i
*/
__pyx_t_1 = (0 <= __pyx_v_i);
if (__pyx_t_1) {
__pyx_t_1 = (__pyx_v_i < this->length);
}
__pyx_t_2 = (__pyx_t_1 != 0);
if (__pyx_t_2) {
/* "_state.pxd":421
* void set_break(int i) nogil:
* if 0 <= i < this.length:
* this._sent[i].sent_start = 1 # <<<<<<<<<<<<<<
* this._break = this._b_i
*
*/
(this->_sent[__pyx_v_i]).sent_start = 1;
/* "_state.pxd":422
* if 0 <= i < this.length:
* this._sent[i].sent_start = 1
* this._break = this._b_i # <<<<<<<<<<<<<<
*
* void clone(const StateC* src) nogil:
*/
__pyx_t_3 = this->_b_i;
this->_break = __pyx_t_3;
/* "_state.pxd":420
*
* void set_break(int i) nogil:
* if 0 <= i < this.length: # <<<<<<<<<<<<<<
* this._sent[i].sent_start = 1
* this._break = this._b_i
*/
}
/* "_state.pxd":419
* this._sent[i].ent_type = ent_type
*
* void set_break(int i) nogil: # <<<<<<<<<<<<<<
* if 0 <= i < this.length:
* this._sent[i].sent_start = 1
*/
/* function exit code */
goto __pyx_L0;
__pyx_L1_error:;
__Pyx_WriteUnraisable("StateC.set_break", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 1);
__pyx_L0:;
__Pyx_TraceReturn(Py_None, 1);
}
/* "_state.pxd":424
* this._break = this._b_i
*
* void clone(const StateC* src) nogil: # <<<<<<<<<<<<<<
* this.length = src.length
* memcpy(this._sent, src._sent, this.length * sizeof(TokenC))
*/
void __pyx_t_5spacy_6syntax_6_state_StateC::clone(__pyx_t_5spacy_6syntax_6_state_StateC const *__pyx_v_src) {
__Pyx_TraceDeclarations
int __pyx_t_1;
struct __pyx_t_5spacy_7structs_TokenC __pyx_t_2;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_TraceCall("clone", __pyx_f[4], 424, 1, __PYX_ERR(4, 424, __pyx_L1_error));
/* "_state.pxd":425
*
* void clone(const StateC* src) nogil:
* this.length = src.length # <<<<<<<<<<<<<<
* memcpy(this._sent, src._sent, this.length * sizeof(TokenC))
* memcpy(this._stack, src._stack, this.length * sizeof(int))
*/
__pyx_t_1 = __pyx_v_src->length;
this->length = __pyx_t_1;
/* "_state.pxd":426
* void clone(const StateC* src) nogil:
* this.length = src.length
* memcpy(this._sent, src._sent, this.length * sizeof(TokenC)) # <<<<<<<<<<<<<<
* memcpy(this._stack, src._stack, this.length * sizeof(int))
* memcpy(this._buffer, src._buffer, this.length * sizeof(int))
*/
(void)(memcpy(this->_sent, __pyx_v_src->_sent, (this->length * (sizeof(struct __pyx_t_5spacy_7structs_TokenC)))));
/* "_state.pxd":427
* this.length = src.length
* memcpy(this._sent, src._sent, this.length * sizeof(TokenC))
* memcpy(this._stack, src._stack, this.length * sizeof(int)) # <<<<<<<<<<<<<<
* memcpy(this._buffer, src._buffer, this.length * sizeof(int))
* memcpy(this._ents, src._ents, this.length * sizeof(SpanC))
*/
(void)(memcpy(this->_stack, __pyx_v_src->_stack, (this->length * (sizeof(int)))));
/* "_state.pxd":428
* memcpy(this._sent, src._sent, this.length * sizeof(TokenC))
* memcpy(this._stack, src._stack, this.length * sizeof(int))
* memcpy(this._buffer, src._buffer, this.length * sizeof(int)) # <<<<<<<<<<<<<<
* memcpy(this._ents, src._ents, this.length * sizeof(SpanC))
* memcpy(this.shifted, src.shifted, this.length * sizeof(this.shifted[0]))
*/
(void)(memcpy(this->_buffer, __pyx_v_src->_buffer, (this->length * (sizeof(int)))));
/* "_state.pxd":429
* memcpy(this._stack, src._stack, this.length * sizeof(int))
* memcpy(this._buffer, src._buffer, this.length * sizeof(int))
* memcpy(this._ents, src._ents, this.length * sizeof(SpanC)) # <<<<<<<<<<<<<<
* memcpy(this.shifted, src.shifted, this.length * sizeof(this.shifted[0]))
* this._b_i = src._b_i
*/
(void)(memcpy(this->_ents, __pyx_v_src->_ents, (this->length * (sizeof(struct __pyx_t_5spacy_7structs_SpanC)))));
/* "_state.pxd":430
* memcpy(this._buffer, src._buffer, this.length * sizeof(int))
* memcpy(this._ents, src._ents, this.length * sizeof(SpanC))
* memcpy(this.shifted, src.shifted, this.length * sizeof(this.shifted[0])) # <<<<<<<<<<<<<<
* this._b_i = src._b_i
* this._s_i = src._s_i
*/
(void)(memcpy(this->shifted, __pyx_v_src->shifted, (this->length * (sizeof((this->shifted[0]))))));
/* "_state.pxd":431
* memcpy(this._ents, src._ents, this.length * sizeof(SpanC))
* memcpy(this.shifted, src.shifted, this.length * sizeof(this.shifted[0]))
* this._b_i = src._b_i # <<<<<<<<<<<<<<
* this._s_i = src._s_i
* this._e_i = src._e_i
*/
__pyx_t_1 = __pyx_v_src->_b_i;
this->_b_i = __pyx_t_1;
/* "_state.pxd":432
* memcpy(this.shifted, src.shifted, this.length * sizeof(this.shifted[0]))
* this._b_i = src._b_i
* this._s_i = src._s_i # <<<<<<<<<<<<<<
* this._e_i = src._e_i
* this._break = src._break
*/
__pyx_t_1 = __pyx_v_src->_s_i;
this->_s_i = __pyx_t_1;
/* "_state.pxd":433
* this._b_i = src._b_i
* this._s_i = src._s_i
* this._e_i = src._e_i # <<<<<<<<<<<<<<
* this._break = src._break
* this.offset = src.offset
*/
__pyx_t_1 = __pyx_v_src->_e_i;
this->_e_i = __pyx_t_1;
/* "_state.pxd":434
* this._s_i = src._s_i
* this._e_i = src._e_i
* this._break = src._break # <<<<<<<<<<<<<<
* this.offset = src.offset
* this._empty_token = src._empty_token
*/
__pyx_t_1 = __pyx_v_src->_break;
this->_break = __pyx_t_1;
/* "_state.pxd":435
* this._e_i = src._e_i
* this._break = src._break
* this.offset = src.offset # <<<<<<<<<<<<<<
* this._empty_token = src._empty_token
*
*/
__pyx_t_1 = __pyx_v_src->offset;
this->offset = __pyx_t_1;
/* "_state.pxd":436
* this._break = src._break
* this.offset = src.offset
* this._empty_token = src._empty_token # <<<<<<<<<<<<<<
*
* void fast_forward() nogil:
*/
__pyx_t_2 = __pyx_v_src->_empty_token;
this->_empty_token = __pyx_t_2;
/* "_state.pxd":424
* this._break = this._b_i
*
* void clone(const StateC* src) nogil: # <<<<<<<<<<<<<<
* this.length = src.length
* memcpy(this._sent, src._sent, this.length * sizeof(TokenC))
*/
/* function exit code */
goto __pyx_L0;
__pyx_L1_error:;
__Pyx_WriteUnraisable("StateC.clone", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 1);
__pyx_L0:;
__Pyx_TraceReturn(Py_None, 1);
}
/* "_state.pxd":438
* this._empty_token = src._empty_token
*
* void fast_forward() nogil: # <<<<<<<<<<<<<<
* # space token attachement policy:
* # - attach space tokens always to the last preceding real token
*/
void __pyx_t_5spacy_6syntax_6_state_StateC::fast_forward(void) {
__Pyx_TraceDeclarations
int __pyx_t_1;
int __pyx_t_2;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_TraceCall("fast_forward", __pyx_f[4], 438, 1, __PYX_ERR(4, 438, __pyx_L1_error));
/* "_state.pxd":445
* # then make the last space token the head of all others
*
* while is_space_token(this.B_(0)) \ # <<<<<<<<<<<<<<
* or this.buffer_length() == 0 \
* or this.stack_depth() == 0:
*/
while (1) {
/* "_state.pxd":446
*
* while is_space_token(this.B_(0)) \
* or this.buffer_length() == 0 \ # <<<<<<<<<<<<<<
* or this.stack_depth() == 0:
* if this.buffer_length() == 0:
*/
__pyx_t_2 = (__pyx_f_5spacy_6syntax_6_state_is_space_token(this->B_(0)) != 0);
if (!__pyx_t_2) {
} else {
__pyx_t_1 = __pyx_t_2;
goto __pyx_L5_bool_binop_done;
}
/* "_state.pxd":447
* while is_space_token(this.B_(0)) \
* or this.buffer_length() == 0 \
* or this.stack_depth() == 0: # <<<<<<<<<<<<<<
* if this.buffer_length() == 0:
* # remove the last sentence's root from the stack
*/
__pyx_t_2 = ((this->buffer_length() == 0) != 0);
if (!__pyx_t_2) {
} else {
__pyx_t_1 = __pyx_t_2;
goto __pyx_L5_bool_binop_done;
}
__pyx_t_2 = ((this->stack_depth() == 0) != 0);
__pyx_t_1 = __pyx_t_2;
__pyx_L5_bool_binop_done:;
if (!__pyx_t_1) break;
/* "_state.pxd":448
* or this.buffer_length() == 0 \
* or this.stack_depth() == 0:
* if this.buffer_length() == 0: # <<<<<<<<<<<<<<
* # remove the last sentence's root from the stack
* if this.stack_depth() == 1:
*/
__pyx_t_1 = ((this->buffer_length() == 0) != 0);
if (__pyx_t_1) {
/* "_state.pxd":450
* if this.buffer_length() == 0:
* # remove the last sentence's root from the stack
* if this.stack_depth() == 1: # <<<<<<<<<<<<<<
* this.pop()
* # parser got stuck: reduce stack or unshift
*/
__pyx_t_1 = ((this->stack_depth() == 1) != 0);
if (__pyx_t_1) {
/* "_state.pxd":451
* # remove the last sentence's root from the stack
* if this.stack_depth() == 1:
* this.pop() # <<<<<<<<<<<<<<
* # parser got stuck: reduce stack or unshift
* elif this.stack_depth() > 1:
*/
this->pop();
/* "_state.pxd":450
* if this.buffer_length() == 0:
* # remove the last sentence's root from the stack
* if this.stack_depth() == 1: # <<<<<<<<<<<<<<
* this.pop()
* # parser got stuck: reduce stack or unshift
*/
goto __pyx_L9;
}
/* "_state.pxd":453
* this.pop()
* # parser got stuck: reduce stack or unshift
* elif this.stack_depth() > 1: # <<<<<<<<<<<<<<
* if this.has_head(this.S(0)):
* this.pop()
*/
__pyx_t_1 = ((this->stack_depth() > 1) != 0);
if (__pyx_t_1) {
/* "_state.pxd":454
* # parser got stuck: reduce stack or unshift
* elif this.stack_depth() > 1:
* if this.has_head(this.S(0)): # <<<<<<<<<<<<<<
* this.pop()
* else:
*/
__pyx_t_1 = (this->has_head(this->S(0)) != 0);
if (__pyx_t_1) {
/* "_state.pxd":455
* elif this.stack_depth() > 1:
* if this.has_head(this.S(0)):
* this.pop() # <<<<<<<<<<<<<<
* else:
* this.unshift()
*/
this->pop();
/* "_state.pxd":454
* # parser got stuck: reduce stack or unshift
* elif this.stack_depth() > 1:
* if this.has_head(this.S(0)): # <<<<<<<<<<<<<<
* this.pop()
* else:
*/
goto __pyx_L10;
}
/* "_state.pxd":457
* this.pop()
* else:
* this.unshift() # <<<<<<<<<<<<<<
* # stack is empty but there is another sentence on the buffer
* elif (this.length - this._b_i) >= 1:
*/
/*else*/ {
this->unshift();
}
__pyx_L10:;
/* "_state.pxd":453
* this.pop()
* # parser got stuck: reduce stack or unshift
* elif this.stack_depth() > 1: # <<<<<<<<<<<<<<
* if this.has_head(this.S(0)):
* this.pop()
*/
goto __pyx_L9;
}
/* "_state.pxd":459
* this.unshift()
* # stack is empty but there is another sentence on the buffer
* elif (this.length - this._b_i) >= 1: # <<<<<<<<<<<<<<
* this.push()
* else: # stack empty and nothing else coming
*/
__pyx_t_1 = (((this->length - this->_b_i) >= 1) != 0);
if (__pyx_t_1) {
/* "_state.pxd":460
* # stack is empty but there is another sentence on the buffer
* elif (this.length - this._b_i) >= 1:
* this.push() # <<<<<<<<<<<<<<
* else: # stack empty and nothing else coming
* break
*/
this->push();
/* "_state.pxd":459
* this.unshift()
* # stack is empty but there is another sentence on the buffer
* elif (this.length - this._b_i) >= 1: # <<<<<<<<<<<<<<
* this.push()
* else: # stack empty and nothing else coming
*/
goto __pyx_L9;
}
/* "_state.pxd":462
* this.push()
* else: # stack empty and nothing else coming
* break # <<<<<<<<<<<<<<
*
* elif is_space_token(this.B_(0)):
*/
/*else*/ {
goto __pyx_L4_break;
}
__pyx_L9:;
/* "_state.pxd":448
* or this.buffer_length() == 0 \
* or this.stack_depth() == 0:
* if this.buffer_length() == 0: # <<<<<<<<<<<<<<
* # remove the last sentence's root from the stack
* if this.stack_depth() == 1:
*/
goto __pyx_L8;
}
/* "_state.pxd":464
* break
*
* elif is_space_token(this.B_(0)): # <<<<<<<<<<<<<<
* # the normal case: we're somewhere inside a sentence
* if this.stack_depth() > 0:
*/
__pyx_t_1 = (__pyx_f_5spacy_6syntax_6_state_is_space_token(this->B_(0)) != 0);
if (__pyx_t_1) {
/* "_state.pxd":466
* elif is_space_token(this.B_(0)):
* # the normal case: we're somewhere inside a sentence
* if this.stack_depth() > 0: # <<<<<<<<<<<<<<
* # assert not is_space_token(this.S_(0))
* # attach all coming space tokens to their last preceding
*/
__pyx_t_1 = ((this->stack_depth() > 0) != 0);
if (__pyx_t_1) {
/* "_state.pxd":470
* # attach all coming space tokens to their last preceding
* # real token (which should be on the top of the stack)
* while is_space_token(this.B_(0)): # <<<<<<<<<<<<<<
* this.add_arc(this.S(0),this.B(0),0)
* this.push()
*/
while (1) {
__pyx_t_1 = (__pyx_f_5spacy_6syntax_6_state_is_space_token(this->B_(0)) != 0);
if (!__pyx_t_1) break;
/* "_state.pxd":471
* # real token (which should be on the top of the stack)
* while is_space_token(this.B_(0)):
* this.add_arc(this.S(0),this.B(0),0) # <<<<<<<<<<<<<<
* this.push()
* this.pop()
*/
this->add_arc(this->S(0), this->B(0), 0);
/* "_state.pxd":472
* while is_space_token(this.B_(0)):
* this.add_arc(this.S(0),this.B(0),0)
* this.push() # <<<<<<<<<<<<<<
* this.pop()
* # the rare case: we're at the beginning of a document:
*/
this->push();
/* "_state.pxd":473
* this.add_arc(this.S(0),this.B(0),0)
* this.push()
* this.pop() # <<<<<<<<<<<<<<
* # the rare case: we're at the beginning of a document:
* # space tokens are attached to the first real token on the buffer
*/
this->pop();
}
/* "_state.pxd":466
* elif is_space_token(this.B_(0)):
* # the normal case: we're somewhere inside a sentence
* if this.stack_depth() > 0: # <<<<<<<<<<<<<<
* # assert not is_space_token(this.S_(0))
* # attach all coming space tokens to their last preceding
*/
goto __pyx_L11;
}
/* "_state.pxd":476
* # the rare case: we're at the beginning of a document:
* # space tokens are attached to the first real token on the buffer
* elif this.stack_depth() == 0: # <<<<<<<<<<<<<<
* # store all space tokens on the stack until a real token shows up
* # or the last token on the buffer is reached
*/
__pyx_t_1 = ((this->stack_depth() == 0) != 0);
if (__pyx_t_1) {
/* "_state.pxd":479
* # store all space tokens on the stack until a real token shows up
* # or the last token on the buffer is reached
* while is_space_token(this.B_(0)) and this.buffer_length() > 1: # <<<<<<<<<<<<<<
* this.push()
* # empty the stack by attaching all space tokens to the
*/
while (1) {
__pyx_t_2 = (__pyx_f_5spacy_6syntax_6_state_is_space_token(this->B_(0)) != 0);
if (__pyx_t_2) {
} else {
__pyx_t_1 = __pyx_t_2;
goto __pyx_L16_bool_binop_done;
}
__pyx_t_2 = ((this->buffer_length() > 1) != 0);
__pyx_t_1 = __pyx_t_2;
__pyx_L16_bool_binop_done:;
if (!__pyx_t_1) break;
/* "_state.pxd":480
* # or the last token on the buffer is reached
* while is_space_token(this.B_(0)) and this.buffer_length() > 1:
* this.push() # <<<<<<<<<<<<<<
* # empty the stack by attaching all space tokens to the
* # first token on the buffer
*/
this->push();
}
/* "_state.pxd":485
* # boundary case: if all tokens are space tokens, the last one
* # becomes the head of all others
* while this.stack_depth() > 0: # <<<<<<<<<<<<<<
* this.add_arc(this.B(0),this.S(0),0)
* this.pop()
*/
while (1) {
__pyx_t_1 = ((this->stack_depth() > 0) != 0);
if (!__pyx_t_1) break;
/* "_state.pxd":486
* # becomes the head of all others
* while this.stack_depth() > 0:
* this.add_arc(this.B(0),this.S(0),0) # <<<<<<<<<<<<<<
* this.pop()
* # move the first token onto the stack
*/
this->add_arc(this->B(0), this->S(0), 0);
/* "_state.pxd":487
* while this.stack_depth() > 0:
* this.add_arc(this.B(0),this.S(0),0)
* this.pop() # <<<<<<<<<<<<<<
* # move the first token onto the stack
* this.push()
*/
this->pop();
}
/* "_state.pxd":489
* this.pop()
* # move the first token onto the stack
* this.push() # <<<<<<<<<<<<<<
*
* elif this.stack_depth() == 0:
*/
this->push();
/* "_state.pxd":476
* # the rare case: we're at the beginning of a document:
* # space tokens are attached to the first real token on the buffer
* elif this.stack_depth() == 0: # <<<<<<<<<<<<<<
* # store all space tokens on the stack until a real token shows up
* # or the last token on the buffer is reached
*/
}
__pyx_L11:;
/* "_state.pxd":464
* break
*
* elif is_space_token(this.B_(0)): # <<<<<<<<<<<<<<
* # the normal case: we're somewhere inside a sentence
* if this.stack_depth() > 0:
*/
goto __pyx_L8;
}
/* "_state.pxd":491
* this.push()
*
* elif this.stack_depth() == 0: # <<<<<<<<<<<<<<
* # for one token sentences (?)
* if this.buffer_length() == 1:
*/
__pyx_t_1 = ((this->stack_depth() == 0) != 0);
if (__pyx_t_1) {
/* "_state.pxd":493
* elif this.stack_depth() == 0:
* # for one token sentences (?)
* if this.buffer_length() == 1: # <<<<<<<<<<<<<<
* this.push()
* this.pop()
*/
__pyx_t_1 = ((this->buffer_length() == 1) != 0);
if (__pyx_t_1) {
/* "_state.pxd":494
* # for one token sentences (?)
* if this.buffer_length() == 1:
* this.push() # <<<<<<<<<<<<<<
* this.pop()
* # with an empty stack and a non-empty buffer
*/
this->push();
/* "_state.pxd":495
* if this.buffer_length() == 1:
* this.push()
* this.pop() # <<<<<<<<<<<<<<
* # with an empty stack and a non-empty buffer
* # only shift is valid anyway
*/
this->pop();
/* "_state.pxd":493
* elif this.stack_depth() == 0:
* # for one token sentences (?)
* if this.buffer_length() == 1: # <<<<<<<<<<<<<<
* this.push()
* this.pop()
*/
goto __pyx_L20;
}
/* "_state.pxd":498
* # with an empty stack and a non-empty buffer
* # only shift is valid anyway
* elif (this.length - this._b_i) >= 1: # <<<<<<<<<<<<<<
* this.push()
*
*/
__pyx_t_1 = (((this->length - this->_b_i) >= 1) != 0);
if (__pyx_t_1) {
/* "_state.pxd":499
* # only shift is valid anyway
* elif (this.length - this._b_i) >= 1:
* this.push() # <<<<<<<<<<<<<<
*
* else: # can this even happen?
*/
this->push();
/* "_state.pxd":498
* # with an empty stack and a non-empty buffer
* # only shift is valid anyway
* elif (this.length - this._b_i) >= 1: # <<<<<<<<<<<<<<
* this.push()
*
*/
}
__pyx_L20:;
/* "_state.pxd":491
* this.push()
*
* elif this.stack_depth() == 0: # <<<<<<<<<<<<<<
* # for one token sentences (?)
* if this.buffer_length() == 1:
*/
goto __pyx_L8;
}
/* "_state.pxd":502
*
* else: # can this even happen?
* break # <<<<<<<<<<<<<<
*/
/*else*/ {
goto __pyx_L4_break;
}
__pyx_L8:;
}
__pyx_L4_break:;
/* "_state.pxd":438
* this._empty_token = src._empty_token
*
* void fast_forward() nogil: # <<<<<<<<<<<<<<
* # space token attachement policy:
* # - attach space tokens always to the last preceding real token
*/
/* function exit code */
goto __pyx_L0;
__pyx_L1_error:;
__Pyx_WriteUnraisable("StateC.fast_forward", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 1);
__pyx_L0:;
__Pyx_TraceReturn(Py_None, 1);
}
/* "stateclass.pxd":19
*
* @staticmethod
* cdef inline StateClass init(const TokenC* sent, int length): # <<<<<<<<<<<<<<
* cdef StateClass self = StateClass()
* self.c = new StateC(sent, length)
*/
static CYTHON_INLINE struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *__pyx_f_5spacy_6syntax_10stateclass_10StateClass_init(struct __pyx_t_5spacy_7structs_TokenC const *__pyx_v_sent, int __pyx_v_length) {
struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *__pyx_v_self = 0;
struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *__pyx_r = NULL;
__Pyx_TraceDeclarations
__Pyx_RefNannyDeclarations
PyObject *__pyx_t_1 = NULL;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("init", 0);
__Pyx_TraceCall("init", __pyx_f[5], 19, 0, __PYX_ERR(5, 19, __pyx_L1_error));
/* "stateclass.pxd":20
* @staticmethod
* cdef inline StateClass init(const TokenC* sent, int length):
* cdef StateClass self = StateClass() # <<<<<<<<<<<<<<
* self.c = new StateC(sent, length)
* return self
*/
__pyx_t_1 = __Pyx_PyObject_CallNoArg(((PyObject *)__pyx_ptype_5spacy_6syntax_10stateclass_StateClass)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 20, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_v_self = ((struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *)__pyx_t_1);
__pyx_t_1 = 0;
/* "stateclass.pxd":21
* cdef inline StateClass init(const TokenC* sent, int length):
* cdef StateClass self = StateClass()
* self.c = new StateC(sent, length) # <<<<<<<<<<<<<<
* return self
*
*/
__pyx_v_self->c = new __pyx_t_5spacy_6syntax_6_state_StateC(__pyx_v_sent, __pyx_v_length);
/* "stateclass.pxd":22
* cdef StateClass self = StateClass()
* self.c = new StateC(sent, length)
* return self # <<<<<<<<<<<<<<
*
* @staticmethod
*/
__Pyx_XDECREF(((PyObject *)__pyx_r));
__Pyx_INCREF(((PyObject *)__pyx_v_self));
__pyx_r = __pyx_v_self;
goto __pyx_L0;
/* "stateclass.pxd":19
*
* @staticmethod
* cdef inline StateClass init(const TokenC* sent, int length): # <<<<<<<<<<<<<<
* cdef StateClass self = StateClass()
* self.c = new StateC(sent, length)
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_1);
__Pyx_AddTraceback("spacy.syntax.stateclass.StateClass.init", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = 0;
__pyx_L0:;
__Pyx_XDECREF((PyObject *)__pyx_v_self);
__Pyx_XGIVEREF((PyObject *)__pyx_r);
__Pyx_TraceReturn(__pyx_r, 0);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "stateclass.pxd":25
*
* @staticmethod
* cdef inline StateClass borrow(StateC* ptr): # <<<<<<<<<<<<<<
* cdef StateClass self = StateClass()
* del self.c
*/
static CYTHON_INLINE struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *__pyx_f_5spacy_6syntax_10stateclass_10StateClass_borrow(__pyx_t_5spacy_6syntax_6_state_StateC *__pyx_v_ptr) {
struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *__pyx_v_self = 0;
struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *__pyx_r = NULL;
__Pyx_TraceDeclarations
__Pyx_RefNannyDeclarations
PyObject *__pyx_t_1 = NULL;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("borrow", 0);
__Pyx_TraceCall("borrow", __pyx_f[5], 25, 0, __PYX_ERR(5, 25, __pyx_L1_error));
/* "stateclass.pxd":26
* @staticmethod
* cdef inline StateClass borrow(StateC* ptr):
* cdef StateClass self = StateClass() # <<<<<<<<<<<<<<
* del self.c
* self.c = ptr
*/
__pyx_t_1 = __Pyx_PyObject_CallNoArg(((PyObject *)__pyx_ptype_5spacy_6syntax_10stateclass_StateClass)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 26, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_v_self = ((struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *)__pyx_t_1);
__pyx_t_1 = 0;
/* "stateclass.pxd":27
* cdef inline StateClass borrow(StateC* ptr):
* cdef StateClass self = StateClass()
* del self.c # <<<<<<<<<<<<<<
* self.c = ptr
* self._borrowed = 1
*/
delete __pyx_v_self->c;
/* "stateclass.pxd":28
* cdef StateClass self = StateClass()
* del self.c
* self.c = ptr # <<<<<<<<<<<<<<
* self._borrowed = 1
* return self
*/
__pyx_v_self->c = __pyx_v_ptr;
/* "stateclass.pxd":29
* del self.c
* self.c = ptr
* self._borrowed = 1 # <<<<<<<<<<<<<<
* return self
*
*/
__pyx_v_self->_borrowed = 1;
/* "stateclass.pxd":30
* self.c = ptr
* self._borrowed = 1
* return self # <<<<<<<<<<<<<<
*
*
*/
__Pyx_XDECREF(((PyObject *)__pyx_r));
__Pyx_INCREF(((PyObject *)__pyx_v_self));
__pyx_r = __pyx_v_self;
goto __pyx_L0;
/* "stateclass.pxd":25
*
* @staticmethod
* cdef inline StateClass borrow(StateC* ptr): # <<<<<<<<<<<<<<
* cdef StateClass self = StateClass()
* del self.c
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_1);
__Pyx_AddTraceback("spacy.syntax.stateclass.StateClass.borrow", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = 0;
__pyx_L0:;
__Pyx_XDECREF((PyObject *)__pyx_v_self);
__Pyx_XGIVEREF((PyObject *)__pyx_r);
__Pyx_TraceReturn(__pyx_r, 0);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "stateclass.pxd":34
*
* @staticmethod
* cdef inline StateClass init_offset(const TokenC* sent, int length, int # <<<<<<<<<<<<<<
* offset):
* cdef StateClass self = StateClass()
*/
static CYTHON_INLINE struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *__pyx_f_5spacy_6syntax_10stateclass_10StateClass_init_offset(struct __pyx_t_5spacy_7structs_TokenC const *__pyx_v_sent, int __pyx_v_length, int __pyx_v_offset) {
struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *__pyx_v_self = 0;
struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *__pyx_r = NULL;
__Pyx_TraceDeclarations
__Pyx_RefNannyDeclarations
PyObject *__pyx_t_1 = NULL;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("init_offset", 0);
__Pyx_TraceCall("init_offset", __pyx_f[5], 34, 0, __PYX_ERR(5, 34, __pyx_L1_error));
/* "stateclass.pxd":36
* cdef inline StateClass init_offset(const TokenC* sent, int length, int
* offset):
* cdef StateClass self = StateClass() # <<<<<<<<<<<<<<
* self.c = new StateC(sent, length)
* self.c.offset = offset
*/
__pyx_t_1 = __Pyx_PyObject_CallNoArg(((PyObject *)__pyx_ptype_5spacy_6syntax_10stateclass_StateClass)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 36, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_v_self = ((struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *)__pyx_t_1);
__pyx_t_1 = 0;
/* "stateclass.pxd":37
* offset):
* cdef StateClass self = StateClass()
* self.c = new StateC(sent, length) # <<<<<<<<<<<<<<
* self.c.offset = offset
* return self
*/
__pyx_v_self->c = new __pyx_t_5spacy_6syntax_6_state_StateC(__pyx_v_sent, __pyx_v_length);
/* "stateclass.pxd":38
* cdef StateClass self = StateClass()
* self.c = new StateC(sent, length)
* self.c.offset = offset # <<<<<<<<<<<<<<
* return self
*
*/
__pyx_v_self->c->offset = __pyx_v_offset;
/* "stateclass.pxd":39
* self.c = new StateC(sent, length)
* self.c.offset = offset
* return self # <<<<<<<<<<<<<<
*
* cdef inline int S(self, int i) nogil:
*/
__Pyx_XDECREF(((PyObject *)__pyx_r));
__Pyx_INCREF(((PyObject *)__pyx_v_self));
__pyx_r = __pyx_v_self;
goto __pyx_L0;
/* "stateclass.pxd":34
*
* @staticmethod
* cdef inline StateClass init_offset(const TokenC* sent, int length, int # <<<<<<<<<<<<<<
* offset):
* cdef StateClass self = StateClass()
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_1);
__Pyx_AddTraceback("spacy.syntax.stateclass.StateClass.init_offset", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = 0;
__pyx_L0:;
__Pyx_XDECREF((PyObject *)__pyx_v_self);
__Pyx_XGIVEREF((PyObject *)__pyx_r);
__Pyx_TraceReturn(__pyx_r, 0);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "stateclass.pxd":41
* return self
*
* cdef inline int S(self, int i) nogil: # <<<<<<<<<<<<<<
* return self.c.S(i)
*
*/
static CYTHON_INLINE int __pyx_f_5spacy_6syntax_10stateclass_10StateClass_S(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *__pyx_v_self, int __pyx_v_i) {
int __pyx_r;
__Pyx_TraceDeclarations
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_TraceCall("S", __pyx_f[5], 41, 1, __PYX_ERR(5, 41, __pyx_L1_error));
/* "stateclass.pxd":42
*
* cdef inline int S(self, int i) nogil:
* return self.c.S(i) # <<<<<<<<<<<<<<
*
* cdef inline int B(self, int i) nogil:
*/
__pyx_r = __pyx_v_self->c->S(__pyx_v_i);
goto __pyx_L0;
/* "stateclass.pxd":41
* return self
*
* cdef inline int S(self, int i) nogil: # <<<<<<<<<<<<<<
* return self.c.S(i)
*
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_WriteUnraisable("spacy.syntax.stateclass.StateClass.S", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 1);
__pyx_r = 0;
__pyx_L0:;
__Pyx_TraceReturn(Py_None, 1);
return __pyx_r;
}
/* "stateclass.pxd":44
* return self.c.S(i)
*
* cdef inline int B(self, int i) nogil: # <<<<<<<<<<<<<<
* return self.c.B(i)
*
*/
static CYTHON_INLINE int __pyx_f_5spacy_6syntax_10stateclass_10StateClass_B(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *__pyx_v_self, int __pyx_v_i) {
int __pyx_r;
__Pyx_TraceDeclarations
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_TraceCall("B", __pyx_f[5], 44, 1, __PYX_ERR(5, 44, __pyx_L1_error));
/* "stateclass.pxd":45
*
* cdef inline int B(self, int i) nogil:
* return self.c.B(i) # <<<<<<<<<<<<<<
*
* cdef inline const TokenC* S_(self, int i) nogil:
*/
__pyx_r = __pyx_v_self->c->B(__pyx_v_i);
goto __pyx_L0;
/* "stateclass.pxd":44
* return self.c.S(i)
*
* cdef inline int B(self, int i) nogil: # <<<<<<<<<<<<<<
* return self.c.B(i)
*
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_WriteUnraisable("spacy.syntax.stateclass.StateClass.B", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 1);
__pyx_r = 0;
__pyx_L0:;
__Pyx_TraceReturn(Py_None, 1);
return __pyx_r;
}
/* "stateclass.pxd":47
* return self.c.B(i)
*
* cdef inline const TokenC* S_(self, int i) nogil: # <<<<<<<<<<<<<<
* return self.c.S_(i)
*
*/
static CYTHON_INLINE struct __pyx_t_5spacy_7structs_TokenC const *__pyx_f_5spacy_6syntax_10stateclass_10StateClass_S_(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *__pyx_v_self, int __pyx_v_i) {
struct __pyx_t_5spacy_7structs_TokenC const *__pyx_r;
__Pyx_TraceDeclarations
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_TraceCall("S_", __pyx_f[5], 47, 1, __PYX_ERR(5, 47, __pyx_L1_error));
/* "stateclass.pxd":48
*
* cdef inline const TokenC* S_(self, int i) nogil:
* return self.c.S_(i) # <<<<<<<<<<<<<<
*
* cdef inline const TokenC* B_(self, int i) nogil:
*/
__pyx_r = __pyx_v_self->c->S_(__pyx_v_i);
goto __pyx_L0;
/* "stateclass.pxd":47
* return self.c.B(i)
*
* cdef inline const TokenC* S_(self, int i) nogil: # <<<<<<<<<<<<<<
* return self.c.S_(i)
*
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_WriteUnraisable("spacy.syntax.stateclass.StateClass.S_", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 1);
__pyx_r = 0;
__pyx_L0:;
__Pyx_TraceReturn(Py_None, 1);
return __pyx_r;
}
/* "stateclass.pxd":50
* return self.c.S_(i)
*
* cdef inline const TokenC* B_(self, int i) nogil: # <<<<<<<<<<<<<<
* return self.c.B_(i)
*
*/
static CYTHON_INLINE struct __pyx_t_5spacy_7structs_TokenC const *__pyx_f_5spacy_6syntax_10stateclass_10StateClass_B_(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *__pyx_v_self, int __pyx_v_i) {
struct __pyx_t_5spacy_7structs_TokenC const *__pyx_r;
__Pyx_TraceDeclarations
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_TraceCall("B_", __pyx_f[5], 50, 1, __PYX_ERR(5, 50, __pyx_L1_error));
/* "stateclass.pxd":51
*
* cdef inline const TokenC* B_(self, int i) nogil:
* return self.c.B_(i) # <<<<<<<<<<<<<<
*
* cdef inline const TokenC* H_(self, int i) nogil:
*/
__pyx_r = __pyx_v_self->c->B_(__pyx_v_i);
goto __pyx_L0;
/* "stateclass.pxd":50
* return self.c.S_(i)
*
* cdef inline const TokenC* B_(self, int i) nogil: # <<<<<<<<<<<<<<
* return self.c.B_(i)
*
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_WriteUnraisable("spacy.syntax.stateclass.StateClass.B_", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 1);
__pyx_r = 0;
__pyx_L0:;
__Pyx_TraceReturn(Py_None, 1);
return __pyx_r;
}
/* "stateclass.pxd":53
* return self.c.B_(i)
*
* cdef inline const TokenC* H_(self, int i) nogil: # <<<<<<<<<<<<<<
* return self.c.H_(i)
*
*/
static CYTHON_INLINE struct __pyx_t_5spacy_7structs_TokenC const *__pyx_f_5spacy_6syntax_10stateclass_10StateClass_H_(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *__pyx_v_self, int __pyx_v_i) {
struct __pyx_t_5spacy_7structs_TokenC const *__pyx_r;
__Pyx_TraceDeclarations
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_TraceCall("H_", __pyx_f[5], 53, 1, __PYX_ERR(5, 53, __pyx_L1_error));
/* "stateclass.pxd":54
*
* cdef inline const TokenC* H_(self, int i) nogil:
* return self.c.H_(i) # <<<<<<<<<<<<<<
*
* cdef inline const TokenC* E_(self, int i) nogil:
*/
__pyx_r = __pyx_v_self->c->H_(__pyx_v_i);
goto __pyx_L0;
/* "stateclass.pxd":53
* return self.c.B_(i)
*
* cdef inline const TokenC* H_(self, int i) nogil: # <<<<<<<<<<<<<<
* return self.c.H_(i)
*
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_WriteUnraisable("spacy.syntax.stateclass.StateClass.H_", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 1);
__pyx_r = 0;
__pyx_L0:;
__Pyx_TraceReturn(Py_None, 1);
return __pyx_r;
}
/* "stateclass.pxd":56
* return self.c.H_(i)
*
* cdef inline const TokenC* E_(self, int i) nogil: # <<<<<<<<<<<<<<
* return self.c.E_(i)
*
*/
static CYTHON_INLINE struct __pyx_t_5spacy_7structs_TokenC const *__pyx_f_5spacy_6syntax_10stateclass_10StateClass_E_(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *__pyx_v_self, int __pyx_v_i) {
struct __pyx_t_5spacy_7structs_TokenC const *__pyx_r;
__Pyx_TraceDeclarations
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_TraceCall("E_", __pyx_f[5], 56, 1, __PYX_ERR(5, 56, __pyx_L1_error));
/* "stateclass.pxd":57
*
* cdef inline const TokenC* E_(self, int i) nogil:
* return self.c.E_(i) # <<<<<<<<<<<<<<
*
* cdef inline const TokenC* L_(self, int i, int idx) nogil:
*/
__pyx_r = __pyx_v_self->c->E_(__pyx_v_i);
goto __pyx_L0;
/* "stateclass.pxd":56
* return self.c.H_(i)
*
* cdef inline const TokenC* E_(self, int i) nogil: # <<<<<<<<<<<<<<
* return self.c.E_(i)
*
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_WriteUnraisable("spacy.syntax.stateclass.StateClass.E_", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 1);
__pyx_r = 0;
__pyx_L0:;
__Pyx_TraceReturn(Py_None, 1);
return __pyx_r;
}
/* "stateclass.pxd":59
* return self.c.E_(i)
*
* cdef inline const TokenC* L_(self, int i, int idx) nogil: # <<<<<<<<<<<<<<
* return self.c.L_(i, idx)
*
*/
static CYTHON_INLINE struct __pyx_t_5spacy_7structs_TokenC const *__pyx_f_5spacy_6syntax_10stateclass_10StateClass_L_(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *__pyx_v_self, int __pyx_v_i, int __pyx_v_idx) {
struct __pyx_t_5spacy_7structs_TokenC const *__pyx_r;
__Pyx_TraceDeclarations
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_TraceCall("L_", __pyx_f[5], 59, 1, __PYX_ERR(5, 59, __pyx_L1_error));
/* "stateclass.pxd":60
*
* cdef inline const TokenC* L_(self, int i, int idx) nogil:
* return self.c.L_(i, idx) # <<<<<<<<<<<<<<
*
* cdef inline const TokenC* R_(self, int i, int idx) nogil:
*/
__pyx_r = __pyx_v_self->c->L_(__pyx_v_i, __pyx_v_idx);
goto __pyx_L0;
/* "stateclass.pxd":59
* return self.c.E_(i)
*
* cdef inline const TokenC* L_(self, int i, int idx) nogil: # <<<<<<<<<<<<<<
* return self.c.L_(i, idx)
*
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_WriteUnraisable("spacy.syntax.stateclass.StateClass.L_", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 1);
__pyx_r = 0;
__pyx_L0:;
__Pyx_TraceReturn(Py_None, 1);
return __pyx_r;
}
/* "stateclass.pxd":62
* return self.c.L_(i, idx)
*
* cdef inline const TokenC* R_(self, int i, int idx) nogil: # <<<<<<<<<<<<<<
* return self.c.R_(i, idx)
*
*/
static CYTHON_INLINE struct __pyx_t_5spacy_7structs_TokenC const *__pyx_f_5spacy_6syntax_10stateclass_10StateClass_R_(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *__pyx_v_self, int __pyx_v_i, int __pyx_v_idx) {
struct __pyx_t_5spacy_7structs_TokenC const *__pyx_r;
__Pyx_TraceDeclarations
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_TraceCall("R_", __pyx_f[5], 62, 1, __PYX_ERR(5, 62, __pyx_L1_error));
/* "stateclass.pxd":63
*
* cdef inline const TokenC* R_(self, int i, int idx) nogil:
* return self.c.R_(i, idx) # <<<<<<<<<<<<<<
*
* cdef inline const TokenC* safe_get(self, int i) nogil:
*/
__pyx_r = __pyx_v_self->c->R_(__pyx_v_i, __pyx_v_idx);
goto __pyx_L0;
/* "stateclass.pxd":62
* return self.c.L_(i, idx)
*
* cdef inline const TokenC* R_(self, int i, int idx) nogil: # <<<<<<<<<<<<<<
* return self.c.R_(i, idx)
*
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_WriteUnraisable("spacy.syntax.stateclass.StateClass.R_", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 1);
__pyx_r = 0;
__pyx_L0:;
__Pyx_TraceReturn(Py_None, 1);
return __pyx_r;
}
/* "stateclass.pxd":65
* return self.c.R_(i, idx)
*
* cdef inline const TokenC* safe_get(self, int i) nogil: # <<<<<<<<<<<<<<
* return self.c.safe_get(i)
*
*/
static CYTHON_INLINE struct __pyx_t_5spacy_7structs_TokenC const *__pyx_f_5spacy_6syntax_10stateclass_10StateClass_safe_get(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *__pyx_v_self, int __pyx_v_i) {
struct __pyx_t_5spacy_7structs_TokenC const *__pyx_r;
__Pyx_TraceDeclarations
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_TraceCall("safe_get", __pyx_f[5], 65, 1, __PYX_ERR(5, 65, __pyx_L1_error));
/* "stateclass.pxd":66
*
* cdef inline const TokenC* safe_get(self, int i) nogil:
* return self.c.safe_get(i) # <<<<<<<<<<<<<<
*
* cdef inline int H(self, int i) nogil:
*/
__pyx_r = __pyx_v_self->c->safe_get(__pyx_v_i);
goto __pyx_L0;
/* "stateclass.pxd":65
* return self.c.R_(i, idx)
*
* cdef inline const TokenC* safe_get(self, int i) nogil: # <<<<<<<<<<<<<<
* return self.c.safe_get(i)
*
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_WriteUnraisable("spacy.syntax.stateclass.StateClass.safe_get", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 1);
__pyx_r = 0;
__pyx_L0:;
__Pyx_TraceReturn(Py_None, 1);
return __pyx_r;
}
/* "stateclass.pxd":68
* return self.c.safe_get(i)
*
* cdef inline int H(self, int i) nogil: # <<<<<<<<<<<<<<
* return self.c.H(i)
*
*/
static CYTHON_INLINE int __pyx_f_5spacy_6syntax_10stateclass_10StateClass_H(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *__pyx_v_self, int __pyx_v_i) {
int __pyx_r;
__Pyx_TraceDeclarations
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_TraceCall("H", __pyx_f[5], 68, 1, __PYX_ERR(5, 68, __pyx_L1_error));
/* "stateclass.pxd":69
*
* cdef inline int H(self, int i) nogil:
* return self.c.H(i) # <<<<<<<<<<<<<<
*
* cdef inline int E(self, int i) nogil:
*/
__pyx_r = __pyx_v_self->c->H(__pyx_v_i);
goto __pyx_L0;
/* "stateclass.pxd":68
* return self.c.safe_get(i)
*
* cdef inline int H(self, int i) nogil: # <<<<<<<<<<<<<<
* return self.c.H(i)
*
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_WriteUnraisable("spacy.syntax.stateclass.StateClass.H", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 1);
__pyx_r = 0;
__pyx_L0:;
__Pyx_TraceReturn(Py_None, 1);
return __pyx_r;
}
/* "stateclass.pxd":71
* return self.c.H(i)
*
* cdef inline int E(self, int i) nogil: # <<<<<<<<<<<<<<
* return self.c.E(i)
*
*/
static CYTHON_INLINE int __pyx_f_5spacy_6syntax_10stateclass_10StateClass_E(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *__pyx_v_self, int __pyx_v_i) {
int __pyx_r;
__Pyx_TraceDeclarations
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_TraceCall("E", __pyx_f[5], 71, 1, __PYX_ERR(5, 71, __pyx_L1_error));
/* "stateclass.pxd":72
*
* cdef inline int E(self, int i) nogil:
* return self.c.E(i) # <<<<<<<<<<<<<<
*
* cdef inline int L(self, int i, int idx) nogil:
*/
__pyx_r = __pyx_v_self->c->E(__pyx_v_i);
goto __pyx_L0;
/* "stateclass.pxd":71
* return self.c.H(i)
*
* cdef inline int E(self, int i) nogil: # <<<<<<<<<<<<<<
* return self.c.E(i)
*
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_WriteUnraisable("spacy.syntax.stateclass.StateClass.E", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 1);
__pyx_r = 0;
__pyx_L0:;
__Pyx_TraceReturn(Py_None, 1);
return __pyx_r;
}
/* "stateclass.pxd":74
* return self.c.E(i)
*
* cdef inline int L(self, int i, int idx) nogil: # <<<<<<<<<<<<<<
* return self.c.L(i, idx)
*
*/
static CYTHON_INLINE int __pyx_f_5spacy_6syntax_10stateclass_10StateClass_L(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *__pyx_v_self, int __pyx_v_i, int __pyx_v_idx) {
int __pyx_r;
__Pyx_TraceDeclarations
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_TraceCall("L", __pyx_f[5], 74, 1, __PYX_ERR(5, 74, __pyx_L1_error));
/* "stateclass.pxd":75
*
* cdef inline int L(self, int i, int idx) nogil:
* return self.c.L(i, idx) # <<<<<<<<<<<<<<
*
* cdef inline int R(self, int i, int idx) nogil:
*/
__pyx_r = __pyx_v_self->c->L(__pyx_v_i, __pyx_v_idx);
goto __pyx_L0;
/* "stateclass.pxd":74
* return self.c.E(i)
*
* cdef inline int L(self, int i, int idx) nogil: # <<<<<<<<<<<<<<
* return self.c.L(i, idx)
*
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_WriteUnraisable("spacy.syntax.stateclass.StateClass.L", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 1);
__pyx_r = 0;
__pyx_L0:;
__Pyx_TraceReturn(Py_None, 1);
return __pyx_r;
}
/* "stateclass.pxd":77
* return self.c.L(i, idx)
*
* cdef inline int R(self, int i, int idx) nogil: # <<<<<<<<<<<<<<
* return self.c.R(i, idx)
*
*/
static CYTHON_INLINE int __pyx_f_5spacy_6syntax_10stateclass_10StateClass_R(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *__pyx_v_self, int __pyx_v_i, int __pyx_v_idx) {
int __pyx_r;
__Pyx_TraceDeclarations
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_TraceCall("R", __pyx_f[5], 77, 1, __PYX_ERR(5, 77, __pyx_L1_error));
/* "stateclass.pxd":78
*
* cdef inline int R(self, int i, int idx) nogil:
* return self.c.R(i, idx) # <<<<<<<<<<<<<<
*
* cdef inline bint empty(self) nogil:
*/
__pyx_r = __pyx_v_self->c->R(__pyx_v_i, __pyx_v_idx);
goto __pyx_L0;
/* "stateclass.pxd":77
* return self.c.L(i, idx)
*
* cdef inline int R(self, int i, int idx) nogil: # <<<<<<<<<<<<<<
* return self.c.R(i, idx)
*
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_WriteUnraisable("spacy.syntax.stateclass.StateClass.R", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 1);
__pyx_r = 0;
__pyx_L0:;
__Pyx_TraceReturn(Py_None, 1);
return __pyx_r;
}
/* "stateclass.pxd":80
* return self.c.R(i, idx)
*
* cdef inline bint empty(self) nogil: # <<<<<<<<<<<<<<
* return self.c.empty()
*
*/
static CYTHON_INLINE int __pyx_f_5spacy_6syntax_10stateclass_10StateClass_empty(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *__pyx_v_self) {
int __pyx_r;
__Pyx_TraceDeclarations
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_TraceCall("empty", __pyx_f[5], 80, 1, __PYX_ERR(5, 80, __pyx_L1_error));
/* "stateclass.pxd":81
*
* cdef inline bint empty(self) nogil:
* return self.c.empty() # <<<<<<<<<<<<<<
*
* cdef inline bint eol(self) nogil:
*/
__pyx_r = __pyx_v_self->c->empty();
goto __pyx_L0;
/* "stateclass.pxd":80
* return self.c.R(i, idx)
*
* cdef inline bint empty(self) nogil: # <<<<<<<<<<<<<<
* return self.c.empty()
*
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_WriteUnraisable("spacy.syntax.stateclass.StateClass.empty", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 1);
__pyx_r = 0;
__pyx_L0:;
__Pyx_TraceReturn(Py_None, 1);
return __pyx_r;
}
/* "stateclass.pxd":83
* return self.c.empty()
*
* cdef inline bint eol(self) nogil: # <<<<<<<<<<<<<<
* return self.c.eol()
*
*/
static CYTHON_INLINE int __pyx_f_5spacy_6syntax_10stateclass_10StateClass_eol(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *__pyx_v_self) {
int __pyx_r;
__Pyx_TraceDeclarations
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_TraceCall("eol", __pyx_f[5], 83, 1, __PYX_ERR(5, 83, __pyx_L1_error));
/* "stateclass.pxd":84
*
* cdef inline bint eol(self) nogil:
* return self.c.eol() # <<<<<<<<<<<<<<
*
* cdef inline bint at_break(self) nogil:
*/
__pyx_r = __pyx_v_self->c->eol();
goto __pyx_L0;
/* "stateclass.pxd":83
* return self.c.empty()
*
* cdef inline bint eol(self) nogil: # <<<<<<<<<<<<<<
* return self.c.eol()
*
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_WriteUnraisable("spacy.syntax.stateclass.StateClass.eol", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 1);
__pyx_r = 0;
__pyx_L0:;
__Pyx_TraceReturn(Py_None, 1);
return __pyx_r;
}
/* "stateclass.pxd":86
* return self.c.eol()
*
* cdef inline bint at_break(self) nogil: # <<<<<<<<<<<<<<
* return self.c.at_break()
*
*/
static CYTHON_INLINE int __pyx_f_5spacy_6syntax_10stateclass_10StateClass_at_break(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *__pyx_v_self) {
int __pyx_r;
__Pyx_TraceDeclarations
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_TraceCall("at_break", __pyx_f[5], 86, 1, __PYX_ERR(5, 86, __pyx_L1_error));
/* "stateclass.pxd":87
*
* cdef inline bint at_break(self) nogil:
* return self.c.at_break() # <<<<<<<<<<<<<<
*
* cdef inline bint has_head(self, int i) nogil:
*/
__pyx_r = __pyx_v_self->c->at_break();
goto __pyx_L0;
/* "stateclass.pxd":86
* return self.c.eol()
*
* cdef inline bint at_break(self) nogil: # <<<<<<<<<<<<<<
* return self.c.at_break()
*
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_WriteUnraisable("spacy.syntax.stateclass.StateClass.at_break", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 1);
__pyx_r = 0;
__pyx_L0:;
__Pyx_TraceReturn(Py_None, 1);
return __pyx_r;
}
/* "stateclass.pxd":89
* return self.c.at_break()
*
* cdef inline bint has_head(self, int i) nogil: # <<<<<<<<<<<<<<
* return self.c.has_head(i)
*
*/
static CYTHON_INLINE int __pyx_f_5spacy_6syntax_10stateclass_10StateClass_has_head(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *__pyx_v_self, int __pyx_v_i) {
int __pyx_r;
__Pyx_TraceDeclarations
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_TraceCall("has_head", __pyx_f[5], 89, 1, __PYX_ERR(5, 89, __pyx_L1_error));
/* "stateclass.pxd":90
*
* cdef inline bint has_head(self, int i) nogil:
* return self.c.has_head(i) # <<<<<<<<<<<<<<
*
* cdef inline int n_L(self, int i) nogil:
*/
__pyx_r = __pyx_v_self->c->has_head(__pyx_v_i);
goto __pyx_L0;
/* "stateclass.pxd":89
* return self.c.at_break()
*
* cdef inline bint has_head(self, int i) nogil: # <<<<<<<<<<<<<<
* return self.c.has_head(i)
*
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_WriteUnraisable("spacy.syntax.stateclass.StateClass.has_head", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 1);
__pyx_r = 0;
__pyx_L0:;
__Pyx_TraceReturn(Py_None, 1);
return __pyx_r;
}
/* "stateclass.pxd":92
* return self.c.has_head(i)
*
* cdef inline int n_L(self, int i) nogil: # <<<<<<<<<<<<<<
* return self.c.n_L(i)
*
*/
static CYTHON_INLINE int __pyx_f_5spacy_6syntax_10stateclass_10StateClass_n_L(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *__pyx_v_self, int __pyx_v_i) {
int __pyx_r;
__Pyx_TraceDeclarations
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_TraceCall("n_L", __pyx_f[5], 92, 1, __PYX_ERR(5, 92, __pyx_L1_error));
/* "stateclass.pxd":93
*
* cdef inline int n_L(self, int i) nogil:
* return self.c.n_L(i) # <<<<<<<<<<<<<<
*
* cdef inline int n_R(self, int i) nogil:
*/
__pyx_r = __pyx_v_self->c->n_L(__pyx_v_i);
goto __pyx_L0;
/* "stateclass.pxd":92
* return self.c.has_head(i)
*
* cdef inline int n_L(self, int i) nogil: # <<<<<<<<<<<<<<
* return self.c.n_L(i)
*
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_WriteUnraisable("spacy.syntax.stateclass.StateClass.n_L", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 1);
__pyx_r = 0;
__pyx_L0:;
__Pyx_TraceReturn(Py_None, 1);
return __pyx_r;
}
/* "stateclass.pxd":95
* return self.c.n_L(i)
*
* cdef inline int n_R(self, int i) nogil: # <<<<<<<<<<<<<<
* return self.c.n_R(i)
*
*/
static CYTHON_INLINE int __pyx_f_5spacy_6syntax_10stateclass_10StateClass_n_R(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *__pyx_v_self, int __pyx_v_i) {
int __pyx_r;
__Pyx_TraceDeclarations
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_TraceCall("n_R", __pyx_f[5], 95, 1, __PYX_ERR(5, 95, __pyx_L1_error));
/* "stateclass.pxd":96
*
* cdef inline int n_R(self, int i) nogil:
* return self.c.n_R(i) # <<<<<<<<<<<<<<
*
* cdef inline bint stack_is_connected(self) nogil:
*/
__pyx_r = __pyx_v_self->c->n_R(__pyx_v_i);
goto __pyx_L0;
/* "stateclass.pxd":95
* return self.c.n_L(i)
*
* cdef inline int n_R(self, int i) nogil: # <<<<<<<<<<<<<<
* return self.c.n_R(i)
*
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_WriteUnraisable("spacy.syntax.stateclass.StateClass.n_R", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 1);
__pyx_r = 0;
__pyx_L0:;
__Pyx_TraceReturn(Py_None, 1);
return __pyx_r;
}
/* "stateclass.pxd":98
* return self.c.n_R(i)
*
* cdef inline bint stack_is_connected(self) nogil: # <<<<<<<<<<<<<<
* return False
*
*/
static CYTHON_INLINE int __pyx_f_5spacy_6syntax_10stateclass_10StateClass_stack_is_connected(CYTHON_UNUSED struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *__pyx_v_self) {
int __pyx_r;
__Pyx_TraceDeclarations
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_TraceCall("stack_is_connected", __pyx_f[5], 98, 1, __PYX_ERR(5, 98, __pyx_L1_error));
/* "stateclass.pxd":99
*
* cdef inline bint stack_is_connected(self) nogil:
* return False # <<<<<<<<<<<<<<
*
* cdef inline bint entity_is_open(self) nogil:
*/
__pyx_r = 0;
goto __pyx_L0;
/* "stateclass.pxd":98
* return self.c.n_R(i)
*
* cdef inline bint stack_is_connected(self) nogil: # <<<<<<<<<<<<<<
* return False
*
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_WriteUnraisable("spacy.syntax.stateclass.StateClass.stack_is_connected", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 1);
__pyx_r = 0;
__pyx_L0:;
__Pyx_TraceReturn(Py_None, 1);
return __pyx_r;
}
/* "stateclass.pxd":101
* return False
*
* cdef inline bint entity_is_open(self) nogil: # <<<<<<<<<<<<<<
* return self.c.entity_is_open()
*
*/
static CYTHON_INLINE int __pyx_f_5spacy_6syntax_10stateclass_10StateClass_entity_is_open(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *__pyx_v_self) {
int __pyx_r;
__Pyx_TraceDeclarations
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_TraceCall("entity_is_open", __pyx_f[5], 101, 1, __PYX_ERR(5, 101, __pyx_L1_error));
/* "stateclass.pxd":102
*
* cdef inline bint entity_is_open(self) nogil:
* return self.c.entity_is_open() # <<<<<<<<<<<<<<
*
* cdef inline int stack_depth(self) nogil:
*/
__pyx_r = __pyx_v_self->c->entity_is_open();
goto __pyx_L0;
/* "stateclass.pxd":101
* return False
*
* cdef inline bint entity_is_open(self) nogil: # <<<<<<<<<<<<<<
* return self.c.entity_is_open()
*
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_WriteUnraisable("spacy.syntax.stateclass.StateClass.entity_is_open", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 1);
__pyx_r = 0;
__pyx_L0:;
__Pyx_TraceReturn(Py_None, 1);
return __pyx_r;
}
/* "stateclass.pxd":104
* return self.c.entity_is_open()
*
* cdef inline int stack_depth(self) nogil: # <<<<<<<<<<<<<<
* return self.c.stack_depth()
*
*/
static CYTHON_INLINE int __pyx_f_5spacy_6syntax_10stateclass_10StateClass_stack_depth(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *__pyx_v_self) {
int __pyx_r;
__Pyx_TraceDeclarations
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_TraceCall("stack_depth", __pyx_f[5], 104, 1, __PYX_ERR(5, 104, __pyx_L1_error));
/* "stateclass.pxd":105
*
* cdef inline int stack_depth(self) nogil:
* return self.c.stack_depth() # <<<<<<<<<<<<<<
*
* cdef inline int buffer_length(self) nogil:
*/
__pyx_r = __pyx_v_self->c->stack_depth();
goto __pyx_L0;
/* "stateclass.pxd":104
* return self.c.entity_is_open()
*
* cdef inline int stack_depth(self) nogil: # <<<<<<<<<<<<<<
* return self.c.stack_depth()
*
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_WriteUnraisable("spacy.syntax.stateclass.StateClass.stack_depth", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 1);
__pyx_r = 0;
__pyx_L0:;
__Pyx_TraceReturn(Py_None, 1);
return __pyx_r;
}
/* "stateclass.pxd":107
* return self.c.stack_depth()
*
* cdef inline int buffer_length(self) nogil: # <<<<<<<<<<<<<<
* return self.c.buffer_length()
*
*/
static CYTHON_INLINE int __pyx_f_5spacy_6syntax_10stateclass_10StateClass_buffer_length(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *__pyx_v_self) {
int __pyx_r;
__Pyx_TraceDeclarations
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_TraceCall("buffer_length", __pyx_f[5], 107, 1, __PYX_ERR(5, 107, __pyx_L1_error));
/* "stateclass.pxd":108
*
* cdef inline int buffer_length(self) nogil:
* return self.c.buffer_length() # <<<<<<<<<<<<<<
*
* cdef inline void push(self) nogil:
*/
__pyx_r = __pyx_v_self->c->buffer_length();
goto __pyx_L0;
/* "stateclass.pxd":107
* return self.c.stack_depth()
*
* cdef inline int buffer_length(self) nogil: # <<<<<<<<<<<<<<
* return self.c.buffer_length()
*
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_WriteUnraisable("spacy.syntax.stateclass.StateClass.buffer_length", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 1);
__pyx_r = 0;
__pyx_L0:;
__Pyx_TraceReturn(Py_None, 1);
return __pyx_r;
}
/* "stateclass.pxd":110
* return self.c.buffer_length()
*
* cdef inline void push(self) nogil: # <<<<<<<<<<<<<<
* self.c.push()
*
*/
static CYTHON_INLINE void __pyx_f_5spacy_6syntax_10stateclass_10StateClass_push(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *__pyx_v_self) {
__Pyx_TraceDeclarations
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_TraceCall("push", __pyx_f[5], 110, 1, __PYX_ERR(5, 110, __pyx_L1_error));
/* "stateclass.pxd":111
*
* cdef inline void push(self) nogil:
* self.c.push() # <<<<<<<<<<<<<<
*
* cdef inline void pop(self) nogil:
*/
__pyx_v_self->c->push();
/* "stateclass.pxd":110
* return self.c.buffer_length()
*
* cdef inline void push(self) nogil: # <<<<<<<<<<<<<<
* self.c.push()
*
*/
/* function exit code */
goto __pyx_L0;
__pyx_L1_error:;
__Pyx_WriteUnraisable("spacy.syntax.stateclass.StateClass.push", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 1);
__pyx_L0:;
__Pyx_TraceReturn(Py_None, 1);
}
/* "stateclass.pxd":113
* self.c.push()
*
* cdef inline void pop(self) nogil: # <<<<<<<<<<<<<<
* self.c.pop()
*
*/
static CYTHON_INLINE void __pyx_f_5spacy_6syntax_10stateclass_10StateClass_pop(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *__pyx_v_self) {
__Pyx_TraceDeclarations
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_TraceCall("pop", __pyx_f[5], 113, 1, __PYX_ERR(5, 113, __pyx_L1_error));
/* "stateclass.pxd":114
*
* cdef inline void pop(self) nogil:
* self.c.pop() # <<<<<<<<<<<<<<
*
* cdef inline void unshift(self) nogil:
*/
__pyx_v_self->c->pop();
/* "stateclass.pxd":113
* self.c.push()
*
* cdef inline void pop(self) nogil: # <<<<<<<<<<<<<<
* self.c.pop()
*
*/
/* function exit code */
goto __pyx_L0;
__pyx_L1_error:;
__Pyx_WriteUnraisable("spacy.syntax.stateclass.StateClass.pop", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 1);
__pyx_L0:;
__Pyx_TraceReturn(Py_None, 1);
}
/* "stateclass.pxd":116
* self.c.pop()
*
* cdef inline void unshift(self) nogil: # <<<<<<<<<<<<<<
* self.c.unshift()
*
*/
static CYTHON_INLINE void __pyx_f_5spacy_6syntax_10stateclass_10StateClass_unshift(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *__pyx_v_self) {
__Pyx_TraceDeclarations
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_TraceCall("unshift", __pyx_f[5], 116, 1, __PYX_ERR(5, 116, __pyx_L1_error));
/* "stateclass.pxd":117
*
* cdef inline void unshift(self) nogil:
* self.c.unshift() # <<<<<<<<<<<<<<
*
* cdef inline void add_arc(self, int head, int child, attr_t label) nogil:
*/
__pyx_v_self->c->unshift();
/* "stateclass.pxd":116
* self.c.pop()
*
* cdef inline void unshift(self) nogil: # <<<<<<<<<<<<<<
* self.c.unshift()
*
*/
/* function exit code */
goto __pyx_L0;
__pyx_L1_error:;
__Pyx_WriteUnraisable("spacy.syntax.stateclass.StateClass.unshift", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 1);
__pyx_L0:;
__Pyx_TraceReturn(Py_None, 1);
}
/* "stateclass.pxd":119
* self.c.unshift()
*
* cdef inline void add_arc(self, int head, int child, attr_t label) nogil: # <<<<<<<<<<<<<<
* self.c.add_arc(head, child, label)
*
*/
static CYTHON_INLINE void __pyx_f_5spacy_6syntax_10stateclass_10StateClass_add_arc(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *__pyx_v_self, int __pyx_v_head, int __pyx_v_child, __pyx_t_5spacy_8typedefs_attr_t __pyx_v_label) {
__Pyx_TraceDeclarations
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_TraceCall("add_arc", __pyx_f[5], 119, 1, __PYX_ERR(5, 119, __pyx_L1_error));
/* "stateclass.pxd":120
*
* cdef inline void add_arc(self, int head, int child, attr_t label) nogil:
* self.c.add_arc(head, child, label) # <<<<<<<<<<<<<<
*
* cdef inline void del_arc(self, int head, int child) nogil:
*/
__pyx_v_self->c->add_arc(__pyx_v_head, __pyx_v_child, __pyx_v_label);
/* "stateclass.pxd":119
* self.c.unshift()
*
* cdef inline void add_arc(self, int head, int child, attr_t label) nogil: # <<<<<<<<<<<<<<
* self.c.add_arc(head, child, label)
*
*/
/* function exit code */
goto __pyx_L0;
__pyx_L1_error:;
__Pyx_WriteUnraisable("spacy.syntax.stateclass.StateClass.add_arc", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 1);
__pyx_L0:;
__Pyx_TraceReturn(Py_None, 1);
}
/* "stateclass.pxd":122
* self.c.add_arc(head, child, label)
*
* cdef inline void del_arc(self, int head, int child) nogil: # <<<<<<<<<<<<<<
* self.c.del_arc(head, child)
*
*/
static CYTHON_INLINE void __pyx_f_5spacy_6syntax_10stateclass_10StateClass_del_arc(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *__pyx_v_self, int __pyx_v_head, int __pyx_v_child) {
__Pyx_TraceDeclarations
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_TraceCall("del_arc", __pyx_f[5], 122, 1, __PYX_ERR(5, 122, __pyx_L1_error));
/* "stateclass.pxd":123
*
* cdef inline void del_arc(self, int head, int child) nogil:
* self.c.del_arc(head, child) # <<<<<<<<<<<<<<
*
* cdef inline void open_ent(self, attr_t label) nogil:
*/
__pyx_v_self->c->del_arc(__pyx_v_head, __pyx_v_child);
/* "stateclass.pxd":122
* self.c.add_arc(head, child, label)
*
* cdef inline void del_arc(self, int head, int child) nogil: # <<<<<<<<<<<<<<
* self.c.del_arc(head, child)
*
*/
/* function exit code */
goto __pyx_L0;
__pyx_L1_error:;
__Pyx_WriteUnraisable("spacy.syntax.stateclass.StateClass.del_arc", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 1);
__pyx_L0:;
__Pyx_TraceReturn(Py_None, 1);
}
/* "stateclass.pxd":125
* self.c.del_arc(head, child)
*
* cdef inline void open_ent(self, attr_t label) nogil: # <<<<<<<<<<<<<<
* self.c.open_ent(label)
*
*/
static CYTHON_INLINE void __pyx_f_5spacy_6syntax_10stateclass_10StateClass_open_ent(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *__pyx_v_self, __pyx_t_5spacy_8typedefs_attr_t __pyx_v_label) {
__Pyx_TraceDeclarations
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_TraceCall("open_ent", __pyx_f[5], 125, 1, __PYX_ERR(5, 125, __pyx_L1_error));
/* "stateclass.pxd":126
*
* cdef inline void open_ent(self, attr_t label) nogil:
* self.c.open_ent(label) # <<<<<<<<<<<<<<
*
* cdef inline void close_ent(self) nogil:
*/
__pyx_v_self->c->open_ent(__pyx_v_label);
/* "stateclass.pxd":125
* self.c.del_arc(head, child)
*
* cdef inline void open_ent(self, attr_t label) nogil: # <<<<<<<<<<<<<<
* self.c.open_ent(label)
*
*/
/* function exit code */
goto __pyx_L0;
__pyx_L1_error:;
__Pyx_WriteUnraisable("spacy.syntax.stateclass.StateClass.open_ent", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 1);
__pyx_L0:;
__Pyx_TraceReturn(Py_None, 1);
}
/* "stateclass.pxd":128
* self.c.open_ent(label)
*
* cdef inline void close_ent(self) nogil: # <<<<<<<<<<<<<<
* self.c.close_ent()
*
*/
static CYTHON_INLINE void __pyx_f_5spacy_6syntax_10stateclass_10StateClass_close_ent(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *__pyx_v_self) {
__Pyx_TraceDeclarations
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_TraceCall("close_ent", __pyx_f[5], 128, 1, __PYX_ERR(5, 128, __pyx_L1_error));
/* "stateclass.pxd":129
*
* cdef inline void close_ent(self) nogil:
* self.c.close_ent() # <<<<<<<<<<<<<<
*
* cdef inline void set_ent_tag(self, int i, int ent_iob, attr_t ent_type) nogil:
*/
__pyx_v_self->c->close_ent();
/* "stateclass.pxd":128
* self.c.open_ent(label)
*
* cdef inline void close_ent(self) nogil: # <<<<<<<<<<<<<<
* self.c.close_ent()
*
*/
/* function exit code */
goto __pyx_L0;
__pyx_L1_error:;
__Pyx_WriteUnraisable("spacy.syntax.stateclass.StateClass.close_ent", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 1);
__pyx_L0:;
__Pyx_TraceReturn(Py_None, 1);
}
/* "stateclass.pxd":131
* self.c.close_ent()
*
* cdef inline void set_ent_tag(self, int i, int ent_iob, attr_t ent_type) nogil: # <<<<<<<<<<<<<<
* self.c.set_ent_tag(i, ent_iob, ent_type)
*
*/
static CYTHON_INLINE void __pyx_f_5spacy_6syntax_10stateclass_10StateClass_set_ent_tag(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *__pyx_v_self, int __pyx_v_i, int __pyx_v_ent_iob, __pyx_t_5spacy_8typedefs_attr_t __pyx_v_ent_type) {
__Pyx_TraceDeclarations
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_TraceCall("set_ent_tag", __pyx_f[5], 131, 1, __PYX_ERR(5, 131, __pyx_L1_error));
/* "stateclass.pxd":132
*
* cdef inline void set_ent_tag(self, int i, int ent_iob, attr_t ent_type) nogil:
* self.c.set_ent_tag(i, ent_iob, ent_type) # <<<<<<<<<<<<<<
*
* cdef inline void set_break(self, int i) nogil:
*/
__pyx_v_self->c->set_ent_tag(__pyx_v_i, __pyx_v_ent_iob, __pyx_v_ent_type);
/* "stateclass.pxd":131
* self.c.close_ent()
*
* cdef inline void set_ent_tag(self, int i, int ent_iob, attr_t ent_type) nogil: # <<<<<<<<<<<<<<
* self.c.set_ent_tag(i, ent_iob, ent_type)
*
*/
/* function exit code */
goto __pyx_L0;
__pyx_L1_error:;
__Pyx_WriteUnraisable("spacy.syntax.stateclass.StateClass.set_ent_tag", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 1);
__pyx_L0:;
__Pyx_TraceReturn(Py_None, 1);
}
/* "stateclass.pxd":134
* self.c.set_ent_tag(i, ent_iob, ent_type)
*
* cdef inline void set_break(self, int i) nogil: # <<<<<<<<<<<<<<
* self.c.set_break(i)
*
*/
static CYTHON_INLINE void __pyx_f_5spacy_6syntax_10stateclass_10StateClass_set_break(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *__pyx_v_self, int __pyx_v_i) {
__Pyx_TraceDeclarations
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_TraceCall("set_break", __pyx_f[5], 134, 1, __PYX_ERR(5, 134, __pyx_L1_error));
/* "stateclass.pxd":135
*
* cdef inline void set_break(self, int i) nogil:
* self.c.set_break(i) # <<<<<<<<<<<<<<
*
* cdef inline void clone(self, StateClass src) nogil:
*/
__pyx_v_self->c->set_break(__pyx_v_i);
/* "stateclass.pxd":134
* self.c.set_ent_tag(i, ent_iob, ent_type)
*
* cdef inline void set_break(self, int i) nogil: # <<<<<<<<<<<<<<
* self.c.set_break(i)
*
*/
/* function exit code */
goto __pyx_L0;
__pyx_L1_error:;
__Pyx_WriteUnraisable("spacy.syntax.stateclass.StateClass.set_break", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 1);
__pyx_L0:;
__Pyx_TraceReturn(Py_None, 1);
}
/* "stateclass.pxd":137
* self.c.set_break(i)
*
* cdef inline void clone(self, StateClass src) nogil: # <<<<<<<<<<<<<<
* self.c.clone(src.c)
*
*/
static CYTHON_INLINE void __pyx_f_5spacy_6syntax_10stateclass_10StateClass_clone(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *__pyx_v_self, struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *__pyx_v_src) {
__Pyx_TraceDeclarations
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_TraceCall("clone", __pyx_f[5], 137, 1, __PYX_ERR(5, 137, __pyx_L1_error));
/* "stateclass.pxd":138
*
* cdef inline void clone(self, StateClass src) nogil:
* self.c.clone(src.c) # <<<<<<<<<<<<<<
*
* cdef inline void fast_forward(self) nogil:
*/
__pyx_v_self->c->clone(__pyx_v_src->c);
/* "stateclass.pxd":137
* self.c.set_break(i)
*
* cdef inline void clone(self, StateClass src) nogil: # <<<<<<<<<<<<<<
* self.c.clone(src.c)
*
*/
/* function exit code */
goto __pyx_L0;
__pyx_L1_error:;
__Pyx_WriteUnraisable("spacy.syntax.stateclass.StateClass.clone", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 1);
__pyx_L0:;
__Pyx_TraceReturn(Py_None, 1);
}
/* "stateclass.pxd":140
* self.c.clone(src.c)
*
* cdef inline void fast_forward(self) nogil: # <<<<<<<<<<<<<<
* self.c.fast_forward()
*/
static CYTHON_INLINE void __pyx_f_5spacy_6syntax_10stateclass_10StateClass_fast_forward(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *__pyx_v_self) {
__Pyx_TraceDeclarations
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_TraceCall("fast_forward", __pyx_f[5], 140, 1, __PYX_ERR(5, 140, __pyx_L1_error));
/* "stateclass.pxd":141
*
* cdef inline void fast_forward(self) nogil:
* self.c.fast_forward() # <<<<<<<<<<<<<<
*/
__pyx_v_self->c->fast_forward();
/* "stateclass.pxd":140
* self.c.clone(src.c)
*
* cdef inline void fast_forward(self) nogil: # <<<<<<<<<<<<<<
* self.c.fast_forward()
*/
/* function exit code */
goto __pyx_L0;
__pyx_L1_error:;
__Pyx_WriteUnraisable("spacy.syntax.stateclass.StateClass.fast_forward", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 1);
__pyx_L0:;
__Pyx_TraceReturn(Py_None, 1);
}
/* "thinc/extra/search.pxd":56
* cdef int _fill(self, Queue* q, weight_t** scores, int** is_valid) except -1
*
* cdef inline void* at(self, int i) nogil: # <<<<<<<<<<<<<<
* return self._states[i].content
*
*/
static CYTHON_INLINE void *__pyx_f_5thinc_5extra_6search_4Beam_at(struct __pyx_obj_5thinc_5extra_6search_Beam *__pyx_v_self, int __pyx_v_i) {
void *__pyx_r;
__Pyx_TraceDeclarations
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_TraceCall("at", __pyx_f[6], 56, 1, __PYX_ERR(6, 56, __pyx_L1_error));
/* "thinc/extra/search.pxd":57
*
* cdef inline void* at(self, int i) nogil:
* return self._states[i].content # <<<<<<<<<<<<<<
*
* cdef int initialize(self, init_func_t init_func, del_func_t del_func, int n, void* extra_args) except -1
*/
__pyx_r = (__pyx_v_self->_states[__pyx_v_i]).content;
goto __pyx_L0;
/* "thinc/extra/search.pxd":56
* cdef int _fill(self, Queue* q, weight_t** scores, int** is_valid) except -1
*
* cdef inline void* at(self, int i) nogil: # <<<<<<<<<<<<<<
* return self._states[i].content
*
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_WriteUnraisable("thinc.extra.search.Beam.at", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 1);
__pyx_r = 0;
__pyx_L0:;
__Pyx_TraceReturn(Py_None, 1);
return __pyx_r;
}
/* "thinc/extra/search.pxd":65
*
*
* cdef inline void set_cell(self, int i, int j, weight_t score, int is_valid, weight_t cost) nogil: # <<<<<<<<<<<<<<
* self.scores[i][j] = score
* self.is_valid[i][j] = is_valid
*/
static CYTHON_INLINE void __pyx_f_5thinc_5extra_6search_4Beam_set_cell(struct __pyx_obj_5thinc_5extra_6search_Beam *__pyx_v_self, int __pyx_v_i, int __pyx_v_j, __pyx_t_5thinc_8typedefs_weight_t __pyx_v_score, int __pyx_v_is_valid, __pyx_t_5thinc_8typedefs_weight_t __pyx_v_cost) {
__Pyx_TraceDeclarations
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_TraceCall("set_cell", __pyx_f[6], 65, 1, __PYX_ERR(6, 65, __pyx_L1_error));
/* "thinc/extra/search.pxd":66
*
* cdef inline void set_cell(self, int i, int j, weight_t score, int is_valid, weight_t cost) nogil:
* self.scores[i][j] = score # <<<<<<<<<<<<<<
* self.is_valid[i][j] = is_valid
* self.costs[i][j] = cost
*/
((__pyx_v_self->scores[__pyx_v_i])[__pyx_v_j]) = __pyx_v_score;
/* "thinc/extra/search.pxd":67
* cdef inline void set_cell(self, int i, int j, weight_t score, int is_valid, weight_t cost) nogil:
* self.scores[i][j] = score
* self.is_valid[i][j] = is_valid # <<<<<<<<<<<<<<
* self.costs[i][j] = cost
*
*/
((__pyx_v_self->is_valid[__pyx_v_i])[__pyx_v_j]) = __pyx_v_is_valid;
/* "thinc/extra/search.pxd":68
* self.scores[i][j] = score
* self.is_valid[i][j] = is_valid
* self.costs[i][j] = cost # <<<<<<<<<<<<<<
*
* cdef int set_row(self, int i, const weight_t* scores, const int* is_valid,
*/
((__pyx_v_self->costs[__pyx_v_i])[__pyx_v_j]) = __pyx_v_cost;
/* "thinc/extra/search.pxd":65
*
*
* cdef inline void set_cell(self, int i, int j, weight_t score, int is_valid, weight_t cost) nogil: # <<<<<<<<<<<<<<
* self.scores[i][j] = score
* self.is_valid[i][j] = is_valid
*/
/* function exit code */
goto __pyx_L0;
__pyx_L1_error:;
__Pyx_WriteUnraisable("thinc.extra.search.Beam.set_cell", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 1);
__pyx_L0:;
__Pyx_TraceReturn(Py_None, 1);
}
/* "View.MemoryView":122
* cdef bint dtype_is_object
*
* def __cinit__(array self, tuple shape, Py_ssize_t itemsize, format not None, # <<<<<<<<<<<<<<
* mode="c", bint allocate_buffer=True):
*
*/
/* Python wrapper */
static int __pyx_array___cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static int __pyx_array___cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
PyObject *__pyx_v_shape = 0;
Py_ssize_t __pyx_v_itemsize;
PyObject *__pyx_v_format = 0;
PyObject *__pyx_v_mode = 0;
int __pyx_v_allocate_buffer;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
int __pyx_r;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0);
{
static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_shape,&__pyx_n_s_itemsize,&__pyx_n_s_format,&__pyx_n_s_mode,&__pyx_n_s_allocate_buffer,0};
PyObject* values[5] = {0,0,0,0,0};
values[3] = ((PyObject *)__pyx_n_s_c);
if (unlikely(__pyx_kwds)) {
Py_ssize_t kw_args;
const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
switch (pos_args) {
case 5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
CYTHON_FALLTHROUGH;
case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
CYTHON_FALLTHROUGH;
case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
CYTHON_FALLTHROUGH;
case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
CYTHON_FALLTHROUGH;
case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
CYTHON_FALLTHROUGH;
case 0: break;
default: goto __pyx_L5_argtuple_error;
}
kw_args = PyDict_Size(__pyx_kwds);
switch (pos_args) {
case 0:
if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_shape)) != 0)) kw_args--;
else goto __pyx_L5_argtuple_error;
CYTHON_FALLTHROUGH;
case 1:
if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_itemsize)) != 0)) kw_args--;
else {
__Pyx_RaiseArgtupleInvalid("__cinit__", 0, 3, 5, 1); __PYX_ERR(1, 122, __pyx_L3_error)
}
CYTHON_FALLTHROUGH;
case 2:
if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_format)) != 0)) kw_args--;
else {
__Pyx_RaiseArgtupleInvalid("__cinit__", 0, 3, 5, 2); __PYX_ERR(1, 122, __pyx_L3_error)
}
CYTHON_FALLTHROUGH;
case 3:
if (kw_args > 0) {
PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_mode);
if (value) { values[3] = value; kw_args--; }
}
CYTHON_FALLTHROUGH;
case 4:
if (kw_args > 0) {
PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_allocate_buffer);
if (value) { values[4] = value; kw_args--; }
}
}
if (unlikely(kw_args > 0)) {
if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__cinit__") < 0)) __PYX_ERR(1, 122, __pyx_L3_error)
}
} else {
switch (PyTuple_GET_SIZE(__pyx_args)) {
case 5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
CYTHON_FALLTHROUGH;
case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
CYTHON_FALLTHROUGH;
case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
break;
default: goto __pyx_L5_argtuple_error;
}
}
__pyx_v_shape = ((PyObject*)values[0]);
__pyx_v_itemsize = __Pyx_PyIndex_AsSsize_t(values[1]); if (unlikely((__pyx_v_itemsize == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(1, 122, __pyx_L3_error)
__pyx_v_format = values[2];
__pyx_v_mode = values[3];
if (values[4]) {
__pyx_v_allocate_buffer = __Pyx_PyObject_IsTrue(values[4]); if (unlikely((__pyx_v_allocate_buffer == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 123, __pyx_L3_error)
} else {
/* "View.MemoryView":123
*
* def __cinit__(array self, tuple shape, Py_ssize_t itemsize, format not None,
* mode="c", bint allocate_buffer=True): # <<<<<<<<<<<<<<
*
* cdef int idx
*/
__pyx_v_allocate_buffer = ((int)1);
}
}
goto __pyx_L4_argument_unpacking_done;
__pyx_L5_argtuple_error:;
__Pyx_RaiseArgtupleInvalid("__cinit__", 0, 3, 5, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 122, __pyx_L3_error)
__pyx_L3_error:;
__Pyx_AddTraceback("View.MemoryView.array.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
__Pyx_RefNannyFinishContext();
return -1;
__pyx_L4_argument_unpacking_done:;
if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_shape), (&PyTuple_Type), 1, "shape", 1))) __PYX_ERR(1, 122, __pyx_L1_error)
if (unlikely(((PyObject *)__pyx_v_format) == Py_None)) {
PyErr_Format(PyExc_TypeError, "Argument '%.200s' must not be None", "format"); __PYX_ERR(1, 122, __pyx_L1_error)
}
__pyx_r = __pyx_array___pyx_pf_15View_dot_MemoryView_5array___cinit__(((struct __pyx_array_obj *)__pyx_v_self), __pyx_v_shape, __pyx_v_itemsize, __pyx_v_format, __pyx_v_mode, __pyx_v_allocate_buffer);
/* "View.MemoryView":122
* cdef bint dtype_is_object
*
* def __cinit__(array self, tuple shape, Py_ssize_t itemsize, format not None, # <<<<<<<<<<<<<<
* mode="c", bint allocate_buffer=True):
*
*/
/* function exit code */
goto __pyx_L0;
__pyx_L1_error:;
__pyx_r = -1;
__pyx_L0:;
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
static int __pyx_array___pyx_pf_15View_dot_MemoryView_5array___cinit__(struct __pyx_array_obj *__pyx_v_self, PyObject *__pyx_v_shape, Py_ssize_t __pyx_v_itemsize, PyObject *__pyx_v_format, PyObject *__pyx_v_mode, int __pyx_v_allocate_buffer) {
int __pyx_v_idx;
Py_ssize_t __pyx_v_i;
Py_ssize_t __pyx_v_dim;
PyObject **__pyx_v_p;
char __pyx_v_order;
int __pyx_r;
__Pyx_TraceDeclarations
__Pyx_RefNannyDeclarations
Py_ssize_t __pyx_t_1;
int __pyx_t_2;
PyObject *__pyx_t_3 = NULL;
int __pyx_t_4;
PyObject *__pyx_t_5 = NULL;
PyObject *__pyx_t_6 = NULL;
char *__pyx_t_7;
int __pyx_t_8;
Py_ssize_t __pyx_t_9;
PyObject *__pyx_t_10 = NULL;
Py_ssize_t __pyx_t_11;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("__cinit__", 0);
__Pyx_TraceCall("__cinit__", __pyx_f[1], 122, 0, __PYX_ERR(1, 122, __pyx_L1_error));
__Pyx_INCREF(__pyx_v_format);
/* "View.MemoryView":129
* cdef PyObject **p
*
* self.ndim = <int> len(shape) # <<<<<<<<<<<<<<
* self.itemsize = itemsize
*
*/
if (unlikely(__pyx_v_shape == Py_None)) {
PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()");
__PYX_ERR(1, 129, __pyx_L1_error)
}
__pyx_t_1 = PyTuple_GET_SIZE(__pyx_v_shape); if (unlikely(__pyx_t_1 == ((Py_ssize_t)-1))) __PYX_ERR(1, 129, __pyx_L1_error)
__pyx_v_self->ndim = ((int)__pyx_t_1);
/* "View.MemoryView":130
*
* self.ndim = <int> len(shape)
* self.itemsize = itemsize # <<<<<<<<<<<<<<
*
* if not self.ndim:
*/
__pyx_v_self->itemsize = __pyx_v_itemsize;
/* "View.MemoryView":132
* self.itemsize = itemsize
*
* if not self.ndim: # <<<<<<<<<<<<<<
* raise ValueError("Empty shape tuple for cython.array")
*
*/
__pyx_t_2 = ((!(__pyx_v_self->ndim != 0)) != 0);
if (unlikely(__pyx_t_2)) {
/* "View.MemoryView":133
*
* if not self.ndim:
* raise ValueError("Empty shape tuple for cython.array") # <<<<<<<<<<<<<<
*
* if itemsize <= 0:
*/
__pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__19, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 133, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_Raise(__pyx_t_3, 0, 0, 0);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__PYX_ERR(1, 133, __pyx_L1_error)
/* "View.MemoryView":132
* self.itemsize = itemsize
*
* if not self.ndim: # <<<<<<<<<<<<<<
* raise ValueError("Empty shape tuple for cython.array")
*
*/
}
/* "View.MemoryView":135
* raise ValueError("Empty shape tuple for cython.array")
*
* if itemsize <= 0: # <<<<<<<<<<<<<<
* raise ValueError("itemsize <= 0 for cython.array")
*
*/
__pyx_t_2 = ((__pyx_v_itemsize <= 0) != 0);
if (unlikely(__pyx_t_2)) {
/* "View.MemoryView":136
*
* if itemsize <= 0:
* raise ValueError("itemsize <= 0 for cython.array") # <<<<<<<<<<<<<<
*
* if not isinstance(format, bytes):
*/
__pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__20, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 136, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_Raise(__pyx_t_3, 0, 0, 0);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__PYX_ERR(1, 136, __pyx_L1_error)
/* "View.MemoryView":135
* raise ValueError("Empty shape tuple for cython.array")
*
* if itemsize <= 0: # <<<<<<<<<<<<<<
* raise ValueError("itemsize <= 0 for cython.array")
*
*/
}
/* "View.MemoryView":138
* raise ValueError("itemsize <= 0 for cython.array")
*
* if not isinstance(format, bytes): # <<<<<<<<<<<<<<
* format = format.encode('ASCII')
* self._format = format # keep a reference to the byte string
*/
__pyx_t_2 = PyBytes_Check(__pyx_v_format);
__pyx_t_4 = ((!(__pyx_t_2 != 0)) != 0);
if (__pyx_t_4) {
/* "View.MemoryView":139
*
* if not isinstance(format, bytes):
* format = format.encode('ASCII') # <<<<<<<<<<<<<<
* self._format = format # keep a reference to the byte string
* self.format = self._format
*/
__pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_format, __pyx_n_s_encode); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 139, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__pyx_t_6 = NULL;
if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_5))) {
__pyx_t_6 = PyMethod_GET_SELF(__pyx_t_5);
if (likely(__pyx_t_6)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5);
__Pyx_INCREF(__pyx_t_6);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_5, function);
}
}
__pyx_t_3 = (__pyx_t_6) ? __Pyx_PyObject_Call2Args(__pyx_t_5, __pyx_t_6, __pyx_n_s_ASCII) : __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_n_s_ASCII);
__Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 139, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
__Pyx_DECREF_SET(__pyx_v_format, __pyx_t_3);
__pyx_t_3 = 0;
/* "View.MemoryView":138
* raise ValueError("itemsize <= 0 for cython.array")
*
* if not isinstance(format, bytes): # <<<<<<<<<<<<<<
* format = format.encode('ASCII')
* self._format = format # keep a reference to the byte string
*/
}
/* "View.MemoryView":140
* if not isinstance(format, bytes):
* format = format.encode('ASCII')
* self._format = format # keep a reference to the byte string # <<<<<<<<<<<<<<
* self.format = self._format
*
*/
if (!(likely(PyBytes_CheckExact(__pyx_v_format))||((__pyx_v_format) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "bytes", Py_TYPE(__pyx_v_format)->tp_name), 0))) __PYX_ERR(1, 140, __pyx_L1_error)
__pyx_t_3 = __pyx_v_format;
__Pyx_INCREF(__pyx_t_3);
__Pyx_GIVEREF(__pyx_t_3);
__Pyx_GOTREF(__pyx_v_self->_format);
__Pyx_DECREF(__pyx_v_self->_format);
__pyx_v_self->_format = ((PyObject*)__pyx_t_3);
__pyx_t_3 = 0;
/* "View.MemoryView":141
* format = format.encode('ASCII')
* self._format = format # keep a reference to the byte string
* self.format = self._format # <<<<<<<<<<<<<<
*
*
*/
if (unlikely(__pyx_v_self->_format == Py_None)) {
PyErr_SetString(PyExc_TypeError, "expected bytes, NoneType found");
__PYX_ERR(1, 141, __pyx_L1_error)
}
__pyx_t_7 = __Pyx_PyBytes_AsWritableString(__pyx_v_self->_format); if (unlikely((!__pyx_t_7) && PyErr_Occurred())) __PYX_ERR(1, 141, __pyx_L1_error)
__pyx_v_self->format = __pyx_t_7;
/* "View.MemoryView":144
*
*
* self._shape = <Py_ssize_t *> PyObject_Malloc(sizeof(Py_ssize_t)*self.ndim*2) # <<<<<<<<<<<<<<
* self._strides = self._shape + self.ndim
*
*/
__pyx_v_self->_shape = ((Py_ssize_t *)PyObject_Malloc((((sizeof(Py_ssize_t)) * __pyx_v_self->ndim) * 2)));
/* "View.MemoryView":145
*
* self._shape = <Py_ssize_t *> PyObject_Malloc(sizeof(Py_ssize_t)*self.ndim*2)
* self._strides = self._shape + self.ndim # <<<<<<<<<<<<<<
*
* if not self._shape:
*/
__pyx_v_self->_strides = (__pyx_v_self->_shape + __pyx_v_self->ndim);
/* "View.MemoryView":147
* self._strides = self._shape + self.ndim
*
* if not self._shape: # <<<<<<<<<<<<<<
* raise MemoryError("unable to allocate shape and strides.")
*
*/
__pyx_t_4 = ((!(__pyx_v_self->_shape != 0)) != 0);
if (unlikely(__pyx_t_4)) {
/* "View.MemoryView":148
*
* if not self._shape:
* raise MemoryError("unable to allocate shape and strides.") # <<<<<<<<<<<<<<
*
*
*/
__pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_MemoryError, __pyx_tuple__21, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 148, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_Raise(__pyx_t_3, 0, 0, 0);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__PYX_ERR(1, 148, __pyx_L1_error)
/* "View.MemoryView":147
* self._strides = self._shape + self.ndim
*
* if not self._shape: # <<<<<<<<<<<<<<
* raise MemoryError("unable to allocate shape and strides.")
*
*/
}
/* "View.MemoryView":151
*
*
* for idx, dim in enumerate(shape): # <<<<<<<<<<<<<<
* if dim <= 0:
* raise ValueError("Invalid shape in axis %d: %d." % (idx, dim))
*/
__pyx_t_8 = 0;
__pyx_t_3 = __pyx_v_shape; __Pyx_INCREF(__pyx_t_3); __pyx_t_1 = 0;
for (;;) {
if (__pyx_t_1 >= PyTuple_GET_SIZE(__pyx_t_3)) break;
#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
__pyx_t_5 = PyTuple_GET_ITEM(__pyx_t_3, __pyx_t_1); __Pyx_INCREF(__pyx_t_5); __pyx_t_1++; if (unlikely(0 < 0)) __PYX_ERR(1, 151, __pyx_L1_error)
#else
__pyx_t_5 = PySequence_ITEM(__pyx_t_3, __pyx_t_1); __pyx_t_1++; if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 151, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
#endif
__pyx_t_9 = __Pyx_PyIndex_AsSsize_t(__pyx_t_5); if (unlikely((__pyx_t_9 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(1, 151, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
__pyx_v_dim = __pyx_t_9;
__pyx_v_idx = __pyx_t_8;
__pyx_t_8 = (__pyx_t_8 + 1);
/* "View.MemoryView":152
*
* for idx, dim in enumerate(shape):
* if dim <= 0: # <<<<<<<<<<<<<<
* raise ValueError("Invalid shape in axis %d: %d." % (idx, dim))
* self._shape[idx] = dim
*/
__pyx_t_4 = ((__pyx_v_dim <= 0) != 0);
if (unlikely(__pyx_t_4)) {
/* "View.MemoryView":153
* for idx, dim in enumerate(shape):
* if dim <= 0:
* raise ValueError("Invalid shape in axis %d: %d." % (idx, dim)) # <<<<<<<<<<<<<<
* self._shape[idx] = dim
*
*/
__pyx_t_5 = __Pyx_PyInt_From_int(__pyx_v_idx); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 153, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__pyx_t_6 = PyInt_FromSsize_t(__pyx_v_dim); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 153, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__pyx_t_10 = PyTuple_New(2); if (unlikely(!__pyx_t_10)) __PYX_ERR(1, 153, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_10);
__Pyx_GIVEREF(__pyx_t_5);
PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_t_5);
__Pyx_GIVEREF(__pyx_t_6);
PyTuple_SET_ITEM(__pyx_t_10, 1, __pyx_t_6);
__pyx_t_5 = 0;
__pyx_t_6 = 0;
__pyx_t_6 = __Pyx_PyString_Format(__pyx_kp_s_Invalid_shape_in_axis_d_d, __pyx_t_10); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 153, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
__pyx_t_10 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_6); if (unlikely(!__pyx_t_10)) __PYX_ERR(1, 153, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_10);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_Raise(__pyx_t_10, 0, 0, 0);
__Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
__PYX_ERR(1, 153, __pyx_L1_error)
/* "View.MemoryView":152
*
* for idx, dim in enumerate(shape):
* if dim <= 0: # <<<<<<<<<<<<<<
* raise ValueError("Invalid shape in axis %d: %d." % (idx, dim))
* self._shape[idx] = dim
*/
}
/* "View.MemoryView":154
* if dim <= 0:
* raise ValueError("Invalid shape in axis %d: %d." % (idx, dim))
* self._shape[idx] = dim # <<<<<<<<<<<<<<
*
* cdef char order
*/
(__pyx_v_self->_shape[__pyx_v_idx]) = __pyx_v_dim;
/* "View.MemoryView":151
*
*
* for idx, dim in enumerate(shape): # <<<<<<<<<<<<<<
* if dim <= 0:
* raise ValueError("Invalid shape in axis %d: %d." % (idx, dim))
*/
}
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
/* "View.MemoryView":157
*
* cdef char order
* if mode == 'fortran': # <<<<<<<<<<<<<<
* order = b'F'
* self.mode = u'fortran'
*/
__pyx_t_4 = (__Pyx_PyString_Equals(__pyx_v_mode, __pyx_n_s_fortran, Py_EQ)); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(1, 157, __pyx_L1_error)
if (__pyx_t_4) {
/* "View.MemoryView":158
* cdef char order
* if mode == 'fortran':
* order = b'F' # <<<<<<<<<<<<<<
* self.mode = u'fortran'
* elif mode == 'c':
*/
__pyx_v_order = 'F';
/* "View.MemoryView":159
* if mode == 'fortran':
* order = b'F'
* self.mode = u'fortran' # <<<<<<<<<<<<<<
* elif mode == 'c':
* order = b'C'
*/
__Pyx_INCREF(__pyx_n_u_fortran);
__Pyx_GIVEREF(__pyx_n_u_fortran);
__Pyx_GOTREF(__pyx_v_self->mode);
__Pyx_DECREF(__pyx_v_self->mode);
__pyx_v_self->mode = __pyx_n_u_fortran;
/* "View.MemoryView":157
*
* cdef char order
* if mode == 'fortran': # <<<<<<<<<<<<<<
* order = b'F'
* self.mode = u'fortran'
*/
goto __pyx_L10;
}
/* "View.MemoryView":160
* order = b'F'
* self.mode = u'fortran'
* elif mode == 'c': # <<<<<<<<<<<<<<
* order = b'C'
* self.mode = u'c'
*/
__pyx_t_4 = (__Pyx_PyString_Equals(__pyx_v_mode, __pyx_n_s_c, Py_EQ)); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(1, 160, __pyx_L1_error)
if (likely(__pyx_t_4)) {
/* "View.MemoryView":161
* self.mode = u'fortran'
* elif mode == 'c':
* order = b'C' # <<<<<<<<<<<<<<
* self.mode = u'c'
* else:
*/
__pyx_v_order = 'C';
/* "View.MemoryView":162
* elif mode == 'c':
* order = b'C'
* self.mode = u'c' # <<<<<<<<<<<<<<
* else:
* raise ValueError("Invalid mode, expected 'c' or 'fortran', got %s" % mode)
*/
__Pyx_INCREF(__pyx_n_u_c);
__Pyx_GIVEREF(__pyx_n_u_c);
__Pyx_GOTREF(__pyx_v_self->mode);
__Pyx_DECREF(__pyx_v_self->mode);
__pyx_v_self->mode = __pyx_n_u_c;
/* "View.MemoryView":160
* order = b'F'
* self.mode = u'fortran'
* elif mode == 'c': # <<<<<<<<<<<<<<
* order = b'C'
* self.mode = u'c'
*/
goto __pyx_L10;
}
/* "View.MemoryView":164
* self.mode = u'c'
* else:
* raise ValueError("Invalid mode, expected 'c' or 'fortran', got %s" % mode) # <<<<<<<<<<<<<<
*
* self.len = fill_contig_strides_array(self._shape, self._strides,
*/
/*else*/ {
__pyx_t_3 = __Pyx_PyString_FormatSafe(__pyx_kp_s_Invalid_mode_expected_c_or_fortr, __pyx_v_mode); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 164, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__pyx_t_10 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_3); if (unlikely(!__pyx_t_10)) __PYX_ERR(1, 164, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_10);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__Pyx_Raise(__pyx_t_10, 0, 0, 0);
__Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
__PYX_ERR(1, 164, __pyx_L1_error)
}
__pyx_L10:;
/* "View.MemoryView":166
* raise ValueError("Invalid mode, expected 'c' or 'fortran', got %s" % mode)
*
* self.len = fill_contig_strides_array(self._shape, self._strides, # <<<<<<<<<<<<<<
* itemsize, self.ndim, order)
*
*/
__pyx_v_self->len = __pyx_fill_contig_strides_array(__pyx_v_self->_shape, __pyx_v_self->_strides, __pyx_v_itemsize, __pyx_v_self->ndim, __pyx_v_order);
/* "View.MemoryView":169
* itemsize, self.ndim, order)
*
* self.free_data = allocate_buffer # <<<<<<<<<<<<<<
* self.dtype_is_object = format == b'O'
* if allocate_buffer:
*/
__pyx_v_self->free_data = __pyx_v_allocate_buffer;
/* "View.MemoryView":170
*
* self.free_data = allocate_buffer
* self.dtype_is_object = format == b'O' # <<<<<<<<<<<<<<
* if allocate_buffer:
*
*/
__pyx_t_10 = PyObject_RichCompare(__pyx_v_format, __pyx_n_b_O, Py_EQ); __Pyx_XGOTREF(__pyx_t_10); if (unlikely(!__pyx_t_10)) __PYX_ERR(1, 170, __pyx_L1_error)
__pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_10); if (unlikely((__pyx_t_4 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 170, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
__pyx_v_self->dtype_is_object = __pyx_t_4;
/* "View.MemoryView":171
* self.free_data = allocate_buffer
* self.dtype_is_object = format == b'O'
* if allocate_buffer: # <<<<<<<<<<<<<<
*
*
*/
__pyx_t_4 = (__pyx_v_allocate_buffer != 0);
if (__pyx_t_4) {
/* "View.MemoryView":174
*
*
* self.data = <char *>malloc(self.len) # <<<<<<<<<<<<<<
* if not self.data:
* raise MemoryError("unable to allocate array data.")
*/
__pyx_v_self->data = ((char *)malloc(__pyx_v_self->len));
/* "View.MemoryView":175
*
* self.data = <char *>malloc(self.len)
* if not self.data: # <<<<<<<<<<<<<<
* raise MemoryError("unable to allocate array data.")
*
*/
__pyx_t_4 = ((!(__pyx_v_self->data != 0)) != 0);
if (unlikely(__pyx_t_4)) {
/* "View.MemoryView":176
* self.data = <char *>malloc(self.len)
* if not self.data:
* raise MemoryError("unable to allocate array data.") # <<<<<<<<<<<<<<
*
* if self.dtype_is_object:
*/
__pyx_t_10 = __Pyx_PyObject_Call(__pyx_builtin_MemoryError, __pyx_tuple__22, NULL); if (unlikely(!__pyx_t_10)) __PYX_ERR(1, 176, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_10);
__Pyx_Raise(__pyx_t_10, 0, 0, 0);
__Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
__PYX_ERR(1, 176, __pyx_L1_error)
/* "View.MemoryView":175
*
* self.data = <char *>malloc(self.len)
* if not self.data: # <<<<<<<<<<<<<<
* raise MemoryError("unable to allocate array data.")
*
*/
}
/* "View.MemoryView":178
* raise MemoryError("unable to allocate array data.")
*
* if self.dtype_is_object: # <<<<<<<<<<<<<<
* p = <PyObject **> self.data
* for i in range(self.len / itemsize):
*/
__pyx_t_4 = (__pyx_v_self->dtype_is_object != 0);
if (__pyx_t_4) {
/* "View.MemoryView":179
*
* if self.dtype_is_object:
* p = <PyObject **> self.data # <<<<<<<<<<<<<<
* for i in range(self.len / itemsize):
* p[i] = Py_None
*/
__pyx_v_p = ((PyObject **)__pyx_v_self->data);
/* "View.MemoryView":180
* if self.dtype_is_object:
* p = <PyObject **> self.data
* for i in range(self.len / itemsize): # <<<<<<<<<<<<<<
* p[i] = Py_None
* Py_INCREF(Py_None)
*/
if (unlikely(__pyx_v_itemsize == 0)) {
PyErr_SetString(PyExc_ZeroDivisionError, "integer division or modulo by zero");
__PYX_ERR(1, 180, __pyx_L1_error)
}
else if (sizeof(Py_ssize_t) == sizeof(long) && (!(((Py_ssize_t)-1) > 0)) && unlikely(__pyx_v_itemsize == (Py_ssize_t)-1) && unlikely(UNARY_NEG_WOULD_OVERFLOW(__pyx_v_self->len))) {
PyErr_SetString(PyExc_OverflowError, "value too large to perform division");
__PYX_ERR(1, 180, __pyx_L1_error)
}
__pyx_t_1 = (__pyx_v_self->len / __pyx_v_itemsize);
__pyx_t_9 = __pyx_t_1;
for (__pyx_t_11 = 0; __pyx_t_11 < __pyx_t_9; __pyx_t_11+=1) {
__pyx_v_i = __pyx_t_11;
/* "View.MemoryView":181
* p = <PyObject **> self.data
* for i in range(self.len / itemsize):
* p[i] = Py_None # <<<<<<<<<<<<<<
* Py_INCREF(Py_None)
*
*/
(__pyx_v_p[__pyx_v_i]) = Py_None;
/* "View.MemoryView":182
* for i in range(self.len / itemsize):
* p[i] = Py_None
* Py_INCREF(Py_None) # <<<<<<<<<<<<<<
*
* @cname('getbuffer')
*/
Py_INCREF(Py_None);
}
/* "View.MemoryView":178
* raise MemoryError("unable to allocate array data.")
*
* if self.dtype_is_object: # <<<<<<<<<<<<<<
* p = <PyObject **> self.data
* for i in range(self.len / itemsize):
*/
}
/* "View.MemoryView":171
* self.free_data = allocate_buffer
* self.dtype_is_object = format == b'O'
* if allocate_buffer: # <<<<<<<<<<<<<<
*
*
*/
}
/* "View.MemoryView":122
* cdef bint dtype_is_object
*
* def __cinit__(array self, tuple shape, Py_ssize_t itemsize, format not None, # <<<<<<<<<<<<<<
* mode="c", bint allocate_buffer=True):
*
*/
/* function exit code */
__pyx_r = 0;
goto __pyx_L0;
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_3);
__Pyx_XDECREF(__pyx_t_5);
__Pyx_XDECREF(__pyx_t_6);
__Pyx_XDECREF(__pyx_t_10);
__Pyx_AddTraceback("View.MemoryView.array.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = -1;
__pyx_L0:;
__Pyx_XDECREF(__pyx_v_format);
__Pyx_TraceReturn(Py_None, 0);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "View.MemoryView":185
*
* @cname('getbuffer')
* def __getbuffer__(self, Py_buffer *info, int flags): # <<<<<<<<<<<<<<
* cdef int bufmode = -1
* if self.mode == u"c":
*/
/* Python wrapper */
static CYTHON_UNUSED int __pyx_array_getbuffer(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags); /*proto*/
static CYTHON_UNUSED int __pyx_array_getbuffer(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags) {
int __pyx_r;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("__getbuffer__ (wrapper)", 0);
__pyx_r = __pyx_array___pyx_pf_15View_dot_MemoryView_5array_2__getbuffer__(((struct __pyx_array_obj *)__pyx_v_self), ((Py_buffer *)__pyx_v_info), ((int)__pyx_v_flags));
/* function exit code */
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
static int __pyx_array___pyx_pf_15View_dot_MemoryView_5array_2__getbuffer__(struct __pyx_array_obj *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags) {
int __pyx_v_bufmode;
int __pyx_r;
__Pyx_TraceDeclarations
__Pyx_RefNannyDeclarations
int __pyx_t_1;
int __pyx_t_2;
PyObject *__pyx_t_3 = NULL;
char *__pyx_t_4;
Py_ssize_t __pyx_t_5;
int __pyx_t_6;
Py_ssize_t *__pyx_t_7;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
if (__pyx_v_info == NULL) {
PyErr_SetString(PyExc_BufferError, "PyObject_GetBuffer: view==NULL argument is obsolete");
return -1;
}
__Pyx_RefNannySetupContext("__getbuffer__", 0);
__pyx_v_info->obj = Py_None; __Pyx_INCREF(Py_None);
__Pyx_GIVEREF(__pyx_v_info->obj);
__Pyx_TraceCall("__getbuffer__", __pyx_f[1], 185, 0, __PYX_ERR(1, 185, __pyx_L1_error));
/* "View.MemoryView":186
* @cname('getbuffer')
* def __getbuffer__(self, Py_buffer *info, int flags):
* cdef int bufmode = -1 # <<<<<<<<<<<<<<
* if self.mode == u"c":
* bufmode = PyBUF_C_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS
*/
__pyx_v_bufmode = -1;
/* "View.MemoryView":187
* def __getbuffer__(self, Py_buffer *info, int flags):
* cdef int bufmode = -1
* if self.mode == u"c": # <<<<<<<<<<<<<<
* bufmode = PyBUF_C_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS
* elif self.mode == u"fortran":
*/
__pyx_t_1 = (__Pyx_PyUnicode_Equals(__pyx_v_self->mode, __pyx_n_u_c, Py_EQ)); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(1, 187, __pyx_L1_error)
__pyx_t_2 = (__pyx_t_1 != 0);
if (__pyx_t_2) {
/* "View.MemoryView":188
* cdef int bufmode = -1
* if self.mode == u"c":
* bufmode = PyBUF_C_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS # <<<<<<<<<<<<<<
* elif self.mode == u"fortran":
* bufmode = PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS
*/
__pyx_v_bufmode = (PyBUF_C_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS);
/* "View.MemoryView":187
* def __getbuffer__(self, Py_buffer *info, int flags):
* cdef int bufmode = -1
* if self.mode == u"c": # <<<<<<<<<<<<<<
* bufmode = PyBUF_C_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS
* elif self.mode == u"fortran":
*/
goto __pyx_L3;
}
/* "View.MemoryView":189
* if self.mode == u"c":
* bufmode = PyBUF_C_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS
* elif self.mode == u"fortran": # <<<<<<<<<<<<<<
* bufmode = PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS
* if not (flags & bufmode):
*/
__pyx_t_2 = (__Pyx_PyUnicode_Equals(__pyx_v_self->mode, __pyx_n_u_fortran, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(1, 189, __pyx_L1_error)
__pyx_t_1 = (__pyx_t_2 != 0);
if (__pyx_t_1) {
/* "View.MemoryView":190
* bufmode = PyBUF_C_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS
* elif self.mode == u"fortran":
* bufmode = PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS # <<<<<<<<<<<<<<
* if not (flags & bufmode):
* raise ValueError("Can only create a buffer that is contiguous in memory.")
*/
__pyx_v_bufmode = (PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS);
/* "View.MemoryView":189
* if self.mode == u"c":
* bufmode = PyBUF_C_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS
* elif self.mode == u"fortran": # <<<<<<<<<<<<<<
* bufmode = PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS
* if not (flags & bufmode):
*/
}
__pyx_L3:;
/* "View.MemoryView":191
* elif self.mode == u"fortran":
* bufmode = PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS
* if not (flags & bufmode): # <<<<<<<<<<<<<<
* raise ValueError("Can only create a buffer that is contiguous in memory.")
* info.buf = self.data
*/
__pyx_t_1 = ((!((__pyx_v_flags & __pyx_v_bufmode) != 0)) != 0);
if (unlikely(__pyx_t_1)) {
/* "View.MemoryView":192
* bufmode = PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS
* if not (flags & bufmode):
* raise ValueError("Can only create a buffer that is contiguous in memory.") # <<<<<<<<<<<<<<
* info.buf = self.data
* info.len = self.len
*/
__pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__23, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 192, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_Raise(__pyx_t_3, 0, 0, 0);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__PYX_ERR(1, 192, __pyx_L1_error)
/* "View.MemoryView":191
* elif self.mode == u"fortran":
* bufmode = PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS
* if not (flags & bufmode): # <<<<<<<<<<<<<<
* raise ValueError("Can only create a buffer that is contiguous in memory.")
* info.buf = self.data
*/
}
/* "View.MemoryView":193
* if not (flags & bufmode):
* raise ValueError("Can only create a buffer that is contiguous in memory.")
* info.buf = self.data # <<<<<<<<<<<<<<
* info.len = self.len
* info.ndim = self.ndim
*/
__pyx_t_4 = __pyx_v_self->data;
__pyx_v_info->buf = __pyx_t_4;
/* "View.MemoryView":194
* raise ValueError("Can only create a buffer that is contiguous in memory.")
* info.buf = self.data
* info.len = self.len # <<<<<<<<<<<<<<
* info.ndim = self.ndim
* info.shape = self._shape
*/
__pyx_t_5 = __pyx_v_self->len;
__pyx_v_info->len = __pyx_t_5;
/* "View.MemoryView":195
* info.buf = self.data
* info.len = self.len
* info.ndim = self.ndim # <<<<<<<<<<<<<<
* info.shape = self._shape
* info.strides = self._strides
*/
__pyx_t_6 = __pyx_v_self->ndim;
__pyx_v_info->ndim = __pyx_t_6;
/* "View.MemoryView":196
* info.len = self.len
* info.ndim = self.ndim
* info.shape = self._shape # <<<<<<<<<<<<<<
* info.strides = self._strides
* info.suboffsets = NULL
*/
__pyx_t_7 = __pyx_v_self->_shape;
__pyx_v_info->shape = __pyx_t_7;
/* "View.MemoryView":197
* info.ndim = self.ndim
* info.shape = self._shape
* info.strides = self._strides # <<<<<<<<<<<<<<
* info.suboffsets = NULL
* info.itemsize = self.itemsize
*/
__pyx_t_7 = __pyx_v_self->_strides;
__pyx_v_info->strides = __pyx_t_7;
/* "View.MemoryView":198
* info.shape = self._shape
* info.strides = self._strides
* info.suboffsets = NULL # <<<<<<<<<<<<<<
* info.itemsize = self.itemsize
* info.readonly = 0
*/
__pyx_v_info->suboffsets = NULL;
/* "View.MemoryView":199
* info.strides = self._strides
* info.suboffsets = NULL
* info.itemsize = self.itemsize # <<<<<<<<<<<<<<
* info.readonly = 0
*
*/
__pyx_t_5 = __pyx_v_self->itemsize;
__pyx_v_info->itemsize = __pyx_t_5;
/* "View.MemoryView":200
* info.suboffsets = NULL
* info.itemsize = self.itemsize
* info.readonly = 0 # <<<<<<<<<<<<<<
*
* if flags & PyBUF_FORMAT:
*/
__pyx_v_info->readonly = 0;
/* "View.MemoryView":202
* info.readonly = 0
*
* if flags & PyBUF_FORMAT: # <<<<<<<<<<<<<<
* info.format = self.format
* else:
*/
__pyx_t_1 = ((__pyx_v_flags & PyBUF_FORMAT) != 0);
if (__pyx_t_1) {
/* "View.MemoryView":203
*
* if flags & PyBUF_FORMAT:
* info.format = self.format # <<<<<<<<<<<<<<
* else:
* info.format = NULL
*/
__pyx_t_4 = __pyx_v_self->format;
__pyx_v_info->format = __pyx_t_4;
/* "View.MemoryView":202
* info.readonly = 0
*
* if flags & PyBUF_FORMAT: # <<<<<<<<<<<<<<
* info.format = self.format
* else:
*/
goto __pyx_L5;
}
/* "View.MemoryView":205
* info.format = self.format
* else:
* info.format = NULL # <<<<<<<<<<<<<<
*
* info.obj = self
*/
/*else*/ {
__pyx_v_info->format = NULL;
}
__pyx_L5:;
/* "View.MemoryView":207
* info.format = NULL
*
* info.obj = self # <<<<<<<<<<<<<<
*
* __pyx_getbuffer = capsule(<void *> &__pyx_array_getbuffer, "getbuffer(obj, view, flags)")
*/
__Pyx_INCREF(((PyObject *)__pyx_v_self));
__Pyx_GIVEREF(((PyObject *)__pyx_v_self));
__Pyx_GOTREF(__pyx_v_info->obj);
__Pyx_DECREF(__pyx_v_info->obj);
__pyx_v_info->obj = ((PyObject *)__pyx_v_self);
/* "View.MemoryView":185
*
* @cname('getbuffer')
* def __getbuffer__(self, Py_buffer *info, int flags): # <<<<<<<<<<<<<<
* cdef int bufmode = -1
* if self.mode == u"c":
*/
/* function exit code */
__pyx_r = 0;
goto __pyx_L0;
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_3);
__Pyx_AddTraceback("View.MemoryView.array.__getbuffer__", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = -1;
if (__pyx_v_info->obj != NULL) {
__Pyx_GOTREF(__pyx_v_info->obj);
__Pyx_DECREF(__pyx_v_info->obj); __pyx_v_info->obj = 0;
}
goto __pyx_L2;
__pyx_L0:;
if (__pyx_v_info->obj == Py_None) {
__Pyx_GOTREF(__pyx_v_info->obj);
__Pyx_DECREF(__pyx_v_info->obj); __pyx_v_info->obj = 0;
}
__pyx_L2:;
__Pyx_TraceReturn(Py_None, 0);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "View.MemoryView":211
* __pyx_getbuffer = capsule(<void *> &__pyx_array_getbuffer, "getbuffer(obj, view, flags)")
*
* def __dealloc__(array self): # <<<<<<<<<<<<<<
* if self.callback_free_data != NULL:
* self.callback_free_data(self.data)
*/
/* Python wrapper */
static void __pyx_array___dealloc__(PyObject *__pyx_v_self); /*proto*/
static void __pyx_array___dealloc__(PyObject *__pyx_v_self) {
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0);
__pyx_array___pyx_pf_15View_dot_MemoryView_5array_4__dealloc__(((struct __pyx_array_obj *)__pyx_v_self));
/* function exit code */
__Pyx_RefNannyFinishContext();
}
static void __pyx_array___pyx_pf_15View_dot_MemoryView_5array_4__dealloc__(struct __pyx_array_obj *__pyx_v_self) {
__Pyx_TraceDeclarations
__Pyx_RefNannyDeclarations
int __pyx_t_1;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("__dealloc__", 0);
__Pyx_TraceCall("__dealloc__", __pyx_f[1], 211, 0, __PYX_ERR(1, 211, __pyx_L1_error));
/* "View.MemoryView":212
*
* def __dealloc__(array self):
* if self.callback_free_data != NULL: # <<<<<<<<<<<<<<
* self.callback_free_data(self.data)
* elif self.free_data:
*/
__pyx_t_1 = ((__pyx_v_self->callback_free_data != NULL) != 0);
if (__pyx_t_1) {
/* "View.MemoryView":213
* def __dealloc__(array self):
* if self.callback_free_data != NULL:
* self.callback_free_data(self.data) # <<<<<<<<<<<<<<
* elif self.free_data:
* if self.dtype_is_object:
*/
__pyx_v_self->callback_free_data(__pyx_v_self->data);
/* "View.MemoryView":212
*
* def __dealloc__(array self):
* if self.callback_free_data != NULL: # <<<<<<<<<<<<<<
* self.callback_free_data(self.data)
* elif self.free_data:
*/
goto __pyx_L3;
}
/* "View.MemoryView":214
* if self.callback_free_data != NULL:
* self.callback_free_data(self.data)
* elif self.free_data: # <<<<<<<<<<<<<<
* if self.dtype_is_object:
* refcount_objects_in_slice(self.data, self._shape,
*/
__pyx_t_1 = (__pyx_v_self->free_data != 0);
if (__pyx_t_1) {
/* "View.MemoryView":215
* self.callback_free_data(self.data)
* elif self.free_data:
* if self.dtype_is_object: # <<<<<<<<<<<<<<
* refcount_objects_in_slice(self.data, self._shape,
* self._strides, self.ndim, False)
*/
__pyx_t_1 = (__pyx_v_self->dtype_is_object != 0);
if (__pyx_t_1) {
/* "View.MemoryView":216
* elif self.free_data:
* if self.dtype_is_object:
* refcount_objects_in_slice(self.data, self._shape, # <<<<<<<<<<<<<<
* self._strides, self.ndim, False)
* free(self.data)
*/
__pyx_memoryview_refcount_objects_in_slice(__pyx_v_self->data, __pyx_v_self->_shape, __pyx_v_self->_strides, __pyx_v_self->ndim, 0);
/* "View.MemoryView":215
* self.callback_free_data(self.data)
* elif self.free_data:
* if self.dtype_is_object: # <<<<<<<<<<<<<<
* refcount_objects_in_slice(self.data, self._shape,
* self._strides, self.ndim, False)
*/
}
/* "View.MemoryView":218
* refcount_objects_in_slice(self.data, self._shape,
* self._strides, self.ndim, False)
* free(self.data) # <<<<<<<<<<<<<<
* PyObject_Free(self._shape)
*
*/
free(__pyx_v_self->data);
/* "View.MemoryView":214
* if self.callback_free_data != NULL:
* self.callback_free_data(self.data)
* elif self.free_data: # <<<<<<<<<<<<<<
* if self.dtype_is_object:
* refcount_objects_in_slice(self.data, self._shape,
*/
}
__pyx_L3:;
/* "View.MemoryView":219
* self._strides, self.ndim, False)
* free(self.data)
* PyObject_Free(self._shape) # <<<<<<<<<<<<<<
*
* @property
*/
PyObject_Free(__pyx_v_self->_shape);
/* "View.MemoryView":211
* __pyx_getbuffer = capsule(<void *> &__pyx_array_getbuffer, "getbuffer(obj, view, flags)")
*
* def __dealloc__(array self): # <<<<<<<<<<<<<<
* if self.callback_free_data != NULL:
* self.callback_free_data(self.data)
*/
/* function exit code */
goto __pyx_L0;
__pyx_L1_error:;
__Pyx_WriteUnraisable("View.MemoryView.array.__dealloc__", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0);
__pyx_L0:;
__Pyx_TraceReturn(Py_None, 0);
__Pyx_RefNannyFinishContext();
}
/* "View.MemoryView":222
*
* @property
* def memview(self): # <<<<<<<<<<<<<<
* return self.get_memview()
*
*/
/* Python wrapper */
static PyObject *__pyx_pw_15View_dot_MemoryView_5array_7memview_1__get__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_15View_dot_MemoryView_5array_7memview_1__get__(PyObject *__pyx_v_self) {
PyObject *__pyx_r = 0;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
__pyx_r = __pyx_pf_15View_dot_MemoryView_5array_7memview___get__(((struct __pyx_array_obj *)__pyx_v_self));
/* function exit code */
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
static PyObject *__pyx_pf_15View_dot_MemoryView_5array_7memview___get__(struct __pyx_array_obj *__pyx_v_self) {
PyObject *__pyx_r = NULL;
__Pyx_TraceDeclarations
__Pyx_RefNannyDeclarations
PyObject *__pyx_t_1 = NULL;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("__get__", 0);
__Pyx_TraceCall("__get__", __pyx_f[1], 222, 0, __PYX_ERR(1, 222, __pyx_L1_error));
/* "View.MemoryView":223
* @property
* def memview(self):
* return self.get_memview() # <<<<<<<<<<<<<<
*
* @cname('get_memview')
*/
__Pyx_XDECREF(__pyx_r);
__pyx_t_1 = ((struct __pyx_vtabstruct_array *)__pyx_v_self->__pyx_vtab)->get_memview(__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 223, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_r = __pyx_t_1;
__pyx_t_1 = 0;
goto __pyx_L0;
/* "View.MemoryView":222
*
* @property
* def memview(self): # <<<<<<<<<<<<<<
* return self.get_memview()
*
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_1);
__Pyx_AddTraceback("View.MemoryView.array.memview.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = NULL;
__pyx_L0:;
__Pyx_XGIVEREF(__pyx_r);
__Pyx_TraceReturn(__pyx_r, 0);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "View.MemoryView":226
*
* @cname('get_memview')
* cdef get_memview(self): # <<<<<<<<<<<<<<
* flags = PyBUF_ANY_CONTIGUOUS|PyBUF_FORMAT|PyBUF_WRITABLE
* return memoryview(self, flags, self.dtype_is_object)
*/
static PyObject *__pyx_array_get_memview(struct __pyx_array_obj *__pyx_v_self) {
int __pyx_v_flags;
PyObject *__pyx_r = NULL;
__Pyx_TraceDeclarations
__Pyx_RefNannyDeclarations
PyObject *__pyx_t_1 = NULL;
PyObject *__pyx_t_2 = NULL;
PyObject *__pyx_t_3 = NULL;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("get_memview", 0);
__Pyx_TraceCall("get_memview", __pyx_f[1], 226, 0, __PYX_ERR(1, 226, __pyx_L1_error));
/* "View.MemoryView":227
* @cname('get_memview')
* cdef get_memview(self):
* flags = PyBUF_ANY_CONTIGUOUS|PyBUF_FORMAT|PyBUF_WRITABLE # <<<<<<<<<<<<<<
* return memoryview(self, flags, self.dtype_is_object)
*
*/
__pyx_v_flags = ((PyBUF_ANY_CONTIGUOUS | PyBUF_FORMAT) | PyBUF_WRITABLE);
/* "View.MemoryView":228
* cdef get_memview(self):
* flags = PyBUF_ANY_CONTIGUOUS|PyBUF_FORMAT|PyBUF_WRITABLE
* return memoryview(self, flags, self.dtype_is_object) # <<<<<<<<<<<<<<
*
* def __len__(self):
*/
__Pyx_XDECREF(__pyx_r);
__pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_flags); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 228, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_t_2 = __Pyx_PyBool_FromLong(__pyx_v_self->dtype_is_object); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 228, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 228, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_INCREF(((PyObject *)__pyx_v_self));
__Pyx_GIVEREF(((PyObject *)__pyx_v_self));
PyTuple_SET_ITEM(__pyx_t_3, 0, ((PyObject *)__pyx_v_self));
__Pyx_GIVEREF(__pyx_t_1);
PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_1);
__Pyx_GIVEREF(__pyx_t_2);
PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_t_2);
__pyx_t_1 = 0;
__pyx_t_2 = 0;
__pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_memoryview_type), __pyx_t_3, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 228, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__pyx_r = __pyx_t_2;
__pyx_t_2 = 0;
goto __pyx_L0;
/* "View.MemoryView":226
*
* @cname('get_memview')
* cdef get_memview(self): # <<<<<<<<<<<<<<
* flags = PyBUF_ANY_CONTIGUOUS|PyBUF_FORMAT|PyBUF_WRITABLE
* return memoryview(self, flags, self.dtype_is_object)
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_1);
__Pyx_XDECREF(__pyx_t_2);
__Pyx_XDECREF(__pyx_t_3);
__Pyx_AddTraceback("View.MemoryView.array.get_memview", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = 0;
__pyx_L0:;
__Pyx_XGIVEREF(__pyx_r);
__Pyx_TraceReturn(__pyx_r, 0);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "View.MemoryView":230
* return memoryview(self, flags, self.dtype_is_object)
*
* def __len__(self): # <<<<<<<<<<<<<<
* return self._shape[0]
*
*/
/* Python wrapper */
static Py_ssize_t __pyx_array___len__(PyObject *__pyx_v_self); /*proto*/
static Py_ssize_t __pyx_array___len__(PyObject *__pyx_v_self) {
Py_ssize_t __pyx_r;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("__len__ (wrapper)", 0);
__pyx_r = __pyx_array___pyx_pf_15View_dot_MemoryView_5array_6__len__(((struct __pyx_array_obj *)__pyx_v_self));
/* function exit code */
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
static Py_ssize_t __pyx_array___pyx_pf_15View_dot_MemoryView_5array_6__len__(struct __pyx_array_obj *__pyx_v_self) {
Py_ssize_t __pyx_r;
__Pyx_TraceDeclarations
__Pyx_RefNannyDeclarations
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("__len__", 0);
__Pyx_TraceCall("__len__", __pyx_f[1], 230, 0, __PYX_ERR(1, 230, __pyx_L1_error));
/* "View.MemoryView":231
*
* def __len__(self):
* return self._shape[0] # <<<<<<<<<<<<<<
*
* def __getattr__(self, attr):
*/
__pyx_r = (__pyx_v_self->_shape[0]);
goto __pyx_L0;
/* "View.MemoryView":230
* return memoryview(self, flags, self.dtype_is_object)
*
* def __len__(self): # <<<<<<<<<<<<<<
* return self._shape[0]
*
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_AddTraceback("View.MemoryView.array.__len__", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = -1;
__pyx_L0:;
__Pyx_TraceReturn(Py_None, 0);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "View.MemoryView":233
* return self._shape[0]
*
* def __getattr__(self, attr): # <<<<<<<<<<<<<<
* return getattr(self.memview, attr)
*
*/
/* Python wrapper */
static PyObject *__pyx_array___getattr__(PyObject *__pyx_v_self, PyObject *__pyx_v_attr); /*proto*/
static PyObject *__pyx_array___getattr__(PyObject *__pyx_v_self, PyObject *__pyx_v_attr) {
PyObject *__pyx_r = 0;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("__getattr__ (wrapper)", 0);
__pyx_r = __pyx_array___pyx_pf_15View_dot_MemoryView_5array_8__getattr__(((struct __pyx_array_obj *)__pyx_v_self), ((PyObject *)__pyx_v_attr));
/* function exit code */
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
static PyObject *__pyx_array___pyx_pf_15View_dot_MemoryView_5array_8__getattr__(struct __pyx_array_obj *__pyx_v_self, PyObject *__pyx_v_attr) {
PyObject *__pyx_r = NULL;
__Pyx_TraceDeclarations
__Pyx_RefNannyDeclarations
PyObject *__pyx_t_1 = NULL;
PyObject *__pyx_t_2 = NULL;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("__getattr__", 0);
__Pyx_TraceCall("__getattr__", __pyx_f[1], 233, 0, __PYX_ERR(1, 233, __pyx_L1_error));
/* "View.MemoryView":234
*
* def __getattr__(self, attr):
* return getattr(self.memview, attr) # <<<<<<<<<<<<<<
*
* def __getitem__(self, item):
*/
__Pyx_XDECREF(__pyx_r);
__pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_memview); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 234, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_t_2 = __Pyx_GetAttr(__pyx_t_1, __pyx_v_attr); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 234, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__pyx_r = __pyx_t_2;
__pyx_t_2 = 0;
goto __pyx_L0;
/* "View.MemoryView":233
* return self._shape[0]
*
* def __getattr__(self, attr): # <<<<<<<<<<<<<<
* return getattr(self.memview, attr)
*
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_1);
__Pyx_XDECREF(__pyx_t_2);
__Pyx_AddTraceback("View.MemoryView.array.__getattr__", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = NULL;
__pyx_L0:;
__Pyx_XGIVEREF(__pyx_r);
__Pyx_TraceReturn(__pyx_r, 0);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "View.MemoryView":236
* return getattr(self.memview, attr)
*
* def __getitem__(self, item): # <<<<<<<<<<<<<<
* return self.memview[item]
*
*/
/* Python wrapper */
static PyObject *__pyx_array___getitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_item); /*proto*/
static PyObject *__pyx_array___getitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_item) {
PyObject *__pyx_r = 0;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("__getitem__ (wrapper)", 0);
__pyx_r = __pyx_array___pyx_pf_15View_dot_MemoryView_5array_10__getitem__(((struct __pyx_array_obj *)__pyx_v_self), ((PyObject *)__pyx_v_item));
/* function exit code */
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
static PyObject *__pyx_array___pyx_pf_15View_dot_MemoryView_5array_10__getitem__(struct __pyx_array_obj *__pyx_v_self, PyObject *__pyx_v_item) {
PyObject *__pyx_r = NULL;
__Pyx_TraceDeclarations
__Pyx_RefNannyDeclarations
PyObject *__pyx_t_1 = NULL;
PyObject *__pyx_t_2 = NULL;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("__getitem__", 0);
__Pyx_TraceCall("__getitem__", __pyx_f[1], 236, 0, __PYX_ERR(1, 236, __pyx_L1_error));
/* "View.MemoryView":237
*
* def __getitem__(self, item):
* return self.memview[item] # <<<<<<<<<<<<<<
*
* def __setitem__(self, item, value):
*/
__Pyx_XDECREF(__pyx_r);
__pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_memview); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 237, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_t_2 = __Pyx_PyObject_GetItem(__pyx_t_1, __pyx_v_item); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 237, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__pyx_r = __pyx_t_2;
__pyx_t_2 = 0;
goto __pyx_L0;
/* "View.MemoryView":236
* return getattr(self.memview, attr)
*
* def __getitem__(self, item): # <<<<<<<<<<<<<<
* return self.memview[item]
*
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_1);
__Pyx_XDECREF(__pyx_t_2);
__Pyx_AddTraceback("View.MemoryView.array.__getitem__", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = NULL;
__pyx_L0:;
__Pyx_XGIVEREF(__pyx_r);
__Pyx_TraceReturn(__pyx_r, 0);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "View.MemoryView":239
* return self.memview[item]
*
* def __setitem__(self, item, value): # <<<<<<<<<<<<<<
* self.memview[item] = value
*
*/
/* Python wrapper */
static int __pyx_array___setitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_item, PyObject *__pyx_v_value); /*proto*/
static int __pyx_array___setitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_item, PyObject *__pyx_v_value) {
int __pyx_r;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("__setitem__ (wrapper)", 0);
__pyx_r = __pyx_array___pyx_pf_15View_dot_MemoryView_5array_12__setitem__(((struct __pyx_array_obj *)__pyx_v_self), ((PyObject *)__pyx_v_item), ((PyObject *)__pyx_v_value));
/* function exit code */
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
static int __pyx_array___pyx_pf_15View_dot_MemoryView_5array_12__setitem__(struct __pyx_array_obj *__pyx_v_self, PyObject *__pyx_v_item, PyObject *__pyx_v_value) {
int __pyx_r;
__Pyx_TraceDeclarations
__Pyx_RefNannyDeclarations
PyObject *__pyx_t_1 = NULL;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("__setitem__", 0);
__Pyx_TraceCall("__setitem__", __pyx_f[1], 239, 0, __PYX_ERR(1, 239, __pyx_L1_error));
/* "View.MemoryView":240
*
* def __setitem__(self, item, value):
* self.memview[item] = value # <<<<<<<<<<<<<<
*
*
*/
__pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_memview); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 240, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
if (unlikely(PyObject_SetItem(__pyx_t_1, __pyx_v_item, __pyx_v_value) < 0)) __PYX_ERR(1, 240, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
/* "View.MemoryView":239
* return self.memview[item]
*
* def __setitem__(self, item, value): # <<<<<<<<<<<<<<
* self.memview[item] = value
*
*/
/* function exit code */
__pyx_r = 0;
goto __pyx_L0;
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_1);
__Pyx_AddTraceback("View.MemoryView.array.__setitem__", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = -1;
__pyx_L0:;
__Pyx_TraceReturn(Py_None, 0);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "(tree fragment)":1
* def __reduce_cython__(self): # <<<<<<<<<<<<<<
* raise TypeError("no default __reduce__ due to non-trivial __cinit__")
* def __setstate_cython__(self, __pyx_state):
*/
/* Python wrapper */
static PyObject *__pyx_pw___pyx_array_1__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
static PyObject *__pyx_pw___pyx_array_1__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
PyObject *__pyx_r = 0;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0);
__pyx_r = __pyx_pf___pyx_array___reduce_cython__(((struct __pyx_array_obj *)__pyx_v_self));
/* function exit code */
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
static PyObject *__pyx_pf___pyx_array___reduce_cython__(CYTHON_UNUSED struct __pyx_array_obj *__pyx_v_self) {
PyObject *__pyx_r = NULL;
__Pyx_TraceDeclarations
__Pyx_RefNannyDeclarations
PyObject *__pyx_t_1 = NULL;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("__reduce_cython__", 0);
__Pyx_TraceCall("__reduce_cython__", __pyx_f[1], 1, 0, __PYX_ERR(1, 1, __pyx_L1_error));
/* "(tree fragment)":2
* def __reduce_cython__(self):
* raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<<
* def __setstate_cython__(self, __pyx_state):
* raise TypeError("no default __reduce__ due to non-trivial __cinit__")
*/
__pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__24, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_Raise(__pyx_t_1, 0, 0, 0);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__PYX_ERR(1, 2, __pyx_L1_error)
/* "(tree fragment)":1
* def __reduce_cython__(self): # <<<<<<<<<<<<<<
* raise TypeError("no default __reduce__ due to non-trivial __cinit__")
* def __setstate_cython__(self, __pyx_state):
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_1);
__Pyx_AddTraceback("View.MemoryView.array.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = NULL;
__Pyx_XGIVEREF(__pyx_r);
__Pyx_TraceReturn(__pyx_r, 0);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "(tree fragment)":3
* def __reduce_cython__(self):
* raise TypeError("no default __reduce__ due to non-trivial __cinit__")
* def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<<
* raise TypeError("no default __reduce__ due to non-trivial __cinit__")
*/
/* Python wrapper */
static PyObject *__pyx_pw___pyx_array_3__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state); /*proto*/
static PyObject *__pyx_pw___pyx_array_3__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state) {
PyObject *__pyx_r = 0;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0);
__pyx_r = __pyx_pf___pyx_array_2__setstate_cython__(((struct __pyx_array_obj *)__pyx_v_self), ((PyObject *)__pyx_v___pyx_state));
/* function exit code */
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
static PyObject *__pyx_pf___pyx_array_2__setstate_cython__(CYTHON_UNUSED struct __pyx_array_obj *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) {
PyObject *__pyx_r = NULL;
__Pyx_TraceDeclarations
__Pyx_RefNannyDeclarations
PyObject *__pyx_t_1 = NULL;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("__setstate_cython__", 0);
__Pyx_TraceCall("__setstate_cython__", __pyx_f[1], 3, 0, __PYX_ERR(1, 3, __pyx_L1_error));
/* "(tree fragment)":4
* raise TypeError("no default __reduce__ due to non-trivial __cinit__")
* def __setstate_cython__(self, __pyx_state):
* raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<<
*/
__pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__25, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 4, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_Raise(__pyx_t_1, 0, 0, 0);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__PYX_ERR(1, 4, __pyx_L1_error)
/* "(tree fragment)":3
* def __reduce_cython__(self):
* raise TypeError("no default __reduce__ due to non-trivial __cinit__")
* def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<<
* raise TypeError("no default __reduce__ due to non-trivial __cinit__")
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_1);
__Pyx_AddTraceback("View.MemoryView.array.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = NULL;
__Pyx_XGIVEREF(__pyx_r);
__Pyx_TraceReturn(__pyx_r, 0);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "View.MemoryView":244
*
* @cname("__pyx_array_new")
* cdef array array_cwrapper(tuple shape, Py_ssize_t itemsize, char *format, # <<<<<<<<<<<<<<
* char *mode, char *buf):
* cdef array result
*/
static struct __pyx_array_obj *__pyx_array_new(PyObject *__pyx_v_shape, Py_ssize_t __pyx_v_itemsize, char *__pyx_v_format, char *__pyx_v_mode, char *__pyx_v_buf) {
struct __pyx_array_obj *__pyx_v_result = 0;
struct __pyx_array_obj *__pyx_r = NULL;
__Pyx_TraceDeclarations
__Pyx_RefNannyDeclarations
int __pyx_t_1;
PyObject *__pyx_t_2 = NULL;
PyObject *__pyx_t_3 = NULL;
PyObject *__pyx_t_4 = NULL;
PyObject *__pyx_t_5 = NULL;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("array_cwrapper", 0);
__Pyx_TraceCall("array_cwrapper", __pyx_f[1], 244, 0, __PYX_ERR(1, 244, __pyx_L1_error));
/* "View.MemoryView":248
* cdef array result
*
* if buf == NULL: # <<<<<<<<<<<<<<
* result = array(shape, itemsize, format, mode.decode('ASCII'))
* else:
*/
__pyx_t_1 = ((__pyx_v_buf == NULL) != 0);
if (__pyx_t_1) {
/* "View.MemoryView":249
*
* if buf == NULL:
* result = array(shape, itemsize, format, mode.decode('ASCII')) # <<<<<<<<<<<<<<
* else:
* result = array(shape, itemsize, format, mode.decode('ASCII'),
*/
__pyx_t_2 = PyInt_FromSsize_t(__pyx_v_itemsize); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 249, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__pyx_t_3 = __Pyx_PyBytes_FromString(__pyx_v_format); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 249, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__pyx_t_4 = __Pyx_decode_c_string(__pyx_v_mode, 0, strlen(__pyx_v_mode), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 249, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__pyx_t_5 = PyTuple_New(4); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 249, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_INCREF(__pyx_v_shape);
__Pyx_GIVEREF(__pyx_v_shape);
PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_v_shape);
__Pyx_GIVEREF(__pyx_t_2);
PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_2);
__Pyx_GIVEREF(__pyx_t_3);
PyTuple_SET_ITEM(__pyx_t_5, 2, __pyx_t_3);
__Pyx_GIVEREF(__pyx_t_4);
PyTuple_SET_ITEM(__pyx_t_5, 3, __pyx_t_4);
__pyx_t_2 = 0;
__pyx_t_3 = 0;
__pyx_t_4 = 0;
__pyx_t_4 = __Pyx_PyObject_Call(((PyObject *)__pyx_array_type), __pyx_t_5, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 249, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
__pyx_v_result = ((struct __pyx_array_obj *)__pyx_t_4);
__pyx_t_4 = 0;
/* "View.MemoryView":248
* cdef array result
*
* if buf == NULL: # <<<<<<<<<<<<<<
* result = array(shape, itemsize, format, mode.decode('ASCII'))
* else:
*/
goto __pyx_L3;
}
/* "View.MemoryView":251
* result = array(shape, itemsize, format, mode.decode('ASCII'))
* else:
* result = array(shape, itemsize, format, mode.decode('ASCII'), # <<<<<<<<<<<<<<
* allocate_buffer=False)
* result.data = buf
*/
/*else*/ {
__pyx_t_4 = PyInt_FromSsize_t(__pyx_v_itemsize); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 251, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__pyx_t_5 = __Pyx_PyBytes_FromString(__pyx_v_format); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 251, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__pyx_t_3 = __Pyx_decode_c_string(__pyx_v_mode, 0, strlen(__pyx_v_mode), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 251, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__pyx_t_2 = PyTuple_New(4); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 251, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_INCREF(__pyx_v_shape);
__Pyx_GIVEREF(__pyx_v_shape);
PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_v_shape);
__Pyx_GIVEREF(__pyx_t_4);
PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_t_4);
__Pyx_GIVEREF(__pyx_t_5);
PyTuple_SET_ITEM(__pyx_t_2, 2, __pyx_t_5);
__Pyx_GIVEREF(__pyx_t_3);
PyTuple_SET_ITEM(__pyx_t_2, 3, __pyx_t_3);
__pyx_t_4 = 0;
__pyx_t_5 = 0;
__pyx_t_3 = 0;
/* "View.MemoryView":252
* else:
* result = array(shape, itemsize, format, mode.decode('ASCII'),
* allocate_buffer=False) # <<<<<<<<<<<<<<
* result.data = buf
*
*/
__pyx_t_3 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 252, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_allocate_buffer, Py_False) < 0) __PYX_ERR(1, 252, __pyx_L1_error)
/* "View.MemoryView":251
* result = array(shape, itemsize, format, mode.decode('ASCII'))
* else:
* result = array(shape, itemsize, format, mode.decode('ASCII'), # <<<<<<<<<<<<<<
* allocate_buffer=False)
* result.data = buf
*/
__pyx_t_5 = __Pyx_PyObject_Call(((PyObject *)__pyx_array_type), __pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 251, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__pyx_v_result = ((struct __pyx_array_obj *)__pyx_t_5);
__pyx_t_5 = 0;
/* "View.MemoryView":253
* result = array(shape, itemsize, format, mode.decode('ASCII'),
* allocate_buffer=False)
* result.data = buf # <<<<<<<<<<<<<<
*
* return result
*/
__pyx_v_result->data = __pyx_v_buf;
}
__pyx_L3:;
/* "View.MemoryView":255
* result.data = buf
*
* return result # <<<<<<<<<<<<<<
*
*
*/
__Pyx_XDECREF(((PyObject *)__pyx_r));
__Pyx_INCREF(((PyObject *)__pyx_v_result));
__pyx_r = __pyx_v_result;
goto __pyx_L0;
/* "View.MemoryView":244
*
* @cname("__pyx_array_new")
* cdef array array_cwrapper(tuple shape, Py_ssize_t itemsize, char *format, # <<<<<<<<<<<<<<
* char *mode, char *buf):
* cdef array result
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_2);
__Pyx_XDECREF(__pyx_t_3);
__Pyx_XDECREF(__pyx_t_4);
__Pyx_XDECREF(__pyx_t_5);
__Pyx_AddTraceback("View.MemoryView.array_cwrapper", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = 0;
__pyx_L0:;
__Pyx_XDECREF((PyObject *)__pyx_v_result);
__Pyx_XGIVEREF((PyObject *)__pyx_r);
__Pyx_TraceReturn(__pyx_r, 0);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "View.MemoryView":281
* cdef class Enum(object):
* cdef object name
* def __init__(self, name): # <<<<<<<<<<<<<<
* self.name = name
* def __repr__(self):
*/
/* Python wrapper */
static int __pyx_MemviewEnum___init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static int __pyx_MemviewEnum___init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
PyObject *__pyx_v_name = 0;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
int __pyx_r;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("__init__ (wrapper)", 0);
{
static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_name,0};
PyObject* values[1] = {0};
if (unlikely(__pyx_kwds)) {
Py_ssize_t kw_args;
const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
switch (pos_args) {
case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
CYTHON_FALLTHROUGH;
case 0: break;
default: goto __pyx_L5_argtuple_error;
}
kw_args = PyDict_Size(__pyx_kwds);
switch (pos_args) {
case 0:
if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_name)) != 0)) kw_args--;
else goto __pyx_L5_argtuple_error;
}
if (unlikely(kw_args > 0)) {
if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__init__") < 0)) __PYX_ERR(1, 281, __pyx_L3_error)
}
} else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
goto __pyx_L5_argtuple_error;
} else {
values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
}
__pyx_v_name = values[0];
}
goto __pyx_L4_argument_unpacking_done;
__pyx_L5_argtuple_error:;
__Pyx_RaiseArgtupleInvalid("__init__", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 281, __pyx_L3_error)
__pyx_L3_error:;
__Pyx_AddTraceback("View.MemoryView.Enum.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename);
__Pyx_RefNannyFinishContext();
return -1;
__pyx_L4_argument_unpacking_done:;
__pyx_r = __pyx_MemviewEnum___pyx_pf_15View_dot_MemoryView_4Enum___init__(((struct __pyx_MemviewEnum_obj *)__pyx_v_self), __pyx_v_name);
/* function exit code */
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
static int __pyx_MemviewEnum___pyx_pf_15View_dot_MemoryView_4Enum___init__(struct __pyx_MemviewEnum_obj *__pyx_v_self, PyObject *__pyx_v_name) {
int __pyx_r;
__Pyx_TraceDeclarations
__Pyx_RefNannyDeclarations
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("__init__", 0);
__Pyx_TraceCall("__init__", __pyx_f[1], 281, 0, __PYX_ERR(1, 281, __pyx_L1_error));
/* "View.MemoryView":282
* cdef object name
* def __init__(self, name):
* self.name = name # <<<<<<<<<<<<<<
* def __repr__(self):
* return self.name
*/
__Pyx_INCREF(__pyx_v_name);
__Pyx_GIVEREF(__pyx_v_name);
__Pyx_GOTREF(__pyx_v_self->name);
__Pyx_DECREF(__pyx_v_self->name);
__pyx_v_self->name = __pyx_v_name;
/* "View.MemoryView":281
* cdef class Enum(object):
* cdef object name
* def __init__(self, name): # <<<<<<<<<<<<<<
* self.name = name
* def __repr__(self):
*/
/* function exit code */
__pyx_r = 0;
goto __pyx_L0;
__pyx_L1_error:;
__Pyx_AddTraceback("View.MemoryView.Enum.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = -1;
__pyx_L0:;
__Pyx_TraceReturn(Py_None, 0);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "View.MemoryView":283
* def __init__(self, name):
* self.name = name
* def __repr__(self): # <<<<<<<<<<<<<<
* return self.name
*
*/
/* Python wrapper */
static PyObject *__pyx_MemviewEnum___repr__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_MemviewEnum___repr__(PyObject *__pyx_v_self) {
PyObject *__pyx_r = 0;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("__repr__ (wrapper)", 0);
__pyx_r = __pyx_MemviewEnum___pyx_pf_15View_dot_MemoryView_4Enum_2__repr__(((struct __pyx_MemviewEnum_obj *)__pyx_v_self));
/* function exit code */
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
static PyObject *__pyx_MemviewEnum___pyx_pf_15View_dot_MemoryView_4Enum_2__repr__(struct __pyx_MemviewEnum_obj *__pyx_v_self) {
PyObject *__pyx_r = NULL;
__Pyx_TraceDeclarations
__Pyx_RefNannyDeclarations
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("__repr__", 0);
__Pyx_TraceCall("__repr__", __pyx_f[1], 283, 0, __PYX_ERR(1, 283, __pyx_L1_error));
/* "View.MemoryView":284
* self.name = name
* def __repr__(self):
* return self.name # <<<<<<<<<<<<<<
*
* cdef generic = Enum("<strided and direct or indirect>")
*/
__Pyx_XDECREF(__pyx_r);
__Pyx_INCREF(__pyx_v_self->name);
__pyx_r = __pyx_v_self->name;
goto __pyx_L0;
/* "View.MemoryView":283
* def __init__(self, name):
* self.name = name
* def __repr__(self): # <<<<<<<<<<<<<<
* return self.name
*
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_AddTraceback("View.MemoryView.Enum.__repr__", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = NULL;
__pyx_L0:;
__Pyx_XGIVEREF(__pyx_r);
__Pyx_TraceReturn(__pyx_r, 0);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "(tree fragment)":1
* def __reduce_cython__(self): # <<<<<<<<<<<<<<
* cdef tuple state
* cdef object _dict
*/
/* Python wrapper */
static PyObject *__pyx_pw___pyx_MemviewEnum_1__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
static PyObject *__pyx_pw___pyx_MemviewEnum_1__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
PyObject *__pyx_r = 0;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0);
__pyx_r = __pyx_pf___pyx_MemviewEnum___reduce_cython__(((struct __pyx_MemviewEnum_obj *)__pyx_v_self));
/* function exit code */
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
static PyObject *__pyx_pf___pyx_MemviewEnum___reduce_cython__(struct __pyx_MemviewEnum_obj *__pyx_v_self) {
PyObject *__pyx_v_state = 0;
PyObject *__pyx_v__dict = 0;
int __pyx_v_use_setstate;
PyObject *__pyx_r = NULL;
__Pyx_TraceDeclarations
__Pyx_RefNannyDeclarations
PyObject *__pyx_t_1 = NULL;
int __pyx_t_2;
int __pyx_t_3;
PyObject *__pyx_t_4 = NULL;
PyObject *__pyx_t_5 = NULL;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("__reduce_cython__", 0);
__Pyx_TraceCall("__reduce_cython__", __pyx_f[1], 1, 0, __PYX_ERR(1, 1, __pyx_L1_error));
/* "(tree fragment)":5
* cdef object _dict
* cdef bint use_setstate
* state = (self.name,) # <<<<<<<<<<<<<<
* _dict = getattr(self, '__dict__', None)
* if _dict is not None:
*/
__pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 5, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_INCREF(__pyx_v_self->name);
__Pyx_GIVEREF(__pyx_v_self->name);
PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v_self->name);
__pyx_v_state = ((PyObject*)__pyx_t_1);
__pyx_t_1 = 0;
/* "(tree fragment)":6
* cdef bint use_setstate
* state = (self.name,)
* _dict = getattr(self, '__dict__', None) # <<<<<<<<<<<<<<
* if _dict is not None:
* state += (_dict,)
*/
__pyx_t_1 = __Pyx_GetAttr3(((PyObject *)__pyx_v_self), __pyx_n_s_dict, Py_None); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 6, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_v__dict = __pyx_t_1;
__pyx_t_1 = 0;
/* "(tree fragment)":7
* state = (self.name,)
* _dict = getattr(self, '__dict__', None)
* if _dict is not None: # <<<<<<<<<<<<<<
* state += (_dict,)
* use_setstate = True
*/
__pyx_t_2 = (__pyx_v__dict != Py_None);
__pyx_t_3 = (__pyx_t_2 != 0);
if (__pyx_t_3) {
/* "(tree fragment)":8
* _dict = getattr(self, '__dict__', None)
* if _dict is not None:
* state += (_dict,) # <<<<<<<<<<<<<<
* use_setstate = True
* else:
*/
__pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 8, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_INCREF(__pyx_v__dict);
__Pyx_GIVEREF(__pyx_v__dict);
PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v__dict);
__pyx_t_4 = PyNumber_InPlaceAdd(__pyx_v_state, __pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 8, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__Pyx_DECREF_SET(__pyx_v_state, ((PyObject*)__pyx_t_4));
__pyx_t_4 = 0;
/* "(tree fragment)":9
* if _dict is not None:
* state += (_dict,)
* use_setstate = True # <<<<<<<<<<<<<<
* else:
* use_setstate = self.name is not None
*/
__pyx_v_use_setstate = 1;
/* "(tree fragment)":7
* state = (self.name,)
* _dict = getattr(self, '__dict__', None)
* if _dict is not None: # <<<<<<<<<<<<<<
* state += (_dict,)
* use_setstate = True
*/
goto __pyx_L3;
}
/* "(tree fragment)":11
* use_setstate = True
* else:
* use_setstate = self.name is not None # <<<<<<<<<<<<<<
* if use_setstate:
* return __pyx_unpickle_Enum, (type(self), 0xb068931, None), state
*/
/*else*/ {
__pyx_t_3 = (__pyx_v_self->name != Py_None);
__pyx_v_use_setstate = __pyx_t_3;
}
__pyx_L3:;
/* "(tree fragment)":12
* else:
* use_setstate = self.name is not None
* if use_setstate: # <<<<<<<<<<<<<<
* return __pyx_unpickle_Enum, (type(self), 0xb068931, None), state
* else:
*/
__pyx_t_3 = (__pyx_v_use_setstate != 0);
if (__pyx_t_3) {
/* "(tree fragment)":13
* use_setstate = self.name is not None
* if use_setstate:
* return __pyx_unpickle_Enum, (type(self), 0xb068931, None), state # <<<<<<<<<<<<<<
* else:
* return __pyx_unpickle_Enum, (type(self), 0xb068931, state)
*/
__Pyx_XDECREF(__pyx_r);
__Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_pyx_unpickle_Enum); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 13, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 13, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))));
__Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))));
PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))));
__Pyx_INCREF(__pyx_int_184977713);
__Pyx_GIVEREF(__pyx_int_184977713);
PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_int_184977713);
__Pyx_INCREF(Py_None);
__Pyx_GIVEREF(Py_None);
PyTuple_SET_ITEM(__pyx_t_1, 2, Py_None);
__pyx_t_5 = PyTuple_New(3); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 13, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_GIVEREF(__pyx_t_4);
PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_4);
__Pyx_GIVEREF(__pyx_t_1);
PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_1);
__Pyx_INCREF(__pyx_v_state);
__Pyx_GIVEREF(__pyx_v_state);
PyTuple_SET_ITEM(__pyx_t_5, 2, __pyx_v_state);
__pyx_t_4 = 0;
__pyx_t_1 = 0;
__pyx_r = __pyx_t_5;
__pyx_t_5 = 0;
goto __pyx_L0;
/* "(tree fragment)":12
* else:
* use_setstate = self.name is not None
* if use_setstate: # <<<<<<<<<<<<<<
* return __pyx_unpickle_Enum, (type(self), 0xb068931, None), state
* else:
*/
}
/* "(tree fragment)":15
* return __pyx_unpickle_Enum, (type(self), 0xb068931, None), state
* else:
* return __pyx_unpickle_Enum, (type(self), 0xb068931, state) # <<<<<<<<<<<<<<
* def __setstate_cython__(self, __pyx_state):
* __pyx_unpickle_Enum__set_state(self, __pyx_state)
*/
/*else*/ {
__Pyx_XDECREF(__pyx_r);
__Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_pyx_unpickle_Enum); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 15, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 15, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))));
__Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))));
PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))));
__Pyx_INCREF(__pyx_int_184977713);
__Pyx_GIVEREF(__pyx_int_184977713);
PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_int_184977713);
__Pyx_INCREF(__pyx_v_state);
__Pyx_GIVEREF(__pyx_v_state);
PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_v_state);
__pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 15, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_GIVEREF(__pyx_t_5);
PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_5);
__Pyx_GIVEREF(__pyx_t_1);
PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_1);
__pyx_t_5 = 0;
__pyx_t_1 = 0;
__pyx_r = __pyx_t_4;
__pyx_t_4 = 0;
goto __pyx_L0;
}
/* "(tree fragment)":1
* def __reduce_cython__(self): # <<<<<<<<<<<<<<
* cdef tuple state
* cdef object _dict
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_1);
__Pyx_XDECREF(__pyx_t_4);
__Pyx_XDECREF(__pyx_t_5);
__Pyx_AddTraceback("View.MemoryView.Enum.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = NULL;
__pyx_L0:;
__Pyx_XDECREF(__pyx_v_state);
__Pyx_XDECREF(__pyx_v__dict);
__Pyx_XGIVEREF(__pyx_r);
__Pyx_TraceReturn(__pyx_r, 0);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "(tree fragment)":16
* else:
* return __pyx_unpickle_Enum, (type(self), 0xb068931, state)
* def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<<
* __pyx_unpickle_Enum__set_state(self, __pyx_state)
*/
/* Python wrapper */
static PyObject *__pyx_pw___pyx_MemviewEnum_3__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state); /*proto*/
static PyObject *__pyx_pw___pyx_MemviewEnum_3__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state) {
PyObject *__pyx_r = 0;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0);
__pyx_r = __pyx_pf___pyx_MemviewEnum_2__setstate_cython__(((struct __pyx_MemviewEnum_obj *)__pyx_v_self), ((PyObject *)__pyx_v___pyx_state));
/* function exit code */
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
static PyObject *__pyx_pf___pyx_MemviewEnum_2__setstate_cython__(struct __pyx_MemviewEnum_obj *__pyx_v_self, PyObject *__pyx_v___pyx_state) {
PyObject *__pyx_r = NULL;
__Pyx_TraceDeclarations
__Pyx_RefNannyDeclarations
PyObject *__pyx_t_1 = NULL;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("__setstate_cython__", 0);
__Pyx_TraceCall("__setstate_cython__", __pyx_f[1], 16, 0, __PYX_ERR(1, 16, __pyx_L1_error));
/* "(tree fragment)":17
* return __pyx_unpickle_Enum, (type(self), 0xb068931, state)
* def __setstate_cython__(self, __pyx_state):
* __pyx_unpickle_Enum__set_state(self, __pyx_state) # <<<<<<<<<<<<<<
*/
if (!(likely(PyTuple_CheckExact(__pyx_v___pyx_state))||((__pyx_v___pyx_state) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "tuple", Py_TYPE(__pyx_v___pyx_state)->tp_name), 0))) __PYX_ERR(1, 17, __pyx_L1_error)
__pyx_t_1 = __pyx_unpickle_Enum__set_state(__pyx_v_self, ((PyObject*)__pyx_v___pyx_state)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 17, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
/* "(tree fragment)":16
* else:
* return __pyx_unpickle_Enum, (type(self), 0xb068931, state)
* def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<<
* __pyx_unpickle_Enum__set_state(self, __pyx_state)
*/
/* function exit code */
__pyx_r = Py_None; __Pyx_INCREF(Py_None);
goto __pyx_L0;
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_1);
__Pyx_AddTraceback("View.MemoryView.Enum.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = NULL;
__pyx_L0:;
__Pyx_XGIVEREF(__pyx_r);
__Pyx_TraceReturn(__pyx_r, 0);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "View.MemoryView":298
*
* @cname('__pyx_align_pointer')
* cdef void *align_pointer(void *memory, size_t alignment) nogil: # <<<<<<<<<<<<<<
* "Align pointer memory on a given boundary"
* cdef Py_intptr_t aligned_p = <Py_intptr_t> memory
*/
static void *__pyx_align_pointer(void *__pyx_v_memory, size_t __pyx_v_alignment) {
Py_intptr_t __pyx_v_aligned_p;
size_t __pyx_v_offset;
void *__pyx_r;
__Pyx_TraceDeclarations
int __pyx_t_1;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_TraceCall("align_pointer", __pyx_f[1], 298, 1, __PYX_ERR(1, 298, __pyx_L1_error));
/* "View.MemoryView":300
* cdef void *align_pointer(void *memory, size_t alignment) nogil:
* "Align pointer memory on a given boundary"
* cdef Py_intptr_t aligned_p = <Py_intptr_t> memory # <<<<<<<<<<<<<<
* cdef size_t offset
*
*/
__pyx_v_aligned_p = ((Py_intptr_t)__pyx_v_memory);
/* "View.MemoryView":304
*
* with cython.cdivision(True):
* offset = aligned_p % alignment # <<<<<<<<<<<<<<
*
* if offset > 0:
*/
__pyx_v_offset = (__pyx_v_aligned_p % __pyx_v_alignment);
/* "View.MemoryView":306
* offset = aligned_p % alignment
*
* if offset > 0: # <<<<<<<<<<<<<<
* aligned_p += alignment - offset
*
*/
__pyx_t_1 = ((__pyx_v_offset > 0) != 0);
if (__pyx_t_1) {
/* "View.MemoryView":307
*
* if offset > 0:
* aligned_p += alignment - offset # <<<<<<<<<<<<<<
*
* return <void *> aligned_p
*/
__pyx_v_aligned_p = (__pyx_v_aligned_p + (__pyx_v_alignment - __pyx_v_offset));
/* "View.MemoryView":306
* offset = aligned_p % alignment
*
* if offset > 0: # <<<<<<<<<<<<<<
* aligned_p += alignment - offset
*
*/
}
/* "View.MemoryView":309
* aligned_p += alignment - offset
*
* return <void *> aligned_p # <<<<<<<<<<<<<<
*
*
*/
__pyx_r = ((void *)__pyx_v_aligned_p);
goto __pyx_L0;
/* "View.MemoryView":298
*
* @cname('__pyx_align_pointer')
* cdef void *align_pointer(void *memory, size_t alignment) nogil: # <<<<<<<<<<<<<<
* "Align pointer memory on a given boundary"
* cdef Py_intptr_t aligned_p = <Py_intptr_t> memory
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_WriteUnraisable("View.MemoryView.align_pointer", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 1);
__pyx_r = 0;
__pyx_L0:;
__Pyx_TraceReturn(Py_None, 1);
return __pyx_r;
}
/* "View.MemoryView":345
* cdef __Pyx_TypeInfo *typeinfo
*
* def __cinit__(memoryview self, object obj, int flags, bint dtype_is_object=False): # <<<<<<<<<<<<<<
* self.obj = obj
* self.flags = flags
*/
/* Python wrapper */
static int __pyx_memoryview___cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static int __pyx_memoryview___cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
PyObject *__pyx_v_obj = 0;
int __pyx_v_flags;
int __pyx_v_dtype_is_object;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
int __pyx_r;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0);
{
static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_obj,&__pyx_n_s_flags,&__pyx_n_s_dtype_is_object,0};
PyObject* values[3] = {0,0,0};
if (unlikely(__pyx_kwds)) {
Py_ssize_t kw_args;
const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
switch (pos_args) {
case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
CYTHON_FALLTHROUGH;
case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
CYTHON_FALLTHROUGH;
case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
CYTHON_FALLTHROUGH;
case 0: break;
default: goto __pyx_L5_argtuple_error;
}
kw_args = PyDict_Size(__pyx_kwds);
switch (pos_args) {
case 0:
if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_obj)) != 0)) kw_args--;
else goto __pyx_L5_argtuple_error;
CYTHON_FALLTHROUGH;
case 1:
if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_flags)) != 0)) kw_args--;
else {
__Pyx_RaiseArgtupleInvalid("__cinit__", 0, 2, 3, 1); __PYX_ERR(1, 345, __pyx_L3_error)
}
CYTHON_FALLTHROUGH;
case 2:
if (kw_args > 0) {
PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_dtype_is_object);
if (value) { values[2] = value; kw_args--; }
}
}
if (unlikely(kw_args > 0)) {
if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__cinit__") < 0)) __PYX_ERR(1, 345, __pyx_L3_error)
}
} else {
switch (PyTuple_GET_SIZE(__pyx_args)) {
case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
CYTHON_FALLTHROUGH;
case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
break;
default: goto __pyx_L5_argtuple_error;
}
}
__pyx_v_obj = values[0];
__pyx_v_flags = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_flags == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 345, __pyx_L3_error)
if (values[2]) {
__pyx_v_dtype_is_object = __Pyx_PyObject_IsTrue(values[2]); if (unlikely((__pyx_v_dtype_is_object == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 345, __pyx_L3_error)
} else {
__pyx_v_dtype_is_object = ((int)0);
}
}
goto __pyx_L4_argument_unpacking_done;
__pyx_L5_argtuple_error:;
__Pyx_RaiseArgtupleInvalid("__cinit__", 0, 2, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 345, __pyx_L3_error)
__pyx_L3_error:;
__Pyx_AddTraceback("View.MemoryView.memoryview.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
__Pyx_RefNannyFinishContext();
return -1;
__pyx_L4_argument_unpacking_done:;
__pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview___cinit__(((struct __pyx_memoryview_obj *)__pyx_v_self), __pyx_v_obj, __pyx_v_flags, __pyx_v_dtype_is_object);
/* function exit code */
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview___cinit__(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_obj, int __pyx_v_flags, int __pyx_v_dtype_is_object) {
int __pyx_r;
__Pyx_TraceDeclarations
__Pyx_RefNannyDeclarations
int __pyx_t_1;
int __pyx_t_2;
int __pyx_t_3;
int __pyx_t_4;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("__cinit__", 0);
__Pyx_TraceCall("__cinit__", __pyx_f[1], 345, 0, __PYX_ERR(1, 345, __pyx_L1_error));
/* "View.MemoryView":346
*
* def __cinit__(memoryview self, object obj, int flags, bint dtype_is_object=False):
* self.obj = obj # <<<<<<<<<<<<<<
* self.flags = flags
* if type(self) is memoryview or obj is not None:
*/
__Pyx_INCREF(__pyx_v_obj);
__Pyx_GIVEREF(__pyx_v_obj);
__Pyx_GOTREF(__pyx_v_self->obj);
__Pyx_DECREF(__pyx_v_self->obj);
__pyx_v_self->obj = __pyx_v_obj;
/* "View.MemoryView":347
* def __cinit__(memoryview self, object obj, int flags, bint dtype_is_object=False):
* self.obj = obj
* self.flags = flags # <<<<<<<<<<<<<<
* if type(self) is memoryview or obj is not None:
* __Pyx_GetBuffer(obj, &self.view, flags)
*/
__pyx_v_self->flags = __pyx_v_flags;
/* "View.MemoryView":348
* self.obj = obj
* self.flags = flags
* if type(self) is memoryview or obj is not None: # <<<<<<<<<<<<<<
* __Pyx_GetBuffer(obj, &self.view, flags)
* if <PyObject *> self.view.obj == NULL:
*/
__pyx_t_2 = (((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))) == ((PyObject *)__pyx_memoryview_type));
__pyx_t_3 = (__pyx_t_2 != 0);
if (!__pyx_t_3) {
} else {
__pyx_t_1 = __pyx_t_3;
goto __pyx_L4_bool_binop_done;
}
__pyx_t_3 = (__pyx_v_obj != Py_None);
__pyx_t_2 = (__pyx_t_3 != 0);
__pyx_t_1 = __pyx_t_2;
__pyx_L4_bool_binop_done:;
if (__pyx_t_1) {
/* "View.MemoryView":349
* self.flags = flags
* if type(self) is memoryview or obj is not None:
* __Pyx_GetBuffer(obj, &self.view, flags) # <<<<<<<<<<<<<<
* if <PyObject *> self.view.obj == NULL:
* (<__pyx_buffer *> &self.view).obj = Py_None
*/
__pyx_t_4 = __Pyx_GetBuffer(__pyx_v_obj, (&__pyx_v_self->view), __pyx_v_flags); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(1, 349, __pyx_L1_error)
/* "View.MemoryView":350
* if type(self) is memoryview or obj is not None:
* __Pyx_GetBuffer(obj, &self.view, flags)
* if <PyObject *> self.view.obj == NULL: # <<<<<<<<<<<<<<
* (<__pyx_buffer *> &self.view).obj = Py_None
* Py_INCREF(Py_None)
*/
__pyx_t_1 = ((((PyObject *)__pyx_v_self->view.obj) == NULL) != 0);
if (__pyx_t_1) {
/* "View.MemoryView":351
* __Pyx_GetBuffer(obj, &self.view, flags)
* if <PyObject *> self.view.obj == NULL:
* (<__pyx_buffer *> &self.view).obj = Py_None # <<<<<<<<<<<<<<
* Py_INCREF(Py_None)
*
*/
((Py_buffer *)(&__pyx_v_self->view))->obj = Py_None;
/* "View.MemoryView":352
* if <PyObject *> self.view.obj == NULL:
* (<__pyx_buffer *> &self.view).obj = Py_None
* Py_INCREF(Py_None) # <<<<<<<<<<<<<<
*
* global __pyx_memoryview_thread_locks_used
*/
Py_INCREF(Py_None);
/* "View.MemoryView":350
* if type(self) is memoryview or obj is not None:
* __Pyx_GetBuffer(obj, &self.view, flags)
* if <PyObject *> self.view.obj == NULL: # <<<<<<<<<<<<<<
* (<__pyx_buffer *> &self.view).obj = Py_None
* Py_INCREF(Py_None)
*/
}
/* "View.MemoryView":348
* self.obj = obj
* self.flags = flags
* if type(self) is memoryview or obj is not None: # <<<<<<<<<<<<<<
* __Pyx_GetBuffer(obj, &self.view, flags)
* if <PyObject *> self.view.obj == NULL:
*/
}
/* "View.MemoryView":355
*
* global __pyx_memoryview_thread_locks_used
* if __pyx_memoryview_thread_locks_used < THREAD_LOCKS_PREALLOCATED: # <<<<<<<<<<<<<<
* self.lock = __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used]
* __pyx_memoryview_thread_locks_used += 1
*/
__pyx_t_1 = ((__pyx_memoryview_thread_locks_used < 8) != 0);
if (__pyx_t_1) {
/* "View.MemoryView":356
* global __pyx_memoryview_thread_locks_used
* if __pyx_memoryview_thread_locks_used < THREAD_LOCKS_PREALLOCATED:
* self.lock = __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] # <<<<<<<<<<<<<<
* __pyx_memoryview_thread_locks_used += 1
* if self.lock is NULL:
*/
__pyx_v_self->lock = (__pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used]);
/* "View.MemoryView":357
* if __pyx_memoryview_thread_locks_used < THREAD_LOCKS_PREALLOCATED:
* self.lock = __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used]
* __pyx_memoryview_thread_locks_used += 1 # <<<<<<<<<<<<<<
* if self.lock is NULL:
* self.lock = PyThread_allocate_lock()
*/
__pyx_memoryview_thread_locks_used = (__pyx_memoryview_thread_locks_used + 1);
/* "View.MemoryView":355
*
* global __pyx_memoryview_thread_locks_used
* if __pyx_memoryview_thread_locks_used < THREAD_LOCKS_PREALLOCATED: # <<<<<<<<<<<<<<
* self.lock = __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used]
* __pyx_memoryview_thread_locks_used += 1
*/
}
/* "View.MemoryView":358
* self.lock = __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used]
* __pyx_memoryview_thread_locks_used += 1
* if self.lock is NULL: # <<<<<<<<<<<<<<
* self.lock = PyThread_allocate_lock()
* if self.lock is NULL:
*/
__pyx_t_1 = ((__pyx_v_self->lock == NULL) != 0);
if (__pyx_t_1) {
/* "View.MemoryView":359
* __pyx_memoryview_thread_locks_used += 1
* if self.lock is NULL:
* self.lock = PyThread_allocate_lock() # <<<<<<<<<<<<<<
* if self.lock is NULL:
* raise MemoryError
*/
__pyx_v_self->lock = PyThread_allocate_lock();
/* "View.MemoryView":360
* if self.lock is NULL:
* self.lock = PyThread_allocate_lock()
* if self.lock is NULL: # <<<<<<<<<<<<<<
* raise MemoryError
*
*/
__pyx_t_1 = ((__pyx_v_self->lock == NULL) != 0);
if (unlikely(__pyx_t_1)) {
/* "View.MemoryView":361
* self.lock = PyThread_allocate_lock()
* if self.lock is NULL:
* raise MemoryError # <<<<<<<<<<<<<<
*
* if flags & PyBUF_FORMAT:
*/
PyErr_NoMemory(); __PYX_ERR(1, 361, __pyx_L1_error)
/* "View.MemoryView":360
* if self.lock is NULL:
* self.lock = PyThread_allocate_lock()
* if self.lock is NULL: # <<<<<<<<<<<<<<
* raise MemoryError
*
*/
}
/* "View.MemoryView":358
* self.lock = __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used]
* __pyx_memoryview_thread_locks_used += 1
* if self.lock is NULL: # <<<<<<<<<<<<<<
* self.lock = PyThread_allocate_lock()
* if self.lock is NULL:
*/
}
/* "View.MemoryView":363
* raise MemoryError
*
* if flags & PyBUF_FORMAT: # <<<<<<<<<<<<<<
* self.dtype_is_object = (self.view.format[0] == b'O' and self.view.format[1] == b'\0')
* else:
*/
__pyx_t_1 = ((__pyx_v_flags & PyBUF_FORMAT) != 0);
if (__pyx_t_1) {
/* "View.MemoryView":364
*
* if flags & PyBUF_FORMAT:
* self.dtype_is_object = (self.view.format[0] == b'O' and self.view.format[1] == b'\0') # <<<<<<<<<<<<<<
* else:
* self.dtype_is_object = dtype_is_object
*/
__pyx_t_2 = (((__pyx_v_self->view.format[0]) == 'O') != 0);
if (__pyx_t_2) {
} else {
__pyx_t_1 = __pyx_t_2;
goto __pyx_L11_bool_binop_done;
}
__pyx_t_2 = (((__pyx_v_self->view.format[1]) == '\x00') != 0);
__pyx_t_1 = __pyx_t_2;
__pyx_L11_bool_binop_done:;
__pyx_v_self->dtype_is_object = __pyx_t_1;
/* "View.MemoryView":363
* raise MemoryError
*
* if flags & PyBUF_FORMAT: # <<<<<<<<<<<<<<
* self.dtype_is_object = (self.view.format[0] == b'O' and self.view.format[1] == b'\0')
* else:
*/
goto __pyx_L10;
}
/* "View.MemoryView":366
* self.dtype_is_object = (self.view.format[0] == b'O' and self.view.format[1] == b'\0')
* else:
* self.dtype_is_object = dtype_is_object # <<<<<<<<<<<<<<
*
* self.acquisition_count_aligned_p = <__pyx_atomic_int *> align_pointer(
*/
/*else*/ {
__pyx_v_self->dtype_is_object = __pyx_v_dtype_is_object;
}
__pyx_L10:;
/* "View.MemoryView":368
* self.dtype_is_object = dtype_is_object
*
* self.acquisition_count_aligned_p = <__pyx_atomic_int *> align_pointer( # <<<<<<<<<<<<<<
* <void *> &self.acquisition_count[0], sizeof(__pyx_atomic_int))
* self.typeinfo = NULL
*/
__pyx_v_self->acquisition_count_aligned_p = ((__pyx_atomic_int *)__pyx_align_pointer(((void *)(&(__pyx_v_self->acquisition_count[0]))), (sizeof(__pyx_atomic_int))));
/* "View.MemoryView":370
* self.acquisition_count_aligned_p = <__pyx_atomic_int *> align_pointer(
* <void *> &self.acquisition_count[0], sizeof(__pyx_atomic_int))
* self.typeinfo = NULL # <<<<<<<<<<<<<<
*
* def __dealloc__(memoryview self):
*/
__pyx_v_self->typeinfo = NULL;
/* "View.MemoryView":345
* cdef __Pyx_TypeInfo *typeinfo
*
* def __cinit__(memoryview self, object obj, int flags, bint dtype_is_object=False): # <<<<<<<<<<<<<<
* self.obj = obj
* self.flags = flags
*/
/* function exit code */
__pyx_r = 0;
goto __pyx_L0;
__pyx_L1_error:;
__Pyx_AddTraceback("View.MemoryView.memoryview.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = -1;
__pyx_L0:;
__Pyx_TraceReturn(Py_None, 0);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "View.MemoryView":372
* self.typeinfo = NULL
*
* def __dealloc__(memoryview self): # <<<<<<<<<<<<<<
* if self.obj is not None:
* __Pyx_ReleaseBuffer(&self.view)
*/
/* Python wrapper */
static void __pyx_memoryview___dealloc__(PyObject *__pyx_v_self); /*proto*/
static void __pyx_memoryview___dealloc__(PyObject *__pyx_v_self) {
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0);
__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_2__dealloc__(((struct __pyx_memoryview_obj *)__pyx_v_self));
/* function exit code */
__Pyx_RefNannyFinishContext();
}
static void __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_2__dealloc__(struct __pyx_memoryview_obj *__pyx_v_self) {
int __pyx_v_i;
__Pyx_TraceDeclarations
__Pyx_RefNannyDeclarations
int __pyx_t_1;
int __pyx_t_2;
int __pyx_t_3;
int __pyx_t_4;
int __pyx_t_5;
PyThread_type_lock __pyx_t_6;
PyThread_type_lock __pyx_t_7;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("__dealloc__", 0);
__Pyx_TraceCall("__dealloc__", __pyx_f[1], 372, 0, __PYX_ERR(1, 372, __pyx_L1_error));
/* "View.MemoryView":373
*
* def __dealloc__(memoryview self):
* if self.obj is not None: # <<<<<<<<<<<<<<
* __Pyx_ReleaseBuffer(&self.view)
* elif (<__pyx_buffer *> &self.view).obj == Py_None:
*/
__pyx_t_1 = (__pyx_v_self->obj != Py_None);
__pyx_t_2 = (__pyx_t_1 != 0);
if (__pyx_t_2) {
/* "View.MemoryView":374
* def __dealloc__(memoryview self):
* if self.obj is not None:
* __Pyx_ReleaseBuffer(&self.view) # <<<<<<<<<<<<<<
* elif (<__pyx_buffer *> &self.view).obj == Py_None:
*
*/
__Pyx_ReleaseBuffer((&__pyx_v_self->view));
/* "View.MemoryView":373
*
* def __dealloc__(memoryview self):
* if self.obj is not None: # <<<<<<<<<<<<<<
* __Pyx_ReleaseBuffer(&self.view)
* elif (<__pyx_buffer *> &self.view).obj == Py_None:
*/
goto __pyx_L3;
}
/* "View.MemoryView":375
* if self.obj is not None:
* __Pyx_ReleaseBuffer(&self.view)
* elif (<__pyx_buffer *> &self.view).obj == Py_None: # <<<<<<<<<<<<<<
*
* (<__pyx_buffer *> &self.view).obj = NULL
*/
__pyx_t_2 = ((((Py_buffer *)(&__pyx_v_self->view))->obj == Py_None) != 0);
if (__pyx_t_2) {
/* "View.MemoryView":377
* elif (<__pyx_buffer *> &self.view).obj == Py_None:
*
* (<__pyx_buffer *> &self.view).obj = NULL # <<<<<<<<<<<<<<
* Py_DECREF(Py_None)
*
*/
((Py_buffer *)(&__pyx_v_self->view))->obj = NULL;
/* "View.MemoryView":378
*
* (<__pyx_buffer *> &self.view).obj = NULL
* Py_DECREF(Py_None) # <<<<<<<<<<<<<<
*
* cdef int i
*/
Py_DECREF(Py_None);
/* "View.MemoryView":375
* if self.obj is not None:
* __Pyx_ReleaseBuffer(&self.view)
* elif (<__pyx_buffer *> &self.view).obj == Py_None: # <<<<<<<<<<<<<<
*
* (<__pyx_buffer *> &self.view).obj = NULL
*/
}
__pyx_L3:;
/* "View.MemoryView":382
* cdef int i
* global __pyx_memoryview_thread_locks_used
* if self.lock != NULL: # <<<<<<<<<<<<<<
* for i in range(__pyx_memoryview_thread_locks_used):
* if __pyx_memoryview_thread_locks[i] is self.lock:
*/
__pyx_t_2 = ((__pyx_v_self->lock != NULL) != 0);
if (__pyx_t_2) {
/* "View.MemoryView":383
* global __pyx_memoryview_thread_locks_used
* if self.lock != NULL:
* for i in range(__pyx_memoryview_thread_locks_used): # <<<<<<<<<<<<<<
* if __pyx_memoryview_thread_locks[i] is self.lock:
* __pyx_memoryview_thread_locks_used -= 1
*/
__pyx_t_3 = __pyx_memoryview_thread_locks_used;
__pyx_t_4 = __pyx_t_3;
for (__pyx_t_5 = 0; __pyx_t_5 < __pyx_t_4; __pyx_t_5+=1) {
__pyx_v_i = __pyx_t_5;
/* "View.MemoryView":384
* if self.lock != NULL:
* for i in range(__pyx_memoryview_thread_locks_used):
* if __pyx_memoryview_thread_locks[i] is self.lock: # <<<<<<<<<<<<<<
* __pyx_memoryview_thread_locks_used -= 1
* if i != __pyx_memoryview_thread_locks_used:
*/
__pyx_t_2 = (((__pyx_memoryview_thread_locks[__pyx_v_i]) == __pyx_v_self->lock) != 0);
if (__pyx_t_2) {
/* "View.MemoryView":385
* for i in range(__pyx_memoryview_thread_locks_used):
* if __pyx_memoryview_thread_locks[i] is self.lock:
* __pyx_memoryview_thread_locks_used -= 1 # <<<<<<<<<<<<<<
* if i != __pyx_memoryview_thread_locks_used:
* __pyx_memoryview_thread_locks[i], __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] = (
*/
__pyx_memoryview_thread_locks_used = (__pyx_memoryview_thread_locks_used - 1);
/* "View.MemoryView":386
* if __pyx_memoryview_thread_locks[i] is self.lock:
* __pyx_memoryview_thread_locks_used -= 1
* if i != __pyx_memoryview_thread_locks_used: # <<<<<<<<<<<<<<
* __pyx_memoryview_thread_locks[i], __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] = (
* __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used], __pyx_memoryview_thread_locks[i])
*/
__pyx_t_2 = ((__pyx_v_i != __pyx_memoryview_thread_locks_used) != 0);
if (__pyx_t_2) {
/* "View.MemoryView":388
* if i != __pyx_memoryview_thread_locks_used:
* __pyx_memoryview_thread_locks[i], __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] = (
* __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used], __pyx_memoryview_thread_locks[i]) # <<<<<<<<<<<<<<
* break
* else:
*/
__pyx_t_6 = (__pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used]);
__pyx_t_7 = (__pyx_memoryview_thread_locks[__pyx_v_i]);
/* "View.MemoryView":387
* __pyx_memoryview_thread_locks_used -= 1
* if i != __pyx_memoryview_thread_locks_used:
* __pyx_memoryview_thread_locks[i], __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] = ( # <<<<<<<<<<<<<<
* __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used], __pyx_memoryview_thread_locks[i])
* break
*/
(__pyx_memoryview_thread_locks[__pyx_v_i]) = __pyx_t_6;
(__pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used]) = __pyx_t_7;
/* "View.MemoryView":386
* if __pyx_memoryview_thread_locks[i] is self.lock:
* __pyx_memoryview_thread_locks_used -= 1
* if i != __pyx_memoryview_thread_locks_used: # <<<<<<<<<<<<<<
* __pyx_memoryview_thread_locks[i], __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] = (
* __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used], __pyx_memoryview_thread_locks[i])
*/
}
/* "View.MemoryView":389
* __pyx_memoryview_thread_locks[i], __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] = (
* __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used], __pyx_memoryview_thread_locks[i])
* break # <<<<<<<<<<<<<<
* else:
* PyThread_free_lock(self.lock)
*/
goto __pyx_L6_break;
/* "View.MemoryView":384
* if self.lock != NULL:
* for i in range(__pyx_memoryview_thread_locks_used):
* if __pyx_memoryview_thread_locks[i] is self.lock: # <<<<<<<<<<<<<<
* __pyx_memoryview_thread_locks_used -= 1
* if i != __pyx_memoryview_thread_locks_used:
*/
}
}
/*else*/ {
/* "View.MemoryView":391
* break
* else:
* PyThread_free_lock(self.lock) # <<<<<<<<<<<<<<
*
* cdef char *get_item_pointer(memoryview self, object index) except NULL:
*/
PyThread_free_lock(__pyx_v_self->lock);
}
__pyx_L6_break:;
/* "View.MemoryView":382
* cdef int i
* global __pyx_memoryview_thread_locks_used
* if self.lock != NULL: # <<<<<<<<<<<<<<
* for i in range(__pyx_memoryview_thread_locks_used):
* if __pyx_memoryview_thread_locks[i] is self.lock:
*/
}
/* "View.MemoryView":372
* self.typeinfo = NULL
*
* def __dealloc__(memoryview self): # <<<<<<<<<<<<<<
* if self.obj is not None:
* __Pyx_ReleaseBuffer(&self.view)
*/
/* function exit code */
goto __pyx_L0;
__pyx_L1_error:;
__Pyx_WriteUnraisable("View.MemoryView.memoryview.__dealloc__", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0);
__pyx_L0:;
__Pyx_TraceReturn(Py_None, 0);
__Pyx_RefNannyFinishContext();
}
/* "View.MemoryView":393
* PyThread_free_lock(self.lock)
*
* cdef char *get_item_pointer(memoryview self, object index) except NULL: # <<<<<<<<<<<<<<
* cdef Py_ssize_t dim
* cdef char *itemp = <char *> self.view.buf
*/
static char *__pyx_memoryview_get_item_pointer(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_index) {
Py_ssize_t __pyx_v_dim;
char *__pyx_v_itemp;
PyObject *__pyx_v_idx = NULL;
char *__pyx_r;
__Pyx_TraceDeclarations
__Pyx_RefNannyDeclarations
Py_ssize_t __pyx_t_1;
PyObject *__pyx_t_2 = NULL;
Py_ssize_t __pyx_t_3;
PyObject *(*__pyx_t_4)(PyObject *);
PyObject *__pyx_t_5 = NULL;
Py_ssize_t __pyx_t_6;
char *__pyx_t_7;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("get_item_pointer", 0);
__Pyx_TraceCall("get_item_pointer", __pyx_f[1], 393, 0, __PYX_ERR(1, 393, __pyx_L1_error));
/* "View.MemoryView":395
* cdef char *get_item_pointer(memoryview self, object index) except NULL:
* cdef Py_ssize_t dim
* cdef char *itemp = <char *> self.view.buf # <<<<<<<<<<<<<<
*
* for dim, idx in enumerate(index):
*/
__pyx_v_itemp = ((char *)__pyx_v_self->view.buf);
/* "View.MemoryView":397
* cdef char *itemp = <char *> self.view.buf
*
* for dim, idx in enumerate(index): # <<<<<<<<<<<<<<
* itemp = pybuffer_index(&self.view, itemp, idx, dim)
*
*/
__pyx_t_1 = 0;
if (likely(PyList_CheckExact(__pyx_v_index)) || PyTuple_CheckExact(__pyx_v_index)) {
__pyx_t_2 = __pyx_v_index; __Pyx_INCREF(__pyx_t_2); __pyx_t_3 = 0;
__pyx_t_4 = NULL;
} else {
__pyx_t_3 = -1; __pyx_t_2 = PyObject_GetIter(__pyx_v_index); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 397, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__pyx_t_4 = Py_TYPE(__pyx_t_2)->tp_iternext; if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 397, __pyx_L1_error)
}
for (;;) {
if (likely(!__pyx_t_4)) {
if (likely(PyList_CheckExact(__pyx_t_2))) {
if (__pyx_t_3 >= PyList_GET_SIZE(__pyx_t_2)) break;
#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
__pyx_t_5 = PyList_GET_ITEM(__pyx_t_2, __pyx_t_3); __Pyx_INCREF(__pyx_t_5); __pyx_t_3++; if (unlikely(0 < 0)) __PYX_ERR(1, 397, __pyx_L1_error)
#else
__pyx_t_5 = PySequence_ITEM(__pyx_t_2, __pyx_t_3); __pyx_t_3++; if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 397, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
#endif
} else {
if (__pyx_t_3 >= PyTuple_GET_SIZE(__pyx_t_2)) break;
#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
__pyx_t_5 = PyTuple_GET_ITEM(__pyx_t_2, __pyx_t_3); __Pyx_INCREF(__pyx_t_5); __pyx_t_3++; if (unlikely(0 < 0)) __PYX_ERR(1, 397, __pyx_L1_error)
#else
__pyx_t_5 = PySequence_ITEM(__pyx_t_2, __pyx_t_3); __pyx_t_3++; if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 397, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
#endif
}
} else {
__pyx_t_5 = __pyx_t_4(__pyx_t_2);
if (unlikely(!__pyx_t_5)) {
PyObject* exc_type = PyErr_Occurred();
if (exc_type) {
if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
else __PYX_ERR(1, 397, __pyx_L1_error)
}
break;
}
__Pyx_GOTREF(__pyx_t_5);
}
__Pyx_XDECREF_SET(__pyx_v_idx, __pyx_t_5);
__pyx_t_5 = 0;
__pyx_v_dim = __pyx_t_1;
__pyx_t_1 = (__pyx_t_1 + 1);
/* "View.MemoryView":398
*
* for dim, idx in enumerate(index):
* itemp = pybuffer_index(&self.view, itemp, idx, dim) # <<<<<<<<<<<<<<
*
* return itemp
*/
__pyx_t_6 = __Pyx_PyIndex_AsSsize_t(__pyx_v_idx); if (unlikely((__pyx_t_6 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(1, 398, __pyx_L1_error)
__pyx_t_7 = __pyx_pybuffer_index((&__pyx_v_self->view), __pyx_v_itemp, __pyx_t_6, __pyx_v_dim); if (unlikely(__pyx_t_7 == ((char *)NULL))) __PYX_ERR(1, 398, __pyx_L1_error)
__pyx_v_itemp = __pyx_t_7;
/* "View.MemoryView":397
* cdef char *itemp = <char *> self.view.buf
*
* for dim, idx in enumerate(index): # <<<<<<<<<<<<<<
* itemp = pybuffer_index(&self.view, itemp, idx, dim)
*
*/
}
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
/* "View.MemoryView":400
* itemp = pybuffer_index(&self.view, itemp, idx, dim)
*
* return itemp # <<<<<<<<<<<<<<
*
*
*/
__pyx_r = __pyx_v_itemp;
goto __pyx_L0;
/* "View.MemoryView":393
* PyThread_free_lock(self.lock)
*
* cdef char *get_item_pointer(memoryview self, object index) except NULL: # <<<<<<<<<<<<<<
* cdef Py_ssize_t dim
* cdef char *itemp = <char *> self.view.buf
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_2);
__Pyx_XDECREF(__pyx_t_5);
__Pyx_AddTraceback("View.MemoryView.memoryview.get_item_pointer", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = NULL;
__pyx_L0:;
__Pyx_XDECREF(__pyx_v_idx);
__Pyx_TraceReturn(Py_None, 0);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "View.MemoryView":403
*
*
* def __getitem__(memoryview self, object index): # <<<<<<<<<<<<<<
* if index is Ellipsis:
* return self
*/
/* Python wrapper */
static PyObject *__pyx_memoryview___getitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_index); /*proto*/
static PyObject *__pyx_memoryview___getitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_index) {
PyObject *__pyx_r = 0;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("__getitem__ (wrapper)", 0);
__pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_4__getitem__(((struct __pyx_memoryview_obj *)__pyx_v_self), ((PyObject *)__pyx_v_index));
/* function exit code */
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_4__getitem__(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_index) {
PyObject *__pyx_v_have_slices = NULL;
PyObject *__pyx_v_indices = NULL;
char *__pyx_v_itemp;
PyObject *__pyx_r = NULL;
__Pyx_TraceDeclarations
__Pyx_RefNannyDeclarations
int __pyx_t_1;
int __pyx_t_2;
PyObject *__pyx_t_3 = NULL;
PyObject *__pyx_t_4 = NULL;
PyObject *__pyx_t_5 = NULL;
char *__pyx_t_6;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("__getitem__", 0);
__Pyx_TraceCall("__getitem__", __pyx_f[1], 403, 0, __PYX_ERR(1, 403, __pyx_L1_error));
/* "View.MemoryView":404
*
* def __getitem__(memoryview self, object index):
* if index is Ellipsis: # <<<<<<<<<<<<<<
* return self
*
*/
__pyx_t_1 = (__pyx_v_index == __pyx_builtin_Ellipsis);
__pyx_t_2 = (__pyx_t_1 != 0);
if (__pyx_t_2) {
/* "View.MemoryView":405
* def __getitem__(memoryview self, object index):
* if index is Ellipsis:
* return self # <<<<<<<<<<<<<<
*
* have_slices, indices = _unellipsify(index, self.view.ndim)
*/
__Pyx_XDECREF(__pyx_r);
__Pyx_INCREF(((PyObject *)__pyx_v_self));
__pyx_r = ((PyObject *)__pyx_v_self);
goto __pyx_L0;
/* "View.MemoryView":404
*
* def __getitem__(memoryview self, object index):
* if index is Ellipsis: # <<<<<<<<<<<<<<
* return self
*
*/
}
/* "View.MemoryView":407
* return self
*
* have_slices, indices = _unellipsify(index, self.view.ndim) # <<<<<<<<<<<<<<
*
* cdef char *itemp
*/
__pyx_t_3 = _unellipsify(__pyx_v_index, __pyx_v_self->view.ndim); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 407, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
if (likely(__pyx_t_3 != Py_None)) {
PyObject* sequence = __pyx_t_3;
Py_ssize_t size = __Pyx_PySequence_SIZE(sequence);
if (unlikely(size != 2)) {
if (size > 2) __Pyx_RaiseTooManyValuesError(2);
else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
__PYX_ERR(1, 407, __pyx_L1_error)
}
#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
__pyx_t_4 = PyTuple_GET_ITEM(sequence, 0);
__pyx_t_5 = PyTuple_GET_ITEM(sequence, 1);
__Pyx_INCREF(__pyx_t_4);
__Pyx_INCREF(__pyx_t_5);
#else
__pyx_t_4 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 407, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__pyx_t_5 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 407, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
#endif
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
} else {
__Pyx_RaiseNoneNotIterableError(); __PYX_ERR(1, 407, __pyx_L1_error)
}
__pyx_v_have_slices = __pyx_t_4;
__pyx_t_4 = 0;
__pyx_v_indices = __pyx_t_5;
__pyx_t_5 = 0;
/* "View.MemoryView":410
*
* cdef char *itemp
* if have_slices: # <<<<<<<<<<<<<<
* return memview_slice(self, indices)
* else:
*/
__pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_v_have_slices); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(1, 410, __pyx_L1_error)
if (__pyx_t_2) {
/* "View.MemoryView":411
* cdef char *itemp
* if have_slices:
* return memview_slice(self, indices) # <<<<<<<<<<<<<<
* else:
* itemp = self.get_item_pointer(indices)
*/
__Pyx_XDECREF(__pyx_r);
__pyx_t_3 = ((PyObject *)__pyx_memview_slice(__pyx_v_self, __pyx_v_indices)); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 411, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__pyx_r = __pyx_t_3;
__pyx_t_3 = 0;
goto __pyx_L0;
/* "View.MemoryView":410
*
* cdef char *itemp
* if have_slices: # <<<<<<<<<<<<<<
* return memview_slice(self, indices)
* else:
*/
}
/* "View.MemoryView":413
* return memview_slice(self, indices)
* else:
* itemp = self.get_item_pointer(indices) # <<<<<<<<<<<<<<
* return self.convert_item_to_object(itemp)
*
*/
/*else*/ {
__pyx_t_6 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->get_item_pointer(__pyx_v_self, __pyx_v_indices); if (unlikely(__pyx_t_6 == ((char *)NULL))) __PYX_ERR(1, 413, __pyx_L1_error)
__pyx_v_itemp = __pyx_t_6;
/* "View.MemoryView":414
* else:
* itemp = self.get_item_pointer(indices)
* return self.convert_item_to_object(itemp) # <<<<<<<<<<<<<<
*
* def __setitem__(memoryview self, object index, object value):
*/
__Pyx_XDECREF(__pyx_r);
__pyx_t_3 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->convert_item_to_object(__pyx_v_self, __pyx_v_itemp); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 414, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__pyx_r = __pyx_t_3;
__pyx_t_3 = 0;
goto __pyx_L0;
}
/* "View.MemoryView":403
*
*
* def __getitem__(memoryview self, object index): # <<<<<<<<<<<<<<
* if index is Ellipsis:
* return self
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_3);
__Pyx_XDECREF(__pyx_t_4);
__Pyx_XDECREF(__pyx_t_5);
__Pyx_AddTraceback("View.MemoryView.memoryview.__getitem__", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = NULL;
__pyx_L0:;
__Pyx_XDECREF(__pyx_v_have_slices);
__Pyx_XDECREF(__pyx_v_indices);
__Pyx_XGIVEREF(__pyx_r);
__Pyx_TraceReturn(__pyx_r, 0);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "View.MemoryView":416
* return self.convert_item_to_object(itemp)
*
* def __setitem__(memoryview self, object index, object value): # <<<<<<<<<<<<<<
* if self.view.readonly:
* raise TypeError("Cannot assign to read-only memoryview")
*/
/* Python wrapper */
static int __pyx_memoryview___setitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_index, PyObject *__pyx_v_value); /*proto*/
static int __pyx_memoryview___setitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_index, PyObject *__pyx_v_value) {
int __pyx_r;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("__setitem__ (wrapper)", 0);
__pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_6__setitem__(((struct __pyx_memoryview_obj *)__pyx_v_self), ((PyObject *)__pyx_v_index), ((PyObject *)__pyx_v_value));
/* function exit code */
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_6__setitem__(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_index, PyObject *__pyx_v_value) {
PyObject *__pyx_v_have_slices = NULL;
PyObject *__pyx_v_obj = NULL;
int __pyx_r;
__Pyx_TraceDeclarations
__Pyx_RefNannyDeclarations
int __pyx_t_1;
PyObject *__pyx_t_2 = NULL;
PyObject *__pyx_t_3 = NULL;
PyObject *__pyx_t_4 = NULL;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("__setitem__", 0);
__Pyx_TraceCall("__setitem__", __pyx_f[1], 416, 0, __PYX_ERR(1, 416, __pyx_L1_error));
__Pyx_INCREF(__pyx_v_index);
/* "View.MemoryView":417
*
* def __setitem__(memoryview self, object index, object value):
* if self.view.readonly: # <<<<<<<<<<<<<<
* raise TypeError("Cannot assign to read-only memoryview")
*
*/
__pyx_t_1 = (__pyx_v_self->view.readonly != 0);
if (unlikely(__pyx_t_1)) {
/* "View.MemoryView":418
* def __setitem__(memoryview self, object index, object value):
* if self.view.readonly:
* raise TypeError("Cannot assign to read-only memoryview") # <<<<<<<<<<<<<<
*
* have_slices, index = _unellipsify(index, self.view.ndim)
*/
__pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__26, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 418, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_Raise(__pyx_t_2, 0, 0, 0);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__PYX_ERR(1, 418, __pyx_L1_error)
/* "View.MemoryView":417
*
* def __setitem__(memoryview self, object index, object value):
* if self.view.readonly: # <<<<<<<<<<<<<<
* raise TypeError("Cannot assign to read-only memoryview")
*
*/
}
/* "View.MemoryView":420
* raise TypeError("Cannot assign to read-only memoryview")
*
* have_slices, index = _unellipsify(index, self.view.ndim) # <<<<<<<<<<<<<<
*
* if have_slices:
*/
__pyx_t_2 = _unellipsify(__pyx_v_index, __pyx_v_self->view.ndim); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 420, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
if (likely(__pyx_t_2 != Py_None)) {
PyObject* sequence = __pyx_t_2;
Py_ssize_t size = __Pyx_PySequence_SIZE(sequence);
if (unlikely(size != 2)) {
if (size > 2) __Pyx_RaiseTooManyValuesError(2);
else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
__PYX_ERR(1, 420, __pyx_L1_error)
}
#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
__pyx_t_3 = PyTuple_GET_ITEM(sequence, 0);
__pyx_t_4 = PyTuple_GET_ITEM(sequence, 1);
__Pyx_INCREF(__pyx_t_3);
__Pyx_INCREF(__pyx_t_4);
#else
__pyx_t_3 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 420, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__pyx_t_4 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 420, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
#endif
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
} else {
__Pyx_RaiseNoneNotIterableError(); __PYX_ERR(1, 420, __pyx_L1_error)
}
__pyx_v_have_slices = __pyx_t_3;
__pyx_t_3 = 0;
__Pyx_DECREF_SET(__pyx_v_index, __pyx_t_4);
__pyx_t_4 = 0;
/* "View.MemoryView":422
* have_slices, index = _unellipsify(index, self.view.ndim)
*
* if have_slices: # <<<<<<<<<<<<<<
* obj = self.is_slice(value)
* if obj:
*/
__pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_have_slices); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(1, 422, __pyx_L1_error)
if (__pyx_t_1) {
/* "View.MemoryView":423
*
* if have_slices:
* obj = self.is_slice(value) # <<<<<<<<<<<<<<
* if obj:
* self.setitem_slice_assignment(self[index], obj)
*/
__pyx_t_2 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->is_slice(__pyx_v_self, __pyx_v_value); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 423, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__pyx_v_obj = __pyx_t_2;
__pyx_t_2 = 0;
/* "View.MemoryView":424
* if have_slices:
* obj = self.is_slice(value)
* if obj: # <<<<<<<<<<<<<<
* self.setitem_slice_assignment(self[index], obj)
* else:
*/
__pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_obj); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(1, 424, __pyx_L1_error)
if (__pyx_t_1) {
/* "View.MemoryView":425
* obj = self.is_slice(value)
* if obj:
* self.setitem_slice_assignment(self[index], obj) # <<<<<<<<<<<<<<
* else:
* self.setitem_slice_assign_scalar(self[index], value)
*/
__pyx_t_2 = __Pyx_PyObject_GetItem(((PyObject *)__pyx_v_self), __pyx_v_index); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 425, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__pyx_t_4 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->setitem_slice_assignment(__pyx_v_self, __pyx_t_2, __pyx_v_obj); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 425, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
/* "View.MemoryView":424
* if have_slices:
* obj = self.is_slice(value)
* if obj: # <<<<<<<<<<<<<<
* self.setitem_slice_assignment(self[index], obj)
* else:
*/
goto __pyx_L5;
}
/* "View.MemoryView":427
* self.setitem_slice_assignment(self[index], obj)
* else:
* self.setitem_slice_assign_scalar(self[index], value) # <<<<<<<<<<<<<<
* else:
* self.setitem_indexed(index, value)
*/
/*else*/ {
__pyx_t_4 = __Pyx_PyObject_GetItem(((PyObject *)__pyx_v_self), __pyx_v_index); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 427, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
if (!(likely(((__pyx_t_4) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_4, __pyx_memoryview_type))))) __PYX_ERR(1, 427, __pyx_L1_error)
__pyx_t_2 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->setitem_slice_assign_scalar(__pyx_v_self, ((struct __pyx_memoryview_obj *)__pyx_t_4), __pyx_v_value); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 427, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
}
__pyx_L5:;
/* "View.MemoryView":422
* have_slices, index = _unellipsify(index, self.view.ndim)
*
* if have_slices: # <<<<<<<<<<<<<<
* obj = self.is_slice(value)
* if obj:
*/
goto __pyx_L4;
}
/* "View.MemoryView":429
* self.setitem_slice_assign_scalar(self[index], value)
* else:
* self.setitem_indexed(index, value) # <<<<<<<<<<<<<<
*
* cdef is_slice(self, obj):
*/
/*else*/ {
__pyx_t_2 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->setitem_indexed(__pyx_v_self, __pyx_v_index, __pyx_v_value); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 429, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
}
__pyx_L4:;
/* "View.MemoryView":416
* return self.convert_item_to_object(itemp)
*
* def __setitem__(memoryview self, object index, object value): # <<<<<<<<<<<<<<
* if self.view.readonly:
* raise TypeError("Cannot assign to read-only memoryview")
*/
/* function exit code */
__pyx_r = 0;
goto __pyx_L0;
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_2);
__Pyx_XDECREF(__pyx_t_3);
__Pyx_XDECREF(__pyx_t_4);
__Pyx_AddTraceback("View.MemoryView.memoryview.__setitem__", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = -1;
__pyx_L0:;
__Pyx_XDECREF(__pyx_v_have_slices);
__Pyx_XDECREF(__pyx_v_obj);
__Pyx_XDECREF(__pyx_v_index);
__Pyx_TraceReturn(Py_None, 0);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "View.MemoryView":431
* self.setitem_indexed(index, value)
*
* cdef is_slice(self, obj): # <<<<<<<<<<<<<<
* if not isinstance(obj, memoryview):
* try:
*/
static PyObject *__pyx_memoryview_is_slice(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_obj) {
PyObject *__pyx_r = NULL;
__Pyx_TraceDeclarations
__Pyx_RefNannyDeclarations
int __pyx_t_1;
int __pyx_t_2;
PyObject *__pyx_t_3 = NULL;
PyObject *__pyx_t_4 = NULL;
PyObject *__pyx_t_5 = NULL;
PyObject *__pyx_t_6 = NULL;
PyObject *__pyx_t_7 = NULL;
PyObject *__pyx_t_8 = NULL;
int __pyx_t_9;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("is_slice", 0);
__Pyx_TraceCall("is_slice", __pyx_f[1], 431, 0, __PYX_ERR(1, 431, __pyx_L1_error));
__Pyx_INCREF(__pyx_v_obj);
/* "View.MemoryView":432
*
* cdef is_slice(self, obj):
* if not isinstance(obj, memoryview): # <<<<<<<<<<<<<<
* try:
* obj = memoryview(obj, self.flags & ~PyBUF_WRITABLE | PyBUF_ANY_CONTIGUOUS,
*/
__pyx_t_1 = __Pyx_TypeCheck(__pyx_v_obj, __pyx_memoryview_type);
__pyx_t_2 = ((!(__pyx_t_1 != 0)) != 0);
if (__pyx_t_2) {
/* "View.MemoryView":433
* cdef is_slice(self, obj):
* if not isinstance(obj, memoryview):
* try: # <<<<<<<<<<<<<<
* obj = memoryview(obj, self.flags & ~PyBUF_WRITABLE | PyBUF_ANY_CONTIGUOUS,
* self.dtype_is_object)
*/
{
__Pyx_PyThreadState_declare
__Pyx_PyThreadState_assign
__Pyx_ExceptionSave(&__pyx_t_3, &__pyx_t_4, &__pyx_t_5);
__Pyx_XGOTREF(__pyx_t_3);
__Pyx_XGOTREF(__pyx_t_4);
__Pyx_XGOTREF(__pyx_t_5);
/*try:*/ {
/* "View.MemoryView":434
* if not isinstance(obj, memoryview):
* try:
* obj = memoryview(obj, self.flags & ~PyBUF_WRITABLE | PyBUF_ANY_CONTIGUOUS, # <<<<<<<<<<<<<<
* self.dtype_is_object)
* except TypeError:
*/
__pyx_t_6 = __Pyx_PyInt_From_int(((__pyx_v_self->flags & (~PyBUF_WRITABLE)) | PyBUF_ANY_CONTIGUOUS)); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 434, __pyx_L4_error)
__Pyx_GOTREF(__pyx_t_6);
/* "View.MemoryView":435
* try:
* obj = memoryview(obj, self.flags & ~PyBUF_WRITABLE | PyBUF_ANY_CONTIGUOUS,
* self.dtype_is_object) # <<<<<<<<<<<<<<
* except TypeError:
* return None
*/
__pyx_t_7 = __Pyx_PyBool_FromLong(__pyx_v_self->dtype_is_object); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 435, __pyx_L4_error)
__Pyx_GOTREF(__pyx_t_7);
/* "View.MemoryView":434
* if not isinstance(obj, memoryview):
* try:
* obj = memoryview(obj, self.flags & ~PyBUF_WRITABLE | PyBUF_ANY_CONTIGUOUS, # <<<<<<<<<<<<<<
* self.dtype_is_object)
* except TypeError:
*/
__pyx_t_8 = PyTuple_New(3); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 434, __pyx_L4_error)
__Pyx_GOTREF(__pyx_t_8);
__Pyx_INCREF(__pyx_v_obj);
__Pyx_GIVEREF(__pyx_v_obj);
PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_v_obj);
__Pyx_GIVEREF(__pyx_t_6);
PyTuple_SET_ITEM(__pyx_t_8, 1, __pyx_t_6);
__Pyx_GIVEREF(__pyx_t_7);
PyTuple_SET_ITEM(__pyx_t_8, 2, __pyx_t_7);
__pyx_t_6 = 0;
__pyx_t_7 = 0;
__pyx_t_7 = __Pyx_PyObject_Call(((PyObject *)__pyx_memoryview_type), __pyx_t_8, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 434, __pyx_L4_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
__Pyx_DECREF_SET(__pyx_v_obj, __pyx_t_7);
__pyx_t_7 = 0;
/* "View.MemoryView":433
* cdef is_slice(self, obj):
* if not isinstance(obj, memoryview):
* try: # <<<<<<<<<<<<<<
* obj = memoryview(obj, self.flags & ~PyBUF_WRITABLE | PyBUF_ANY_CONTIGUOUS,
* self.dtype_is_object)
*/
}
__Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
__Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
goto __pyx_L9_try_end;
__pyx_L4_error:;
__Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
__Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
/* "View.MemoryView":436
* obj = memoryview(obj, self.flags & ~PyBUF_WRITABLE | PyBUF_ANY_CONTIGUOUS,
* self.dtype_is_object)
* except TypeError: # <<<<<<<<<<<<<<
* return None
*
*/
__pyx_t_9 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_TypeError);
if (__pyx_t_9) {
__Pyx_AddTraceback("View.MemoryView.memoryview.is_slice", __pyx_clineno, __pyx_lineno, __pyx_filename);
if (__Pyx_GetException(&__pyx_t_7, &__pyx_t_8, &__pyx_t_6) < 0) __PYX_ERR(1, 436, __pyx_L6_except_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_GOTREF(__pyx_t_8);
__Pyx_GOTREF(__pyx_t_6);
/* "View.MemoryView":437
* self.dtype_is_object)
* except TypeError:
* return None # <<<<<<<<<<<<<<
*
* return obj
*/
__Pyx_XDECREF(__pyx_r);
__pyx_r = Py_None; __Pyx_INCREF(Py_None);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
__Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
goto __pyx_L7_except_return;
}
goto __pyx_L6_except_error;
__pyx_L6_except_error:;
/* "View.MemoryView":433
* cdef is_slice(self, obj):
* if not isinstance(obj, memoryview):
* try: # <<<<<<<<<<<<<<
* obj = memoryview(obj, self.flags & ~PyBUF_WRITABLE | PyBUF_ANY_CONTIGUOUS,
* self.dtype_is_object)
*/
__Pyx_XGIVEREF(__pyx_t_3);
__Pyx_XGIVEREF(__pyx_t_4);
__Pyx_XGIVEREF(__pyx_t_5);
__Pyx_ExceptionReset(__pyx_t_3, __pyx_t_4, __pyx_t_5);
goto __pyx_L1_error;
__pyx_L7_except_return:;
__Pyx_XGIVEREF(__pyx_t_3);
__Pyx_XGIVEREF(__pyx_t_4);
__Pyx_XGIVEREF(__pyx_t_5);
__Pyx_ExceptionReset(__pyx_t_3, __pyx_t_4, __pyx_t_5);
goto __pyx_L0;
__pyx_L9_try_end:;
}
/* "View.MemoryView":432
*
* cdef is_slice(self, obj):
* if not isinstance(obj, memoryview): # <<<<<<<<<<<<<<
* try:
* obj = memoryview(obj, self.flags & ~PyBUF_WRITABLE | PyBUF_ANY_CONTIGUOUS,
*/
}
/* "View.MemoryView":439
* return None
*
* return obj # <<<<<<<<<<<<<<
*
* cdef setitem_slice_assignment(self, dst, src):
*/
__Pyx_XDECREF(__pyx_r);
__Pyx_INCREF(__pyx_v_obj);
__pyx_r = __pyx_v_obj;
goto __pyx_L0;
/* "View.MemoryView":431
* self.setitem_indexed(index, value)
*
* cdef is_slice(self, obj): # <<<<<<<<<<<<<<
* if not isinstance(obj, memoryview):
* try:
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_6);
__Pyx_XDECREF(__pyx_t_7);
__Pyx_XDECREF(__pyx_t_8);
__Pyx_AddTraceback("View.MemoryView.memoryview.is_slice", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = 0;
__pyx_L0:;
__Pyx_XDECREF(__pyx_v_obj);
__Pyx_XGIVEREF(__pyx_r);
__Pyx_TraceReturn(__pyx_r, 0);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "View.MemoryView":441
* return obj
*
* cdef setitem_slice_assignment(self, dst, src): # <<<<<<<<<<<<<<
* cdef __Pyx_memviewslice dst_slice
* cdef __Pyx_memviewslice src_slice
*/
static PyObject *__pyx_memoryview_setitem_slice_assignment(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_dst, PyObject *__pyx_v_src) {
__Pyx_memviewslice __pyx_v_dst_slice;
__Pyx_memviewslice __pyx_v_src_slice;
PyObject *__pyx_r = NULL;
__Pyx_TraceDeclarations
__Pyx_RefNannyDeclarations
__Pyx_memviewslice *__pyx_t_1;
__Pyx_memviewslice *__pyx_t_2;
PyObject *__pyx_t_3 = NULL;
int __pyx_t_4;
int __pyx_t_5;
int __pyx_t_6;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("setitem_slice_assignment", 0);
__Pyx_TraceCall("setitem_slice_assignment", __pyx_f[1], 441, 0, __PYX_ERR(1, 441, __pyx_L1_error));
/* "View.MemoryView":445
* cdef __Pyx_memviewslice src_slice
*
* memoryview_copy_contents(get_slice_from_memview(src, &src_slice)[0], # <<<<<<<<<<<<<<
* get_slice_from_memview(dst, &dst_slice)[0],
* src.ndim, dst.ndim, self.dtype_is_object)
*/
if (!(likely(((__pyx_v_src) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_src, __pyx_memoryview_type))))) __PYX_ERR(1, 445, __pyx_L1_error)
__pyx_t_1 = __pyx_memoryview_get_slice_from_memoryview(((struct __pyx_memoryview_obj *)__pyx_v_src), (&__pyx_v_src_slice)); if (unlikely(__pyx_t_1 == ((__Pyx_memviewslice *)NULL))) __PYX_ERR(1, 445, __pyx_L1_error)
/* "View.MemoryView":446
*
* memoryview_copy_contents(get_slice_from_memview(src, &src_slice)[0],
* get_slice_from_memview(dst, &dst_slice)[0], # <<<<<<<<<<<<<<
* src.ndim, dst.ndim, self.dtype_is_object)
*
*/
if (!(likely(((__pyx_v_dst) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_dst, __pyx_memoryview_type))))) __PYX_ERR(1, 446, __pyx_L1_error)
__pyx_t_2 = __pyx_memoryview_get_slice_from_memoryview(((struct __pyx_memoryview_obj *)__pyx_v_dst), (&__pyx_v_dst_slice)); if (unlikely(__pyx_t_2 == ((__Pyx_memviewslice *)NULL))) __PYX_ERR(1, 446, __pyx_L1_error)
/* "View.MemoryView":447
* memoryview_copy_contents(get_slice_from_memview(src, &src_slice)[0],
* get_slice_from_memview(dst, &dst_slice)[0],
* src.ndim, dst.ndim, self.dtype_is_object) # <<<<<<<<<<<<<<
*
* cdef setitem_slice_assign_scalar(self, memoryview dst, value):
*/
__pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_src, __pyx_n_s_ndim); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 447, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__pyx_t_4 = __Pyx_PyInt_As_int(__pyx_t_3); if (unlikely((__pyx_t_4 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 447, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_dst, __pyx_n_s_ndim); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 447, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__pyx_t_5 = __Pyx_PyInt_As_int(__pyx_t_3); if (unlikely((__pyx_t_5 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 447, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
/* "View.MemoryView":445
* cdef __Pyx_memviewslice src_slice
*
* memoryview_copy_contents(get_slice_from_memview(src, &src_slice)[0], # <<<<<<<<<<<<<<
* get_slice_from_memview(dst, &dst_slice)[0],
* src.ndim, dst.ndim, self.dtype_is_object)
*/
__pyx_t_6 = __pyx_memoryview_copy_contents((__pyx_t_1[0]), (__pyx_t_2[0]), __pyx_t_4, __pyx_t_5, __pyx_v_self->dtype_is_object); if (unlikely(__pyx_t_6 == ((int)-1))) __PYX_ERR(1, 445, __pyx_L1_error)
/* "View.MemoryView":441
* return obj
*
* cdef setitem_slice_assignment(self, dst, src): # <<<<<<<<<<<<<<
* cdef __Pyx_memviewslice dst_slice
* cdef __Pyx_memviewslice src_slice
*/
/* function exit code */
__pyx_r = Py_None; __Pyx_INCREF(Py_None);
goto __pyx_L0;
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_3);
__Pyx_AddTraceback("View.MemoryView.memoryview.setitem_slice_assignment", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = 0;
__pyx_L0:;
__Pyx_XGIVEREF(__pyx_r);
__Pyx_TraceReturn(__pyx_r, 0);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "View.MemoryView":449
* src.ndim, dst.ndim, self.dtype_is_object)
*
* cdef setitem_slice_assign_scalar(self, memoryview dst, value): # <<<<<<<<<<<<<<
* cdef int array[128]
* cdef void *tmp = NULL
*/
static PyObject *__pyx_memoryview_setitem_slice_assign_scalar(struct __pyx_memoryview_obj *__pyx_v_self, struct __pyx_memoryview_obj *__pyx_v_dst, PyObject *__pyx_v_value) {
int __pyx_v_array[0x80];
void *__pyx_v_tmp;
void *__pyx_v_item;
__Pyx_memviewslice *__pyx_v_dst_slice;
__Pyx_memviewslice __pyx_v_tmp_slice;
PyObject *__pyx_r = NULL;
__Pyx_TraceDeclarations
__Pyx_RefNannyDeclarations
__Pyx_memviewslice *__pyx_t_1;
int __pyx_t_2;
PyObject *__pyx_t_3 = NULL;
int __pyx_t_4;
int __pyx_t_5;
char const *__pyx_t_6;
PyObject *__pyx_t_7 = NULL;
PyObject *__pyx_t_8 = NULL;
PyObject *__pyx_t_9 = NULL;
PyObject *__pyx_t_10 = NULL;
PyObject *__pyx_t_11 = NULL;
PyObject *__pyx_t_12 = NULL;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("setitem_slice_assign_scalar", 0);
__Pyx_TraceCall("setitem_slice_assign_scalar", __pyx_f[1], 449, 0, __PYX_ERR(1, 449, __pyx_L1_error));
/* "View.MemoryView":451
* cdef setitem_slice_assign_scalar(self, memoryview dst, value):
* cdef int array[128]
* cdef void *tmp = NULL # <<<<<<<<<<<<<<
* cdef void *item
*
*/
__pyx_v_tmp = NULL;
/* "View.MemoryView":456
* cdef __Pyx_memviewslice *dst_slice
* cdef __Pyx_memviewslice tmp_slice
* dst_slice = get_slice_from_memview(dst, &tmp_slice) # <<<<<<<<<<<<<<
*
* if <size_t>self.view.itemsize > sizeof(array):
*/
__pyx_t_1 = __pyx_memoryview_get_slice_from_memoryview(__pyx_v_dst, (&__pyx_v_tmp_slice)); if (unlikely(__pyx_t_1 == ((__Pyx_memviewslice *)NULL))) __PYX_ERR(1, 456, __pyx_L1_error)
__pyx_v_dst_slice = __pyx_t_1;
/* "View.MemoryView":458
* dst_slice = get_slice_from_memview(dst, &tmp_slice)
*
* if <size_t>self.view.itemsize > sizeof(array): # <<<<<<<<<<<<<<
* tmp = PyMem_Malloc(self.view.itemsize)
* if tmp == NULL:
*/
__pyx_t_2 = ((((size_t)__pyx_v_self->view.itemsize) > (sizeof(__pyx_v_array))) != 0);
if (__pyx_t_2) {
/* "View.MemoryView":459
*
* if <size_t>self.view.itemsize > sizeof(array):
* tmp = PyMem_Malloc(self.view.itemsize) # <<<<<<<<<<<<<<
* if tmp == NULL:
* raise MemoryError
*/
__pyx_v_tmp = PyMem_Malloc(__pyx_v_self->view.itemsize);
/* "View.MemoryView":460
* if <size_t>self.view.itemsize > sizeof(array):
* tmp = PyMem_Malloc(self.view.itemsize)
* if tmp == NULL: # <<<<<<<<<<<<<<
* raise MemoryError
* item = tmp
*/
__pyx_t_2 = ((__pyx_v_tmp == NULL) != 0);
if (unlikely(__pyx_t_2)) {
/* "View.MemoryView":461
* tmp = PyMem_Malloc(self.view.itemsize)
* if tmp == NULL:
* raise MemoryError # <<<<<<<<<<<<<<
* item = tmp
* else:
*/
PyErr_NoMemory(); __PYX_ERR(1, 461, __pyx_L1_error)
/* "View.MemoryView":460
* if <size_t>self.view.itemsize > sizeof(array):
* tmp = PyMem_Malloc(self.view.itemsize)
* if tmp == NULL: # <<<<<<<<<<<<<<
* raise MemoryError
* item = tmp
*/
}
/* "View.MemoryView":462
* if tmp == NULL:
* raise MemoryError
* item = tmp # <<<<<<<<<<<<<<
* else:
* item = <void *> array
*/
__pyx_v_item = __pyx_v_tmp;
/* "View.MemoryView":458
* dst_slice = get_slice_from_memview(dst, &tmp_slice)
*
* if <size_t>self.view.itemsize > sizeof(array): # <<<<<<<<<<<<<<
* tmp = PyMem_Malloc(self.view.itemsize)
* if tmp == NULL:
*/
goto __pyx_L3;
}
/* "View.MemoryView":464
* item = tmp
* else:
* item = <void *> array # <<<<<<<<<<<<<<
*
* try:
*/
/*else*/ {
__pyx_v_item = ((void *)__pyx_v_array);
}
__pyx_L3:;
/* "View.MemoryView":466
* item = <void *> array
*
* try: # <<<<<<<<<<<<<<
* if self.dtype_is_object:
* (<PyObject **> item)[0] = <PyObject *> value
*/
/*try:*/ {
/* "View.MemoryView":467
*
* try:
* if self.dtype_is_object: # <<<<<<<<<<<<<<
* (<PyObject **> item)[0] = <PyObject *> value
* else:
*/
__pyx_t_2 = (__pyx_v_self->dtype_is_object != 0);
if (__pyx_t_2) {
/* "View.MemoryView":468
* try:
* if self.dtype_is_object:
* (<PyObject **> item)[0] = <PyObject *> value # <<<<<<<<<<<<<<
* else:
* self.assign_item_from_object(<char *> item, value)
*/
(((PyObject **)__pyx_v_item)[0]) = ((PyObject *)__pyx_v_value);
/* "View.MemoryView":467
*
* try:
* if self.dtype_is_object: # <<<<<<<<<<<<<<
* (<PyObject **> item)[0] = <PyObject *> value
* else:
*/
goto __pyx_L8;
}
/* "View.MemoryView":470
* (<PyObject **> item)[0] = <PyObject *> value
* else:
* self.assign_item_from_object(<char *> item, value) # <<<<<<<<<<<<<<
*
*
*/
/*else*/ {
__pyx_t_3 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->assign_item_from_object(__pyx_v_self, ((char *)__pyx_v_item), __pyx_v_value); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 470, __pyx_L6_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
}
__pyx_L8:;
/* "View.MemoryView":474
*
*
* if self.view.suboffsets != NULL: # <<<<<<<<<<<<<<
* assert_direct_dimensions(self.view.suboffsets, self.view.ndim)
* slice_assign_scalar(dst_slice, dst.view.ndim, self.view.itemsize,
*/
__pyx_t_2 = ((__pyx_v_self->view.suboffsets != NULL) != 0);
if (__pyx_t_2) {
/* "View.MemoryView":475
*
* if self.view.suboffsets != NULL:
* assert_direct_dimensions(self.view.suboffsets, self.view.ndim) # <<<<<<<<<<<<<<
* slice_assign_scalar(dst_slice, dst.view.ndim, self.view.itemsize,
* item, self.dtype_is_object)
*/
__pyx_t_3 = assert_direct_dimensions(__pyx_v_self->view.suboffsets, __pyx_v_self->view.ndim); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 475, __pyx_L6_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
/* "View.MemoryView":474
*
*
* if self.view.suboffsets != NULL: # <<<<<<<<<<<<<<
* assert_direct_dimensions(self.view.suboffsets, self.view.ndim)
* slice_assign_scalar(dst_slice, dst.view.ndim, self.view.itemsize,
*/
}
/* "View.MemoryView":476
* if self.view.suboffsets != NULL:
* assert_direct_dimensions(self.view.suboffsets, self.view.ndim)
* slice_assign_scalar(dst_slice, dst.view.ndim, self.view.itemsize, # <<<<<<<<<<<<<<
* item, self.dtype_is_object)
* finally:
*/
__pyx_memoryview_slice_assign_scalar(__pyx_v_dst_slice, __pyx_v_dst->view.ndim, __pyx_v_self->view.itemsize, __pyx_v_item, __pyx_v_self->dtype_is_object);
}
/* "View.MemoryView":479
* item, self.dtype_is_object)
* finally:
* PyMem_Free(tmp) # <<<<<<<<<<<<<<
*
* cdef setitem_indexed(self, index, value):
*/
/*finally:*/ {
/*normal exit:*/{
PyMem_Free(__pyx_v_tmp);
goto __pyx_L7;
}
__pyx_L6_error:;
/*exception exit:*/{
__Pyx_PyThreadState_declare
__Pyx_PyThreadState_assign
__pyx_t_7 = 0; __pyx_t_8 = 0; __pyx_t_9 = 0; __pyx_t_10 = 0; __pyx_t_11 = 0; __pyx_t_12 = 0;
__Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_10, &__pyx_t_11, &__pyx_t_12);
if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_7, &__pyx_t_8, &__pyx_t_9) < 0)) __Pyx_ErrFetch(&__pyx_t_7, &__pyx_t_8, &__pyx_t_9);
__Pyx_XGOTREF(__pyx_t_7);
__Pyx_XGOTREF(__pyx_t_8);
__Pyx_XGOTREF(__pyx_t_9);
__Pyx_XGOTREF(__pyx_t_10);
__Pyx_XGOTREF(__pyx_t_11);
__Pyx_XGOTREF(__pyx_t_12);
__pyx_t_4 = __pyx_lineno; __pyx_t_5 = __pyx_clineno; __pyx_t_6 = __pyx_filename;
{
PyMem_Free(__pyx_v_tmp);
}
if (PY_MAJOR_VERSION >= 3) {
__Pyx_XGIVEREF(__pyx_t_10);
__Pyx_XGIVEREF(__pyx_t_11);
__Pyx_XGIVEREF(__pyx_t_12);
__Pyx_ExceptionReset(__pyx_t_10, __pyx_t_11, __pyx_t_12);
}
__Pyx_XGIVEREF(__pyx_t_7);
__Pyx_XGIVEREF(__pyx_t_8);
__Pyx_XGIVEREF(__pyx_t_9);
__Pyx_ErrRestore(__pyx_t_7, __pyx_t_8, __pyx_t_9);
__pyx_t_7 = 0; __pyx_t_8 = 0; __pyx_t_9 = 0; __pyx_t_10 = 0; __pyx_t_11 = 0; __pyx_t_12 = 0;
__pyx_lineno = __pyx_t_4; __pyx_clineno = __pyx_t_5; __pyx_filename = __pyx_t_6;
goto __pyx_L1_error;
}
__pyx_L7:;
}
/* "View.MemoryView":449
* src.ndim, dst.ndim, self.dtype_is_object)
*
* cdef setitem_slice_assign_scalar(self, memoryview dst, value): # <<<<<<<<<<<<<<
* cdef int array[128]
* cdef void *tmp = NULL
*/
/* function exit code */
__pyx_r = Py_None; __Pyx_INCREF(Py_None);
goto __pyx_L0;
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_3);
__Pyx_AddTraceback("View.MemoryView.memoryview.setitem_slice_assign_scalar", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = 0;
__pyx_L0:;
__Pyx_XGIVEREF(__pyx_r);
__Pyx_TraceReturn(__pyx_r, 0);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "View.MemoryView":481
* PyMem_Free(tmp)
*
* cdef setitem_indexed(self, index, value): # <<<<<<<<<<<<<<
* cdef char *itemp = self.get_item_pointer(index)
* self.assign_item_from_object(itemp, value)
*/
static PyObject *__pyx_memoryview_setitem_indexed(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_index, PyObject *__pyx_v_value) {
char *__pyx_v_itemp;
PyObject *__pyx_r = NULL;
__Pyx_TraceDeclarations
__Pyx_RefNannyDeclarations
char *__pyx_t_1;
PyObject *__pyx_t_2 = NULL;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("setitem_indexed", 0);
__Pyx_TraceCall("setitem_indexed", __pyx_f[1], 481, 0, __PYX_ERR(1, 481, __pyx_L1_error));
/* "View.MemoryView":482
*
* cdef setitem_indexed(self, index, value):
* cdef char *itemp = self.get_item_pointer(index) # <<<<<<<<<<<<<<
* self.assign_item_from_object(itemp, value)
*
*/
__pyx_t_1 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->get_item_pointer(__pyx_v_self, __pyx_v_index); if (unlikely(__pyx_t_1 == ((char *)NULL))) __PYX_ERR(1, 482, __pyx_L1_error)
__pyx_v_itemp = __pyx_t_1;
/* "View.MemoryView":483
* cdef setitem_indexed(self, index, value):
* cdef char *itemp = self.get_item_pointer(index)
* self.assign_item_from_object(itemp, value) # <<<<<<<<<<<<<<
*
* cdef convert_item_to_object(self, char *itemp):
*/
__pyx_t_2 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->assign_item_from_object(__pyx_v_self, __pyx_v_itemp, __pyx_v_value); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 483, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
/* "View.MemoryView":481
* PyMem_Free(tmp)
*
* cdef setitem_indexed(self, index, value): # <<<<<<<<<<<<<<
* cdef char *itemp = self.get_item_pointer(index)
* self.assign_item_from_object(itemp, value)
*/
/* function exit code */
__pyx_r = Py_None; __Pyx_INCREF(Py_None);
goto __pyx_L0;
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_2);
__Pyx_AddTraceback("View.MemoryView.memoryview.setitem_indexed", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = 0;
__pyx_L0:;
__Pyx_XGIVEREF(__pyx_r);
__Pyx_TraceReturn(__pyx_r, 0);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "View.MemoryView":485
* self.assign_item_from_object(itemp, value)
*
* cdef convert_item_to_object(self, char *itemp): # <<<<<<<<<<<<<<
* """Only used if instantiated manually by the user, or if Cython doesn't
* know how to convert the type"""
*/
static PyObject *__pyx_memoryview_convert_item_to_object(struct __pyx_memoryview_obj *__pyx_v_self, char *__pyx_v_itemp) {
PyObject *__pyx_v_struct = NULL;
PyObject *__pyx_v_bytesitem = 0;
PyObject *__pyx_v_result = NULL;
PyObject *__pyx_r = NULL;
__Pyx_TraceDeclarations
__Pyx_RefNannyDeclarations
PyObject *__pyx_t_1 = NULL;
PyObject *__pyx_t_2 = NULL;
PyObject *__pyx_t_3 = NULL;
PyObject *__pyx_t_4 = NULL;
PyObject *__pyx_t_5 = NULL;
PyObject *__pyx_t_6 = NULL;
PyObject *__pyx_t_7 = NULL;
int __pyx_t_8;
PyObject *__pyx_t_9 = NULL;
size_t __pyx_t_10;
int __pyx_t_11;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("convert_item_to_object", 0);
__Pyx_TraceCall("convert_item_to_object", __pyx_f[1], 485, 0, __PYX_ERR(1, 485, __pyx_L1_error));
/* "View.MemoryView":488
* """Only used if instantiated manually by the user, or if Cython doesn't
* know how to convert the type"""
* import struct # <<<<<<<<<<<<<<
* cdef bytes bytesitem
*
*/
__pyx_t_1 = __Pyx_Import(__pyx_n_s_struct, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 488, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_v_struct = __pyx_t_1;
__pyx_t_1 = 0;
/* "View.MemoryView":491
* cdef bytes bytesitem
*
* bytesitem = itemp[:self.view.itemsize] # <<<<<<<<<<<<<<
* try:
* result = struct.unpack(self.view.format, bytesitem)
*/
__pyx_t_1 = __Pyx_PyBytes_FromStringAndSize(__pyx_v_itemp + 0, __pyx_v_self->view.itemsize - 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 491, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_v_bytesitem = ((PyObject*)__pyx_t_1);
__pyx_t_1 = 0;
/* "View.MemoryView":492
*
* bytesitem = itemp[:self.view.itemsize]
* try: # <<<<<<<<<<<<<<
* result = struct.unpack(self.view.format, bytesitem)
* except struct.error:
*/
{
__Pyx_PyThreadState_declare
__Pyx_PyThreadState_assign
__Pyx_ExceptionSave(&__pyx_t_2, &__pyx_t_3, &__pyx_t_4);
__Pyx_XGOTREF(__pyx_t_2);
__Pyx_XGOTREF(__pyx_t_3);
__Pyx_XGOTREF(__pyx_t_4);
/*try:*/ {
/* "View.MemoryView":493
* bytesitem = itemp[:self.view.itemsize]
* try:
* result = struct.unpack(self.view.format, bytesitem) # <<<<<<<<<<<<<<
* except struct.error:
* raise ValueError("Unable to convert item to object")
*/
__pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_struct, __pyx_n_s_unpack); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 493, __pyx_L3_error)
__Pyx_GOTREF(__pyx_t_5);
__pyx_t_6 = __Pyx_PyBytes_FromString(__pyx_v_self->view.format); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 493, __pyx_L3_error)
__Pyx_GOTREF(__pyx_t_6);
__pyx_t_7 = NULL;
__pyx_t_8 = 0;
if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_5))) {
__pyx_t_7 = PyMethod_GET_SELF(__pyx_t_5);
if (likely(__pyx_t_7)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5);
__Pyx_INCREF(__pyx_t_7);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_5, function);
__pyx_t_8 = 1;
}
}
#if CYTHON_FAST_PYCALL
if (PyFunction_Check(__pyx_t_5)) {
PyObject *__pyx_temp[3] = {__pyx_t_7, __pyx_t_6, __pyx_v_bytesitem};
__pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_8, 2+__pyx_t_8); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 493, __pyx_L3_error)
__Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
} else
#endif
#if CYTHON_FAST_PYCCALL
if (__Pyx_PyFastCFunction_Check(__pyx_t_5)) {
PyObject *__pyx_temp[3] = {__pyx_t_7, __pyx_t_6, __pyx_v_bytesitem};
__pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_8, 2+__pyx_t_8); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 493, __pyx_L3_error)
__Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
} else
#endif
{
__pyx_t_9 = PyTuple_New(2+__pyx_t_8); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 493, __pyx_L3_error)
__Pyx_GOTREF(__pyx_t_9);
if (__pyx_t_7) {
__Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_7); __pyx_t_7 = NULL;
}
__Pyx_GIVEREF(__pyx_t_6);
PyTuple_SET_ITEM(__pyx_t_9, 0+__pyx_t_8, __pyx_t_6);
__Pyx_INCREF(__pyx_v_bytesitem);
__Pyx_GIVEREF(__pyx_v_bytesitem);
PyTuple_SET_ITEM(__pyx_t_9, 1+__pyx_t_8, __pyx_v_bytesitem);
__pyx_t_6 = 0;
__pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_9, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 493, __pyx_L3_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
}
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
__pyx_v_result = __pyx_t_1;
__pyx_t_1 = 0;
/* "View.MemoryView":492
*
* bytesitem = itemp[:self.view.itemsize]
* try: # <<<<<<<<<<<<<<
* result = struct.unpack(self.view.format, bytesitem)
* except struct.error:
*/
}
/* "View.MemoryView":497
* raise ValueError("Unable to convert item to object")
* else:
* if len(self.view.format) == 1: # <<<<<<<<<<<<<<
* return result[0]
* return result
*/
/*else:*/ {
__pyx_t_10 = strlen(__pyx_v_self->view.format);
__pyx_t_11 = ((__pyx_t_10 == 1) != 0);
if (__pyx_t_11) {
/* "View.MemoryView":498
* else:
* if len(self.view.format) == 1:
* return result[0] # <<<<<<<<<<<<<<
* return result
*
*/
__Pyx_XDECREF(__pyx_r);
__pyx_t_1 = __Pyx_GetItemInt(__pyx_v_result, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 498, __pyx_L5_except_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_r = __pyx_t_1;
__pyx_t_1 = 0;
goto __pyx_L6_except_return;
/* "View.MemoryView":497
* raise ValueError("Unable to convert item to object")
* else:
* if len(self.view.format) == 1: # <<<<<<<<<<<<<<
* return result[0]
* return result
*/
}
/* "View.MemoryView":499
* if len(self.view.format) == 1:
* return result[0]
* return result # <<<<<<<<<<<<<<
*
* cdef assign_item_from_object(self, char *itemp, object value):
*/
__Pyx_XDECREF(__pyx_r);
__Pyx_INCREF(__pyx_v_result);
__pyx_r = __pyx_v_result;
goto __pyx_L6_except_return;
}
__pyx_L3_error:;
__Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
__Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
__Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
__Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
/* "View.MemoryView":494
* try:
* result = struct.unpack(self.view.format, bytesitem)
* except struct.error: # <<<<<<<<<<<<<<
* raise ValueError("Unable to convert item to object")
* else:
*/
__Pyx_ErrFetch(&__pyx_t_1, &__pyx_t_5, &__pyx_t_9);
__pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_struct, __pyx_n_s_error); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 494, __pyx_L5_except_error)
__Pyx_GOTREF(__pyx_t_6);
__pyx_t_8 = __Pyx_PyErr_GivenExceptionMatches(__pyx_t_1, __pyx_t_6);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_ErrRestore(__pyx_t_1, __pyx_t_5, __pyx_t_9);
__pyx_t_1 = 0; __pyx_t_5 = 0; __pyx_t_9 = 0;
if (__pyx_t_8) {
__Pyx_AddTraceback("View.MemoryView.memoryview.convert_item_to_object", __pyx_clineno, __pyx_lineno, __pyx_filename);
if (__Pyx_GetException(&__pyx_t_9, &__pyx_t_5, &__pyx_t_1) < 0) __PYX_ERR(1, 494, __pyx_L5_except_error)
__Pyx_GOTREF(__pyx_t_9);
__Pyx_GOTREF(__pyx_t_5);
__Pyx_GOTREF(__pyx_t_1);
/* "View.MemoryView":495
* result = struct.unpack(self.view.format, bytesitem)
* except struct.error:
* raise ValueError("Unable to convert item to object") # <<<<<<<<<<<<<<
* else:
* if len(self.view.format) == 1:
*/
__pyx_t_6 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__27, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 495, __pyx_L5_except_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_Raise(__pyx_t_6, 0, 0, 0);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
__PYX_ERR(1, 495, __pyx_L5_except_error)
}
goto __pyx_L5_except_error;
__pyx_L5_except_error:;
/* "View.MemoryView":492
*
* bytesitem = itemp[:self.view.itemsize]
* try: # <<<<<<<<<<<<<<
* result = struct.unpack(self.view.format, bytesitem)
* except struct.error:
*/
__Pyx_XGIVEREF(__pyx_t_2);
__Pyx_XGIVEREF(__pyx_t_3);
__Pyx_XGIVEREF(__pyx_t_4);
__Pyx_ExceptionReset(__pyx_t_2, __pyx_t_3, __pyx_t_4);
goto __pyx_L1_error;
__pyx_L6_except_return:;
__Pyx_XGIVEREF(__pyx_t_2);
__Pyx_XGIVEREF(__pyx_t_3);
__Pyx_XGIVEREF(__pyx_t_4);
__Pyx_ExceptionReset(__pyx_t_2, __pyx_t_3, __pyx_t_4);
goto __pyx_L0;
}
/* "View.MemoryView":485
* self.assign_item_from_object(itemp, value)
*
* cdef convert_item_to_object(self, char *itemp): # <<<<<<<<<<<<<<
* """Only used if instantiated manually by the user, or if Cython doesn't
* know how to convert the type"""
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_1);
__Pyx_XDECREF(__pyx_t_5);
__Pyx_XDECREF(__pyx_t_6);
__Pyx_XDECREF(__pyx_t_7);
__Pyx_XDECREF(__pyx_t_9);
__Pyx_AddTraceback("View.MemoryView.memoryview.convert_item_to_object", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = 0;
__pyx_L0:;
__Pyx_XDECREF(__pyx_v_struct);
__Pyx_XDECREF(__pyx_v_bytesitem);
__Pyx_XDECREF(__pyx_v_result);
__Pyx_XGIVEREF(__pyx_r);
__Pyx_TraceReturn(__pyx_r, 0);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "View.MemoryView":501
* return result
*
* cdef assign_item_from_object(self, char *itemp, object value): # <<<<<<<<<<<<<<
* """Only used if instantiated manually by the user, or if Cython doesn't
* know how to convert the type"""
*/
static PyObject *__pyx_memoryview_assign_item_from_object(struct __pyx_memoryview_obj *__pyx_v_self, char *__pyx_v_itemp, PyObject *__pyx_v_value) {
PyObject *__pyx_v_struct = NULL;
char __pyx_v_c;
PyObject *__pyx_v_bytesvalue = 0;
Py_ssize_t __pyx_v_i;
PyObject *__pyx_r = NULL;
__Pyx_TraceDeclarations
__Pyx_RefNannyDeclarations
PyObject *__pyx_t_1 = NULL;
int __pyx_t_2;
int __pyx_t_3;
PyObject *__pyx_t_4 = NULL;
PyObject *__pyx_t_5 = NULL;
PyObject *__pyx_t_6 = NULL;
int __pyx_t_7;
PyObject *__pyx_t_8 = NULL;
Py_ssize_t __pyx_t_9;
PyObject *__pyx_t_10 = NULL;
char *__pyx_t_11;
char *__pyx_t_12;
char *__pyx_t_13;
char *__pyx_t_14;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("assign_item_from_object", 0);
__Pyx_TraceCall("assign_item_from_object", __pyx_f[1], 501, 0, __PYX_ERR(1, 501, __pyx_L1_error));
/* "View.MemoryView":504
* """Only used if instantiated manually by the user, or if Cython doesn't
* know how to convert the type"""
* import struct # <<<<<<<<<<<<<<
* cdef char c
* cdef bytes bytesvalue
*/
__pyx_t_1 = __Pyx_Import(__pyx_n_s_struct, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 504, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_v_struct = __pyx_t_1;
__pyx_t_1 = 0;
/* "View.MemoryView":509
* cdef Py_ssize_t i
*
* if isinstance(value, tuple): # <<<<<<<<<<<<<<
* bytesvalue = struct.pack(self.view.format, *value)
* else:
*/
__pyx_t_2 = PyTuple_Check(__pyx_v_value);
__pyx_t_3 = (__pyx_t_2 != 0);
if (__pyx_t_3) {
/* "View.MemoryView":510
*
* if isinstance(value, tuple):
* bytesvalue = struct.pack(self.view.format, *value) # <<<<<<<<<<<<<<
* else:
* bytesvalue = struct.pack(self.view.format, value)
*/
__pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_struct, __pyx_n_s_pack); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 510, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_t_4 = __Pyx_PyBytes_FromString(__pyx_v_self->view.format); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 510, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 510, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_GIVEREF(__pyx_t_4);
PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_4);
__pyx_t_4 = 0;
__pyx_t_4 = __Pyx_PySequence_Tuple(__pyx_v_value); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 510, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__pyx_t_6 = PyNumber_Add(__pyx_t_5, __pyx_t_4); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 510, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_6, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 510, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
if (!(likely(PyBytes_CheckExact(__pyx_t_4))||((__pyx_t_4) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "bytes", Py_TYPE(__pyx_t_4)->tp_name), 0))) __PYX_ERR(1, 510, __pyx_L1_error)
__pyx_v_bytesvalue = ((PyObject*)__pyx_t_4);
__pyx_t_4 = 0;
/* "View.MemoryView":509
* cdef Py_ssize_t i
*
* if isinstance(value, tuple): # <<<<<<<<<<<<<<
* bytesvalue = struct.pack(self.view.format, *value)
* else:
*/
goto __pyx_L3;
}
/* "View.MemoryView":512
* bytesvalue = struct.pack(self.view.format, *value)
* else:
* bytesvalue = struct.pack(self.view.format, value) # <<<<<<<<<<<<<<
*
* for i, c in enumerate(bytesvalue):
*/
/*else*/ {
__pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_struct, __pyx_n_s_pack); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 512, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__pyx_t_1 = __Pyx_PyBytes_FromString(__pyx_v_self->view.format); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 512, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_t_5 = NULL;
__pyx_t_7 = 0;
if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_6))) {
__pyx_t_5 = PyMethod_GET_SELF(__pyx_t_6);
if (likely(__pyx_t_5)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6);
__Pyx_INCREF(__pyx_t_5);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_6, function);
__pyx_t_7 = 1;
}
}
#if CYTHON_FAST_PYCALL
if (PyFunction_Check(__pyx_t_6)) {
PyObject *__pyx_temp[3] = {__pyx_t_5, __pyx_t_1, __pyx_v_value};
__pyx_t_4 = __Pyx_PyFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_7, 2+__pyx_t_7); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 512, __pyx_L1_error)
__Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
__Pyx_GOTREF(__pyx_t_4);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
} else
#endif
#if CYTHON_FAST_PYCCALL
if (__Pyx_PyFastCFunction_Check(__pyx_t_6)) {
PyObject *__pyx_temp[3] = {__pyx_t_5, __pyx_t_1, __pyx_v_value};
__pyx_t_4 = __Pyx_PyCFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_7, 2+__pyx_t_7); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 512, __pyx_L1_error)
__Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
__Pyx_GOTREF(__pyx_t_4);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
} else
#endif
{
__pyx_t_8 = PyTuple_New(2+__pyx_t_7); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 512, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_8);
if (__pyx_t_5) {
__Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_5); __pyx_t_5 = NULL;
}
__Pyx_GIVEREF(__pyx_t_1);
PyTuple_SET_ITEM(__pyx_t_8, 0+__pyx_t_7, __pyx_t_1);
__Pyx_INCREF(__pyx_v_value);
__Pyx_GIVEREF(__pyx_v_value);
PyTuple_SET_ITEM(__pyx_t_8, 1+__pyx_t_7, __pyx_v_value);
__pyx_t_1 = 0;
__pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_8, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 512, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
}
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
if (!(likely(PyBytes_CheckExact(__pyx_t_4))||((__pyx_t_4) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "bytes", Py_TYPE(__pyx_t_4)->tp_name), 0))) __PYX_ERR(1, 512, __pyx_L1_error)
__pyx_v_bytesvalue = ((PyObject*)__pyx_t_4);
__pyx_t_4 = 0;
}
__pyx_L3:;
/* "View.MemoryView":514
* bytesvalue = struct.pack(self.view.format, value)
*
* for i, c in enumerate(bytesvalue): # <<<<<<<<<<<<<<
* itemp[i] = c
*
*/
__pyx_t_9 = 0;
if (unlikely(__pyx_v_bytesvalue == Py_None)) {
PyErr_SetString(PyExc_TypeError, "'NoneType' is not iterable");
__PYX_ERR(1, 514, __pyx_L1_error)
}
__Pyx_INCREF(__pyx_v_bytesvalue);
__pyx_t_10 = __pyx_v_bytesvalue;
__pyx_t_12 = PyBytes_AS_STRING(__pyx_t_10);
__pyx_t_13 = (__pyx_t_12 + PyBytes_GET_SIZE(__pyx_t_10));
for (__pyx_t_14 = __pyx_t_12; __pyx_t_14 < __pyx_t_13; __pyx_t_14++) {
__pyx_t_11 = __pyx_t_14;
__pyx_v_c = (__pyx_t_11[0]);
/* "View.MemoryView":515
*
* for i, c in enumerate(bytesvalue):
* itemp[i] = c # <<<<<<<<<<<<<<
*
* @cname('getbuffer')
*/
__pyx_v_i = __pyx_t_9;
/* "View.MemoryView":514
* bytesvalue = struct.pack(self.view.format, value)
*
* for i, c in enumerate(bytesvalue): # <<<<<<<<<<<<<<
* itemp[i] = c
*
*/
__pyx_t_9 = (__pyx_t_9 + 1);
/* "View.MemoryView":515
*
* for i, c in enumerate(bytesvalue):
* itemp[i] = c # <<<<<<<<<<<<<<
*
* @cname('getbuffer')
*/
(__pyx_v_itemp[__pyx_v_i]) = __pyx_v_c;
}
__Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
/* "View.MemoryView":501
* return result
*
* cdef assign_item_from_object(self, char *itemp, object value): # <<<<<<<<<<<<<<
* """Only used if instantiated manually by the user, or if Cython doesn't
* know how to convert the type"""
*/
/* function exit code */
__pyx_r = Py_None; __Pyx_INCREF(Py_None);
goto __pyx_L0;
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_1);
__Pyx_XDECREF(__pyx_t_4);
__Pyx_XDECREF(__pyx_t_5);
__Pyx_XDECREF(__pyx_t_6);
__Pyx_XDECREF(__pyx_t_8);
__Pyx_XDECREF(__pyx_t_10);
__Pyx_AddTraceback("View.MemoryView.memoryview.assign_item_from_object", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = 0;
__pyx_L0:;
__Pyx_XDECREF(__pyx_v_struct);
__Pyx_XDECREF(__pyx_v_bytesvalue);
__Pyx_XGIVEREF(__pyx_r);
__Pyx_TraceReturn(__pyx_r, 0);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "View.MemoryView":518
*
* @cname('getbuffer')
* def __getbuffer__(self, Py_buffer *info, int flags): # <<<<<<<<<<<<<<
* if flags & PyBUF_WRITABLE and self.view.readonly:
* raise ValueError("Cannot create writable memory view from read-only memoryview")
*/
/* Python wrapper */
static CYTHON_UNUSED int __pyx_memoryview_getbuffer(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags); /*proto*/
static CYTHON_UNUSED int __pyx_memoryview_getbuffer(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags) {
int __pyx_r;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("__getbuffer__ (wrapper)", 0);
__pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_8__getbuffer__(((struct __pyx_memoryview_obj *)__pyx_v_self), ((Py_buffer *)__pyx_v_info), ((int)__pyx_v_flags));
/* function exit code */
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_8__getbuffer__(struct __pyx_memoryview_obj *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags) {
int __pyx_r;
__Pyx_TraceDeclarations
__Pyx_RefNannyDeclarations
int __pyx_t_1;
int __pyx_t_2;
PyObject *__pyx_t_3 = NULL;
Py_ssize_t *__pyx_t_4;
char *__pyx_t_5;
void *__pyx_t_6;
int __pyx_t_7;
Py_ssize_t __pyx_t_8;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
if (__pyx_v_info == NULL) {
PyErr_SetString(PyExc_BufferError, "PyObject_GetBuffer: view==NULL argument is obsolete");
return -1;
}
__Pyx_RefNannySetupContext("__getbuffer__", 0);
__pyx_v_info->obj = Py_None; __Pyx_INCREF(Py_None);
__Pyx_GIVEREF(__pyx_v_info->obj);
__Pyx_TraceCall("__getbuffer__", __pyx_f[1], 518, 0, __PYX_ERR(1, 518, __pyx_L1_error));
/* "View.MemoryView":519
* @cname('getbuffer')
* def __getbuffer__(self, Py_buffer *info, int flags):
* if flags & PyBUF_WRITABLE and self.view.readonly: # <<<<<<<<<<<<<<
* raise ValueError("Cannot create writable memory view from read-only memoryview")
*
*/
__pyx_t_2 = ((__pyx_v_flags & PyBUF_WRITABLE) != 0);
if (__pyx_t_2) {
} else {
__pyx_t_1 = __pyx_t_2;
goto __pyx_L4_bool_binop_done;
}
__pyx_t_2 = (__pyx_v_self->view.readonly != 0);
__pyx_t_1 = __pyx_t_2;
__pyx_L4_bool_binop_done:;
if (unlikely(__pyx_t_1)) {
/* "View.MemoryView":520
* def __getbuffer__(self, Py_buffer *info, int flags):
* if flags & PyBUF_WRITABLE and self.view.readonly:
* raise ValueError("Cannot create writable memory view from read-only memoryview") # <<<<<<<<<<<<<<
*
* if flags & PyBUF_ND:
*/
__pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__28, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 520, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_Raise(__pyx_t_3, 0, 0, 0);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__PYX_ERR(1, 520, __pyx_L1_error)
/* "View.MemoryView":519
* @cname('getbuffer')
* def __getbuffer__(self, Py_buffer *info, int flags):
* if flags & PyBUF_WRITABLE and self.view.readonly: # <<<<<<<<<<<<<<
* raise ValueError("Cannot create writable memory view from read-only memoryview")
*
*/
}
/* "View.MemoryView":522
* raise ValueError("Cannot create writable memory view from read-only memoryview")
*
* if flags & PyBUF_ND: # <<<<<<<<<<<<<<
* info.shape = self.view.shape
* else:
*/
__pyx_t_1 = ((__pyx_v_flags & PyBUF_ND) != 0);
if (__pyx_t_1) {
/* "View.MemoryView":523
*
* if flags & PyBUF_ND:
* info.shape = self.view.shape # <<<<<<<<<<<<<<
* else:
* info.shape = NULL
*/
__pyx_t_4 = __pyx_v_self->view.shape;
__pyx_v_info->shape = __pyx_t_4;
/* "View.MemoryView":522
* raise ValueError("Cannot create writable memory view from read-only memoryview")
*
* if flags & PyBUF_ND: # <<<<<<<<<<<<<<
* info.shape = self.view.shape
* else:
*/
goto __pyx_L6;
}
/* "View.MemoryView":525
* info.shape = self.view.shape
* else:
* info.shape = NULL # <<<<<<<<<<<<<<
*
* if flags & PyBUF_STRIDES:
*/
/*else*/ {
__pyx_v_info->shape = NULL;
}
__pyx_L6:;
/* "View.MemoryView":527
* info.shape = NULL
*
* if flags & PyBUF_STRIDES: # <<<<<<<<<<<<<<
* info.strides = self.view.strides
* else:
*/
__pyx_t_1 = ((__pyx_v_flags & PyBUF_STRIDES) != 0);
if (__pyx_t_1) {
/* "View.MemoryView":528
*
* if flags & PyBUF_STRIDES:
* info.strides = self.view.strides # <<<<<<<<<<<<<<
* else:
* info.strides = NULL
*/
__pyx_t_4 = __pyx_v_self->view.strides;
__pyx_v_info->strides = __pyx_t_4;
/* "View.MemoryView":527
* info.shape = NULL
*
* if flags & PyBUF_STRIDES: # <<<<<<<<<<<<<<
* info.strides = self.view.strides
* else:
*/
goto __pyx_L7;
}
/* "View.MemoryView":530
* info.strides = self.view.strides
* else:
* info.strides = NULL # <<<<<<<<<<<<<<
*
* if flags & PyBUF_INDIRECT:
*/
/*else*/ {
__pyx_v_info->strides = NULL;
}
__pyx_L7:;
/* "View.MemoryView":532
* info.strides = NULL
*
* if flags & PyBUF_INDIRECT: # <<<<<<<<<<<<<<
* info.suboffsets = self.view.suboffsets
* else:
*/
__pyx_t_1 = ((__pyx_v_flags & PyBUF_INDIRECT) != 0);
if (__pyx_t_1) {
/* "View.MemoryView":533
*
* if flags & PyBUF_INDIRECT:
* info.suboffsets = self.view.suboffsets # <<<<<<<<<<<<<<
* else:
* info.suboffsets = NULL
*/
__pyx_t_4 = __pyx_v_self->view.suboffsets;
__pyx_v_info->suboffsets = __pyx_t_4;
/* "View.MemoryView":532
* info.strides = NULL
*
* if flags & PyBUF_INDIRECT: # <<<<<<<<<<<<<<
* info.suboffsets = self.view.suboffsets
* else:
*/
goto __pyx_L8;
}
/* "View.MemoryView":535
* info.suboffsets = self.view.suboffsets
* else:
* info.suboffsets = NULL # <<<<<<<<<<<<<<
*
* if flags & PyBUF_FORMAT:
*/
/*else*/ {
__pyx_v_info->suboffsets = NULL;
}
__pyx_L8:;
/* "View.MemoryView":537
* info.suboffsets = NULL
*
* if flags & PyBUF_FORMAT: # <<<<<<<<<<<<<<
* info.format = self.view.format
* else:
*/
__pyx_t_1 = ((__pyx_v_flags & PyBUF_FORMAT) != 0);
if (__pyx_t_1) {
/* "View.MemoryView":538
*
* if flags & PyBUF_FORMAT:
* info.format = self.view.format # <<<<<<<<<<<<<<
* else:
* info.format = NULL
*/
__pyx_t_5 = __pyx_v_self->view.format;
__pyx_v_info->format = __pyx_t_5;
/* "View.MemoryView":537
* info.suboffsets = NULL
*
* if flags & PyBUF_FORMAT: # <<<<<<<<<<<<<<
* info.format = self.view.format
* else:
*/
goto __pyx_L9;
}
/* "View.MemoryView":540
* info.format = self.view.format
* else:
* info.format = NULL # <<<<<<<<<<<<<<
*
* info.buf = self.view.buf
*/
/*else*/ {
__pyx_v_info->format = NULL;
}
__pyx_L9:;
/* "View.MemoryView":542
* info.format = NULL
*
* info.buf = self.view.buf # <<<<<<<<<<<<<<
* info.ndim = self.view.ndim
* info.itemsize = self.view.itemsize
*/
__pyx_t_6 = __pyx_v_self->view.buf;
__pyx_v_info->buf = __pyx_t_6;
/* "View.MemoryView":543
*
* info.buf = self.view.buf
* info.ndim = self.view.ndim # <<<<<<<<<<<<<<
* info.itemsize = self.view.itemsize
* info.len = self.view.len
*/
__pyx_t_7 = __pyx_v_self->view.ndim;
__pyx_v_info->ndim = __pyx_t_7;
/* "View.MemoryView":544
* info.buf = self.view.buf
* info.ndim = self.view.ndim
* info.itemsize = self.view.itemsize # <<<<<<<<<<<<<<
* info.len = self.view.len
* info.readonly = self.view.readonly
*/
__pyx_t_8 = __pyx_v_self->view.itemsize;
__pyx_v_info->itemsize = __pyx_t_8;
/* "View.MemoryView":545
* info.ndim = self.view.ndim
* info.itemsize = self.view.itemsize
* info.len = self.view.len # <<<<<<<<<<<<<<
* info.readonly = self.view.readonly
* info.obj = self
*/
__pyx_t_8 = __pyx_v_self->view.len;
__pyx_v_info->len = __pyx_t_8;
/* "View.MemoryView":546
* info.itemsize = self.view.itemsize
* info.len = self.view.len
* info.readonly = self.view.readonly # <<<<<<<<<<<<<<
* info.obj = self
*
*/
__pyx_t_1 = __pyx_v_self->view.readonly;
__pyx_v_info->readonly = __pyx_t_1;
/* "View.MemoryView":547
* info.len = self.view.len
* info.readonly = self.view.readonly
* info.obj = self # <<<<<<<<<<<<<<
*
* __pyx_getbuffer = capsule(<void *> &__pyx_memoryview_getbuffer, "getbuffer(obj, view, flags)")
*/
__Pyx_INCREF(((PyObject *)__pyx_v_self));
__Pyx_GIVEREF(((PyObject *)__pyx_v_self));
__Pyx_GOTREF(__pyx_v_info->obj);
__Pyx_DECREF(__pyx_v_info->obj);
__pyx_v_info->obj = ((PyObject *)__pyx_v_self);
/* "View.MemoryView":518
*
* @cname('getbuffer')
* def __getbuffer__(self, Py_buffer *info, int flags): # <<<<<<<<<<<<<<
* if flags & PyBUF_WRITABLE and self.view.readonly:
* raise ValueError("Cannot create writable memory view from read-only memoryview")
*/
/* function exit code */
__pyx_r = 0;
goto __pyx_L0;
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_3);
__Pyx_AddTraceback("View.MemoryView.memoryview.__getbuffer__", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = -1;
if (__pyx_v_info->obj != NULL) {
__Pyx_GOTREF(__pyx_v_info->obj);
__Pyx_DECREF(__pyx_v_info->obj); __pyx_v_info->obj = 0;
}
goto __pyx_L2;
__pyx_L0:;
if (__pyx_v_info->obj == Py_None) {
__Pyx_GOTREF(__pyx_v_info->obj);
__Pyx_DECREF(__pyx_v_info->obj); __pyx_v_info->obj = 0;
}
__pyx_L2:;
__Pyx_TraceReturn(Py_None, 0);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "View.MemoryView":553
*
* @property
* def T(self): # <<<<<<<<<<<<<<
* cdef _memoryviewslice result = memoryview_copy(self)
* transpose_memslice(&result.from_slice)
*/
/* Python wrapper */
static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_1T_1__get__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_1T_1__get__(PyObject *__pyx_v_self) {
PyObject *__pyx_r = 0;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
__pyx_r = __pyx_pf_15View_dot_MemoryView_10memoryview_1T___get__(((struct __pyx_memoryview_obj *)__pyx_v_self));
/* function exit code */
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_1T___get__(struct __pyx_memoryview_obj *__pyx_v_self) {
struct __pyx_memoryviewslice_obj *__pyx_v_result = 0;
PyObject *__pyx_r = NULL;
__Pyx_TraceDeclarations
__Pyx_RefNannyDeclarations
PyObject *__pyx_t_1 = NULL;
int __pyx_t_2;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("__get__", 0);
__Pyx_TraceCall("__get__", __pyx_f[1], 553, 0, __PYX_ERR(1, 553, __pyx_L1_error));
/* "View.MemoryView":554
* @property
* def T(self):
* cdef _memoryviewslice result = memoryview_copy(self) # <<<<<<<<<<<<<<
* transpose_memslice(&result.from_slice)
* return result
*/
__pyx_t_1 = __pyx_memoryview_copy_object(__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 554, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_memoryviewslice_type))))) __PYX_ERR(1, 554, __pyx_L1_error)
__pyx_v_result = ((struct __pyx_memoryviewslice_obj *)__pyx_t_1);
__pyx_t_1 = 0;
/* "View.MemoryView":555
* def T(self):
* cdef _memoryviewslice result = memoryview_copy(self)
* transpose_memslice(&result.from_slice) # <<<<<<<<<<<<<<
* return result
*
*/
__pyx_t_2 = __pyx_memslice_transpose((&__pyx_v_result->from_slice)); if (unlikely(__pyx_t_2 == ((int)0))) __PYX_ERR(1, 555, __pyx_L1_error)
/* "View.MemoryView":556
* cdef _memoryviewslice result = memoryview_copy(self)
* transpose_memslice(&result.from_slice)
* return result # <<<<<<<<<<<<<<
*
* @property
*/
__Pyx_XDECREF(__pyx_r);
__Pyx_INCREF(((PyObject *)__pyx_v_result));
__pyx_r = ((PyObject *)__pyx_v_result);
goto __pyx_L0;
/* "View.MemoryView":553
*
* @property
* def T(self): # <<<<<<<<<<<<<<
* cdef _memoryviewslice result = memoryview_copy(self)
* transpose_memslice(&result.from_slice)
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_1);
__Pyx_AddTraceback("View.MemoryView.memoryview.T.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = NULL;
__pyx_L0:;
__Pyx_XDECREF((PyObject *)__pyx_v_result);
__Pyx_XGIVEREF(__pyx_r);
__Pyx_TraceReturn(__pyx_r, 0);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "View.MemoryView":559
*
* @property
* def base(self): # <<<<<<<<<<<<<<
* return self.obj
*
*/
/* Python wrapper */
static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_4base_1__get__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_4base_1__get__(PyObject *__pyx_v_self) {
PyObject *__pyx_r = 0;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
__pyx_r = __pyx_pf_15View_dot_MemoryView_10memoryview_4base___get__(((struct __pyx_memoryview_obj *)__pyx_v_self));
/* function exit code */
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_4base___get__(struct __pyx_memoryview_obj *__pyx_v_self) {
PyObject *__pyx_r = NULL;
__Pyx_TraceDeclarations
__Pyx_RefNannyDeclarations
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("__get__", 0);
__Pyx_TraceCall("__get__", __pyx_f[1], 559, 0, __PYX_ERR(1, 559, __pyx_L1_error));
/* "View.MemoryView":560
* @property
* def base(self):
* return self.obj # <<<<<<<<<<<<<<
*
* @property
*/
__Pyx_XDECREF(__pyx_r);
__Pyx_INCREF(__pyx_v_self->obj);
__pyx_r = __pyx_v_self->obj;
goto __pyx_L0;
/* "View.MemoryView":559
*
* @property
* def base(self): # <<<<<<<<<<<<<<
* return self.obj
*
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_AddTraceback("View.MemoryView.memoryview.base.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = NULL;
__pyx_L0:;
__Pyx_XGIVEREF(__pyx_r);
__Pyx_TraceReturn(__pyx_r, 0);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "View.MemoryView":563
*
* @property
* def shape(self): # <<<<<<<<<<<<<<
* return tuple([length for length in self.view.shape[:self.view.ndim]])
*
*/
/* Python wrapper */
static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_5shape_1__get__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_5shape_1__get__(PyObject *__pyx_v_self) {
PyObject *__pyx_r = 0;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
__pyx_r = __pyx_pf_15View_dot_MemoryView_10memoryview_5shape___get__(((struct __pyx_memoryview_obj *)__pyx_v_self));
/* function exit code */
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_5shape___get__(struct __pyx_memoryview_obj *__pyx_v_self) {
Py_ssize_t __pyx_v_length;
PyObject *__pyx_r = NULL;
__Pyx_TraceDeclarations
__Pyx_RefNannyDeclarations
PyObject *__pyx_t_1 = NULL;
Py_ssize_t *__pyx_t_2;
Py_ssize_t *__pyx_t_3;
Py_ssize_t *__pyx_t_4;
PyObject *__pyx_t_5 = NULL;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("__get__", 0);
__Pyx_TraceCall("__get__", __pyx_f[1], 563, 0, __PYX_ERR(1, 563, __pyx_L1_error));
/* "View.MemoryView":564
* @property
* def shape(self):
* return tuple([length for length in self.view.shape[:self.view.ndim]]) # <<<<<<<<<<<<<<
*
* @property
*/
__Pyx_XDECREF(__pyx_r);
__pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 564, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_t_3 = (__pyx_v_self->view.shape + __pyx_v_self->view.ndim);
for (__pyx_t_4 = __pyx_v_self->view.shape; __pyx_t_4 < __pyx_t_3; __pyx_t_4++) {
__pyx_t_2 = __pyx_t_4;
__pyx_v_length = (__pyx_t_2[0]);
__pyx_t_5 = PyInt_FromSsize_t(__pyx_v_length); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 564, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
if (unlikely(__Pyx_ListComp_Append(__pyx_t_1, (PyObject*)__pyx_t_5))) __PYX_ERR(1, 564, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
}
__pyx_t_5 = PyList_AsTuple(((PyObject*)__pyx_t_1)); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 564, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__pyx_r = __pyx_t_5;
__pyx_t_5 = 0;
goto __pyx_L0;
/* "View.MemoryView":563
*
* @property
* def shape(self): # <<<<<<<<<<<<<<
* return tuple([length for length in self.view.shape[:self.view.ndim]])
*
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_1);
__Pyx_XDECREF(__pyx_t_5);
__Pyx_AddTraceback("View.MemoryView.memoryview.shape.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = NULL;
__pyx_L0:;
__Pyx_XGIVEREF(__pyx_r);
__Pyx_TraceReturn(__pyx_r, 0);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "View.MemoryView":567
*
* @property
* def strides(self): # <<<<<<<<<<<<<<
* if self.view.strides == NULL:
*
*/
/* Python wrapper */
static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_7strides_1__get__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_7strides_1__get__(PyObject *__pyx_v_self) {
PyObject *__pyx_r = 0;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
__pyx_r = __pyx_pf_15View_dot_MemoryView_10memoryview_7strides___get__(((struct __pyx_memoryview_obj *)__pyx_v_self));
/* function exit code */
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_7strides___get__(struct __pyx_memoryview_obj *__pyx_v_self) {
Py_ssize_t __pyx_v_stride;
PyObject *__pyx_r = NULL;
__Pyx_TraceDeclarations
__Pyx_RefNannyDeclarations
int __pyx_t_1;
PyObject *__pyx_t_2 = NULL;
Py_ssize_t *__pyx_t_3;
Py_ssize_t *__pyx_t_4;
Py_ssize_t *__pyx_t_5;
PyObject *__pyx_t_6 = NULL;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("__get__", 0);
__Pyx_TraceCall("__get__", __pyx_f[1], 567, 0, __PYX_ERR(1, 567, __pyx_L1_error));
/* "View.MemoryView":568
* @property
* def strides(self):
* if self.view.strides == NULL: # <<<<<<<<<<<<<<
*
* raise ValueError("Buffer view does not expose strides")
*/
__pyx_t_1 = ((__pyx_v_self->view.strides == NULL) != 0);
if (unlikely(__pyx_t_1)) {
/* "View.MemoryView":570
* if self.view.strides == NULL:
*
* raise ValueError("Buffer view does not expose strides") # <<<<<<<<<<<<<<
*
* return tuple([stride for stride in self.view.strides[:self.view.ndim]])
*/
__pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__29, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 570, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_Raise(__pyx_t_2, 0, 0, 0);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__PYX_ERR(1, 570, __pyx_L1_error)
/* "View.MemoryView":568
* @property
* def strides(self):
* if self.view.strides == NULL: # <<<<<<<<<<<<<<
*
* raise ValueError("Buffer view does not expose strides")
*/
}
/* "View.MemoryView":572
* raise ValueError("Buffer view does not expose strides")
*
* return tuple([stride for stride in self.view.strides[:self.view.ndim]]) # <<<<<<<<<<<<<<
*
* @property
*/
__Pyx_XDECREF(__pyx_r);
__pyx_t_2 = PyList_New(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 572, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__pyx_t_4 = (__pyx_v_self->view.strides + __pyx_v_self->view.ndim);
for (__pyx_t_5 = __pyx_v_self->view.strides; __pyx_t_5 < __pyx_t_4; __pyx_t_5++) {
__pyx_t_3 = __pyx_t_5;
__pyx_v_stride = (__pyx_t_3[0]);
__pyx_t_6 = PyInt_FromSsize_t(__pyx_v_stride); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 572, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
if (unlikely(__Pyx_ListComp_Append(__pyx_t_2, (PyObject*)__pyx_t_6))) __PYX_ERR(1, 572, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
}
__pyx_t_6 = PyList_AsTuple(((PyObject*)__pyx_t_2)); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 572, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__pyx_r = __pyx_t_6;
__pyx_t_6 = 0;
goto __pyx_L0;
/* "View.MemoryView":567
*
* @property
* def strides(self): # <<<<<<<<<<<<<<
* if self.view.strides == NULL:
*
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_2);
__Pyx_XDECREF(__pyx_t_6);
__Pyx_AddTraceback("View.MemoryView.memoryview.strides.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = NULL;
__pyx_L0:;
__Pyx_XGIVEREF(__pyx_r);
__Pyx_TraceReturn(__pyx_r, 0);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "View.MemoryView":575
*
* @property
* def suboffsets(self): # <<<<<<<<<<<<<<
* if self.view.suboffsets == NULL:
* return (-1,) * self.view.ndim
*/
/* Python wrapper */
static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_10suboffsets_1__get__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_10suboffsets_1__get__(PyObject *__pyx_v_self) {
PyObject *__pyx_r = 0;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
__pyx_r = __pyx_pf_15View_dot_MemoryView_10memoryview_10suboffsets___get__(((struct __pyx_memoryview_obj *)__pyx_v_self));
/* function exit code */
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_10suboffsets___get__(struct __pyx_memoryview_obj *__pyx_v_self) {
Py_ssize_t __pyx_v_suboffset;
PyObject *__pyx_r = NULL;
__Pyx_TraceDeclarations
__Pyx_RefNannyDeclarations
int __pyx_t_1;
PyObject *__pyx_t_2 = NULL;
PyObject *__pyx_t_3 = NULL;
Py_ssize_t *__pyx_t_4;
Py_ssize_t *__pyx_t_5;
Py_ssize_t *__pyx_t_6;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("__get__", 0);
__Pyx_TraceCall("__get__", __pyx_f[1], 575, 0, __PYX_ERR(1, 575, __pyx_L1_error));
/* "View.MemoryView":576
* @property
* def suboffsets(self):
* if self.view.suboffsets == NULL: # <<<<<<<<<<<<<<
* return (-1,) * self.view.ndim
*
*/
__pyx_t_1 = ((__pyx_v_self->view.suboffsets == NULL) != 0);
if (__pyx_t_1) {
/* "View.MemoryView":577
* def suboffsets(self):
* if self.view.suboffsets == NULL:
* return (-1,) * self.view.ndim # <<<<<<<<<<<<<<
*
* return tuple([suboffset for suboffset in self.view.suboffsets[:self.view.ndim]])
*/
__Pyx_XDECREF(__pyx_r);
__pyx_t_2 = __Pyx_PyInt_From_int(__pyx_v_self->view.ndim); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 577, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__pyx_t_3 = PyNumber_Multiply(__pyx_tuple__30, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 577, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__pyx_r = __pyx_t_3;
__pyx_t_3 = 0;
goto __pyx_L0;
/* "View.MemoryView":576
* @property
* def suboffsets(self):
* if self.view.suboffsets == NULL: # <<<<<<<<<<<<<<
* return (-1,) * self.view.ndim
*
*/
}
/* "View.MemoryView":579
* return (-1,) * self.view.ndim
*
* return tuple([suboffset for suboffset in self.view.suboffsets[:self.view.ndim]]) # <<<<<<<<<<<<<<
*
* @property
*/
__Pyx_XDECREF(__pyx_r);
__pyx_t_3 = PyList_New(0); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 579, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__pyx_t_5 = (__pyx_v_self->view.suboffsets + __pyx_v_self->view.ndim);
for (__pyx_t_6 = __pyx_v_self->view.suboffsets; __pyx_t_6 < __pyx_t_5; __pyx_t_6++) {
__pyx_t_4 = __pyx_t_6;
__pyx_v_suboffset = (__pyx_t_4[0]);
__pyx_t_2 = PyInt_FromSsize_t(__pyx_v_suboffset); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 579, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
if (unlikely(__Pyx_ListComp_Append(__pyx_t_3, (PyObject*)__pyx_t_2))) __PYX_ERR(1, 579, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
}
__pyx_t_2 = PyList_AsTuple(((PyObject*)__pyx_t_3)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 579, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__pyx_r = __pyx_t_2;
__pyx_t_2 = 0;
goto __pyx_L0;
/* "View.MemoryView":575
*
* @property
* def suboffsets(self): # <<<<<<<<<<<<<<
* if self.view.suboffsets == NULL:
* return (-1,) * self.view.ndim
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_2);
__Pyx_XDECREF(__pyx_t_3);
__Pyx_AddTraceback("View.MemoryView.memoryview.suboffsets.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = NULL;
__pyx_L0:;
__Pyx_XGIVEREF(__pyx_r);
__Pyx_TraceReturn(__pyx_r, 0);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "View.MemoryView":582
*
* @property
* def ndim(self): # <<<<<<<<<<<<<<
* return self.view.ndim
*
*/
/* Python wrapper */
static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_4ndim_1__get__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_4ndim_1__get__(PyObject *__pyx_v_self) {
PyObject *__pyx_r = 0;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
__pyx_r = __pyx_pf_15View_dot_MemoryView_10memoryview_4ndim___get__(((struct __pyx_memoryview_obj *)__pyx_v_self));
/* function exit code */
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_4ndim___get__(struct __pyx_memoryview_obj *__pyx_v_self) {
PyObject *__pyx_r = NULL;
__Pyx_TraceDeclarations
__Pyx_RefNannyDeclarations
PyObject *__pyx_t_1 = NULL;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("__get__", 0);
__Pyx_TraceCall("__get__", __pyx_f[1], 582, 0, __PYX_ERR(1, 582, __pyx_L1_error));
/* "View.MemoryView":583
* @property
* def ndim(self):
* return self.view.ndim # <<<<<<<<<<<<<<
*
* @property
*/
__Pyx_XDECREF(__pyx_r);
__pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_self->view.ndim); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 583, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_r = __pyx_t_1;
__pyx_t_1 = 0;
goto __pyx_L0;
/* "View.MemoryView":582
*
* @property
* def ndim(self): # <<<<<<<<<<<<<<
* return self.view.ndim
*
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_1);
__Pyx_AddTraceback("View.MemoryView.memoryview.ndim.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = NULL;
__pyx_L0:;
__Pyx_XGIVEREF(__pyx_r);
__Pyx_TraceReturn(__pyx_r, 0);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "View.MemoryView":586
*
* @property
* def itemsize(self): # <<<<<<<<<<<<<<
* return self.view.itemsize
*
*/
/* Python wrapper */
static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_8itemsize_1__get__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_8itemsize_1__get__(PyObject *__pyx_v_self) {
PyObject *__pyx_r = 0;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
__pyx_r = __pyx_pf_15View_dot_MemoryView_10memoryview_8itemsize___get__(((struct __pyx_memoryview_obj *)__pyx_v_self));
/* function exit code */
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_8itemsize___get__(struct __pyx_memoryview_obj *__pyx_v_self) {
PyObject *__pyx_r = NULL;
__Pyx_TraceDeclarations
__Pyx_RefNannyDeclarations
PyObject *__pyx_t_1 = NULL;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("__get__", 0);
__Pyx_TraceCall("__get__", __pyx_f[1], 586, 0, __PYX_ERR(1, 586, __pyx_L1_error));
/* "View.MemoryView":587
* @property
* def itemsize(self):
* return self.view.itemsize # <<<<<<<<<<<<<<
*
* @property
*/
__Pyx_XDECREF(__pyx_r);
__pyx_t_1 = PyInt_FromSsize_t(__pyx_v_self->view.itemsize); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 587, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_r = __pyx_t_1;
__pyx_t_1 = 0;
goto __pyx_L0;
/* "View.MemoryView":586
*
* @property
* def itemsize(self): # <<<<<<<<<<<<<<
* return self.view.itemsize
*
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_1);
__Pyx_AddTraceback("View.MemoryView.memoryview.itemsize.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = NULL;
__pyx_L0:;
__Pyx_XGIVEREF(__pyx_r);
__Pyx_TraceReturn(__pyx_r, 0);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "View.MemoryView":590
*
* @property
* def nbytes(self): # <<<<<<<<<<<<<<
* return self.size * self.view.itemsize
*
*/
/* Python wrapper */
static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_6nbytes_1__get__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_6nbytes_1__get__(PyObject *__pyx_v_self) {
PyObject *__pyx_r = 0;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
__pyx_r = __pyx_pf_15View_dot_MemoryView_10memoryview_6nbytes___get__(((struct __pyx_memoryview_obj *)__pyx_v_self));
/* function exit code */
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_6nbytes___get__(struct __pyx_memoryview_obj *__pyx_v_self) {
PyObject *__pyx_r = NULL;
__Pyx_TraceDeclarations
__Pyx_RefNannyDeclarations
PyObject *__pyx_t_1 = NULL;
PyObject *__pyx_t_2 = NULL;
PyObject *__pyx_t_3 = NULL;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("__get__", 0);
__Pyx_TraceCall("__get__", __pyx_f[1], 590, 0, __PYX_ERR(1, 590, __pyx_L1_error));
/* "View.MemoryView":591
* @property
* def nbytes(self):
* return self.size * self.view.itemsize # <<<<<<<<<<<<<<
*
* @property
*/
__Pyx_XDECREF(__pyx_r);
__pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_size); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 591, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_t_2 = PyInt_FromSsize_t(__pyx_v_self->view.itemsize); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 591, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__pyx_t_3 = PyNumber_Multiply(__pyx_t_1, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 591, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__pyx_r = __pyx_t_3;
__pyx_t_3 = 0;
goto __pyx_L0;
/* "View.MemoryView":590
*
* @property
* def nbytes(self): # <<<<<<<<<<<<<<
* return self.size * self.view.itemsize
*
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_1);
__Pyx_XDECREF(__pyx_t_2);
__Pyx_XDECREF(__pyx_t_3);
__Pyx_AddTraceback("View.MemoryView.memoryview.nbytes.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = NULL;
__pyx_L0:;
__Pyx_XGIVEREF(__pyx_r);
__Pyx_TraceReturn(__pyx_r, 0);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "View.MemoryView":594
*
* @property
* def size(self): # <<<<<<<<<<<<<<
* if self._size is None:
* result = 1
*/
/* Python wrapper */
static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_4size_1__get__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_4size_1__get__(PyObject *__pyx_v_self) {
PyObject *__pyx_r = 0;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
__pyx_r = __pyx_pf_15View_dot_MemoryView_10memoryview_4size___get__(((struct __pyx_memoryview_obj *)__pyx_v_self));
/* function exit code */
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_4size___get__(struct __pyx_memoryview_obj *__pyx_v_self) {
PyObject *__pyx_v_result = NULL;
PyObject *__pyx_v_length = NULL;
PyObject *__pyx_r = NULL;
__Pyx_TraceDeclarations
__Pyx_RefNannyDeclarations
int __pyx_t_1;
int __pyx_t_2;
Py_ssize_t *__pyx_t_3;
Py_ssize_t *__pyx_t_4;
Py_ssize_t *__pyx_t_5;
PyObject *__pyx_t_6 = NULL;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("__get__", 0);
__Pyx_TraceCall("__get__", __pyx_f[1], 594, 0, __PYX_ERR(1, 594, __pyx_L1_error));
/* "View.MemoryView":595
* @property
* def size(self):
* if self._size is None: # <<<<<<<<<<<<<<
* result = 1
*
*/
__pyx_t_1 = (__pyx_v_self->_size == Py_None);
__pyx_t_2 = (__pyx_t_1 != 0);
if (__pyx_t_2) {
/* "View.MemoryView":596
* def size(self):
* if self._size is None:
* result = 1 # <<<<<<<<<<<<<<
*
* for length in self.view.shape[:self.view.ndim]:
*/
__Pyx_INCREF(__pyx_int_1);
__pyx_v_result = __pyx_int_1;
/* "View.MemoryView":598
* result = 1
*
* for length in self.view.shape[:self.view.ndim]: # <<<<<<<<<<<<<<
* result *= length
*
*/
__pyx_t_4 = (__pyx_v_self->view.shape + __pyx_v_self->view.ndim);
for (__pyx_t_5 = __pyx_v_self->view.shape; __pyx_t_5 < __pyx_t_4; __pyx_t_5++) {
__pyx_t_3 = __pyx_t_5;
__pyx_t_6 = PyInt_FromSsize_t((__pyx_t_3[0])); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 598, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_XDECREF_SET(__pyx_v_length, __pyx_t_6);
__pyx_t_6 = 0;
/* "View.MemoryView":599
*
* for length in self.view.shape[:self.view.ndim]:
* result *= length # <<<<<<<<<<<<<<
*
* self._size = result
*/
__pyx_t_6 = PyNumber_InPlaceMultiply(__pyx_v_result, __pyx_v_length); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 599, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_DECREF_SET(__pyx_v_result, __pyx_t_6);
__pyx_t_6 = 0;
}
/* "View.MemoryView":601
* result *= length
*
* self._size = result # <<<<<<<<<<<<<<
*
* return self._size
*/
__Pyx_INCREF(__pyx_v_result);
__Pyx_GIVEREF(__pyx_v_result);
__Pyx_GOTREF(__pyx_v_self->_size);
__Pyx_DECREF(__pyx_v_self->_size);
__pyx_v_self->_size = __pyx_v_result;
/* "View.MemoryView":595
* @property
* def size(self):
* if self._size is None: # <<<<<<<<<<<<<<
* result = 1
*
*/
}
/* "View.MemoryView":603
* self._size = result
*
* return self._size # <<<<<<<<<<<<<<
*
* def __len__(self):
*/
__Pyx_XDECREF(__pyx_r);
__Pyx_INCREF(__pyx_v_self->_size);
__pyx_r = __pyx_v_self->_size;
goto __pyx_L0;
/* "View.MemoryView":594
*
* @property
* def size(self): # <<<<<<<<<<<<<<
* if self._size is None:
* result = 1
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_6);
__Pyx_AddTraceback("View.MemoryView.memoryview.size.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = NULL;
__pyx_L0:;
__Pyx_XDECREF(__pyx_v_result);
__Pyx_XDECREF(__pyx_v_length);
__Pyx_XGIVEREF(__pyx_r);
__Pyx_TraceReturn(__pyx_r, 0);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "View.MemoryView":605
* return self._size
*
* def __len__(self): # <<<<<<<<<<<<<<
* if self.view.ndim >= 1:
* return self.view.shape[0]
*/
/* Python wrapper */
static Py_ssize_t __pyx_memoryview___len__(PyObject *__pyx_v_self); /*proto*/
static Py_ssize_t __pyx_memoryview___len__(PyObject *__pyx_v_self) {
Py_ssize_t __pyx_r;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("__len__ (wrapper)", 0);
__pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_10__len__(((struct __pyx_memoryview_obj *)__pyx_v_self));
/* function exit code */
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
static Py_ssize_t __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_10__len__(struct __pyx_memoryview_obj *__pyx_v_self) {
Py_ssize_t __pyx_r;
__Pyx_TraceDeclarations
__Pyx_RefNannyDeclarations
int __pyx_t_1;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("__len__", 0);
__Pyx_TraceCall("__len__", __pyx_f[1], 605, 0, __PYX_ERR(1, 605, __pyx_L1_error));
/* "View.MemoryView":606
*
* def __len__(self):
* if self.view.ndim >= 1: # <<<<<<<<<<<<<<
* return self.view.shape[0]
*
*/
__pyx_t_1 = ((__pyx_v_self->view.ndim >= 1) != 0);
if (__pyx_t_1) {
/* "View.MemoryView":607
* def __len__(self):
* if self.view.ndim >= 1:
* return self.view.shape[0] # <<<<<<<<<<<<<<
*
* return 0
*/
__pyx_r = (__pyx_v_self->view.shape[0]);
goto __pyx_L0;
/* "View.MemoryView":606
*
* def __len__(self):
* if self.view.ndim >= 1: # <<<<<<<<<<<<<<
* return self.view.shape[0]
*
*/
}
/* "View.MemoryView":609
* return self.view.shape[0]
*
* return 0 # <<<<<<<<<<<<<<
*
* def __repr__(self):
*/
__pyx_r = 0;
goto __pyx_L0;
/* "View.MemoryView":605
* return self._size
*
* def __len__(self): # <<<<<<<<<<<<<<
* if self.view.ndim >= 1:
* return self.view.shape[0]
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_AddTraceback("View.MemoryView.memoryview.__len__", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = -1;
__pyx_L0:;
__Pyx_TraceReturn(Py_None, 0);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "View.MemoryView":611
* return 0
*
* def __repr__(self): # <<<<<<<<<<<<<<
* return "<MemoryView of %r at 0x%x>" % (self.base.__class__.__name__,
* id(self))
*/
/* Python wrapper */
static PyObject *__pyx_memoryview___repr__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_memoryview___repr__(PyObject *__pyx_v_self) {
PyObject *__pyx_r = 0;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("__repr__ (wrapper)", 0);
__pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_12__repr__(((struct __pyx_memoryview_obj *)__pyx_v_self));
/* function exit code */
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_12__repr__(struct __pyx_memoryview_obj *__pyx_v_self) {
PyObject *__pyx_r = NULL;
__Pyx_TraceDeclarations
__Pyx_RefNannyDeclarations
PyObject *__pyx_t_1 = NULL;
PyObject *__pyx_t_2 = NULL;
PyObject *__pyx_t_3 = NULL;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("__repr__", 0);
__Pyx_TraceCall("__repr__", __pyx_f[1], 611, 0, __PYX_ERR(1, 611, __pyx_L1_error));
/* "View.MemoryView":612
*
* def __repr__(self):
* return "<MemoryView of %r at 0x%x>" % (self.base.__class__.__name__, # <<<<<<<<<<<<<<
* id(self))
*
*/
__Pyx_XDECREF(__pyx_r);
__pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_base); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 612, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_class); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 612, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_name_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 612, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
/* "View.MemoryView":613
* def __repr__(self):
* return "<MemoryView of %r at 0x%x>" % (self.base.__class__.__name__,
* id(self)) # <<<<<<<<<<<<<<
*
* def __str__(self):
*/
__pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_builtin_id, ((PyObject *)__pyx_v_self)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 613, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
/* "View.MemoryView":612
*
* def __repr__(self):
* return "<MemoryView of %r at 0x%x>" % (self.base.__class__.__name__, # <<<<<<<<<<<<<<
* id(self))
*
*/
__pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 612, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_GIVEREF(__pyx_t_1);
PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_1);
__Pyx_GIVEREF(__pyx_t_2);
PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_2);
__pyx_t_1 = 0;
__pyx_t_2 = 0;
__pyx_t_2 = __Pyx_PyString_Format(__pyx_kp_s_MemoryView_of_r_at_0x_x, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 612, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__pyx_r = __pyx_t_2;
__pyx_t_2 = 0;
goto __pyx_L0;
/* "View.MemoryView":611
* return 0
*
* def __repr__(self): # <<<<<<<<<<<<<<
* return "<MemoryView of %r at 0x%x>" % (self.base.__class__.__name__,
* id(self))
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_1);
__Pyx_XDECREF(__pyx_t_2);
__Pyx_XDECREF(__pyx_t_3);
__Pyx_AddTraceback("View.MemoryView.memoryview.__repr__", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = NULL;
__pyx_L0:;
__Pyx_XGIVEREF(__pyx_r);
__Pyx_TraceReturn(__pyx_r, 0);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "View.MemoryView":615
* id(self))
*
* def __str__(self): # <<<<<<<<<<<<<<
* return "<MemoryView of %r object>" % (self.base.__class__.__name__,)
*
*/
/* Python wrapper */
static PyObject *__pyx_memoryview___str__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_memoryview___str__(PyObject *__pyx_v_self) {
PyObject *__pyx_r = 0;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("__str__ (wrapper)", 0);
__pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_14__str__(((struct __pyx_memoryview_obj *)__pyx_v_self));
/* function exit code */
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_14__str__(struct __pyx_memoryview_obj *__pyx_v_self) {
PyObject *__pyx_r = NULL;
__Pyx_TraceDeclarations
__Pyx_RefNannyDeclarations
PyObject *__pyx_t_1 = NULL;
PyObject *__pyx_t_2 = NULL;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("__str__", 0);
__Pyx_TraceCall("__str__", __pyx_f[1], 615, 0, __PYX_ERR(1, 615, __pyx_L1_error));
/* "View.MemoryView":616
*
* def __str__(self):
* return "<MemoryView of %r object>" % (self.base.__class__.__name__,) # <<<<<<<<<<<<<<
*
*
*/
__Pyx_XDECREF(__pyx_r);
__pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_base); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 616, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_class); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 616, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_name_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 616, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 616, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_GIVEREF(__pyx_t_1);
PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_1);
__pyx_t_1 = 0;
__pyx_t_1 = __Pyx_PyString_Format(__pyx_kp_s_MemoryView_of_r_object, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 616, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__pyx_r = __pyx_t_1;
__pyx_t_1 = 0;
goto __pyx_L0;
/* "View.MemoryView":615
* id(self))
*
* def __str__(self): # <<<<<<<<<<<<<<
* return "<MemoryView of %r object>" % (self.base.__class__.__name__,)
*
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_1);
__Pyx_XDECREF(__pyx_t_2);
__Pyx_AddTraceback("View.MemoryView.memoryview.__str__", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = NULL;
__pyx_L0:;
__Pyx_XGIVEREF(__pyx_r);
__Pyx_TraceReturn(__pyx_r, 0);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "View.MemoryView":619
*
*
* def is_c_contig(self): # <<<<<<<<<<<<<<
* cdef __Pyx_memviewslice *mslice
* cdef __Pyx_memviewslice tmp
*/
/* Python wrapper */
static PyObject *__pyx_memoryview_is_c_contig(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
static PyObject *__pyx_memoryview_is_c_contig(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
PyObject *__pyx_r = 0;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("is_c_contig (wrapper)", 0);
__pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_16is_c_contig(((struct __pyx_memoryview_obj *)__pyx_v_self));
/* function exit code */
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_16is_c_contig(struct __pyx_memoryview_obj *__pyx_v_self) {
__Pyx_memviewslice *__pyx_v_mslice;
__Pyx_memviewslice __pyx_v_tmp;
PyObject *__pyx_r = NULL;
__Pyx_TraceDeclarations
__Pyx_RefNannyDeclarations
__Pyx_memviewslice *__pyx_t_1;
PyObject *__pyx_t_2 = NULL;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("is_c_contig", 0);
__Pyx_TraceCall("is_c_contig", __pyx_f[1], 619, 0, __PYX_ERR(1, 619, __pyx_L1_error));
/* "View.MemoryView":622
* cdef __Pyx_memviewslice *mslice
* cdef __Pyx_memviewslice tmp
* mslice = get_slice_from_memview(self, &tmp) # <<<<<<<<<<<<<<
* return slice_is_contig(mslice[0], 'C', self.view.ndim)
*
*/
__pyx_t_1 = __pyx_memoryview_get_slice_from_memoryview(__pyx_v_self, (&__pyx_v_tmp)); if (unlikely(__pyx_t_1 == ((__Pyx_memviewslice *)NULL))) __PYX_ERR(1, 622, __pyx_L1_error)
__pyx_v_mslice = __pyx_t_1;
/* "View.MemoryView":623
* cdef __Pyx_memviewslice tmp
* mslice = get_slice_from_memview(self, &tmp)
* return slice_is_contig(mslice[0], 'C', self.view.ndim) # <<<<<<<<<<<<<<
*
* def is_f_contig(self):
*/
__Pyx_XDECREF(__pyx_r);
__pyx_t_2 = __Pyx_PyBool_FromLong(__pyx_memviewslice_is_contig((__pyx_v_mslice[0]), 'C', __pyx_v_self->view.ndim)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 623, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__pyx_r = __pyx_t_2;
__pyx_t_2 = 0;
goto __pyx_L0;
/* "View.MemoryView":619
*
*
* def is_c_contig(self): # <<<<<<<<<<<<<<
* cdef __Pyx_memviewslice *mslice
* cdef __Pyx_memviewslice tmp
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_2);
__Pyx_AddTraceback("View.MemoryView.memoryview.is_c_contig", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = NULL;
__pyx_L0:;
__Pyx_XGIVEREF(__pyx_r);
__Pyx_TraceReturn(__pyx_r, 0);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "View.MemoryView":625
* return slice_is_contig(mslice[0], 'C', self.view.ndim)
*
* def is_f_contig(self): # <<<<<<<<<<<<<<
* cdef __Pyx_memviewslice *mslice
* cdef __Pyx_memviewslice tmp
*/
/* Python wrapper */
static PyObject *__pyx_memoryview_is_f_contig(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
static PyObject *__pyx_memoryview_is_f_contig(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
PyObject *__pyx_r = 0;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("is_f_contig (wrapper)", 0);
__pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_18is_f_contig(((struct __pyx_memoryview_obj *)__pyx_v_self));
/* function exit code */
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_18is_f_contig(struct __pyx_memoryview_obj *__pyx_v_self) {
__Pyx_memviewslice *__pyx_v_mslice;
__Pyx_memviewslice __pyx_v_tmp;
PyObject *__pyx_r = NULL;
__Pyx_TraceDeclarations
__Pyx_RefNannyDeclarations
__Pyx_memviewslice *__pyx_t_1;
PyObject *__pyx_t_2 = NULL;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("is_f_contig", 0);
__Pyx_TraceCall("is_f_contig", __pyx_f[1], 625, 0, __PYX_ERR(1, 625, __pyx_L1_error));
/* "View.MemoryView":628
* cdef __Pyx_memviewslice *mslice
* cdef __Pyx_memviewslice tmp
* mslice = get_slice_from_memview(self, &tmp) # <<<<<<<<<<<<<<
* return slice_is_contig(mslice[0], 'F', self.view.ndim)
*
*/
__pyx_t_1 = __pyx_memoryview_get_slice_from_memoryview(__pyx_v_self, (&__pyx_v_tmp)); if (unlikely(__pyx_t_1 == ((__Pyx_memviewslice *)NULL))) __PYX_ERR(1, 628, __pyx_L1_error)
__pyx_v_mslice = __pyx_t_1;
/* "View.MemoryView":629
* cdef __Pyx_memviewslice tmp
* mslice = get_slice_from_memview(self, &tmp)
* return slice_is_contig(mslice[0], 'F', self.view.ndim) # <<<<<<<<<<<<<<
*
* def copy(self):
*/
__Pyx_XDECREF(__pyx_r);
__pyx_t_2 = __Pyx_PyBool_FromLong(__pyx_memviewslice_is_contig((__pyx_v_mslice[0]), 'F', __pyx_v_self->view.ndim)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 629, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__pyx_r = __pyx_t_2;
__pyx_t_2 = 0;
goto __pyx_L0;
/* "View.MemoryView":625
* return slice_is_contig(mslice[0], 'C', self.view.ndim)
*
* def is_f_contig(self): # <<<<<<<<<<<<<<
* cdef __Pyx_memviewslice *mslice
* cdef __Pyx_memviewslice tmp
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_2);
__Pyx_AddTraceback("View.MemoryView.memoryview.is_f_contig", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = NULL;
__pyx_L0:;
__Pyx_XGIVEREF(__pyx_r);
__Pyx_TraceReturn(__pyx_r, 0);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "View.MemoryView":631
* return slice_is_contig(mslice[0], 'F', self.view.ndim)
*
* def copy(self): # <<<<<<<<<<<<<<
* cdef __Pyx_memviewslice mslice
* cdef int flags = self.flags & ~PyBUF_F_CONTIGUOUS
*/
/* Python wrapper */
static PyObject *__pyx_memoryview_copy(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
static PyObject *__pyx_memoryview_copy(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
PyObject *__pyx_r = 0;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("copy (wrapper)", 0);
__pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_20copy(((struct __pyx_memoryview_obj *)__pyx_v_self));
/* function exit code */
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_20copy(struct __pyx_memoryview_obj *__pyx_v_self) {
__Pyx_memviewslice __pyx_v_mslice;
int __pyx_v_flags;
PyObject *__pyx_r = NULL;
__Pyx_TraceDeclarations
__Pyx_RefNannyDeclarations
__Pyx_memviewslice __pyx_t_1;
PyObject *__pyx_t_2 = NULL;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("copy", 0);
__Pyx_TraceCall("copy", __pyx_f[1], 631, 0, __PYX_ERR(1, 631, __pyx_L1_error));
/* "View.MemoryView":633
* def copy(self):
* cdef __Pyx_memviewslice mslice
* cdef int flags = self.flags & ~PyBUF_F_CONTIGUOUS # <<<<<<<<<<<<<<
*
* slice_copy(self, &mslice)
*/
__pyx_v_flags = (__pyx_v_self->flags & (~PyBUF_F_CONTIGUOUS));
/* "View.MemoryView":635
* cdef int flags = self.flags & ~PyBUF_F_CONTIGUOUS
*
* slice_copy(self, &mslice) # <<<<<<<<<<<<<<
* mslice = slice_copy_contig(&mslice, "c", self.view.ndim,
* self.view.itemsize,
*/
__pyx_memoryview_slice_copy(__pyx_v_self, (&__pyx_v_mslice));
/* "View.MemoryView":636
*
* slice_copy(self, &mslice)
* mslice = slice_copy_contig(&mslice, "c", self.view.ndim, # <<<<<<<<<<<<<<
* self.view.itemsize,
* flags|PyBUF_C_CONTIGUOUS,
*/
__pyx_t_1 = __pyx_memoryview_copy_new_contig((&__pyx_v_mslice), ((char *)"c"), __pyx_v_self->view.ndim, __pyx_v_self->view.itemsize, (__pyx_v_flags | PyBUF_C_CONTIGUOUS), __pyx_v_self->dtype_is_object); if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 636, __pyx_L1_error)
__pyx_v_mslice = __pyx_t_1;
/* "View.MemoryView":641
* self.dtype_is_object)
*
* return memoryview_copy_from_slice(self, &mslice) # <<<<<<<<<<<<<<
*
* def copy_fortran(self):
*/
__Pyx_XDECREF(__pyx_r);
__pyx_t_2 = __pyx_memoryview_copy_object_from_slice(__pyx_v_self, (&__pyx_v_mslice)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 641, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__pyx_r = __pyx_t_2;
__pyx_t_2 = 0;
goto __pyx_L0;
/* "View.MemoryView":631
* return slice_is_contig(mslice[0], 'F', self.view.ndim)
*
* def copy(self): # <<<<<<<<<<<<<<
* cdef __Pyx_memviewslice mslice
* cdef int flags = self.flags & ~PyBUF_F_CONTIGUOUS
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_2);
__Pyx_AddTraceback("View.MemoryView.memoryview.copy", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = NULL;
__pyx_L0:;
__Pyx_XGIVEREF(__pyx_r);
__Pyx_TraceReturn(__pyx_r, 0);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "View.MemoryView":643
* return memoryview_copy_from_slice(self, &mslice)
*
* def copy_fortran(self): # <<<<<<<<<<<<<<
* cdef __Pyx_memviewslice src, dst
* cdef int flags = self.flags & ~PyBUF_C_CONTIGUOUS
*/
/* Python wrapper */
static PyObject *__pyx_memoryview_copy_fortran(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
static PyObject *__pyx_memoryview_copy_fortran(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
PyObject *__pyx_r = 0;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("copy_fortran (wrapper)", 0);
__pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_22copy_fortran(((struct __pyx_memoryview_obj *)__pyx_v_self));
/* function exit code */
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_22copy_fortran(struct __pyx_memoryview_obj *__pyx_v_self) {
__Pyx_memviewslice __pyx_v_src;
__Pyx_memviewslice __pyx_v_dst;
int __pyx_v_flags;
PyObject *__pyx_r = NULL;
__Pyx_TraceDeclarations
__Pyx_RefNannyDeclarations
__Pyx_memviewslice __pyx_t_1;
PyObject *__pyx_t_2 = NULL;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("copy_fortran", 0);
__Pyx_TraceCall("copy_fortran", __pyx_f[1], 643, 0, __PYX_ERR(1, 643, __pyx_L1_error));
/* "View.MemoryView":645
* def copy_fortran(self):
* cdef __Pyx_memviewslice src, dst
* cdef int flags = self.flags & ~PyBUF_C_CONTIGUOUS # <<<<<<<<<<<<<<
*
* slice_copy(self, &src)
*/
__pyx_v_flags = (__pyx_v_self->flags & (~PyBUF_C_CONTIGUOUS));
/* "View.MemoryView":647
* cdef int flags = self.flags & ~PyBUF_C_CONTIGUOUS
*
* slice_copy(self, &src) # <<<<<<<<<<<<<<
* dst = slice_copy_contig(&src, "fortran", self.view.ndim,
* self.view.itemsize,
*/
__pyx_memoryview_slice_copy(__pyx_v_self, (&__pyx_v_src));
/* "View.MemoryView":648
*
* slice_copy(self, &src)
* dst = slice_copy_contig(&src, "fortran", self.view.ndim, # <<<<<<<<<<<<<<
* self.view.itemsize,
* flags|PyBUF_F_CONTIGUOUS,
*/
__pyx_t_1 = __pyx_memoryview_copy_new_contig((&__pyx_v_src), ((char *)"fortran"), __pyx_v_self->view.ndim, __pyx_v_self->view.itemsize, (__pyx_v_flags | PyBUF_F_CONTIGUOUS), __pyx_v_self->dtype_is_object); if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 648, __pyx_L1_error)
__pyx_v_dst = __pyx_t_1;
/* "View.MemoryView":653
* self.dtype_is_object)
*
* return memoryview_copy_from_slice(self, &dst) # <<<<<<<<<<<<<<
*
*
*/
__Pyx_XDECREF(__pyx_r);
__pyx_t_2 = __pyx_memoryview_copy_object_from_slice(__pyx_v_self, (&__pyx_v_dst)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 653, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__pyx_r = __pyx_t_2;
__pyx_t_2 = 0;
goto __pyx_L0;
/* "View.MemoryView":643
* return memoryview_copy_from_slice(self, &mslice)
*
* def copy_fortran(self): # <<<<<<<<<<<<<<
* cdef __Pyx_memviewslice src, dst
* cdef int flags = self.flags & ~PyBUF_C_CONTIGUOUS
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_2);
__Pyx_AddTraceback("View.MemoryView.memoryview.copy_fortran", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = NULL;
__pyx_L0:;
__Pyx_XGIVEREF(__pyx_r);
__Pyx_TraceReturn(__pyx_r, 0);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "(tree fragment)":1
* def __reduce_cython__(self): # <<<<<<<<<<<<<<
* raise TypeError("no default __reduce__ due to non-trivial __cinit__")
* def __setstate_cython__(self, __pyx_state):
*/
/* Python wrapper */
static PyObject *__pyx_pw___pyx_memoryview_1__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
static PyObject *__pyx_pw___pyx_memoryview_1__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
PyObject *__pyx_r = 0;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0);
__pyx_r = __pyx_pf___pyx_memoryview___reduce_cython__(((struct __pyx_memoryview_obj *)__pyx_v_self));
/* function exit code */
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
static PyObject *__pyx_pf___pyx_memoryview___reduce_cython__(CYTHON_UNUSED struct __pyx_memoryview_obj *__pyx_v_self) {
PyObject *__pyx_r = NULL;
__Pyx_TraceDeclarations
__Pyx_RefNannyDeclarations
PyObject *__pyx_t_1 = NULL;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("__reduce_cython__", 0);
__Pyx_TraceCall("__reduce_cython__", __pyx_f[1], 1, 0, __PYX_ERR(1, 1, __pyx_L1_error));
/* "(tree fragment)":2
* def __reduce_cython__(self):
* raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<<
* def __setstate_cython__(self, __pyx_state):
* raise TypeError("no default __reduce__ due to non-trivial __cinit__")
*/
__pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__31, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_Raise(__pyx_t_1, 0, 0, 0);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__PYX_ERR(1, 2, __pyx_L1_error)
/* "(tree fragment)":1
* def __reduce_cython__(self): # <<<<<<<<<<<<<<
* raise TypeError("no default __reduce__ due to non-trivial __cinit__")
* def __setstate_cython__(self, __pyx_state):
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_1);
__Pyx_AddTraceback("View.MemoryView.memoryview.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = NULL;
__Pyx_XGIVEREF(__pyx_r);
__Pyx_TraceReturn(__pyx_r, 0);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "(tree fragment)":3
* def __reduce_cython__(self):
* raise TypeError("no default __reduce__ due to non-trivial __cinit__")
* def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<<
* raise TypeError("no default __reduce__ due to non-trivial __cinit__")
*/
/* Python wrapper */
static PyObject *__pyx_pw___pyx_memoryview_3__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state); /*proto*/
static PyObject *__pyx_pw___pyx_memoryview_3__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state) {
PyObject *__pyx_r = 0;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0);
__pyx_r = __pyx_pf___pyx_memoryview_2__setstate_cython__(((struct __pyx_memoryview_obj *)__pyx_v_self), ((PyObject *)__pyx_v___pyx_state));
/* function exit code */
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
static PyObject *__pyx_pf___pyx_memoryview_2__setstate_cython__(CYTHON_UNUSED struct __pyx_memoryview_obj *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) {
PyObject *__pyx_r = NULL;
__Pyx_TraceDeclarations
__Pyx_RefNannyDeclarations
PyObject *__pyx_t_1 = NULL;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("__setstate_cython__", 0);
__Pyx_TraceCall("__setstate_cython__", __pyx_f[1], 3, 0, __PYX_ERR(1, 3, __pyx_L1_error));
/* "(tree fragment)":4
* raise TypeError("no default __reduce__ due to non-trivial __cinit__")
* def __setstate_cython__(self, __pyx_state):
* raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<<
*/
__pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__32, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 4, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_Raise(__pyx_t_1, 0, 0, 0);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__PYX_ERR(1, 4, __pyx_L1_error)
/* "(tree fragment)":3
* def __reduce_cython__(self):
* raise TypeError("no default __reduce__ due to non-trivial __cinit__")
* def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<<
* raise TypeError("no default __reduce__ due to non-trivial __cinit__")
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_1);
__Pyx_AddTraceback("View.MemoryView.memoryview.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = NULL;
__Pyx_XGIVEREF(__pyx_r);
__Pyx_TraceReturn(__pyx_r, 0);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "View.MemoryView":657
*
* @cname('__pyx_memoryview_new')
* cdef memoryview_cwrapper(object o, int flags, bint dtype_is_object, __Pyx_TypeInfo *typeinfo): # <<<<<<<<<<<<<<
* cdef memoryview result = memoryview(o, flags, dtype_is_object)
* result.typeinfo = typeinfo
*/
static PyObject *__pyx_memoryview_new(PyObject *__pyx_v_o, int __pyx_v_flags, int __pyx_v_dtype_is_object, __Pyx_TypeInfo *__pyx_v_typeinfo) {
struct __pyx_memoryview_obj *__pyx_v_result = 0;
PyObject *__pyx_r = NULL;
__Pyx_TraceDeclarations
__Pyx_RefNannyDeclarations
PyObject *__pyx_t_1 = NULL;
PyObject *__pyx_t_2 = NULL;
PyObject *__pyx_t_3 = NULL;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("memoryview_cwrapper", 0);
__Pyx_TraceCall("memoryview_cwrapper", __pyx_f[1], 657, 0, __PYX_ERR(1, 657, __pyx_L1_error));
/* "View.MemoryView":658
* @cname('__pyx_memoryview_new')
* cdef memoryview_cwrapper(object o, int flags, bint dtype_is_object, __Pyx_TypeInfo *typeinfo):
* cdef memoryview result = memoryview(o, flags, dtype_is_object) # <<<<<<<<<<<<<<
* result.typeinfo = typeinfo
* return result
*/
__pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_flags); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 658, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_t_2 = __Pyx_PyBool_FromLong(__pyx_v_dtype_is_object); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 658, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 658, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_INCREF(__pyx_v_o);
__Pyx_GIVEREF(__pyx_v_o);
PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_v_o);
__Pyx_GIVEREF(__pyx_t_1);
PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_1);
__Pyx_GIVEREF(__pyx_t_2);
PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_t_2);
__pyx_t_1 = 0;
__pyx_t_2 = 0;
__pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_memoryview_type), __pyx_t_3, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 658, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__pyx_v_result = ((struct __pyx_memoryview_obj *)__pyx_t_2);
__pyx_t_2 = 0;
/* "View.MemoryView":659
* cdef memoryview_cwrapper(object o, int flags, bint dtype_is_object, __Pyx_TypeInfo *typeinfo):
* cdef memoryview result = memoryview(o, flags, dtype_is_object)
* result.typeinfo = typeinfo # <<<<<<<<<<<<<<
* return result
*
*/
__pyx_v_result->typeinfo = __pyx_v_typeinfo;
/* "View.MemoryView":660
* cdef memoryview result = memoryview(o, flags, dtype_is_object)
* result.typeinfo = typeinfo
* return result # <<<<<<<<<<<<<<
*
* @cname('__pyx_memoryview_check')
*/
__Pyx_XDECREF(__pyx_r);
__Pyx_INCREF(((PyObject *)__pyx_v_result));
__pyx_r = ((PyObject *)__pyx_v_result);
goto __pyx_L0;
/* "View.MemoryView":657
*
* @cname('__pyx_memoryview_new')
* cdef memoryview_cwrapper(object o, int flags, bint dtype_is_object, __Pyx_TypeInfo *typeinfo): # <<<<<<<<<<<<<<
* cdef memoryview result = memoryview(o, flags, dtype_is_object)
* result.typeinfo = typeinfo
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_1);
__Pyx_XDECREF(__pyx_t_2);
__Pyx_XDECREF(__pyx_t_3);
__Pyx_AddTraceback("View.MemoryView.memoryview_cwrapper", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = 0;
__pyx_L0:;
__Pyx_XDECREF((PyObject *)__pyx_v_result);
__Pyx_XGIVEREF(__pyx_r);
__Pyx_TraceReturn(__pyx_r, 0);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "View.MemoryView":663
*
* @cname('__pyx_memoryview_check')
* cdef inline bint memoryview_check(object o): # <<<<<<<<<<<<<<
* return isinstance(o, memoryview)
*
*/
static CYTHON_INLINE int __pyx_memoryview_check(PyObject *__pyx_v_o) {
int __pyx_r;
__Pyx_TraceDeclarations
__Pyx_RefNannyDeclarations
int __pyx_t_1;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("memoryview_check", 0);
__Pyx_TraceCall("memoryview_check", __pyx_f[1], 663, 0, __PYX_ERR(1, 663, __pyx_L1_error));
/* "View.MemoryView":664
* @cname('__pyx_memoryview_check')
* cdef inline bint memoryview_check(object o):
* return isinstance(o, memoryview) # <<<<<<<<<<<<<<
*
* cdef tuple _unellipsify(object index, int ndim):
*/
__pyx_t_1 = __Pyx_TypeCheck(__pyx_v_o, __pyx_memoryview_type);
__pyx_r = __pyx_t_1;
goto __pyx_L0;
/* "View.MemoryView":663
*
* @cname('__pyx_memoryview_check')
* cdef inline bint memoryview_check(object o): # <<<<<<<<<<<<<<
* return isinstance(o, memoryview)
*
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_WriteUnraisable("View.MemoryView.memoryview_check", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0);
__pyx_r = 0;
__pyx_L0:;
__Pyx_TraceReturn(Py_None, 0);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "View.MemoryView":666
* return isinstance(o, memoryview)
*
* cdef tuple _unellipsify(object index, int ndim): # <<<<<<<<<<<<<<
* """
* Replace all ellipses with full slices and fill incomplete indices with
*/
static PyObject *_unellipsify(PyObject *__pyx_v_index, int __pyx_v_ndim) {
PyObject *__pyx_v_tup = NULL;
PyObject *__pyx_v_result = NULL;
int __pyx_v_have_slices;
int __pyx_v_seen_ellipsis;
CYTHON_UNUSED PyObject *__pyx_v_idx = NULL;
PyObject *__pyx_v_item = NULL;
Py_ssize_t __pyx_v_nslices;
PyObject *__pyx_r = NULL;
__Pyx_TraceDeclarations
__Pyx_RefNannyDeclarations
int __pyx_t_1;
int __pyx_t_2;
PyObject *__pyx_t_3 = NULL;
PyObject *__pyx_t_4 = NULL;
Py_ssize_t __pyx_t_5;
PyObject *(*__pyx_t_6)(PyObject *);
PyObject *__pyx_t_7 = NULL;
Py_ssize_t __pyx_t_8;
int __pyx_t_9;
int __pyx_t_10;
PyObject *__pyx_t_11 = NULL;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("_unellipsify", 0);
__Pyx_TraceCall("_unellipsify", __pyx_f[1], 666, 0, __PYX_ERR(1, 666, __pyx_L1_error));
/* "View.MemoryView":671
* full slices.
* """
* if not isinstance(index, tuple): # <<<<<<<<<<<<<<
* tup = (index,)
* else:
*/
__pyx_t_1 = PyTuple_Check(__pyx_v_index);
__pyx_t_2 = ((!(__pyx_t_1 != 0)) != 0);
if (__pyx_t_2) {
/* "View.MemoryView":672
* """
* if not isinstance(index, tuple):
* tup = (index,) # <<<<<<<<<<<<<<
* else:
* tup = index
*/
__pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 672, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_INCREF(__pyx_v_index);
__Pyx_GIVEREF(__pyx_v_index);
PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_v_index);
__pyx_v_tup = __pyx_t_3;
__pyx_t_3 = 0;
/* "View.MemoryView":671
* full slices.
* """
* if not isinstance(index, tuple): # <<<<<<<<<<<<<<
* tup = (index,)
* else:
*/
goto __pyx_L3;
}
/* "View.MemoryView":674
* tup = (index,)
* else:
* tup = index # <<<<<<<<<<<<<<
*
* result = []
*/
/*else*/ {
__Pyx_INCREF(__pyx_v_index);
__pyx_v_tup = __pyx_v_index;
}
__pyx_L3:;
/* "View.MemoryView":676
* tup = index
*
* result = [] # <<<<<<<<<<<<<<
* have_slices = False
* seen_ellipsis = False
*/
__pyx_t_3 = PyList_New(0); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 676, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__pyx_v_result = ((PyObject*)__pyx_t_3);
__pyx_t_3 = 0;
/* "View.MemoryView":677
*
* result = []
* have_slices = False # <<<<<<<<<<<<<<
* seen_ellipsis = False
* for idx, item in enumerate(tup):
*/
__pyx_v_have_slices = 0;
/* "View.MemoryView":678
* result = []
* have_slices = False
* seen_ellipsis = False # <<<<<<<<<<<<<<
* for idx, item in enumerate(tup):
* if item is Ellipsis:
*/
__pyx_v_seen_ellipsis = 0;
/* "View.MemoryView":679
* have_slices = False
* seen_ellipsis = False
* for idx, item in enumerate(tup): # <<<<<<<<<<<<<<
* if item is Ellipsis:
* if not seen_ellipsis:
*/
__Pyx_INCREF(__pyx_int_0);
__pyx_t_3 = __pyx_int_0;
if (likely(PyList_CheckExact(__pyx_v_tup)) || PyTuple_CheckExact(__pyx_v_tup)) {
__pyx_t_4 = __pyx_v_tup; __Pyx_INCREF(__pyx_t_4); __pyx_t_5 = 0;
__pyx_t_6 = NULL;
} else {
__pyx_t_5 = -1; __pyx_t_4 = PyObject_GetIter(__pyx_v_tup); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 679, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__pyx_t_6 = Py_TYPE(__pyx_t_4)->tp_iternext; if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 679, __pyx_L1_error)
}
for (;;) {
if (likely(!__pyx_t_6)) {
if (likely(PyList_CheckExact(__pyx_t_4))) {
if (__pyx_t_5 >= PyList_GET_SIZE(__pyx_t_4)) break;
#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
__pyx_t_7 = PyList_GET_ITEM(__pyx_t_4, __pyx_t_5); __Pyx_INCREF(__pyx_t_7); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(1, 679, __pyx_L1_error)
#else
__pyx_t_7 = PySequence_ITEM(__pyx_t_4, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 679, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
#endif
} else {
if (__pyx_t_5 >= PyTuple_GET_SIZE(__pyx_t_4)) break;
#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
__pyx_t_7 = PyTuple_GET_ITEM(__pyx_t_4, __pyx_t_5); __Pyx_INCREF(__pyx_t_7); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(1, 679, __pyx_L1_error)
#else
__pyx_t_7 = PySequence_ITEM(__pyx_t_4, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 679, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
#endif
}
} else {
__pyx_t_7 = __pyx_t_6(__pyx_t_4);
if (unlikely(!__pyx_t_7)) {
PyObject* exc_type = PyErr_Occurred();
if (exc_type) {
if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
else __PYX_ERR(1, 679, __pyx_L1_error)
}
break;
}
__Pyx_GOTREF(__pyx_t_7);
}
__Pyx_XDECREF_SET(__pyx_v_item, __pyx_t_7);
__pyx_t_7 = 0;
__Pyx_INCREF(__pyx_t_3);
__Pyx_XDECREF_SET(__pyx_v_idx, __pyx_t_3);
__pyx_t_7 = __Pyx_PyInt_AddObjC(__pyx_t_3, __pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 679, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_DECREF(__pyx_t_3);
__pyx_t_3 = __pyx_t_7;
__pyx_t_7 = 0;
/* "View.MemoryView":680
* seen_ellipsis = False
* for idx, item in enumerate(tup):
* if item is Ellipsis: # <<<<<<<<<<<<<<
* if not seen_ellipsis:
* result.extend([slice(None)] * (ndim - len(tup) + 1))
*/
__pyx_t_2 = (__pyx_v_item == __pyx_builtin_Ellipsis);
__pyx_t_1 = (__pyx_t_2 != 0);
if (__pyx_t_1) {
/* "View.MemoryView":681
* for idx, item in enumerate(tup):
* if item is Ellipsis:
* if not seen_ellipsis: # <<<<<<<<<<<<<<
* result.extend([slice(None)] * (ndim - len(tup) + 1))
* seen_ellipsis = True
*/
__pyx_t_1 = ((!(__pyx_v_seen_ellipsis != 0)) != 0);
if (__pyx_t_1) {
/* "View.MemoryView":682
* if item is Ellipsis:
* if not seen_ellipsis:
* result.extend([slice(None)] * (ndim - len(tup) + 1)) # <<<<<<<<<<<<<<
* seen_ellipsis = True
* else:
*/
__pyx_t_8 = PyObject_Length(__pyx_v_tup); if (unlikely(__pyx_t_8 == ((Py_ssize_t)-1))) __PYX_ERR(1, 682, __pyx_L1_error)
__pyx_t_7 = PyList_New(1 * ((((__pyx_v_ndim - __pyx_t_8) + 1)<0) ? 0:((__pyx_v_ndim - __pyx_t_8) + 1))); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 682, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
{ Py_ssize_t __pyx_temp;
for (__pyx_temp=0; __pyx_temp < ((__pyx_v_ndim - __pyx_t_8) + 1); __pyx_temp++) {
__Pyx_INCREF(__pyx_slice__33);
__Pyx_GIVEREF(__pyx_slice__33);
PyList_SET_ITEM(__pyx_t_7, __pyx_temp, __pyx_slice__33);
}
}
__pyx_t_9 = __Pyx_PyList_Extend(__pyx_v_result, __pyx_t_7); if (unlikely(__pyx_t_9 == ((int)-1))) __PYX_ERR(1, 682, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
/* "View.MemoryView":683
* if not seen_ellipsis:
* result.extend([slice(None)] * (ndim - len(tup) + 1))
* seen_ellipsis = True # <<<<<<<<<<<<<<
* else:
* result.append(slice(None))
*/
__pyx_v_seen_ellipsis = 1;
/* "View.MemoryView":681
* for idx, item in enumerate(tup):
* if item is Ellipsis:
* if not seen_ellipsis: # <<<<<<<<<<<<<<
* result.extend([slice(None)] * (ndim - len(tup) + 1))
* seen_ellipsis = True
*/
goto __pyx_L7;
}
/* "View.MemoryView":685
* seen_ellipsis = True
* else:
* result.append(slice(None)) # <<<<<<<<<<<<<<
* have_slices = True
* else:
*/
/*else*/ {
__pyx_t_9 = __Pyx_PyList_Append(__pyx_v_result, __pyx_slice__33); if (unlikely(__pyx_t_9 == ((int)-1))) __PYX_ERR(1, 685, __pyx_L1_error)
}
__pyx_L7:;
/* "View.MemoryView":686
* else:
* result.append(slice(None))
* have_slices = True # <<<<<<<<<<<<<<
* else:
* if not isinstance(item, slice) and not PyIndex_Check(item):
*/
__pyx_v_have_slices = 1;
/* "View.MemoryView":680
* seen_ellipsis = False
* for idx, item in enumerate(tup):
* if item is Ellipsis: # <<<<<<<<<<<<<<
* if not seen_ellipsis:
* result.extend([slice(None)] * (ndim - len(tup) + 1))
*/
goto __pyx_L6;
}
/* "View.MemoryView":688
* have_slices = True
* else:
* if not isinstance(item, slice) and not PyIndex_Check(item): # <<<<<<<<<<<<<<
* raise TypeError("Cannot index with type '%s'" % type(item))
*
*/
/*else*/ {
__pyx_t_2 = PySlice_Check(__pyx_v_item);
__pyx_t_10 = ((!(__pyx_t_2 != 0)) != 0);
if (__pyx_t_10) {
} else {
__pyx_t_1 = __pyx_t_10;
goto __pyx_L9_bool_binop_done;
}
__pyx_t_10 = ((!(PyIndex_Check(__pyx_v_item) != 0)) != 0);
__pyx_t_1 = __pyx_t_10;
__pyx_L9_bool_binop_done:;
if (unlikely(__pyx_t_1)) {
/* "View.MemoryView":689
* else:
* if not isinstance(item, slice) and not PyIndex_Check(item):
* raise TypeError("Cannot index with type '%s'" % type(item)) # <<<<<<<<<<<<<<
*
* have_slices = have_slices or isinstance(item, slice)
*/
__pyx_t_7 = __Pyx_PyString_FormatSafe(__pyx_kp_s_Cannot_index_with_type_s, ((PyObject *)Py_TYPE(__pyx_v_item))); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 689, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__pyx_t_11 = __Pyx_PyObject_CallOneArg(__pyx_builtin_TypeError, __pyx_t_7); if (unlikely(!__pyx_t_11)) __PYX_ERR(1, 689, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_11);
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
__Pyx_Raise(__pyx_t_11, 0, 0, 0);
__Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
__PYX_ERR(1, 689, __pyx_L1_error)
/* "View.MemoryView":688
* have_slices = True
* else:
* if not isinstance(item, slice) and not PyIndex_Check(item): # <<<<<<<<<<<<<<
* raise TypeError("Cannot index with type '%s'" % type(item))
*
*/
}
/* "View.MemoryView":691
* raise TypeError("Cannot index with type '%s'" % type(item))
*
* have_slices = have_slices or isinstance(item, slice) # <<<<<<<<<<<<<<
* result.append(item)
*
*/
__pyx_t_10 = (__pyx_v_have_slices != 0);
if (!__pyx_t_10) {
} else {
__pyx_t_1 = __pyx_t_10;
goto __pyx_L11_bool_binop_done;
}
__pyx_t_10 = PySlice_Check(__pyx_v_item);
__pyx_t_2 = (__pyx_t_10 != 0);
__pyx_t_1 = __pyx_t_2;
__pyx_L11_bool_binop_done:;
__pyx_v_have_slices = __pyx_t_1;
/* "View.MemoryView":692
*
* have_slices = have_slices or isinstance(item, slice)
* result.append(item) # <<<<<<<<<<<<<<
*
* nslices = ndim - len(result)
*/
__pyx_t_9 = __Pyx_PyList_Append(__pyx_v_result, __pyx_v_item); if (unlikely(__pyx_t_9 == ((int)-1))) __PYX_ERR(1, 692, __pyx_L1_error)
}
__pyx_L6:;
/* "View.MemoryView":679
* have_slices = False
* seen_ellipsis = False
* for idx, item in enumerate(tup): # <<<<<<<<<<<<<<
* if item is Ellipsis:
* if not seen_ellipsis:
*/
}
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
/* "View.MemoryView":694
* result.append(item)
*
* nslices = ndim - len(result) # <<<<<<<<<<<<<<
* if nslices:
* result.extend([slice(None)] * nslices)
*/
__pyx_t_5 = PyList_GET_SIZE(__pyx_v_result); if (unlikely(__pyx_t_5 == ((Py_ssize_t)-1))) __PYX_ERR(1, 694, __pyx_L1_error)
__pyx_v_nslices = (__pyx_v_ndim - __pyx_t_5);
/* "View.MemoryView":695
*
* nslices = ndim - len(result)
* if nslices: # <<<<<<<<<<<<<<
* result.extend([slice(None)] * nslices)
*
*/
__pyx_t_1 = (__pyx_v_nslices != 0);
if (__pyx_t_1) {
/* "View.MemoryView":696
* nslices = ndim - len(result)
* if nslices:
* result.extend([slice(None)] * nslices) # <<<<<<<<<<<<<<
*
* return have_slices or nslices, tuple(result)
*/
__pyx_t_3 = PyList_New(1 * ((__pyx_v_nslices<0) ? 0:__pyx_v_nslices)); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 696, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
{ Py_ssize_t __pyx_temp;
for (__pyx_temp=0; __pyx_temp < __pyx_v_nslices; __pyx_temp++) {
__Pyx_INCREF(__pyx_slice__33);
__Pyx_GIVEREF(__pyx_slice__33);
PyList_SET_ITEM(__pyx_t_3, __pyx_temp, __pyx_slice__33);
}
}
__pyx_t_9 = __Pyx_PyList_Extend(__pyx_v_result, __pyx_t_3); if (unlikely(__pyx_t_9 == ((int)-1))) __PYX_ERR(1, 696, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
/* "View.MemoryView":695
*
* nslices = ndim - len(result)
* if nslices: # <<<<<<<<<<<<<<
* result.extend([slice(None)] * nslices)
*
*/
}
/* "View.MemoryView":698
* result.extend([slice(None)] * nslices)
*
* return have_slices or nslices, tuple(result) # <<<<<<<<<<<<<<
*
* cdef assert_direct_dimensions(Py_ssize_t *suboffsets, int ndim):
*/
__Pyx_XDECREF(__pyx_r);
if (!__pyx_v_have_slices) {
} else {
__pyx_t_4 = __Pyx_PyBool_FromLong(__pyx_v_have_slices); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 698, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__pyx_t_3 = __pyx_t_4;
__pyx_t_4 = 0;
goto __pyx_L14_bool_binop_done;
}
__pyx_t_4 = PyInt_FromSsize_t(__pyx_v_nslices); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 698, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__pyx_t_3 = __pyx_t_4;
__pyx_t_4 = 0;
__pyx_L14_bool_binop_done:;
__pyx_t_4 = PyList_AsTuple(__pyx_v_result); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 698, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__pyx_t_11 = PyTuple_New(2); if (unlikely(!__pyx_t_11)) __PYX_ERR(1, 698, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_11);
__Pyx_GIVEREF(__pyx_t_3);
PyTuple_SET_ITEM(__pyx_t_11, 0, __pyx_t_3);
__Pyx_GIVEREF(__pyx_t_4);
PyTuple_SET_ITEM(__pyx_t_11, 1, __pyx_t_4);
__pyx_t_3 = 0;
__pyx_t_4 = 0;
__pyx_r = ((PyObject*)__pyx_t_11);
__pyx_t_11 = 0;
goto __pyx_L0;
/* "View.MemoryView":666
* return isinstance(o, memoryview)
*
* cdef tuple _unellipsify(object index, int ndim): # <<<<<<<<<<<<<<
* """
* Replace all ellipses with full slices and fill incomplete indices with
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_3);
__Pyx_XDECREF(__pyx_t_4);
__Pyx_XDECREF(__pyx_t_7);
__Pyx_XDECREF(__pyx_t_11);
__Pyx_AddTraceback("View.MemoryView._unellipsify", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = 0;
__pyx_L0:;
__Pyx_XDECREF(__pyx_v_tup);
__Pyx_XDECREF(__pyx_v_result);
__Pyx_XDECREF(__pyx_v_idx);
__Pyx_XDECREF(__pyx_v_item);
__Pyx_XGIVEREF(__pyx_r);
__Pyx_TraceReturn(__pyx_r, 0);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "View.MemoryView":700
* return have_slices or nslices, tuple(result)
*
* cdef assert_direct_dimensions(Py_ssize_t *suboffsets, int ndim): # <<<<<<<<<<<<<<
* for suboffset in suboffsets[:ndim]:
* if suboffset >= 0:
*/
static PyObject *assert_direct_dimensions(Py_ssize_t *__pyx_v_suboffsets, int __pyx_v_ndim) {
Py_ssize_t __pyx_v_suboffset;
PyObject *__pyx_r = NULL;
__Pyx_TraceDeclarations
__Pyx_RefNannyDeclarations
Py_ssize_t *__pyx_t_1;
Py_ssize_t *__pyx_t_2;
Py_ssize_t *__pyx_t_3;
int __pyx_t_4;
PyObject *__pyx_t_5 = NULL;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("assert_direct_dimensions", 0);
__Pyx_TraceCall("assert_direct_dimensions", __pyx_f[1], 700, 0, __PYX_ERR(1, 700, __pyx_L1_error));
/* "View.MemoryView":701
*
* cdef assert_direct_dimensions(Py_ssize_t *suboffsets, int ndim):
* for suboffset in suboffsets[:ndim]: # <<<<<<<<<<<<<<
* if suboffset >= 0:
* raise ValueError("Indirect dimensions not supported")
*/
__pyx_t_2 = (__pyx_v_suboffsets + __pyx_v_ndim);
for (__pyx_t_3 = __pyx_v_suboffsets; __pyx_t_3 < __pyx_t_2; __pyx_t_3++) {
__pyx_t_1 = __pyx_t_3;
__pyx_v_suboffset = (__pyx_t_1[0]);
/* "View.MemoryView":702
* cdef assert_direct_dimensions(Py_ssize_t *suboffsets, int ndim):
* for suboffset in suboffsets[:ndim]:
* if suboffset >= 0: # <<<<<<<<<<<<<<
* raise ValueError("Indirect dimensions not supported")
*
*/
__pyx_t_4 = ((__pyx_v_suboffset >= 0) != 0);
if (unlikely(__pyx_t_4)) {
/* "View.MemoryView":703
* for suboffset in suboffsets[:ndim]:
* if suboffset >= 0:
* raise ValueError("Indirect dimensions not supported") # <<<<<<<<<<<<<<
*
*
*/
__pyx_t_5 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__34, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 703, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_Raise(__pyx_t_5, 0, 0, 0);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
__PYX_ERR(1, 703, __pyx_L1_error)
/* "View.MemoryView":702
* cdef assert_direct_dimensions(Py_ssize_t *suboffsets, int ndim):
* for suboffset in suboffsets[:ndim]:
* if suboffset >= 0: # <<<<<<<<<<<<<<
* raise ValueError("Indirect dimensions not supported")
*
*/
}
}
/* "View.MemoryView":700
* return have_slices or nslices, tuple(result)
*
* cdef assert_direct_dimensions(Py_ssize_t *suboffsets, int ndim): # <<<<<<<<<<<<<<
* for suboffset in suboffsets[:ndim]:
* if suboffset >= 0:
*/
/* function exit code */
__pyx_r = Py_None; __Pyx_INCREF(Py_None);
goto __pyx_L0;
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_5);
__Pyx_AddTraceback("View.MemoryView.assert_direct_dimensions", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = 0;
__pyx_L0:;
__Pyx_XGIVEREF(__pyx_r);
__Pyx_TraceReturn(__pyx_r, 0);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "View.MemoryView":710
*
* @cname('__pyx_memview_slice')
* cdef memoryview memview_slice(memoryview memview, object indices): # <<<<<<<<<<<<<<
* cdef int new_ndim = 0, suboffset_dim = -1, dim
* cdef bint negative_step
*/
static struct __pyx_memoryview_obj *__pyx_memview_slice(struct __pyx_memoryview_obj *__pyx_v_memview, PyObject *__pyx_v_indices) {
int __pyx_v_new_ndim;
int __pyx_v_suboffset_dim;
int __pyx_v_dim;
__Pyx_memviewslice __pyx_v_src;
__Pyx_memviewslice __pyx_v_dst;
__Pyx_memviewslice *__pyx_v_p_src;
struct __pyx_memoryviewslice_obj *__pyx_v_memviewsliceobj = 0;
__Pyx_memviewslice *__pyx_v_p_dst;
int *__pyx_v_p_suboffset_dim;
Py_ssize_t __pyx_v_start;
Py_ssize_t __pyx_v_stop;
Py_ssize_t __pyx_v_step;
int __pyx_v_have_start;
int __pyx_v_have_stop;
int __pyx_v_have_step;
PyObject *__pyx_v_index = NULL;
struct __pyx_memoryview_obj *__pyx_r = NULL;
__Pyx_TraceDeclarations
__Pyx_RefNannyDeclarations
int __pyx_t_1;
int __pyx_t_2;
PyObject *__pyx_t_3 = NULL;
struct __pyx_memoryview_obj *__pyx_t_4;
char *__pyx_t_5;
int __pyx_t_6;
Py_ssize_t __pyx_t_7;
PyObject *(*__pyx_t_8)(PyObject *);
PyObject *__pyx_t_9 = NULL;
Py_ssize_t __pyx_t_10;
int __pyx_t_11;
Py_ssize_t __pyx_t_12;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("memview_slice", 0);
__Pyx_TraceCall("memview_slice", __pyx_f[1], 710, 0, __PYX_ERR(1, 710, __pyx_L1_error));
/* "View.MemoryView":711
* @cname('__pyx_memview_slice')
* cdef memoryview memview_slice(memoryview memview, object indices):
* cdef int new_ndim = 0, suboffset_dim = -1, dim # <<<<<<<<<<<<<<
* cdef bint negative_step
* cdef __Pyx_memviewslice src, dst
*/
__pyx_v_new_ndim = 0;
__pyx_v_suboffset_dim = -1;
/* "View.MemoryView":718
*
*
* memset(&dst, 0, sizeof(dst)) # <<<<<<<<<<<<<<
*
* cdef _memoryviewslice memviewsliceobj
*/
(void)(memset((&__pyx_v_dst), 0, (sizeof(__pyx_v_dst))));
/* "View.MemoryView":722
* cdef _memoryviewslice memviewsliceobj
*
* assert memview.view.ndim > 0 # <<<<<<<<<<<<<<
*
* if isinstance(memview, _memoryviewslice):
*/
#ifndef CYTHON_WITHOUT_ASSERTIONS
if (unlikely(!Py_OptimizeFlag)) {
if (unlikely(!((__pyx_v_memview->view.ndim > 0) != 0))) {
PyErr_SetNone(PyExc_AssertionError);
__PYX_ERR(1, 722, __pyx_L1_error)
}
}
#endif
/* "View.MemoryView":724
* assert memview.view.ndim > 0
*
* if isinstance(memview, _memoryviewslice): # <<<<<<<<<<<<<<
* memviewsliceobj = memview
* p_src = &memviewsliceobj.from_slice
*/
__pyx_t_1 = __Pyx_TypeCheck(((PyObject *)__pyx_v_memview), __pyx_memoryviewslice_type);
__pyx_t_2 = (__pyx_t_1 != 0);
if (__pyx_t_2) {
/* "View.MemoryView":725
*
* if isinstance(memview, _memoryviewslice):
* memviewsliceobj = memview # <<<<<<<<<<<<<<
* p_src = &memviewsliceobj.from_slice
* else:
*/
if (!(likely(((((PyObject *)__pyx_v_memview)) == Py_None) || likely(__Pyx_TypeTest(((PyObject *)__pyx_v_memview), __pyx_memoryviewslice_type))))) __PYX_ERR(1, 725, __pyx_L1_error)
__pyx_t_3 = ((PyObject *)__pyx_v_memview);
__Pyx_INCREF(__pyx_t_3);
__pyx_v_memviewsliceobj = ((struct __pyx_memoryviewslice_obj *)__pyx_t_3);
__pyx_t_3 = 0;
/* "View.MemoryView":726
* if isinstance(memview, _memoryviewslice):
* memviewsliceobj = memview
* p_src = &memviewsliceobj.from_slice # <<<<<<<<<<<<<<
* else:
* slice_copy(memview, &src)
*/
__pyx_v_p_src = (&__pyx_v_memviewsliceobj->from_slice);
/* "View.MemoryView":724
* assert memview.view.ndim > 0
*
* if isinstance(memview, _memoryviewslice): # <<<<<<<<<<<<<<
* memviewsliceobj = memview
* p_src = &memviewsliceobj.from_slice
*/
goto __pyx_L3;
}
/* "View.MemoryView":728
* p_src = &memviewsliceobj.from_slice
* else:
* slice_copy(memview, &src) # <<<<<<<<<<<<<<
* p_src = &src
*
*/
/*else*/ {
__pyx_memoryview_slice_copy(__pyx_v_memview, (&__pyx_v_src));
/* "View.MemoryView":729
* else:
* slice_copy(memview, &src)
* p_src = &src # <<<<<<<<<<<<<<
*
*
*/
__pyx_v_p_src = (&__pyx_v_src);
}
__pyx_L3:;
/* "View.MemoryView":735
*
*
* dst.memview = p_src.memview # <<<<<<<<<<<<<<
* dst.data = p_src.data
*
*/
__pyx_t_4 = __pyx_v_p_src->memview;
__pyx_v_dst.memview = __pyx_t_4;
/* "View.MemoryView":736
*
* dst.memview = p_src.memview
* dst.data = p_src.data # <<<<<<<<<<<<<<
*
*
*/
__pyx_t_5 = __pyx_v_p_src->data;
__pyx_v_dst.data = __pyx_t_5;
/* "View.MemoryView":741
*
*
* cdef __Pyx_memviewslice *p_dst = &dst # <<<<<<<<<<<<<<
* cdef int *p_suboffset_dim = &suboffset_dim
* cdef Py_ssize_t start, stop, step
*/
__pyx_v_p_dst = (&__pyx_v_dst);
/* "View.MemoryView":742
*
* cdef __Pyx_memviewslice *p_dst = &dst
* cdef int *p_suboffset_dim = &suboffset_dim # <<<<<<<<<<<<<<
* cdef Py_ssize_t start, stop, step
* cdef bint have_start, have_stop, have_step
*/
__pyx_v_p_suboffset_dim = (&__pyx_v_suboffset_dim);
/* "View.MemoryView":746
* cdef bint have_start, have_stop, have_step
*
* for dim, index in enumerate(indices): # <<<<<<<<<<<<<<
* if PyIndex_Check(index):
* slice_memviewslice(
*/
__pyx_t_6 = 0;
if (likely(PyList_CheckExact(__pyx_v_indices)) || PyTuple_CheckExact(__pyx_v_indices)) {
__pyx_t_3 = __pyx_v_indices; __Pyx_INCREF(__pyx_t_3); __pyx_t_7 = 0;
__pyx_t_8 = NULL;
} else {
__pyx_t_7 = -1; __pyx_t_3 = PyObject_GetIter(__pyx_v_indices); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 746, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__pyx_t_8 = Py_TYPE(__pyx_t_3)->tp_iternext; if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 746, __pyx_L1_error)
}
for (;;) {
if (likely(!__pyx_t_8)) {
if (likely(PyList_CheckExact(__pyx_t_3))) {
if (__pyx_t_7 >= PyList_GET_SIZE(__pyx_t_3)) break;
#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
__pyx_t_9 = PyList_GET_ITEM(__pyx_t_3, __pyx_t_7); __Pyx_INCREF(__pyx_t_9); __pyx_t_7++; if (unlikely(0 < 0)) __PYX_ERR(1, 746, __pyx_L1_error)
#else
__pyx_t_9 = PySequence_ITEM(__pyx_t_3, __pyx_t_7); __pyx_t_7++; if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 746, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_9);
#endif
} else {
if (__pyx_t_7 >= PyTuple_GET_SIZE(__pyx_t_3)) break;
#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
__pyx_t_9 = PyTuple_GET_ITEM(__pyx_t_3, __pyx_t_7); __Pyx_INCREF(__pyx_t_9); __pyx_t_7++; if (unlikely(0 < 0)) __PYX_ERR(1, 746, __pyx_L1_error)
#else
__pyx_t_9 = PySequence_ITEM(__pyx_t_3, __pyx_t_7); __pyx_t_7++; if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 746, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_9);
#endif
}
} else {
__pyx_t_9 = __pyx_t_8(__pyx_t_3);
if (unlikely(!__pyx_t_9)) {
PyObject* exc_type = PyErr_Occurred();
if (exc_type) {
if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
else __PYX_ERR(1, 746, __pyx_L1_error)
}
break;
}
__Pyx_GOTREF(__pyx_t_9);
}
__Pyx_XDECREF_SET(__pyx_v_index, __pyx_t_9);
__pyx_t_9 = 0;
__pyx_v_dim = __pyx_t_6;
__pyx_t_6 = (__pyx_t_6 + 1);
/* "View.MemoryView":747
*
* for dim, index in enumerate(indices):
* if PyIndex_Check(index): # <<<<<<<<<<<<<<
* slice_memviewslice(
* p_dst, p_src.shape[dim], p_src.strides[dim], p_src.suboffsets[dim],
*/
__pyx_t_2 = (PyIndex_Check(__pyx_v_index) != 0);
if (__pyx_t_2) {
/* "View.MemoryView":751
* p_dst, p_src.shape[dim], p_src.strides[dim], p_src.suboffsets[dim],
* dim, new_ndim, p_suboffset_dim,
* index, 0, 0, # start, stop, step # <<<<<<<<<<<<<<
* 0, 0, 0, # have_{start,stop,step}
* False)
*/
__pyx_t_10 = __Pyx_PyIndex_AsSsize_t(__pyx_v_index); if (unlikely((__pyx_t_10 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(1, 751, __pyx_L1_error)
/* "View.MemoryView":748
* for dim, index in enumerate(indices):
* if PyIndex_Check(index):
* slice_memviewslice( # <<<<<<<<<<<<<<
* p_dst, p_src.shape[dim], p_src.strides[dim], p_src.suboffsets[dim],
* dim, new_ndim, p_suboffset_dim,
*/
__pyx_t_11 = __pyx_memoryview_slice_memviewslice(__pyx_v_p_dst, (__pyx_v_p_src->shape[__pyx_v_dim]), (__pyx_v_p_src->strides[__pyx_v_dim]), (__pyx_v_p_src->suboffsets[__pyx_v_dim]), __pyx_v_dim, __pyx_v_new_ndim, __pyx_v_p_suboffset_dim, __pyx_t_10, 0, 0, 0, 0, 0, 0); if (unlikely(__pyx_t_11 == ((int)-1))) __PYX_ERR(1, 748, __pyx_L1_error)
/* "View.MemoryView":747
*
* for dim, index in enumerate(indices):
* if PyIndex_Check(index): # <<<<<<<<<<<<<<
* slice_memviewslice(
* p_dst, p_src.shape[dim], p_src.strides[dim], p_src.suboffsets[dim],
*/
goto __pyx_L6;
}
/* "View.MemoryView":754
* 0, 0, 0, # have_{start,stop,step}
* False)
* elif index is None: # <<<<<<<<<<<<<<
* p_dst.shape[new_ndim] = 1
* p_dst.strides[new_ndim] = 0
*/
__pyx_t_2 = (__pyx_v_index == Py_None);
__pyx_t_1 = (__pyx_t_2 != 0);
if (__pyx_t_1) {
/* "View.MemoryView":755
* False)
* elif index is None:
* p_dst.shape[new_ndim] = 1 # <<<<<<<<<<<<<<
* p_dst.strides[new_ndim] = 0
* p_dst.suboffsets[new_ndim] = -1
*/
(__pyx_v_p_dst->shape[__pyx_v_new_ndim]) = 1;
/* "View.MemoryView":756
* elif index is None:
* p_dst.shape[new_ndim] = 1
* p_dst.strides[new_ndim] = 0 # <<<<<<<<<<<<<<
* p_dst.suboffsets[new_ndim] = -1
* new_ndim += 1
*/
(__pyx_v_p_dst->strides[__pyx_v_new_ndim]) = 0;
/* "View.MemoryView":757
* p_dst.shape[new_ndim] = 1
* p_dst.strides[new_ndim] = 0
* p_dst.suboffsets[new_ndim] = -1 # <<<<<<<<<<<<<<
* new_ndim += 1
* else:
*/
(__pyx_v_p_dst->suboffsets[__pyx_v_new_ndim]) = -1L;
/* "View.MemoryView":758
* p_dst.strides[new_ndim] = 0
* p_dst.suboffsets[new_ndim] = -1
* new_ndim += 1 # <<<<<<<<<<<<<<
* else:
* start = index.start or 0
*/
__pyx_v_new_ndim = (__pyx_v_new_ndim + 1);
/* "View.MemoryView":754
* 0, 0, 0, # have_{start,stop,step}
* False)
* elif index is None: # <<<<<<<<<<<<<<
* p_dst.shape[new_ndim] = 1
* p_dst.strides[new_ndim] = 0
*/
goto __pyx_L6;
}
/* "View.MemoryView":760
* new_ndim += 1
* else:
* start = index.start or 0 # <<<<<<<<<<<<<<
* stop = index.stop or 0
* step = index.step or 0
*/
/*else*/ {
__pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_index, __pyx_n_s_start); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 760, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_9);
__pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_9); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(1, 760, __pyx_L1_error)
if (!__pyx_t_1) {
__Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
} else {
__pyx_t_12 = __Pyx_PyIndex_AsSsize_t(__pyx_t_9); if (unlikely((__pyx_t_12 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(1, 760, __pyx_L1_error)
__pyx_t_10 = __pyx_t_12;
__Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
goto __pyx_L7_bool_binop_done;
}
__pyx_t_10 = 0;
__pyx_L7_bool_binop_done:;
__pyx_v_start = __pyx_t_10;
/* "View.MemoryView":761
* else:
* start = index.start or 0
* stop = index.stop or 0 # <<<<<<<<<<<<<<
* step = index.step or 0
*
*/
__pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_index, __pyx_n_s_stop); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 761, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_9);
__pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_9); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(1, 761, __pyx_L1_error)
if (!__pyx_t_1) {
__Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
} else {
__pyx_t_12 = __Pyx_PyIndex_AsSsize_t(__pyx_t_9); if (unlikely((__pyx_t_12 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(1, 761, __pyx_L1_error)
__pyx_t_10 = __pyx_t_12;
__Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
goto __pyx_L9_bool_binop_done;
}
__pyx_t_10 = 0;
__pyx_L9_bool_binop_done:;
__pyx_v_stop = __pyx_t_10;
/* "View.MemoryView":762
* start = index.start or 0
* stop = index.stop or 0
* step = index.step or 0 # <<<<<<<<<<<<<<
*
* have_start = index.start is not None
*/
__pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_index, __pyx_n_s_step); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 762, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_9);
__pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_9); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(1, 762, __pyx_L1_error)
if (!__pyx_t_1) {
__Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
} else {
__pyx_t_12 = __Pyx_PyIndex_AsSsize_t(__pyx_t_9); if (unlikely((__pyx_t_12 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(1, 762, __pyx_L1_error)
__pyx_t_10 = __pyx_t_12;
__Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
goto __pyx_L11_bool_binop_done;
}
__pyx_t_10 = 0;
__pyx_L11_bool_binop_done:;
__pyx_v_step = __pyx_t_10;
/* "View.MemoryView":764
* step = index.step or 0
*
* have_start = index.start is not None # <<<<<<<<<<<<<<
* have_stop = index.stop is not None
* have_step = index.step is not None
*/
__pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_index, __pyx_n_s_start); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 764, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_9);
__pyx_t_1 = (__pyx_t_9 != Py_None);
__Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
__pyx_v_have_start = __pyx_t_1;
/* "View.MemoryView":765
*
* have_start = index.start is not None
* have_stop = index.stop is not None # <<<<<<<<<<<<<<
* have_step = index.step is not None
*
*/
__pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_index, __pyx_n_s_stop); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 765, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_9);
__pyx_t_1 = (__pyx_t_9 != Py_None);
__Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
__pyx_v_have_stop = __pyx_t_1;
/* "View.MemoryView":766
* have_start = index.start is not None
* have_stop = index.stop is not None
* have_step = index.step is not None # <<<<<<<<<<<<<<
*
* slice_memviewslice(
*/
__pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_index, __pyx_n_s_step); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 766, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_9);
__pyx_t_1 = (__pyx_t_9 != Py_None);
__Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
__pyx_v_have_step = __pyx_t_1;
/* "View.MemoryView":768
* have_step = index.step is not None
*
* slice_memviewslice( # <<<<<<<<<<<<<<
* p_dst, p_src.shape[dim], p_src.strides[dim], p_src.suboffsets[dim],
* dim, new_ndim, p_suboffset_dim,
*/
__pyx_t_11 = __pyx_memoryview_slice_memviewslice(__pyx_v_p_dst, (__pyx_v_p_src->shape[__pyx_v_dim]), (__pyx_v_p_src->strides[__pyx_v_dim]), (__pyx_v_p_src->suboffsets[__pyx_v_dim]), __pyx_v_dim, __pyx_v_new_ndim, __pyx_v_p_suboffset_dim, __pyx_v_start, __pyx_v_stop, __pyx_v_step, __pyx_v_have_start, __pyx_v_have_stop, __pyx_v_have_step, 1); if (unlikely(__pyx_t_11 == ((int)-1))) __PYX_ERR(1, 768, __pyx_L1_error)
/* "View.MemoryView":774
* have_start, have_stop, have_step,
* True)
* new_ndim += 1 # <<<<<<<<<<<<<<
*
* if isinstance(memview, _memoryviewslice):
*/
__pyx_v_new_ndim = (__pyx_v_new_ndim + 1);
}
__pyx_L6:;
/* "View.MemoryView":746
* cdef bint have_start, have_stop, have_step
*
* for dim, index in enumerate(indices): # <<<<<<<<<<<<<<
* if PyIndex_Check(index):
* slice_memviewslice(
*/
}
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
/* "View.MemoryView":776
* new_ndim += 1
*
* if isinstance(memview, _memoryviewslice): # <<<<<<<<<<<<<<
* return memoryview_fromslice(dst, new_ndim,
* memviewsliceobj.to_object_func,
*/
__pyx_t_1 = __Pyx_TypeCheck(((PyObject *)__pyx_v_memview), __pyx_memoryviewslice_type);
__pyx_t_2 = (__pyx_t_1 != 0);
if (__pyx_t_2) {
/* "View.MemoryView":777
*
* if isinstance(memview, _memoryviewslice):
* return memoryview_fromslice(dst, new_ndim, # <<<<<<<<<<<<<<
* memviewsliceobj.to_object_func,
* memviewsliceobj.to_dtype_func,
*/
__Pyx_XDECREF(((PyObject *)__pyx_r));
/* "View.MemoryView":778
* if isinstance(memview, _memoryviewslice):
* return memoryview_fromslice(dst, new_ndim,
* memviewsliceobj.to_object_func, # <<<<<<<<<<<<<<
* memviewsliceobj.to_dtype_func,
* memview.dtype_is_object)
*/
if (unlikely(!__pyx_v_memviewsliceobj)) { __Pyx_RaiseUnboundLocalError("memviewsliceobj"); __PYX_ERR(1, 778, __pyx_L1_error) }
/* "View.MemoryView":779
* return memoryview_fromslice(dst, new_ndim,
* memviewsliceobj.to_object_func,
* memviewsliceobj.to_dtype_func, # <<<<<<<<<<<<<<
* memview.dtype_is_object)
* else:
*/
if (unlikely(!__pyx_v_memviewsliceobj)) { __Pyx_RaiseUnboundLocalError("memviewsliceobj"); __PYX_ERR(1, 779, __pyx_L1_error) }
/* "View.MemoryView":777
*
* if isinstance(memview, _memoryviewslice):
* return memoryview_fromslice(dst, new_ndim, # <<<<<<<<<<<<<<
* memviewsliceobj.to_object_func,
* memviewsliceobj.to_dtype_func,
*/
__pyx_t_3 = __pyx_memoryview_fromslice(__pyx_v_dst, __pyx_v_new_ndim, __pyx_v_memviewsliceobj->to_object_func, __pyx_v_memviewsliceobj->to_dtype_func, __pyx_v_memview->dtype_is_object); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 777, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
if (!(likely(((__pyx_t_3) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_3, __pyx_memoryview_type))))) __PYX_ERR(1, 777, __pyx_L1_error)
__pyx_r = ((struct __pyx_memoryview_obj *)__pyx_t_3);
__pyx_t_3 = 0;
goto __pyx_L0;
/* "View.MemoryView":776
* new_ndim += 1
*
* if isinstance(memview, _memoryviewslice): # <<<<<<<<<<<<<<
* return memoryview_fromslice(dst, new_ndim,
* memviewsliceobj.to_object_func,
*/
}
/* "View.MemoryView":782
* memview.dtype_is_object)
* else:
* return memoryview_fromslice(dst, new_ndim, NULL, NULL, # <<<<<<<<<<<<<<
* memview.dtype_is_object)
*
*/
/*else*/ {
__Pyx_XDECREF(((PyObject *)__pyx_r));
/* "View.MemoryView":783
* else:
* return memoryview_fromslice(dst, new_ndim, NULL, NULL,
* memview.dtype_is_object) # <<<<<<<<<<<<<<
*
*
*/
__pyx_t_3 = __pyx_memoryview_fromslice(__pyx_v_dst, __pyx_v_new_ndim, NULL, NULL, __pyx_v_memview->dtype_is_object); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 782, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
/* "View.MemoryView":782
* memview.dtype_is_object)
* else:
* return memoryview_fromslice(dst, new_ndim, NULL, NULL, # <<<<<<<<<<<<<<
* memview.dtype_is_object)
*
*/
if (!(likely(((__pyx_t_3) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_3, __pyx_memoryview_type))))) __PYX_ERR(1, 782, __pyx_L1_error)
__pyx_r = ((struct __pyx_memoryview_obj *)__pyx_t_3);
__pyx_t_3 = 0;
goto __pyx_L0;
}
/* "View.MemoryView":710
*
* @cname('__pyx_memview_slice')
* cdef memoryview memview_slice(memoryview memview, object indices): # <<<<<<<<<<<<<<
* cdef int new_ndim = 0, suboffset_dim = -1, dim
* cdef bint negative_step
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_3);
__Pyx_XDECREF(__pyx_t_9);
__Pyx_AddTraceback("View.MemoryView.memview_slice", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = 0;
__pyx_L0:;
__Pyx_XDECREF((PyObject *)__pyx_v_memviewsliceobj);
__Pyx_XDECREF(__pyx_v_index);
__Pyx_XGIVEREF((PyObject *)__pyx_r);
__Pyx_TraceReturn(__pyx_r, 0);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "View.MemoryView":807
*
* @cname('__pyx_memoryview_slice_memviewslice')
* cdef int slice_memviewslice( # <<<<<<<<<<<<<<
* __Pyx_memviewslice *dst,
* Py_ssize_t shape, Py_ssize_t stride, Py_ssize_t suboffset,
*/
static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, Py_ssize_t __pyx_v_shape, Py_ssize_t __pyx_v_stride, Py_ssize_t __pyx_v_suboffset, int __pyx_v_dim, int __pyx_v_new_ndim, int *__pyx_v_suboffset_dim, Py_ssize_t __pyx_v_start, Py_ssize_t __pyx_v_stop, Py_ssize_t __pyx_v_step, int __pyx_v_have_start, int __pyx_v_have_stop, int __pyx_v_have_step, int __pyx_v_is_slice) {
Py_ssize_t __pyx_v_new_shape;
int __pyx_v_negative_step;
int __pyx_r;
__Pyx_TraceDeclarations
int __pyx_t_1;
int __pyx_t_2;
int __pyx_t_3;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_TraceCall("slice_memviewslice", __pyx_f[1], 807, 1, __PYX_ERR(1, 807, __pyx_L1_error));
/* "View.MemoryView":827
* cdef bint negative_step
*
* if not is_slice: # <<<<<<<<<<<<<<
*
* if start < 0:
*/
__pyx_t_1 = ((!(__pyx_v_is_slice != 0)) != 0);
if (__pyx_t_1) {
/* "View.MemoryView":829
* if not is_slice:
*
* if start < 0: # <<<<<<<<<<<<<<
* start += shape
* if not 0 <= start < shape:
*/
__pyx_t_1 = ((__pyx_v_start < 0) != 0);
if (__pyx_t_1) {
/* "View.MemoryView":830
*
* if start < 0:
* start += shape # <<<<<<<<<<<<<<
* if not 0 <= start < shape:
* _err_dim(IndexError, "Index out of bounds (axis %d)", dim)
*/
__pyx_v_start = (__pyx_v_start + __pyx_v_shape);
/* "View.MemoryView":829
* if not is_slice:
*
* if start < 0: # <<<<<<<<<<<<<<
* start += shape
* if not 0 <= start < shape:
*/
}
/* "View.MemoryView":831
* if start < 0:
* start += shape
* if not 0 <= start < shape: # <<<<<<<<<<<<<<
* _err_dim(IndexError, "Index out of bounds (axis %d)", dim)
* else:
*/
__pyx_t_1 = (0 <= __pyx_v_start);
if (__pyx_t_1) {
__pyx_t_1 = (__pyx_v_start < __pyx_v_shape);
}
__pyx_t_2 = ((!(__pyx_t_1 != 0)) != 0);
if (__pyx_t_2) {
/* "View.MemoryView":832
* start += shape
* if not 0 <= start < shape:
* _err_dim(IndexError, "Index out of bounds (axis %d)", dim) # <<<<<<<<<<<<<<
* else:
*
*/
__pyx_t_3 = __pyx_memoryview_err_dim(__pyx_builtin_IndexError, ((char *)"Index out of bounds (axis %d)"), __pyx_v_dim); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(1, 832, __pyx_L1_error)
/* "View.MemoryView":831
* if start < 0:
* start += shape
* if not 0 <= start < shape: # <<<<<<<<<<<<<<
* _err_dim(IndexError, "Index out of bounds (axis %d)", dim)
* else:
*/
}
/* "View.MemoryView":827
* cdef bint negative_step
*
* if not is_slice: # <<<<<<<<<<<<<<
*
* if start < 0:
*/
goto __pyx_L3;
}
/* "View.MemoryView":835
* else:
*
* negative_step = have_step != 0 and step < 0 # <<<<<<<<<<<<<<
*
* if have_step and step == 0:
*/
/*else*/ {
__pyx_t_1 = ((__pyx_v_have_step != 0) != 0);
if (__pyx_t_1) {
} else {
__pyx_t_2 = __pyx_t_1;
goto __pyx_L6_bool_binop_done;
}
__pyx_t_1 = ((__pyx_v_step < 0) != 0);
__pyx_t_2 = __pyx_t_1;
__pyx_L6_bool_binop_done:;
__pyx_v_negative_step = __pyx_t_2;
/* "View.MemoryView":837
* negative_step = have_step != 0 and step < 0
*
* if have_step and step == 0: # <<<<<<<<<<<<<<
* _err_dim(ValueError, "Step may not be zero (axis %d)", dim)
*
*/
__pyx_t_1 = (__pyx_v_have_step != 0);
if (__pyx_t_1) {
} else {
__pyx_t_2 = __pyx_t_1;
goto __pyx_L9_bool_binop_done;
}
__pyx_t_1 = ((__pyx_v_step == 0) != 0);
__pyx_t_2 = __pyx_t_1;
__pyx_L9_bool_binop_done:;
if (__pyx_t_2) {
/* "View.MemoryView":838
*
* if have_step and step == 0:
* _err_dim(ValueError, "Step may not be zero (axis %d)", dim) # <<<<<<<<<<<<<<
*
*
*/
__pyx_t_3 = __pyx_memoryview_err_dim(__pyx_builtin_ValueError, ((char *)"Step may not be zero (axis %d)"), __pyx_v_dim); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(1, 838, __pyx_L1_error)
/* "View.MemoryView":837
* negative_step = have_step != 0 and step < 0
*
* if have_step and step == 0: # <<<<<<<<<<<<<<
* _err_dim(ValueError, "Step may not be zero (axis %d)", dim)
*
*/
}
/* "View.MemoryView":841
*
*
* if have_start: # <<<<<<<<<<<<<<
* if start < 0:
* start += shape
*/
__pyx_t_2 = (__pyx_v_have_start != 0);
if (__pyx_t_2) {
/* "View.MemoryView":842
*
* if have_start:
* if start < 0: # <<<<<<<<<<<<<<
* start += shape
* if start < 0:
*/
__pyx_t_2 = ((__pyx_v_start < 0) != 0);
if (__pyx_t_2) {
/* "View.MemoryView":843
* if have_start:
* if start < 0:
* start += shape # <<<<<<<<<<<<<<
* if start < 0:
* start = 0
*/
__pyx_v_start = (__pyx_v_start + __pyx_v_shape);
/* "View.MemoryView":844
* if start < 0:
* start += shape
* if start < 0: # <<<<<<<<<<<<<<
* start = 0
* elif start >= shape:
*/
__pyx_t_2 = ((__pyx_v_start < 0) != 0);
if (__pyx_t_2) {
/* "View.MemoryView":845
* start += shape
* if start < 0:
* start = 0 # <<<<<<<<<<<<<<
* elif start >= shape:
* if negative_step:
*/
__pyx_v_start = 0;
/* "View.MemoryView":844
* if start < 0:
* start += shape
* if start < 0: # <<<<<<<<<<<<<<
* start = 0
* elif start >= shape:
*/
}
/* "View.MemoryView":842
*
* if have_start:
* if start < 0: # <<<<<<<<<<<<<<
* start += shape
* if start < 0:
*/
goto __pyx_L12;
}
/* "View.MemoryView":846
* if start < 0:
* start = 0
* elif start >= shape: # <<<<<<<<<<<<<<
* if negative_step:
* start = shape - 1
*/
__pyx_t_2 = ((__pyx_v_start >= __pyx_v_shape) != 0);
if (__pyx_t_2) {
/* "View.MemoryView":847
* start = 0
* elif start >= shape:
* if negative_step: # <<<<<<<<<<<<<<
* start = shape - 1
* else:
*/
__pyx_t_2 = (__pyx_v_negative_step != 0);
if (__pyx_t_2) {
/* "View.MemoryView":848
* elif start >= shape:
* if negative_step:
* start = shape - 1 # <<<<<<<<<<<<<<
* else:
* start = shape
*/
__pyx_v_start = (__pyx_v_shape - 1);
/* "View.MemoryView":847
* start = 0
* elif start >= shape:
* if negative_step: # <<<<<<<<<<<<<<
* start = shape - 1
* else:
*/
goto __pyx_L14;
}
/* "View.MemoryView":850
* start = shape - 1
* else:
* start = shape # <<<<<<<<<<<<<<
* else:
* if negative_step:
*/
/*else*/ {
__pyx_v_start = __pyx_v_shape;
}
__pyx_L14:;
/* "View.MemoryView":846
* if start < 0:
* start = 0
* elif start >= shape: # <<<<<<<<<<<<<<
* if negative_step:
* start = shape - 1
*/
}
__pyx_L12:;
/* "View.MemoryView":841
*
*
* if have_start: # <<<<<<<<<<<<<<
* if start < 0:
* start += shape
*/
goto __pyx_L11;
}
/* "View.MemoryView":852
* start = shape
* else:
* if negative_step: # <<<<<<<<<<<<<<
* start = shape - 1
* else:
*/
/*else*/ {
__pyx_t_2 = (__pyx_v_negative_step != 0);
if (__pyx_t_2) {
/* "View.MemoryView":853
* else:
* if negative_step:
* start = shape - 1 # <<<<<<<<<<<<<<
* else:
* start = 0
*/
__pyx_v_start = (__pyx_v_shape - 1);
/* "View.MemoryView":852
* start = shape
* else:
* if negative_step: # <<<<<<<<<<<<<<
* start = shape - 1
* else:
*/
goto __pyx_L15;
}
/* "View.MemoryView":855
* start = shape - 1
* else:
* start = 0 # <<<<<<<<<<<<<<
*
* if have_stop:
*/
/*else*/ {
__pyx_v_start = 0;
}
__pyx_L15:;
}
__pyx_L11:;
/* "View.MemoryView":857
* start = 0
*
* if have_stop: # <<<<<<<<<<<<<<
* if stop < 0:
* stop += shape
*/
__pyx_t_2 = (__pyx_v_have_stop != 0);
if (__pyx_t_2) {
/* "View.MemoryView":858
*
* if have_stop:
* if stop < 0: # <<<<<<<<<<<<<<
* stop += shape
* if stop < 0:
*/
__pyx_t_2 = ((__pyx_v_stop < 0) != 0);
if (__pyx_t_2) {
/* "View.MemoryView":859
* if have_stop:
* if stop < 0:
* stop += shape # <<<<<<<<<<<<<<
* if stop < 0:
* stop = 0
*/
__pyx_v_stop = (__pyx_v_stop + __pyx_v_shape);
/* "View.MemoryView":860
* if stop < 0:
* stop += shape
* if stop < 0: # <<<<<<<<<<<<<<
* stop = 0
* elif stop > shape:
*/
__pyx_t_2 = ((__pyx_v_stop < 0) != 0);
if (__pyx_t_2) {
/* "View.MemoryView":861
* stop += shape
* if stop < 0:
* stop = 0 # <<<<<<<<<<<<<<
* elif stop > shape:
* stop = shape
*/
__pyx_v_stop = 0;
/* "View.MemoryView":860
* if stop < 0:
* stop += shape
* if stop < 0: # <<<<<<<<<<<<<<
* stop = 0
* elif stop > shape:
*/
}
/* "View.MemoryView":858
*
* if have_stop:
* if stop < 0: # <<<<<<<<<<<<<<
* stop += shape
* if stop < 0:
*/
goto __pyx_L17;
}
/* "View.MemoryView":862
* if stop < 0:
* stop = 0
* elif stop > shape: # <<<<<<<<<<<<<<
* stop = shape
* else:
*/
__pyx_t_2 = ((__pyx_v_stop > __pyx_v_shape) != 0);
if (__pyx_t_2) {
/* "View.MemoryView":863
* stop = 0
* elif stop > shape:
* stop = shape # <<<<<<<<<<<<<<
* else:
* if negative_step:
*/
__pyx_v_stop = __pyx_v_shape;
/* "View.MemoryView":862
* if stop < 0:
* stop = 0
* elif stop > shape: # <<<<<<<<<<<<<<
* stop = shape
* else:
*/
}
__pyx_L17:;
/* "View.MemoryView":857
* start = 0
*
* if have_stop: # <<<<<<<<<<<<<<
* if stop < 0:
* stop += shape
*/
goto __pyx_L16;
}
/* "View.MemoryView":865
* stop = shape
* else:
* if negative_step: # <<<<<<<<<<<<<<
* stop = -1
* else:
*/
/*else*/ {
__pyx_t_2 = (__pyx_v_negative_step != 0);
if (__pyx_t_2) {
/* "View.MemoryView":866
* else:
* if negative_step:
* stop = -1 # <<<<<<<<<<<<<<
* else:
* stop = shape
*/
__pyx_v_stop = -1L;
/* "View.MemoryView":865
* stop = shape
* else:
* if negative_step: # <<<<<<<<<<<<<<
* stop = -1
* else:
*/
goto __pyx_L19;
}
/* "View.MemoryView":868
* stop = -1
* else:
* stop = shape # <<<<<<<<<<<<<<
*
* if not have_step:
*/
/*else*/ {
__pyx_v_stop = __pyx_v_shape;
}
__pyx_L19:;
}
__pyx_L16:;
/* "View.MemoryView":870
* stop = shape
*
* if not have_step: # <<<<<<<<<<<<<<
* step = 1
*
*/
__pyx_t_2 = ((!(__pyx_v_have_step != 0)) != 0);
if (__pyx_t_2) {
/* "View.MemoryView":871
*
* if not have_step:
* step = 1 # <<<<<<<<<<<<<<
*
*
*/
__pyx_v_step = 1;
/* "View.MemoryView":870
* stop = shape
*
* if not have_step: # <<<<<<<<<<<<<<
* step = 1
*
*/
}
/* "View.MemoryView":875
*
* with cython.cdivision(True):
* new_shape = (stop - start) // step # <<<<<<<<<<<<<<
*
* if (stop - start) - step * new_shape:
*/
__pyx_v_new_shape = ((__pyx_v_stop - __pyx_v_start) / __pyx_v_step);
/* "View.MemoryView":877
* new_shape = (stop - start) // step
*
* if (stop - start) - step * new_shape: # <<<<<<<<<<<<<<
* new_shape += 1
*
*/
__pyx_t_2 = (((__pyx_v_stop - __pyx_v_start) - (__pyx_v_step * __pyx_v_new_shape)) != 0);
if (__pyx_t_2) {
/* "View.MemoryView":878
*
* if (stop - start) - step * new_shape:
* new_shape += 1 # <<<<<<<<<<<<<<
*
* if new_shape < 0:
*/
__pyx_v_new_shape = (__pyx_v_new_shape + 1);
/* "View.MemoryView":877
* new_shape = (stop - start) // step
*
* if (stop - start) - step * new_shape: # <<<<<<<<<<<<<<
* new_shape += 1
*
*/
}
/* "View.MemoryView":880
* new_shape += 1
*
* if new_shape < 0: # <<<<<<<<<<<<<<
* new_shape = 0
*
*/
__pyx_t_2 = ((__pyx_v_new_shape < 0) != 0);
if (__pyx_t_2) {
/* "View.MemoryView":881
*
* if new_shape < 0:
* new_shape = 0 # <<<<<<<<<<<<<<
*
*
*/
__pyx_v_new_shape = 0;
/* "View.MemoryView":880
* new_shape += 1
*
* if new_shape < 0: # <<<<<<<<<<<<<<
* new_shape = 0
*
*/
}
/* "View.MemoryView":884
*
*
* dst.strides[new_ndim] = stride * step # <<<<<<<<<<<<<<
* dst.shape[new_ndim] = new_shape
* dst.suboffsets[new_ndim] = suboffset
*/
(__pyx_v_dst->strides[__pyx_v_new_ndim]) = (__pyx_v_stride * __pyx_v_step);
/* "View.MemoryView":885
*
* dst.strides[new_ndim] = stride * step
* dst.shape[new_ndim] = new_shape # <<<<<<<<<<<<<<
* dst.suboffsets[new_ndim] = suboffset
*
*/
(__pyx_v_dst->shape[__pyx_v_new_ndim]) = __pyx_v_new_shape;
/* "View.MemoryView":886
* dst.strides[new_ndim] = stride * step
* dst.shape[new_ndim] = new_shape
* dst.suboffsets[new_ndim] = suboffset # <<<<<<<<<<<<<<
*
*
*/
(__pyx_v_dst->suboffsets[__pyx_v_new_ndim]) = __pyx_v_suboffset;
}
__pyx_L3:;
/* "View.MemoryView":889
*
*
* if suboffset_dim[0] < 0: # <<<<<<<<<<<<<<
* dst.data += start * stride
* else:
*/
__pyx_t_2 = (((__pyx_v_suboffset_dim[0]) < 0) != 0);
if (__pyx_t_2) {
/* "View.MemoryView":890
*
* if suboffset_dim[0] < 0:
* dst.data += start * stride # <<<<<<<<<<<<<<
* else:
* dst.suboffsets[suboffset_dim[0]] += start * stride
*/
__pyx_v_dst->data = (__pyx_v_dst->data + (__pyx_v_start * __pyx_v_stride));
/* "View.MemoryView":889
*
*
* if suboffset_dim[0] < 0: # <<<<<<<<<<<<<<
* dst.data += start * stride
* else:
*/
goto __pyx_L23;
}
/* "View.MemoryView":892
* dst.data += start * stride
* else:
* dst.suboffsets[suboffset_dim[0]] += start * stride # <<<<<<<<<<<<<<
*
* if suboffset >= 0:
*/
/*else*/ {
__pyx_t_3 = (__pyx_v_suboffset_dim[0]);
(__pyx_v_dst->suboffsets[__pyx_t_3]) = ((__pyx_v_dst->suboffsets[__pyx_t_3]) + (__pyx_v_start * __pyx_v_stride));
}
__pyx_L23:;
/* "View.MemoryView":894
* dst.suboffsets[suboffset_dim[0]] += start * stride
*
* if suboffset >= 0: # <<<<<<<<<<<<<<
* if not is_slice:
* if new_ndim == 0:
*/
__pyx_t_2 = ((__pyx_v_suboffset >= 0) != 0);
if (__pyx_t_2) {
/* "View.MemoryView":895
*
* if suboffset >= 0:
* if not is_slice: # <<<<<<<<<<<<<<
* if new_ndim == 0:
* dst.data = (<char **> dst.data)[0] + suboffset
*/
__pyx_t_2 = ((!(__pyx_v_is_slice != 0)) != 0);
if (__pyx_t_2) {
/* "View.MemoryView":896
* if suboffset >= 0:
* if not is_slice:
* if new_ndim == 0: # <<<<<<<<<<<<<<
* dst.data = (<char **> dst.data)[0] + suboffset
* else:
*/
__pyx_t_2 = ((__pyx_v_new_ndim == 0) != 0);
if (__pyx_t_2) {
/* "View.MemoryView":897
* if not is_slice:
* if new_ndim == 0:
* dst.data = (<char **> dst.data)[0] + suboffset # <<<<<<<<<<<<<<
* else:
* _err_dim(IndexError, "All dimensions preceding dimension %d "
*/
__pyx_v_dst->data = ((((char **)__pyx_v_dst->data)[0]) + __pyx_v_suboffset);
/* "View.MemoryView":896
* if suboffset >= 0:
* if not is_slice:
* if new_ndim == 0: # <<<<<<<<<<<<<<
* dst.data = (<char **> dst.data)[0] + suboffset
* else:
*/
goto __pyx_L26;
}
/* "View.MemoryView":899
* dst.data = (<char **> dst.data)[0] + suboffset
* else:
* _err_dim(IndexError, "All dimensions preceding dimension %d " # <<<<<<<<<<<<<<
* "must be indexed and not sliced", dim)
* else:
*/
/*else*/ {
/* "View.MemoryView":900
* else:
* _err_dim(IndexError, "All dimensions preceding dimension %d "
* "must be indexed and not sliced", dim) # <<<<<<<<<<<<<<
* else:
* suboffset_dim[0] = new_ndim
*/
__pyx_t_3 = __pyx_memoryview_err_dim(__pyx_builtin_IndexError, ((char *)"All dimensions preceding dimension %d must be indexed and not sliced"), __pyx_v_dim); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(1, 899, __pyx_L1_error)
}
__pyx_L26:;
/* "View.MemoryView":895
*
* if suboffset >= 0:
* if not is_slice: # <<<<<<<<<<<<<<
* if new_ndim == 0:
* dst.data = (<char **> dst.data)[0] + suboffset
*/
goto __pyx_L25;
}
/* "View.MemoryView":902
* "must be indexed and not sliced", dim)
* else:
* suboffset_dim[0] = new_ndim # <<<<<<<<<<<<<<
*
* return 0
*/
/*else*/ {
(__pyx_v_suboffset_dim[0]) = __pyx_v_new_ndim;
}
__pyx_L25:;
/* "View.MemoryView":894
* dst.suboffsets[suboffset_dim[0]] += start * stride
*
* if suboffset >= 0: # <<<<<<<<<<<<<<
* if not is_slice:
* if new_ndim == 0:
*/
}
/* "View.MemoryView":904
* suboffset_dim[0] = new_ndim
*
* return 0 # <<<<<<<<<<<<<<
*
*
*/
__pyx_r = 0;
goto __pyx_L0;
/* "View.MemoryView":807
*
* @cname('__pyx_memoryview_slice_memviewslice')
* cdef int slice_memviewslice( # <<<<<<<<<<<<<<
* __Pyx_memviewslice *dst,
* Py_ssize_t shape, Py_ssize_t stride, Py_ssize_t suboffset,
*/
/* function exit code */
__pyx_L1_error:;
{
#ifdef WITH_THREAD
PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
#endif
__Pyx_AddTraceback("View.MemoryView.slice_memviewslice", __pyx_clineno, __pyx_lineno, __pyx_filename);
#ifdef WITH_THREAD
__Pyx_PyGILState_Release(__pyx_gilstate_save);
#endif
}
__pyx_r = -1;
__pyx_L0:;
__Pyx_TraceReturn(Py_None, 1);
return __pyx_r;
}
/* "View.MemoryView":910
*
* @cname('__pyx_pybuffer_index')
* cdef char *pybuffer_index(Py_buffer *view, char *bufp, Py_ssize_t index, # <<<<<<<<<<<<<<
* Py_ssize_t dim) except NULL:
* cdef Py_ssize_t shape, stride, suboffset = -1
*/
static char *__pyx_pybuffer_index(Py_buffer *__pyx_v_view, char *__pyx_v_bufp, Py_ssize_t __pyx_v_index, Py_ssize_t __pyx_v_dim) {
Py_ssize_t __pyx_v_shape;
Py_ssize_t __pyx_v_stride;
Py_ssize_t __pyx_v_suboffset;
Py_ssize_t __pyx_v_itemsize;
char *__pyx_v_resultp;
char *__pyx_r;
__Pyx_TraceDeclarations
__Pyx_RefNannyDeclarations
Py_ssize_t __pyx_t_1;
int __pyx_t_2;
PyObject *__pyx_t_3 = NULL;
PyObject *__pyx_t_4 = NULL;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("pybuffer_index", 0);
__Pyx_TraceCall("pybuffer_index", __pyx_f[1], 910, 0, __PYX_ERR(1, 910, __pyx_L1_error));
/* "View.MemoryView":912
* cdef char *pybuffer_index(Py_buffer *view, char *bufp, Py_ssize_t index,
* Py_ssize_t dim) except NULL:
* cdef Py_ssize_t shape, stride, suboffset = -1 # <<<<<<<<<<<<<<
* cdef Py_ssize_t itemsize = view.itemsize
* cdef char *resultp
*/
__pyx_v_suboffset = -1L;
/* "View.MemoryView":913
* Py_ssize_t dim) except NULL:
* cdef Py_ssize_t shape, stride, suboffset = -1
* cdef Py_ssize_t itemsize = view.itemsize # <<<<<<<<<<<<<<
* cdef char *resultp
*
*/
__pyx_t_1 = __pyx_v_view->itemsize;
__pyx_v_itemsize = __pyx_t_1;
/* "View.MemoryView":916
* cdef char *resultp
*
* if view.ndim == 0: # <<<<<<<<<<<<<<
* shape = view.len / itemsize
* stride = itemsize
*/
__pyx_t_2 = ((__pyx_v_view->ndim == 0) != 0);
if (__pyx_t_2) {
/* "View.MemoryView":917
*
* if view.ndim == 0:
* shape = view.len / itemsize # <<<<<<<<<<<<<<
* stride = itemsize
* else:
*/
if (unlikely(__pyx_v_itemsize == 0)) {
PyErr_SetString(PyExc_ZeroDivisionError, "integer division or modulo by zero");
__PYX_ERR(1, 917, __pyx_L1_error)
}
else if (sizeof(Py_ssize_t) == sizeof(long) && (!(((Py_ssize_t)-1) > 0)) && unlikely(__pyx_v_itemsize == (Py_ssize_t)-1) && unlikely(UNARY_NEG_WOULD_OVERFLOW(__pyx_v_view->len))) {
PyErr_SetString(PyExc_OverflowError, "value too large to perform division");
__PYX_ERR(1, 917, __pyx_L1_error)
}
__pyx_v_shape = (__pyx_v_view->len / __pyx_v_itemsize);
/* "View.MemoryView":918
* if view.ndim == 0:
* shape = view.len / itemsize
* stride = itemsize # <<<<<<<<<<<<<<
* else:
* shape = view.shape[dim]
*/
__pyx_v_stride = __pyx_v_itemsize;
/* "View.MemoryView":916
* cdef char *resultp
*
* if view.ndim == 0: # <<<<<<<<<<<<<<
* shape = view.len / itemsize
* stride = itemsize
*/
goto __pyx_L3;
}
/* "View.MemoryView":920
* stride = itemsize
* else:
* shape = view.shape[dim] # <<<<<<<<<<<<<<
* stride = view.strides[dim]
* if view.suboffsets != NULL:
*/
/*else*/ {
__pyx_v_shape = (__pyx_v_view->shape[__pyx_v_dim]);
/* "View.MemoryView":921
* else:
* shape = view.shape[dim]
* stride = view.strides[dim] # <<<<<<<<<<<<<<
* if view.suboffsets != NULL:
* suboffset = view.suboffsets[dim]
*/
__pyx_v_stride = (__pyx_v_view->strides[__pyx_v_dim]);
/* "View.MemoryView":922
* shape = view.shape[dim]
* stride = view.strides[dim]
* if view.suboffsets != NULL: # <<<<<<<<<<<<<<
* suboffset = view.suboffsets[dim]
*
*/
__pyx_t_2 = ((__pyx_v_view->suboffsets != NULL) != 0);
if (__pyx_t_2) {
/* "View.MemoryView":923
* stride = view.strides[dim]
* if view.suboffsets != NULL:
* suboffset = view.suboffsets[dim] # <<<<<<<<<<<<<<
*
* if index < 0:
*/
__pyx_v_suboffset = (__pyx_v_view->suboffsets[__pyx_v_dim]);
/* "View.MemoryView":922
* shape = view.shape[dim]
* stride = view.strides[dim]
* if view.suboffsets != NULL: # <<<<<<<<<<<<<<
* suboffset = view.suboffsets[dim]
*
*/
}
}
__pyx_L3:;
/* "View.MemoryView":925
* suboffset = view.suboffsets[dim]
*
* if index < 0: # <<<<<<<<<<<<<<
* index += view.shape[dim]
* if index < 0:
*/
__pyx_t_2 = ((__pyx_v_index < 0) != 0);
if (__pyx_t_2) {
/* "View.MemoryView":926
*
* if index < 0:
* index += view.shape[dim] # <<<<<<<<<<<<<<
* if index < 0:
* raise IndexError("Out of bounds on buffer access (axis %d)" % dim)
*/
__pyx_v_index = (__pyx_v_index + (__pyx_v_view->shape[__pyx_v_dim]));
/* "View.MemoryView":927
* if index < 0:
* index += view.shape[dim]
* if index < 0: # <<<<<<<<<<<<<<
* raise IndexError("Out of bounds on buffer access (axis %d)" % dim)
*
*/
__pyx_t_2 = ((__pyx_v_index < 0) != 0);
if (unlikely(__pyx_t_2)) {
/* "View.MemoryView":928
* index += view.shape[dim]
* if index < 0:
* raise IndexError("Out of bounds on buffer access (axis %d)" % dim) # <<<<<<<<<<<<<<
*
* if index >= shape:
*/
__pyx_t_3 = PyInt_FromSsize_t(__pyx_v_dim); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 928, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__pyx_t_4 = __Pyx_PyString_Format(__pyx_kp_s_Out_of_bounds_on_buffer_access_a, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 928, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_IndexError, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 928, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_Raise(__pyx_t_3, 0, 0, 0);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__PYX_ERR(1, 928, __pyx_L1_error)
/* "View.MemoryView":927
* if index < 0:
* index += view.shape[dim]
* if index < 0: # <<<<<<<<<<<<<<
* raise IndexError("Out of bounds on buffer access (axis %d)" % dim)
*
*/
}
/* "View.MemoryView":925
* suboffset = view.suboffsets[dim]
*
* if index < 0: # <<<<<<<<<<<<<<
* index += view.shape[dim]
* if index < 0:
*/
}
/* "View.MemoryView":930
* raise IndexError("Out of bounds on buffer access (axis %d)" % dim)
*
* if index >= shape: # <<<<<<<<<<<<<<
* raise IndexError("Out of bounds on buffer access (axis %d)" % dim)
*
*/
__pyx_t_2 = ((__pyx_v_index >= __pyx_v_shape) != 0);
if (unlikely(__pyx_t_2)) {
/* "View.MemoryView":931
*
* if index >= shape:
* raise IndexError("Out of bounds on buffer access (axis %d)" % dim) # <<<<<<<<<<<<<<
*
* resultp = bufp + index * stride
*/
__pyx_t_3 = PyInt_FromSsize_t(__pyx_v_dim); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 931, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__pyx_t_4 = __Pyx_PyString_Format(__pyx_kp_s_Out_of_bounds_on_buffer_access_a, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 931, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_IndexError, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 931, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_Raise(__pyx_t_3, 0, 0, 0);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__PYX_ERR(1, 931, __pyx_L1_error)
/* "View.MemoryView":930
* raise IndexError("Out of bounds on buffer access (axis %d)" % dim)
*
* if index >= shape: # <<<<<<<<<<<<<<
* raise IndexError("Out of bounds on buffer access (axis %d)" % dim)
*
*/
}
/* "View.MemoryView":933
* raise IndexError("Out of bounds on buffer access (axis %d)" % dim)
*
* resultp = bufp + index * stride # <<<<<<<<<<<<<<
* if suboffset >= 0:
* resultp = (<char **> resultp)[0] + suboffset
*/
__pyx_v_resultp = (__pyx_v_bufp + (__pyx_v_index * __pyx_v_stride));
/* "View.MemoryView":934
*
* resultp = bufp + index * stride
* if suboffset >= 0: # <<<<<<<<<<<<<<
* resultp = (<char **> resultp)[0] + suboffset
*
*/
__pyx_t_2 = ((__pyx_v_suboffset >= 0) != 0);
if (__pyx_t_2) {
/* "View.MemoryView":935
* resultp = bufp + index * stride
* if suboffset >= 0:
* resultp = (<char **> resultp)[0] + suboffset # <<<<<<<<<<<<<<
*
* return resultp
*/
__pyx_v_resultp = ((((char **)__pyx_v_resultp)[0]) + __pyx_v_suboffset);
/* "View.MemoryView":934
*
* resultp = bufp + index * stride
* if suboffset >= 0: # <<<<<<<<<<<<<<
* resultp = (<char **> resultp)[0] + suboffset
*
*/
}
/* "View.MemoryView":937
* resultp = (<char **> resultp)[0] + suboffset
*
* return resultp # <<<<<<<<<<<<<<
*
*
*/
__pyx_r = __pyx_v_resultp;
goto __pyx_L0;
/* "View.MemoryView":910
*
* @cname('__pyx_pybuffer_index')
* cdef char *pybuffer_index(Py_buffer *view, char *bufp, Py_ssize_t index, # <<<<<<<<<<<<<<
* Py_ssize_t dim) except NULL:
* cdef Py_ssize_t shape, stride, suboffset = -1
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_3);
__Pyx_XDECREF(__pyx_t_4);
__Pyx_AddTraceback("View.MemoryView.pybuffer_index", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = NULL;
__pyx_L0:;
__Pyx_TraceReturn(Py_None, 0);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "View.MemoryView":943
*
* @cname('__pyx_memslice_transpose')
* cdef int transpose_memslice(__Pyx_memviewslice *memslice) nogil except 0: # <<<<<<<<<<<<<<
* cdef int ndim = memslice.memview.view.ndim
*
*/
static int __pyx_memslice_transpose(__Pyx_memviewslice *__pyx_v_memslice) {
int __pyx_v_ndim;
Py_ssize_t *__pyx_v_shape;
Py_ssize_t *__pyx_v_strides;
int __pyx_v_i;
int __pyx_v_j;
int __pyx_r;
__Pyx_TraceDeclarations
int __pyx_t_1;
Py_ssize_t *__pyx_t_2;
long __pyx_t_3;
long __pyx_t_4;
Py_ssize_t __pyx_t_5;
Py_ssize_t __pyx_t_6;
int __pyx_t_7;
int __pyx_t_8;
int __pyx_t_9;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_TraceCall("transpose_memslice", __pyx_f[1], 943, 1, __PYX_ERR(1, 943, __pyx_L1_error));
/* "View.MemoryView":944
* @cname('__pyx_memslice_transpose')
* cdef int transpose_memslice(__Pyx_memviewslice *memslice) nogil except 0:
* cdef int ndim = memslice.memview.view.ndim # <<<<<<<<<<<<<<
*
* cdef Py_ssize_t *shape = memslice.shape
*/
__pyx_t_1 = __pyx_v_memslice->memview->view.ndim;
__pyx_v_ndim = __pyx_t_1;
/* "View.MemoryView":946
* cdef int ndim = memslice.memview.view.ndim
*
* cdef Py_ssize_t *shape = memslice.shape # <<<<<<<<<<<<<<
* cdef Py_ssize_t *strides = memslice.strides
*
*/
__pyx_t_2 = __pyx_v_memslice->shape;
__pyx_v_shape = __pyx_t_2;
/* "View.MemoryView":947
*
* cdef Py_ssize_t *shape = memslice.shape
* cdef Py_ssize_t *strides = memslice.strides # <<<<<<<<<<<<<<
*
*
*/
__pyx_t_2 = __pyx_v_memslice->strides;
__pyx_v_strides = __pyx_t_2;
/* "View.MemoryView":951
*
* cdef int i, j
* for i in range(ndim / 2): # <<<<<<<<<<<<<<
* j = ndim - 1 - i
* strides[i], strides[j] = strides[j], strides[i]
*/
__pyx_t_3 = (__pyx_v_ndim / 2);
__pyx_t_4 = __pyx_t_3;
for (__pyx_t_1 = 0; __pyx_t_1 < __pyx_t_4; __pyx_t_1+=1) {
__pyx_v_i = __pyx_t_1;
/* "View.MemoryView":952
* cdef int i, j
* for i in range(ndim / 2):
* j = ndim - 1 - i # <<<<<<<<<<<<<<
* strides[i], strides[j] = strides[j], strides[i]
* shape[i], shape[j] = shape[j], shape[i]
*/
__pyx_v_j = ((__pyx_v_ndim - 1) - __pyx_v_i);
/* "View.MemoryView":953
* for i in range(ndim / 2):
* j = ndim - 1 - i
* strides[i], strides[j] = strides[j], strides[i] # <<<<<<<<<<<<<<
* shape[i], shape[j] = shape[j], shape[i]
*
*/
__pyx_t_5 = (__pyx_v_strides[__pyx_v_j]);
__pyx_t_6 = (__pyx_v_strides[__pyx_v_i]);
(__pyx_v_strides[__pyx_v_i]) = __pyx_t_5;
(__pyx_v_strides[__pyx_v_j]) = __pyx_t_6;
/* "View.MemoryView":954
* j = ndim - 1 - i
* strides[i], strides[j] = strides[j], strides[i]
* shape[i], shape[j] = shape[j], shape[i] # <<<<<<<<<<<<<<
*
* if memslice.suboffsets[i] >= 0 or memslice.suboffsets[j] >= 0:
*/
__pyx_t_6 = (__pyx_v_shape[__pyx_v_j]);
__pyx_t_5 = (__pyx_v_shape[__pyx_v_i]);
(__pyx_v_shape[__pyx_v_i]) = __pyx_t_6;
(__pyx_v_shape[__pyx_v_j]) = __pyx_t_5;
/* "View.MemoryView":956
* shape[i], shape[j] = shape[j], shape[i]
*
* if memslice.suboffsets[i] >= 0 or memslice.suboffsets[j] >= 0: # <<<<<<<<<<<<<<
* _err(ValueError, "Cannot transpose memoryview with indirect dimensions")
*
*/
__pyx_t_8 = (((__pyx_v_memslice->suboffsets[__pyx_v_i]) >= 0) != 0);
if (!__pyx_t_8) {
} else {
__pyx_t_7 = __pyx_t_8;
goto __pyx_L6_bool_binop_done;
}
__pyx_t_8 = (((__pyx_v_memslice->suboffsets[__pyx_v_j]) >= 0) != 0);
__pyx_t_7 = __pyx_t_8;
__pyx_L6_bool_binop_done:;
if (__pyx_t_7) {
/* "View.MemoryView":957
*
* if memslice.suboffsets[i] >= 0 or memslice.suboffsets[j] >= 0:
* _err(ValueError, "Cannot transpose memoryview with indirect dimensions") # <<<<<<<<<<<<<<
*
* return 1
*/
__pyx_t_9 = __pyx_memoryview_err(__pyx_builtin_ValueError, ((char *)"Cannot transpose memoryview with indirect dimensions")); if (unlikely(__pyx_t_9 == ((int)-1))) __PYX_ERR(1, 957, __pyx_L1_error)
/* "View.MemoryView":956
* shape[i], shape[j] = shape[j], shape[i]
*
* if memslice.suboffsets[i] >= 0 or memslice.suboffsets[j] >= 0: # <<<<<<<<<<<<<<
* _err(ValueError, "Cannot transpose memoryview with indirect dimensions")
*
*/
}
}
/* "View.MemoryView":959
* _err(ValueError, "Cannot transpose memoryview with indirect dimensions")
*
* return 1 # <<<<<<<<<<<<<<
*
*
*/
__pyx_r = 1;
goto __pyx_L0;
/* "View.MemoryView":943
*
* @cname('__pyx_memslice_transpose')
* cdef int transpose_memslice(__Pyx_memviewslice *memslice) nogil except 0: # <<<<<<<<<<<<<<
* cdef int ndim = memslice.memview.view.ndim
*
*/
/* function exit code */
__pyx_L1_error:;
{
#ifdef WITH_THREAD
PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
#endif
__Pyx_AddTraceback("View.MemoryView.transpose_memslice", __pyx_clineno, __pyx_lineno, __pyx_filename);
#ifdef WITH_THREAD
__Pyx_PyGILState_Release(__pyx_gilstate_save);
#endif
}
__pyx_r = 0;
__pyx_L0:;
__Pyx_TraceReturn(Py_None, 1);
return __pyx_r;
}
/* "View.MemoryView":976
* cdef int (*to_dtype_func)(char *, object) except 0
*
* def __dealloc__(self): # <<<<<<<<<<<<<<
* __PYX_XDEC_MEMVIEW(&self.from_slice, 1)
*
*/
/* Python wrapper */
static void __pyx_memoryviewslice___dealloc__(PyObject *__pyx_v_self); /*proto*/
static void __pyx_memoryviewslice___dealloc__(PyObject *__pyx_v_self) {
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0);
__pyx_memoryviewslice___pyx_pf_15View_dot_MemoryView_16_memoryviewslice___dealloc__(((struct __pyx_memoryviewslice_obj *)__pyx_v_self));
/* function exit code */
__Pyx_RefNannyFinishContext();
}
static void __pyx_memoryviewslice___pyx_pf_15View_dot_MemoryView_16_memoryviewslice___dealloc__(struct __pyx_memoryviewslice_obj *__pyx_v_self) {
__Pyx_TraceDeclarations
__Pyx_RefNannyDeclarations
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("__dealloc__", 0);
__Pyx_TraceCall("__dealloc__", __pyx_f[1], 976, 0, __PYX_ERR(1, 976, __pyx_L1_error));
/* "View.MemoryView":977
*
* def __dealloc__(self):
* __PYX_XDEC_MEMVIEW(&self.from_slice, 1) # <<<<<<<<<<<<<<
*
* cdef convert_item_to_object(self, char *itemp):
*/
__PYX_XDEC_MEMVIEW((&__pyx_v_self->from_slice), 1);
/* "View.MemoryView":976
* cdef int (*to_dtype_func)(char *, object) except 0
*
* def __dealloc__(self): # <<<<<<<<<<<<<<
* __PYX_XDEC_MEMVIEW(&self.from_slice, 1)
*
*/
/* function exit code */
goto __pyx_L0;
__pyx_L1_error:;
__Pyx_WriteUnraisable("View.MemoryView._memoryviewslice.__dealloc__", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0);
__pyx_L0:;
__Pyx_TraceReturn(Py_None, 0);
__Pyx_RefNannyFinishContext();
}
/* "View.MemoryView":979
* __PYX_XDEC_MEMVIEW(&self.from_slice, 1)
*
* cdef convert_item_to_object(self, char *itemp): # <<<<<<<<<<<<<<
* if self.to_object_func != NULL:
* return self.to_object_func(itemp)
*/
static PyObject *__pyx_memoryviewslice_convert_item_to_object(struct __pyx_memoryviewslice_obj *__pyx_v_self, char *__pyx_v_itemp) {
PyObject *__pyx_r = NULL;
__Pyx_TraceDeclarations
__Pyx_RefNannyDeclarations
int __pyx_t_1;
PyObject *__pyx_t_2 = NULL;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("convert_item_to_object", 0);
__Pyx_TraceCall("convert_item_to_object", __pyx_f[1], 979, 0, __PYX_ERR(1, 979, __pyx_L1_error));
/* "View.MemoryView":980
*
* cdef convert_item_to_object(self, char *itemp):
* if self.to_object_func != NULL: # <<<<<<<<<<<<<<
* return self.to_object_func(itemp)
* else:
*/
__pyx_t_1 = ((__pyx_v_self->to_object_func != NULL) != 0);
if (__pyx_t_1) {
/* "View.MemoryView":981
* cdef convert_item_to_object(self, char *itemp):
* if self.to_object_func != NULL:
* return self.to_object_func(itemp) # <<<<<<<<<<<<<<
* else:
* return memoryview.convert_item_to_object(self, itemp)
*/
__Pyx_XDECREF(__pyx_r);
__pyx_t_2 = __pyx_v_self->to_object_func(__pyx_v_itemp); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 981, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__pyx_r = __pyx_t_2;
__pyx_t_2 = 0;
goto __pyx_L0;
/* "View.MemoryView":980
*
* cdef convert_item_to_object(self, char *itemp):
* if self.to_object_func != NULL: # <<<<<<<<<<<<<<
* return self.to_object_func(itemp)
* else:
*/
}
/* "View.MemoryView":983
* return self.to_object_func(itemp)
* else:
* return memoryview.convert_item_to_object(self, itemp) # <<<<<<<<<<<<<<
*
* cdef assign_item_from_object(self, char *itemp, object value):
*/
/*else*/ {
__Pyx_XDECREF(__pyx_r);
__pyx_t_2 = __pyx_memoryview_convert_item_to_object(((struct __pyx_memoryview_obj *)__pyx_v_self), __pyx_v_itemp); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 983, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__pyx_r = __pyx_t_2;
__pyx_t_2 = 0;
goto __pyx_L0;
}
/* "View.MemoryView":979
* __PYX_XDEC_MEMVIEW(&self.from_slice, 1)
*
* cdef convert_item_to_object(self, char *itemp): # <<<<<<<<<<<<<<
* if self.to_object_func != NULL:
* return self.to_object_func(itemp)
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_2);
__Pyx_AddTraceback("View.MemoryView._memoryviewslice.convert_item_to_object", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = 0;
__pyx_L0:;
__Pyx_XGIVEREF(__pyx_r);
__Pyx_TraceReturn(__pyx_r, 0);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "View.MemoryView":985
* return memoryview.convert_item_to_object(self, itemp)
*
* cdef assign_item_from_object(self, char *itemp, object value): # <<<<<<<<<<<<<<
* if self.to_dtype_func != NULL:
* self.to_dtype_func(itemp, value)
*/
static PyObject *__pyx_memoryviewslice_assign_item_from_object(struct __pyx_memoryviewslice_obj *__pyx_v_self, char *__pyx_v_itemp, PyObject *__pyx_v_value) {
PyObject *__pyx_r = NULL;
__Pyx_TraceDeclarations
__Pyx_RefNannyDeclarations
int __pyx_t_1;
int __pyx_t_2;
PyObject *__pyx_t_3 = NULL;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("assign_item_from_object", 0);
__Pyx_TraceCall("assign_item_from_object", __pyx_f[1], 985, 0, __PYX_ERR(1, 985, __pyx_L1_error));
/* "View.MemoryView":986
*
* cdef assign_item_from_object(self, char *itemp, object value):
* if self.to_dtype_func != NULL: # <<<<<<<<<<<<<<
* self.to_dtype_func(itemp, value)
* else:
*/
__pyx_t_1 = ((__pyx_v_self->to_dtype_func != NULL) != 0);
if (__pyx_t_1) {
/* "View.MemoryView":987
* cdef assign_item_from_object(self, char *itemp, object value):
* if self.to_dtype_func != NULL:
* self.to_dtype_func(itemp, value) # <<<<<<<<<<<<<<
* else:
* memoryview.assign_item_from_object(self, itemp, value)
*/
__pyx_t_2 = __pyx_v_self->to_dtype_func(__pyx_v_itemp, __pyx_v_value); if (unlikely(__pyx_t_2 == ((int)0))) __PYX_ERR(1, 987, __pyx_L1_error)
/* "View.MemoryView":986
*
* cdef assign_item_from_object(self, char *itemp, object value):
* if self.to_dtype_func != NULL: # <<<<<<<<<<<<<<
* self.to_dtype_func(itemp, value)
* else:
*/
goto __pyx_L3;
}
/* "View.MemoryView":989
* self.to_dtype_func(itemp, value)
* else:
* memoryview.assign_item_from_object(self, itemp, value) # <<<<<<<<<<<<<<
*
* @property
*/
/*else*/ {
__pyx_t_3 = __pyx_memoryview_assign_item_from_object(((struct __pyx_memoryview_obj *)__pyx_v_self), __pyx_v_itemp, __pyx_v_value); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 989, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
}
__pyx_L3:;
/* "View.MemoryView":985
* return memoryview.convert_item_to_object(self, itemp)
*
* cdef assign_item_from_object(self, char *itemp, object value): # <<<<<<<<<<<<<<
* if self.to_dtype_func != NULL:
* self.to_dtype_func(itemp, value)
*/
/* function exit code */
__pyx_r = Py_None; __Pyx_INCREF(Py_None);
goto __pyx_L0;
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_3);
__Pyx_AddTraceback("View.MemoryView._memoryviewslice.assign_item_from_object", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = 0;
__pyx_L0:;
__Pyx_XGIVEREF(__pyx_r);
__Pyx_TraceReturn(__pyx_r, 0);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "View.MemoryView":992
*
* @property
* def base(self): # <<<<<<<<<<<<<<
* return self.from_object
*
*/
/* Python wrapper */
static PyObject *__pyx_pw_15View_dot_MemoryView_16_memoryviewslice_4base_1__get__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_15View_dot_MemoryView_16_memoryviewslice_4base_1__get__(PyObject *__pyx_v_self) {
PyObject *__pyx_r = 0;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
__pyx_r = __pyx_pf_15View_dot_MemoryView_16_memoryviewslice_4base___get__(((struct __pyx_memoryviewslice_obj *)__pyx_v_self));
/* function exit code */
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
static PyObject *__pyx_pf_15View_dot_MemoryView_16_memoryviewslice_4base___get__(struct __pyx_memoryviewslice_obj *__pyx_v_self) {
PyObject *__pyx_r = NULL;
__Pyx_TraceDeclarations
__Pyx_RefNannyDeclarations
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("__get__", 0);
__Pyx_TraceCall("__get__", __pyx_f[1], 992, 0, __PYX_ERR(1, 992, __pyx_L1_error));
/* "View.MemoryView":993
* @property
* def base(self):
* return self.from_object # <<<<<<<<<<<<<<
*
* __pyx_getbuffer = capsule(<void *> &__pyx_memoryview_getbuffer, "getbuffer(obj, view, flags)")
*/
__Pyx_XDECREF(__pyx_r);
__Pyx_INCREF(__pyx_v_self->from_object);
__pyx_r = __pyx_v_self->from_object;
goto __pyx_L0;
/* "View.MemoryView":992
*
* @property
* def base(self): # <<<<<<<<<<<<<<
* return self.from_object
*
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_AddTraceback("View.MemoryView._memoryviewslice.base.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = NULL;
__pyx_L0:;
__Pyx_XGIVEREF(__pyx_r);
__Pyx_TraceReturn(__pyx_r, 0);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "(tree fragment)":1
* def __reduce_cython__(self): # <<<<<<<<<<<<<<
* raise TypeError("no default __reduce__ due to non-trivial __cinit__")
* def __setstate_cython__(self, __pyx_state):
*/
/* Python wrapper */
static PyObject *__pyx_pw___pyx_memoryviewslice_1__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
static PyObject *__pyx_pw___pyx_memoryviewslice_1__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
PyObject *__pyx_r = 0;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0);
__pyx_r = __pyx_pf___pyx_memoryviewslice___reduce_cython__(((struct __pyx_memoryviewslice_obj *)__pyx_v_self));
/* function exit code */
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
static PyObject *__pyx_pf___pyx_memoryviewslice___reduce_cython__(CYTHON_UNUSED struct __pyx_memoryviewslice_obj *__pyx_v_self) {
PyObject *__pyx_r = NULL;
__Pyx_TraceDeclarations
__Pyx_RefNannyDeclarations
PyObject *__pyx_t_1 = NULL;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("__reduce_cython__", 0);
__Pyx_TraceCall("__reduce_cython__", __pyx_f[1], 1, 0, __PYX_ERR(1, 1, __pyx_L1_error));
/* "(tree fragment)":2
* def __reduce_cython__(self):
* raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<<
* def __setstate_cython__(self, __pyx_state):
* raise TypeError("no default __reduce__ due to non-trivial __cinit__")
*/
__pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__35, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_Raise(__pyx_t_1, 0, 0, 0);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__PYX_ERR(1, 2, __pyx_L1_error)
/* "(tree fragment)":1
* def __reduce_cython__(self): # <<<<<<<<<<<<<<
* raise TypeError("no default __reduce__ due to non-trivial __cinit__")
* def __setstate_cython__(self, __pyx_state):
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_1);
__Pyx_AddTraceback("View.MemoryView._memoryviewslice.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = NULL;
__Pyx_XGIVEREF(__pyx_r);
__Pyx_TraceReturn(__pyx_r, 0);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "(tree fragment)":3
* def __reduce_cython__(self):
* raise TypeError("no default __reduce__ due to non-trivial __cinit__")
* def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<<
* raise TypeError("no default __reduce__ due to non-trivial __cinit__")
*/
/* Python wrapper */
static PyObject *__pyx_pw___pyx_memoryviewslice_3__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state); /*proto*/
static PyObject *__pyx_pw___pyx_memoryviewslice_3__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state) {
PyObject *__pyx_r = 0;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0);
__pyx_r = __pyx_pf___pyx_memoryviewslice_2__setstate_cython__(((struct __pyx_memoryviewslice_obj *)__pyx_v_self), ((PyObject *)__pyx_v___pyx_state));
/* function exit code */
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
static PyObject *__pyx_pf___pyx_memoryviewslice_2__setstate_cython__(CYTHON_UNUSED struct __pyx_memoryviewslice_obj *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) {
PyObject *__pyx_r = NULL;
__Pyx_TraceDeclarations
__Pyx_RefNannyDeclarations
PyObject *__pyx_t_1 = NULL;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("__setstate_cython__", 0);
__Pyx_TraceCall("__setstate_cython__", __pyx_f[1], 3, 0, __PYX_ERR(1, 3, __pyx_L1_error));
/* "(tree fragment)":4
* raise TypeError("no default __reduce__ due to non-trivial __cinit__")
* def __setstate_cython__(self, __pyx_state):
* raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<<
*/
__pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__36, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 4, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_Raise(__pyx_t_1, 0, 0, 0);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__PYX_ERR(1, 4, __pyx_L1_error)
/* "(tree fragment)":3
* def __reduce_cython__(self):
* raise TypeError("no default __reduce__ due to non-trivial __cinit__")
* def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<<
* raise TypeError("no default __reduce__ due to non-trivial __cinit__")
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_1);
__Pyx_AddTraceback("View.MemoryView._memoryviewslice.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = NULL;
__Pyx_XGIVEREF(__pyx_r);
__Pyx_TraceReturn(__pyx_r, 0);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "View.MemoryView":999
*
* @cname('__pyx_memoryview_fromslice')
* cdef memoryview_fromslice(__Pyx_memviewslice memviewslice, # <<<<<<<<<<<<<<
* int ndim,
* object (*to_object_func)(char *),
*/
static PyObject *__pyx_memoryview_fromslice(__Pyx_memviewslice __pyx_v_memviewslice, int __pyx_v_ndim, PyObject *(*__pyx_v_to_object_func)(char *), int (*__pyx_v_to_dtype_func)(char *, PyObject *), int __pyx_v_dtype_is_object) {
struct __pyx_memoryviewslice_obj *__pyx_v_result = 0;
Py_ssize_t __pyx_v_suboffset;
PyObject *__pyx_v_length = NULL;
PyObject *__pyx_r = NULL;
__Pyx_TraceDeclarations
__Pyx_RefNannyDeclarations
int __pyx_t_1;
PyObject *__pyx_t_2 = NULL;
PyObject *__pyx_t_3 = NULL;
__Pyx_TypeInfo *__pyx_t_4;
Py_buffer __pyx_t_5;
Py_ssize_t *__pyx_t_6;
Py_ssize_t *__pyx_t_7;
Py_ssize_t *__pyx_t_8;
Py_ssize_t __pyx_t_9;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("memoryview_fromslice", 0);
__Pyx_TraceCall("memoryview_fromslice", __pyx_f[1], 999, 0, __PYX_ERR(1, 999, __pyx_L1_error));
/* "View.MemoryView":1007
* cdef _memoryviewslice result
*
* if <PyObject *> memviewslice.memview == Py_None: # <<<<<<<<<<<<<<
* return None
*
*/
__pyx_t_1 = ((((PyObject *)__pyx_v_memviewslice.memview) == Py_None) != 0);
if (__pyx_t_1) {
/* "View.MemoryView":1008
*
* if <PyObject *> memviewslice.memview == Py_None:
* return None # <<<<<<<<<<<<<<
*
*
*/
__Pyx_XDECREF(__pyx_r);
__pyx_r = Py_None; __Pyx_INCREF(Py_None);
goto __pyx_L0;
/* "View.MemoryView":1007
* cdef _memoryviewslice result
*
* if <PyObject *> memviewslice.memview == Py_None: # <<<<<<<<<<<<<<
* return None
*
*/
}
/* "View.MemoryView":1013
*
*
* result = _memoryviewslice(None, 0, dtype_is_object) # <<<<<<<<<<<<<<
*
* result.from_slice = memviewslice
*/
__pyx_t_2 = __Pyx_PyBool_FromLong(__pyx_v_dtype_is_object); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1013, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1013, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_INCREF(Py_None);
__Pyx_GIVEREF(Py_None);
PyTuple_SET_ITEM(__pyx_t_3, 0, Py_None);
__Pyx_INCREF(__pyx_int_0);
__Pyx_GIVEREF(__pyx_int_0);
PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_int_0);
__Pyx_GIVEREF(__pyx_t_2);
PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_t_2);
__pyx_t_2 = 0;
__pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_memoryviewslice_type), __pyx_t_3, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1013, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__pyx_v_result = ((struct __pyx_memoryviewslice_obj *)__pyx_t_2);
__pyx_t_2 = 0;
/* "View.MemoryView":1015
* result = _memoryviewslice(None, 0, dtype_is_object)
*
* result.from_slice = memviewslice # <<<<<<<<<<<<<<
* __PYX_INC_MEMVIEW(&memviewslice, 1)
*
*/
__pyx_v_result->from_slice = __pyx_v_memviewslice;
/* "View.MemoryView":1016
*
* result.from_slice = memviewslice
* __PYX_INC_MEMVIEW(&memviewslice, 1) # <<<<<<<<<<<<<<
*
* result.from_object = (<memoryview> memviewslice.memview).base
*/
__PYX_INC_MEMVIEW((&__pyx_v_memviewslice), 1);
/* "View.MemoryView":1018
* __PYX_INC_MEMVIEW(&memviewslice, 1)
*
* result.from_object = (<memoryview> memviewslice.memview).base # <<<<<<<<<<<<<<
* result.typeinfo = memviewslice.memview.typeinfo
*
*/
__pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_memviewslice.memview), __pyx_n_s_base); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1018, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_GIVEREF(__pyx_t_2);
__Pyx_GOTREF(__pyx_v_result->from_object);
__Pyx_DECREF(__pyx_v_result->from_object);
__pyx_v_result->from_object = __pyx_t_2;
__pyx_t_2 = 0;
/* "View.MemoryView":1019
*
* result.from_object = (<memoryview> memviewslice.memview).base
* result.typeinfo = memviewslice.memview.typeinfo # <<<<<<<<<<<<<<
*
* result.view = memviewslice.memview.view
*/
__pyx_t_4 = __pyx_v_memviewslice.memview->typeinfo;
__pyx_v_result->__pyx_base.typeinfo = __pyx_t_4;
/* "View.MemoryView":1021
* result.typeinfo = memviewslice.memview.typeinfo
*
* result.view = memviewslice.memview.view # <<<<<<<<<<<<<<
* result.view.buf = <void *> memviewslice.data
* result.view.ndim = ndim
*/
__pyx_t_5 = __pyx_v_memviewslice.memview->view;
__pyx_v_result->__pyx_base.view = __pyx_t_5;
/* "View.MemoryView":1022
*
* result.view = memviewslice.memview.view
* result.view.buf = <void *> memviewslice.data # <<<<<<<<<<<<<<
* result.view.ndim = ndim
* (<__pyx_buffer *> &result.view).obj = Py_None
*/
__pyx_v_result->__pyx_base.view.buf = ((void *)__pyx_v_memviewslice.data);
/* "View.MemoryView":1023
* result.view = memviewslice.memview.view
* result.view.buf = <void *> memviewslice.data
* result.view.ndim = ndim # <<<<<<<<<<<<<<
* (<__pyx_buffer *> &result.view).obj = Py_None
* Py_INCREF(Py_None)
*/
__pyx_v_result->__pyx_base.view.ndim = __pyx_v_ndim;
/* "View.MemoryView":1024
* result.view.buf = <void *> memviewslice.data
* result.view.ndim = ndim
* (<__pyx_buffer *> &result.view).obj = Py_None # <<<<<<<<<<<<<<
* Py_INCREF(Py_None)
*
*/
((Py_buffer *)(&__pyx_v_result->__pyx_base.view))->obj = Py_None;
/* "View.MemoryView":1025
* result.view.ndim = ndim
* (<__pyx_buffer *> &result.view).obj = Py_None
* Py_INCREF(Py_None) # <<<<<<<<<<<<<<
*
* if (<memoryview>memviewslice.memview).flags & PyBUF_WRITABLE:
*/
Py_INCREF(Py_None);
/* "View.MemoryView":1027
* Py_INCREF(Py_None)
*
* if (<memoryview>memviewslice.memview).flags & PyBUF_WRITABLE: # <<<<<<<<<<<<<<
* result.flags = PyBUF_RECORDS
* else:
*/
__pyx_t_1 = ((((struct __pyx_memoryview_obj *)__pyx_v_memviewslice.memview)->flags & PyBUF_WRITABLE) != 0);
if (__pyx_t_1) {
/* "View.MemoryView":1028
*
* if (<memoryview>memviewslice.memview).flags & PyBUF_WRITABLE:
* result.flags = PyBUF_RECORDS # <<<<<<<<<<<<<<
* else:
* result.flags = PyBUF_RECORDS_RO
*/
__pyx_v_result->__pyx_base.flags = PyBUF_RECORDS;
/* "View.MemoryView":1027
* Py_INCREF(Py_None)
*
* if (<memoryview>memviewslice.memview).flags & PyBUF_WRITABLE: # <<<<<<<<<<<<<<
* result.flags = PyBUF_RECORDS
* else:
*/
goto __pyx_L4;
}
/* "View.MemoryView":1030
* result.flags = PyBUF_RECORDS
* else:
* result.flags = PyBUF_RECORDS_RO # <<<<<<<<<<<<<<
*
* result.view.shape = <Py_ssize_t *> result.from_slice.shape
*/
/*else*/ {
__pyx_v_result->__pyx_base.flags = PyBUF_RECORDS_RO;
}
__pyx_L4:;
/* "View.MemoryView":1032
* result.flags = PyBUF_RECORDS_RO
*
* result.view.shape = <Py_ssize_t *> result.from_slice.shape # <<<<<<<<<<<<<<
* result.view.strides = <Py_ssize_t *> result.from_slice.strides
*
*/
__pyx_v_result->__pyx_base.view.shape = ((Py_ssize_t *)__pyx_v_result->from_slice.shape);
/* "View.MemoryView":1033
*
* result.view.shape = <Py_ssize_t *> result.from_slice.shape
* result.view.strides = <Py_ssize_t *> result.from_slice.strides # <<<<<<<<<<<<<<
*
*
*/
__pyx_v_result->__pyx_base.view.strides = ((Py_ssize_t *)__pyx_v_result->from_slice.strides);
/* "View.MemoryView":1036
*
*
* result.view.suboffsets = NULL # <<<<<<<<<<<<<<
* for suboffset in result.from_slice.suboffsets[:ndim]:
* if suboffset >= 0:
*/
__pyx_v_result->__pyx_base.view.suboffsets = NULL;
/* "View.MemoryView":1037
*
* result.view.suboffsets = NULL
* for suboffset in result.from_slice.suboffsets[:ndim]: # <<<<<<<<<<<<<<
* if suboffset >= 0:
* result.view.suboffsets = <Py_ssize_t *> result.from_slice.suboffsets
*/
__pyx_t_7 = (__pyx_v_result->from_slice.suboffsets + __pyx_v_ndim);
for (__pyx_t_8 = __pyx_v_result->from_slice.suboffsets; __pyx_t_8 < __pyx_t_7; __pyx_t_8++) {
__pyx_t_6 = __pyx_t_8;
__pyx_v_suboffset = (__pyx_t_6[0]);
/* "View.MemoryView":1038
* result.view.suboffsets = NULL
* for suboffset in result.from_slice.suboffsets[:ndim]:
* if suboffset >= 0: # <<<<<<<<<<<<<<
* result.view.suboffsets = <Py_ssize_t *> result.from_slice.suboffsets
* break
*/
__pyx_t_1 = ((__pyx_v_suboffset >= 0) != 0);
if (__pyx_t_1) {
/* "View.MemoryView":1039
* for suboffset in result.from_slice.suboffsets[:ndim]:
* if suboffset >= 0:
* result.view.suboffsets = <Py_ssize_t *> result.from_slice.suboffsets # <<<<<<<<<<<<<<
* break
*
*/
__pyx_v_result->__pyx_base.view.suboffsets = ((Py_ssize_t *)__pyx_v_result->from_slice.suboffsets);
/* "View.MemoryView":1040
* if suboffset >= 0:
* result.view.suboffsets = <Py_ssize_t *> result.from_slice.suboffsets
* break # <<<<<<<<<<<<<<
*
* result.view.len = result.view.itemsize
*/
goto __pyx_L6_break;
/* "View.MemoryView":1038
* result.view.suboffsets = NULL
* for suboffset in result.from_slice.suboffsets[:ndim]:
* if suboffset >= 0: # <<<<<<<<<<<<<<
* result.view.suboffsets = <Py_ssize_t *> result.from_slice.suboffsets
* break
*/
}
}
__pyx_L6_break:;
/* "View.MemoryView":1042
* break
*
* result.view.len = result.view.itemsize # <<<<<<<<<<<<<<
* for length in result.view.shape[:ndim]:
* result.view.len *= length
*/
__pyx_t_9 = __pyx_v_result->__pyx_base.view.itemsize;
__pyx_v_result->__pyx_base.view.len = __pyx_t_9;
/* "View.MemoryView":1043
*
* result.view.len = result.view.itemsize
* for length in result.view.shape[:ndim]: # <<<<<<<<<<<<<<
* result.view.len *= length
*
*/
__pyx_t_7 = (__pyx_v_result->__pyx_base.view.shape + __pyx_v_ndim);
for (__pyx_t_8 = __pyx_v_result->__pyx_base.view.shape; __pyx_t_8 < __pyx_t_7; __pyx_t_8++) {
__pyx_t_6 = __pyx_t_8;
__pyx_t_2 = PyInt_FromSsize_t((__pyx_t_6[0])); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1043, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_XDECREF_SET(__pyx_v_length, __pyx_t_2);
__pyx_t_2 = 0;
/* "View.MemoryView":1044
* result.view.len = result.view.itemsize
* for length in result.view.shape[:ndim]:
* result.view.len *= length # <<<<<<<<<<<<<<
*
* result.to_object_func = to_object_func
*/
__pyx_t_2 = PyInt_FromSsize_t(__pyx_v_result->__pyx_base.view.len); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1044, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__pyx_t_3 = PyNumber_InPlaceMultiply(__pyx_t_2, __pyx_v_length); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1044, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__pyx_t_9 = __Pyx_PyIndex_AsSsize_t(__pyx_t_3); if (unlikely((__pyx_t_9 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(1, 1044, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__pyx_v_result->__pyx_base.view.len = __pyx_t_9;
}
/* "View.MemoryView":1046
* result.view.len *= length
*
* result.to_object_func = to_object_func # <<<<<<<<<<<<<<
* result.to_dtype_func = to_dtype_func
*
*/
__pyx_v_result->to_object_func = __pyx_v_to_object_func;
/* "View.MemoryView":1047
*
* result.to_object_func = to_object_func
* result.to_dtype_func = to_dtype_func # <<<<<<<<<<<<<<
*
* return result
*/
__pyx_v_result->to_dtype_func = __pyx_v_to_dtype_func;
/* "View.MemoryView":1049
* result.to_dtype_func = to_dtype_func
*
* return result # <<<<<<<<<<<<<<
*
* @cname('__pyx_memoryview_get_slice_from_memoryview')
*/
__Pyx_XDECREF(__pyx_r);
__Pyx_INCREF(((PyObject *)__pyx_v_result));
__pyx_r = ((PyObject *)__pyx_v_result);
goto __pyx_L0;
/* "View.MemoryView":999
*
* @cname('__pyx_memoryview_fromslice')
* cdef memoryview_fromslice(__Pyx_memviewslice memviewslice, # <<<<<<<<<<<<<<
* int ndim,
* object (*to_object_func)(char *),
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_2);
__Pyx_XDECREF(__pyx_t_3);
__Pyx_AddTraceback("View.MemoryView.memoryview_fromslice", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = 0;
__pyx_L0:;
__Pyx_XDECREF((PyObject *)__pyx_v_result);
__Pyx_XDECREF(__pyx_v_length);
__Pyx_XGIVEREF(__pyx_r);
__Pyx_TraceReturn(__pyx_r, 0);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "View.MemoryView":1052
*
* @cname('__pyx_memoryview_get_slice_from_memoryview')
* cdef __Pyx_memviewslice *get_slice_from_memview(memoryview memview, # <<<<<<<<<<<<<<
* __Pyx_memviewslice *mslice) except NULL:
* cdef _memoryviewslice obj
*/
static __Pyx_memviewslice *__pyx_memoryview_get_slice_from_memoryview(struct __pyx_memoryview_obj *__pyx_v_memview, __Pyx_memviewslice *__pyx_v_mslice) {
struct __pyx_memoryviewslice_obj *__pyx_v_obj = 0;
__Pyx_memviewslice *__pyx_r;
__Pyx_TraceDeclarations
__Pyx_RefNannyDeclarations
int __pyx_t_1;
int __pyx_t_2;
PyObject *__pyx_t_3 = NULL;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("get_slice_from_memview", 0);
__Pyx_TraceCall("get_slice_from_memview", __pyx_f[1], 1052, 0, __PYX_ERR(1, 1052, __pyx_L1_error));
/* "View.MemoryView":1055
* __Pyx_memviewslice *mslice) except NULL:
* cdef _memoryviewslice obj
* if isinstance(memview, _memoryviewslice): # <<<<<<<<<<<<<<
* obj = memview
* return &obj.from_slice
*/
__pyx_t_1 = __Pyx_TypeCheck(((PyObject *)__pyx_v_memview), __pyx_memoryviewslice_type);
__pyx_t_2 = (__pyx_t_1 != 0);
if (__pyx_t_2) {
/* "View.MemoryView":1056
* cdef _memoryviewslice obj
* if isinstance(memview, _memoryviewslice):
* obj = memview # <<<<<<<<<<<<<<
* return &obj.from_slice
* else:
*/
if (!(likely(((((PyObject *)__pyx_v_memview)) == Py_None) || likely(__Pyx_TypeTest(((PyObject *)__pyx_v_memview), __pyx_memoryviewslice_type))))) __PYX_ERR(1, 1056, __pyx_L1_error)
__pyx_t_3 = ((PyObject *)__pyx_v_memview);
__Pyx_INCREF(__pyx_t_3);
__pyx_v_obj = ((struct __pyx_memoryviewslice_obj *)__pyx_t_3);
__pyx_t_3 = 0;
/* "View.MemoryView":1057
* if isinstance(memview, _memoryviewslice):
* obj = memview
* return &obj.from_slice # <<<<<<<<<<<<<<
* else:
* slice_copy(memview, mslice)
*/
__pyx_r = (&__pyx_v_obj->from_slice);
goto __pyx_L0;
/* "View.MemoryView":1055
* __Pyx_memviewslice *mslice) except NULL:
* cdef _memoryviewslice obj
* if isinstance(memview, _memoryviewslice): # <<<<<<<<<<<<<<
* obj = memview
* return &obj.from_slice
*/
}
/* "View.MemoryView":1059
* return &obj.from_slice
* else:
* slice_copy(memview, mslice) # <<<<<<<<<<<<<<
* return mslice
*
*/
/*else*/ {
__pyx_memoryview_slice_copy(__pyx_v_memview, __pyx_v_mslice);
/* "View.MemoryView":1060
* else:
* slice_copy(memview, mslice)
* return mslice # <<<<<<<<<<<<<<
*
* @cname('__pyx_memoryview_slice_copy')
*/
__pyx_r = __pyx_v_mslice;
goto __pyx_L0;
}
/* "View.MemoryView":1052
*
* @cname('__pyx_memoryview_get_slice_from_memoryview')
* cdef __Pyx_memviewslice *get_slice_from_memview(memoryview memview, # <<<<<<<<<<<<<<
* __Pyx_memviewslice *mslice) except NULL:
* cdef _memoryviewslice obj
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_3);
__Pyx_AddTraceback("View.MemoryView.get_slice_from_memview", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = NULL;
__pyx_L0:;
__Pyx_XDECREF((PyObject *)__pyx_v_obj);
__Pyx_TraceReturn(Py_None, 0);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "View.MemoryView":1063
*
* @cname('__pyx_memoryview_slice_copy')
* cdef void slice_copy(memoryview memview, __Pyx_memviewslice *dst): # <<<<<<<<<<<<<<
* cdef int dim
* cdef (Py_ssize_t*) shape, strides, suboffsets
*/
static void __pyx_memoryview_slice_copy(struct __pyx_memoryview_obj *__pyx_v_memview, __Pyx_memviewslice *__pyx_v_dst) {
int __pyx_v_dim;
Py_ssize_t *__pyx_v_shape;
Py_ssize_t *__pyx_v_strides;
Py_ssize_t *__pyx_v_suboffsets;
__Pyx_TraceDeclarations
__Pyx_RefNannyDeclarations
Py_ssize_t *__pyx_t_1;
int __pyx_t_2;
int __pyx_t_3;
int __pyx_t_4;
Py_ssize_t __pyx_t_5;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("slice_copy", 0);
__Pyx_TraceCall("slice_copy", __pyx_f[1], 1063, 0, __PYX_ERR(1, 1063, __pyx_L1_error));
/* "View.MemoryView":1067
* cdef (Py_ssize_t*) shape, strides, suboffsets
*
* shape = memview.view.shape # <<<<<<<<<<<<<<
* strides = memview.view.strides
* suboffsets = memview.view.suboffsets
*/
__pyx_t_1 = __pyx_v_memview->view.shape;
__pyx_v_shape = __pyx_t_1;
/* "View.MemoryView":1068
*
* shape = memview.view.shape
* strides = memview.view.strides # <<<<<<<<<<<<<<
* suboffsets = memview.view.suboffsets
*
*/
__pyx_t_1 = __pyx_v_memview->view.strides;
__pyx_v_strides = __pyx_t_1;
/* "View.MemoryView":1069
* shape = memview.view.shape
* strides = memview.view.strides
* suboffsets = memview.view.suboffsets # <<<<<<<<<<<<<<
*
* dst.memview = <__pyx_memoryview *> memview
*/
__pyx_t_1 = __pyx_v_memview->view.suboffsets;
__pyx_v_suboffsets = __pyx_t_1;
/* "View.MemoryView":1071
* suboffsets = memview.view.suboffsets
*
* dst.memview = <__pyx_memoryview *> memview # <<<<<<<<<<<<<<
* dst.data = <char *> memview.view.buf
*
*/
__pyx_v_dst->memview = ((struct __pyx_memoryview_obj *)__pyx_v_memview);
/* "View.MemoryView":1072
*
* dst.memview = <__pyx_memoryview *> memview
* dst.data = <char *> memview.view.buf # <<<<<<<<<<<<<<
*
* for dim in range(memview.view.ndim):
*/
__pyx_v_dst->data = ((char *)__pyx_v_memview->view.buf);
/* "View.MemoryView":1074
* dst.data = <char *> memview.view.buf
*
* for dim in range(memview.view.ndim): # <<<<<<<<<<<<<<
* dst.shape[dim] = shape[dim]
* dst.strides[dim] = strides[dim]
*/
__pyx_t_2 = __pyx_v_memview->view.ndim;
__pyx_t_3 = __pyx_t_2;
for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) {
__pyx_v_dim = __pyx_t_4;
/* "View.MemoryView":1075
*
* for dim in range(memview.view.ndim):
* dst.shape[dim] = shape[dim] # <<<<<<<<<<<<<<
* dst.strides[dim] = strides[dim]
* dst.suboffsets[dim] = suboffsets[dim] if suboffsets else -1
*/
(__pyx_v_dst->shape[__pyx_v_dim]) = (__pyx_v_shape[__pyx_v_dim]);
/* "View.MemoryView":1076
* for dim in range(memview.view.ndim):
* dst.shape[dim] = shape[dim]
* dst.strides[dim] = strides[dim] # <<<<<<<<<<<<<<
* dst.suboffsets[dim] = suboffsets[dim] if suboffsets else -1
*
*/
(__pyx_v_dst->strides[__pyx_v_dim]) = (__pyx_v_strides[__pyx_v_dim]);
/* "View.MemoryView":1077
* dst.shape[dim] = shape[dim]
* dst.strides[dim] = strides[dim]
* dst.suboffsets[dim] = suboffsets[dim] if suboffsets else -1 # <<<<<<<<<<<<<<
*
* @cname('__pyx_memoryview_copy_object')
*/
if ((__pyx_v_suboffsets != 0)) {
__pyx_t_5 = (__pyx_v_suboffsets[__pyx_v_dim]);
} else {
__pyx_t_5 = -1L;
}
(__pyx_v_dst->suboffsets[__pyx_v_dim]) = __pyx_t_5;
}
/* "View.MemoryView":1063
*
* @cname('__pyx_memoryview_slice_copy')
* cdef void slice_copy(memoryview memview, __Pyx_memviewslice *dst): # <<<<<<<<<<<<<<
* cdef int dim
* cdef (Py_ssize_t*) shape, strides, suboffsets
*/
/* function exit code */
goto __pyx_L0;
__pyx_L1_error:;
__Pyx_WriteUnraisable("View.MemoryView.slice_copy", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0);
__pyx_L0:;
__Pyx_TraceReturn(Py_None, 0);
__Pyx_RefNannyFinishContext();
}
/* "View.MemoryView":1080
*
* @cname('__pyx_memoryview_copy_object')
* cdef memoryview_copy(memoryview memview): # <<<<<<<<<<<<<<
* "Create a new memoryview object"
* cdef __Pyx_memviewslice memviewslice
*/
static PyObject *__pyx_memoryview_copy_object(struct __pyx_memoryview_obj *__pyx_v_memview) {
__Pyx_memviewslice __pyx_v_memviewslice;
PyObject *__pyx_r = NULL;
__Pyx_TraceDeclarations
__Pyx_RefNannyDeclarations
PyObject *__pyx_t_1 = NULL;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("memoryview_copy", 0);
__Pyx_TraceCall("memoryview_copy", __pyx_f[1], 1080, 0, __PYX_ERR(1, 1080, __pyx_L1_error));
/* "View.MemoryView":1083
* "Create a new memoryview object"
* cdef __Pyx_memviewslice memviewslice
* slice_copy(memview, &memviewslice) # <<<<<<<<<<<<<<
* return memoryview_copy_from_slice(memview, &memviewslice)
*
*/
__pyx_memoryview_slice_copy(__pyx_v_memview, (&__pyx_v_memviewslice));
/* "View.MemoryView":1084
* cdef __Pyx_memviewslice memviewslice
* slice_copy(memview, &memviewslice)
* return memoryview_copy_from_slice(memview, &memviewslice) # <<<<<<<<<<<<<<
*
* @cname('__pyx_memoryview_copy_object_from_slice')
*/
__Pyx_XDECREF(__pyx_r);
__pyx_t_1 = __pyx_memoryview_copy_object_from_slice(__pyx_v_memview, (&__pyx_v_memviewslice)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1084, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_r = __pyx_t_1;
__pyx_t_1 = 0;
goto __pyx_L0;
/* "View.MemoryView":1080
*
* @cname('__pyx_memoryview_copy_object')
* cdef memoryview_copy(memoryview memview): # <<<<<<<<<<<<<<
* "Create a new memoryview object"
* cdef __Pyx_memviewslice memviewslice
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_1);
__Pyx_AddTraceback("View.MemoryView.memoryview_copy", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = 0;
__pyx_L0:;
__Pyx_XGIVEREF(__pyx_r);
__Pyx_TraceReturn(__pyx_r, 0);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "View.MemoryView":1087
*
* @cname('__pyx_memoryview_copy_object_from_slice')
* cdef memoryview_copy_from_slice(memoryview memview, __Pyx_memviewslice *memviewslice): # <<<<<<<<<<<<<<
* """
* Create a new memoryview object from a given memoryview object and slice.
*/
static PyObject *__pyx_memoryview_copy_object_from_slice(struct __pyx_memoryview_obj *__pyx_v_memview, __Pyx_memviewslice *__pyx_v_memviewslice) {
PyObject *(*__pyx_v_to_object_func)(char *);
int (*__pyx_v_to_dtype_func)(char *, PyObject *);
PyObject *__pyx_r = NULL;
__Pyx_TraceDeclarations
__Pyx_RefNannyDeclarations
int __pyx_t_1;
int __pyx_t_2;
PyObject *(*__pyx_t_3)(char *);
int (*__pyx_t_4)(char *, PyObject *);
PyObject *__pyx_t_5 = NULL;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("memoryview_copy_from_slice", 0);
__Pyx_TraceCall("memoryview_copy_from_slice", __pyx_f[1], 1087, 0, __PYX_ERR(1, 1087, __pyx_L1_error));
/* "View.MemoryView":1094
* cdef int (*to_dtype_func)(char *, object) except 0
*
* if isinstance(memview, _memoryviewslice): # <<<<<<<<<<<<<<
* to_object_func = (<_memoryviewslice> memview).to_object_func
* to_dtype_func = (<_memoryviewslice> memview).to_dtype_func
*/
__pyx_t_1 = __Pyx_TypeCheck(((PyObject *)__pyx_v_memview), __pyx_memoryviewslice_type);
__pyx_t_2 = (__pyx_t_1 != 0);
if (__pyx_t_2) {
/* "View.MemoryView":1095
*
* if isinstance(memview, _memoryviewslice):
* to_object_func = (<_memoryviewslice> memview).to_object_func # <<<<<<<<<<<<<<
* to_dtype_func = (<_memoryviewslice> memview).to_dtype_func
* else:
*/
__pyx_t_3 = ((struct __pyx_memoryviewslice_obj *)__pyx_v_memview)->to_object_func;
__pyx_v_to_object_func = __pyx_t_3;
/* "View.MemoryView":1096
* if isinstance(memview, _memoryviewslice):
* to_object_func = (<_memoryviewslice> memview).to_object_func
* to_dtype_func = (<_memoryviewslice> memview).to_dtype_func # <<<<<<<<<<<<<<
* else:
* to_object_func = NULL
*/
__pyx_t_4 = ((struct __pyx_memoryviewslice_obj *)__pyx_v_memview)->to_dtype_func;
__pyx_v_to_dtype_func = __pyx_t_4;
/* "View.MemoryView":1094
* cdef int (*to_dtype_func)(char *, object) except 0
*
* if isinstance(memview, _memoryviewslice): # <<<<<<<<<<<<<<
* to_object_func = (<_memoryviewslice> memview).to_object_func
* to_dtype_func = (<_memoryviewslice> memview).to_dtype_func
*/
goto __pyx_L3;
}
/* "View.MemoryView":1098
* to_dtype_func = (<_memoryviewslice> memview).to_dtype_func
* else:
* to_object_func = NULL # <<<<<<<<<<<<<<
* to_dtype_func = NULL
*
*/
/*else*/ {
__pyx_v_to_object_func = NULL;
/* "View.MemoryView":1099
* else:
* to_object_func = NULL
* to_dtype_func = NULL # <<<<<<<<<<<<<<
*
* return memoryview_fromslice(memviewslice[0], memview.view.ndim,
*/
__pyx_v_to_dtype_func = NULL;
}
__pyx_L3:;
/* "View.MemoryView":1101
* to_dtype_func = NULL
*
* return memoryview_fromslice(memviewslice[0], memview.view.ndim, # <<<<<<<<<<<<<<
* to_object_func, to_dtype_func,
* memview.dtype_is_object)
*/
__Pyx_XDECREF(__pyx_r);
/* "View.MemoryView":1103
* return memoryview_fromslice(memviewslice[0], memview.view.ndim,
* to_object_func, to_dtype_func,
* memview.dtype_is_object) # <<<<<<<<<<<<<<
*
*
*/
__pyx_t_5 = __pyx_memoryview_fromslice((__pyx_v_memviewslice[0]), __pyx_v_memview->view.ndim, __pyx_v_to_object_func, __pyx_v_to_dtype_func, __pyx_v_memview->dtype_is_object); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 1101, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__pyx_r = __pyx_t_5;
__pyx_t_5 = 0;
goto __pyx_L0;
/* "View.MemoryView":1087
*
* @cname('__pyx_memoryview_copy_object_from_slice')
* cdef memoryview_copy_from_slice(memoryview memview, __Pyx_memviewslice *memviewslice): # <<<<<<<<<<<<<<
* """
* Create a new memoryview object from a given memoryview object and slice.
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_5);
__Pyx_AddTraceback("View.MemoryView.memoryview_copy_from_slice", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = 0;
__pyx_L0:;
__Pyx_XGIVEREF(__pyx_r);
__Pyx_TraceReturn(__pyx_r, 0);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "View.MemoryView":1109
*
*
* cdef Py_ssize_t abs_py_ssize_t(Py_ssize_t arg) nogil: # <<<<<<<<<<<<<<
* if arg < 0:
* return -arg
*/
static Py_ssize_t abs_py_ssize_t(Py_ssize_t __pyx_v_arg) {
Py_ssize_t __pyx_r;
__Pyx_TraceDeclarations
int __pyx_t_1;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_TraceCall("abs_py_ssize_t", __pyx_f[1], 1109, 1, __PYX_ERR(1, 1109, __pyx_L1_error));
/* "View.MemoryView":1110
*
* cdef Py_ssize_t abs_py_ssize_t(Py_ssize_t arg) nogil:
* if arg < 0: # <<<<<<<<<<<<<<
* return -arg
* else:
*/
__pyx_t_1 = ((__pyx_v_arg < 0) != 0);
if (__pyx_t_1) {
/* "View.MemoryView":1111
* cdef Py_ssize_t abs_py_ssize_t(Py_ssize_t arg) nogil:
* if arg < 0:
* return -arg # <<<<<<<<<<<<<<
* else:
* return arg
*/
__pyx_r = (-__pyx_v_arg);
goto __pyx_L0;
/* "View.MemoryView":1110
*
* cdef Py_ssize_t abs_py_ssize_t(Py_ssize_t arg) nogil:
* if arg < 0: # <<<<<<<<<<<<<<
* return -arg
* else:
*/
}
/* "View.MemoryView":1113
* return -arg
* else:
* return arg # <<<<<<<<<<<<<<
*
* @cname('__pyx_get_best_slice_order')
*/
/*else*/ {
__pyx_r = __pyx_v_arg;
goto __pyx_L0;
}
/* "View.MemoryView":1109
*
*
* cdef Py_ssize_t abs_py_ssize_t(Py_ssize_t arg) nogil: # <<<<<<<<<<<<<<
* if arg < 0:
* return -arg
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_WriteUnraisable("View.MemoryView.abs_py_ssize_t", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 1);
__pyx_r = 0;
__pyx_L0:;
__Pyx_TraceReturn(Py_None, 1);
return __pyx_r;
}
/* "View.MemoryView":1116
*
* @cname('__pyx_get_best_slice_order')
* cdef char get_best_order(__Pyx_memviewslice *mslice, int ndim) nogil: # <<<<<<<<<<<<<<
* """
* Figure out the best memory access order for a given slice.
*/
static char __pyx_get_best_slice_order(__Pyx_memviewslice *__pyx_v_mslice, int __pyx_v_ndim) {
int __pyx_v_i;
Py_ssize_t __pyx_v_c_stride;
Py_ssize_t __pyx_v_f_stride;
char __pyx_r;
__Pyx_TraceDeclarations
int __pyx_t_1;
int __pyx_t_2;
int __pyx_t_3;
int __pyx_t_4;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_TraceCall("get_best_order", __pyx_f[1], 1116, 1, __PYX_ERR(1, 1116, __pyx_L1_error));
/* "View.MemoryView":1121
* """
* cdef int i
* cdef Py_ssize_t c_stride = 0 # <<<<<<<<<<<<<<
* cdef Py_ssize_t f_stride = 0
*
*/
__pyx_v_c_stride = 0;
/* "View.MemoryView":1122
* cdef int i
* cdef Py_ssize_t c_stride = 0
* cdef Py_ssize_t f_stride = 0 # <<<<<<<<<<<<<<
*
* for i in range(ndim - 1, -1, -1):
*/
__pyx_v_f_stride = 0;
/* "View.MemoryView":1124
* cdef Py_ssize_t f_stride = 0
*
* for i in range(ndim - 1, -1, -1): # <<<<<<<<<<<<<<
* if mslice.shape[i] > 1:
* c_stride = mslice.strides[i]
*/
for (__pyx_t_1 = (__pyx_v_ndim - 1); __pyx_t_1 > -1; __pyx_t_1-=1) {
__pyx_v_i = __pyx_t_1;
/* "View.MemoryView":1125
*
* for i in range(ndim - 1, -1, -1):
* if mslice.shape[i] > 1: # <<<<<<<<<<<<<<
* c_stride = mslice.strides[i]
* break
*/
__pyx_t_2 = (((__pyx_v_mslice->shape[__pyx_v_i]) > 1) != 0);
if (__pyx_t_2) {
/* "View.MemoryView":1126
* for i in range(ndim - 1, -1, -1):
* if mslice.shape[i] > 1:
* c_stride = mslice.strides[i] # <<<<<<<<<<<<<<
* break
*
*/
__pyx_v_c_stride = (__pyx_v_mslice->strides[__pyx_v_i]);
/* "View.MemoryView":1127
* if mslice.shape[i] > 1:
* c_stride = mslice.strides[i]
* break # <<<<<<<<<<<<<<
*
* for i in range(ndim):
*/
goto __pyx_L4_break;
/* "View.MemoryView":1125
*
* for i in range(ndim - 1, -1, -1):
* if mslice.shape[i] > 1: # <<<<<<<<<<<<<<
* c_stride = mslice.strides[i]
* break
*/
}
}
__pyx_L4_break:;
/* "View.MemoryView":1129
* break
*
* for i in range(ndim): # <<<<<<<<<<<<<<
* if mslice.shape[i] > 1:
* f_stride = mslice.strides[i]
*/
__pyx_t_1 = __pyx_v_ndim;
__pyx_t_3 = __pyx_t_1;
for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) {
__pyx_v_i = __pyx_t_4;
/* "View.MemoryView":1130
*
* for i in range(ndim):
* if mslice.shape[i] > 1: # <<<<<<<<<<<<<<
* f_stride = mslice.strides[i]
* break
*/
__pyx_t_2 = (((__pyx_v_mslice->shape[__pyx_v_i]) > 1) != 0);
if (__pyx_t_2) {
/* "View.MemoryView":1131
* for i in range(ndim):
* if mslice.shape[i] > 1:
* f_stride = mslice.strides[i] # <<<<<<<<<<<<<<
* break
*
*/
__pyx_v_f_stride = (__pyx_v_mslice->strides[__pyx_v_i]);
/* "View.MemoryView":1132
* if mslice.shape[i] > 1:
* f_stride = mslice.strides[i]
* break # <<<<<<<<<<<<<<
*
* if abs_py_ssize_t(c_stride) <= abs_py_ssize_t(f_stride):
*/
goto __pyx_L7_break;
/* "View.MemoryView":1130
*
* for i in range(ndim):
* if mslice.shape[i] > 1: # <<<<<<<<<<<<<<
* f_stride = mslice.strides[i]
* break
*/
}
}
__pyx_L7_break:;
/* "View.MemoryView":1134
* break
*
* if abs_py_ssize_t(c_stride) <= abs_py_ssize_t(f_stride): # <<<<<<<<<<<<<<
* return 'C'
* else:
*/
__pyx_t_2 = ((abs_py_ssize_t(__pyx_v_c_stride) <= abs_py_ssize_t(__pyx_v_f_stride)) != 0);
if (__pyx_t_2) {
/* "View.MemoryView":1135
*
* if abs_py_ssize_t(c_stride) <= abs_py_ssize_t(f_stride):
* return 'C' # <<<<<<<<<<<<<<
* else:
* return 'F'
*/
__pyx_r = 'C';
goto __pyx_L0;
/* "View.MemoryView":1134
* break
*
* if abs_py_ssize_t(c_stride) <= abs_py_ssize_t(f_stride): # <<<<<<<<<<<<<<
* return 'C'
* else:
*/
}
/* "View.MemoryView":1137
* return 'C'
* else:
* return 'F' # <<<<<<<<<<<<<<
*
* @cython.cdivision(True)
*/
/*else*/ {
__pyx_r = 'F';
goto __pyx_L0;
}
/* "View.MemoryView":1116
*
* @cname('__pyx_get_best_slice_order')
* cdef char get_best_order(__Pyx_memviewslice *mslice, int ndim) nogil: # <<<<<<<<<<<<<<
* """
* Figure out the best memory access order for a given slice.
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_WriteUnraisable("View.MemoryView.get_best_order", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 1);
__pyx_r = 0;
__pyx_L0:;
__Pyx_TraceReturn(Py_None, 1);
return __pyx_r;
}
/* "View.MemoryView":1140
*
* @cython.cdivision(True)
* cdef void _copy_strided_to_strided(char *src_data, Py_ssize_t *src_strides, # <<<<<<<<<<<<<<
* char *dst_data, Py_ssize_t *dst_strides,
* Py_ssize_t *src_shape, Py_ssize_t *dst_shape,
*/
static void _copy_strided_to_strided(char *__pyx_v_src_data, Py_ssize_t *__pyx_v_src_strides, char *__pyx_v_dst_data, Py_ssize_t *__pyx_v_dst_strides, Py_ssize_t *__pyx_v_src_shape, Py_ssize_t *__pyx_v_dst_shape, int __pyx_v_ndim, size_t __pyx_v_itemsize) {
CYTHON_UNUSED Py_ssize_t __pyx_v_i;
CYTHON_UNUSED Py_ssize_t __pyx_v_src_extent;
Py_ssize_t __pyx_v_dst_extent;
Py_ssize_t __pyx_v_src_stride;
Py_ssize_t __pyx_v_dst_stride;
int __pyx_t_1;
int __pyx_t_2;
int __pyx_t_3;
Py_ssize_t __pyx_t_4;
Py_ssize_t __pyx_t_5;
Py_ssize_t __pyx_t_6;
/* "View.MemoryView":1147
*
* cdef Py_ssize_t i
* cdef Py_ssize_t src_extent = src_shape[0] # <<<<<<<<<<<<<<
* cdef Py_ssize_t dst_extent = dst_shape[0]
* cdef Py_ssize_t src_stride = src_strides[0]
*/
__pyx_v_src_extent = (__pyx_v_src_shape[0]);
/* "View.MemoryView":1148
* cdef Py_ssize_t i
* cdef Py_ssize_t src_extent = src_shape[0]
* cdef Py_ssize_t dst_extent = dst_shape[0] # <<<<<<<<<<<<<<
* cdef Py_ssize_t src_stride = src_strides[0]
* cdef Py_ssize_t dst_stride = dst_strides[0]
*/
__pyx_v_dst_extent = (__pyx_v_dst_shape[0]);
/* "View.MemoryView":1149
* cdef Py_ssize_t src_extent = src_shape[0]
* cdef Py_ssize_t dst_extent = dst_shape[0]
* cdef Py_ssize_t src_stride = src_strides[0] # <<<<<<<<<<<<<<
* cdef Py_ssize_t dst_stride = dst_strides[0]
*
*/
__pyx_v_src_stride = (__pyx_v_src_strides[0]);
/* "View.MemoryView":1150
* cdef Py_ssize_t dst_extent = dst_shape[0]
* cdef Py_ssize_t src_stride = src_strides[0]
* cdef Py_ssize_t dst_stride = dst_strides[0] # <<<<<<<<<<<<<<
*
* if ndim == 1:
*/
__pyx_v_dst_stride = (__pyx_v_dst_strides[0]);
/* "View.MemoryView":1152
* cdef Py_ssize_t dst_stride = dst_strides[0]
*
* if ndim == 1: # <<<<<<<<<<<<<<
* if (src_stride > 0 and dst_stride > 0 and
* <size_t> src_stride == itemsize == <size_t> dst_stride):
*/
__pyx_t_1 = ((__pyx_v_ndim == 1) != 0);
if (__pyx_t_1) {
/* "View.MemoryView":1153
*
* if ndim == 1:
* if (src_stride > 0 and dst_stride > 0 and # <<<<<<<<<<<<<<
* <size_t> src_stride == itemsize == <size_t> dst_stride):
* memcpy(dst_data, src_data, itemsize * dst_extent)
*/
__pyx_t_2 = ((__pyx_v_src_stride > 0) != 0);
if (__pyx_t_2) {
} else {
__pyx_t_1 = __pyx_t_2;
goto __pyx_L5_bool_binop_done;
}
__pyx_t_2 = ((__pyx_v_dst_stride > 0) != 0);
if (__pyx_t_2) {
} else {
__pyx_t_1 = __pyx_t_2;
goto __pyx_L5_bool_binop_done;
}
/* "View.MemoryView":1154
* if ndim == 1:
* if (src_stride > 0 and dst_stride > 0 and
* <size_t> src_stride == itemsize == <size_t> dst_stride): # <<<<<<<<<<<<<<
* memcpy(dst_data, src_data, itemsize * dst_extent)
* else:
*/
__pyx_t_2 = (((size_t)__pyx_v_src_stride) == __pyx_v_itemsize);
if (__pyx_t_2) {
__pyx_t_2 = (__pyx_v_itemsize == ((size_t)__pyx_v_dst_stride));
}
__pyx_t_3 = (__pyx_t_2 != 0);
__pyx_t_1 = __pyx_t_3;
__pyx_L5_bool_binop_done:;
/* "View.MemoryView":1153
*
* if ndim == 1:
* if (src_stride > 0 and dst_stride > 0 and # <<<<<<<<<<<<<<
* <size_t> src_stride == itemsize == <size_t> dst_stride):
* memcpy(dst_data, src_data, itemsize * dst_extent)
*/
if (__pyx_t_1) {
/* "View.MemoryView":1155
* if (src_stride > 0 and dst_stride > 0 and
* <size_t> src_stride == itemsize == <size_t> dst_stride):
* memcpy(dst_data, src_data, itemsize * dst_extent) # <<<<<<<<<<<<<<
* else:
* for i in range(dst_extent):
*/
(void)(memcpy(__pyx_v_dst_data, __pyx_v_src_data, (__pyx_v_itemsize * __pyx_v_dst_extent)));
/* "View.MemoryView":1153
*
* if ndim == 1:
* if (src_stride > 0 and dst_stride > 0 and # <<<<<<<<<<<<<<
* <size_t> src_stride == itemsize == <size_t> dst_stride):
* memcpy(dst_data, src_data, itemsize * dst_extent)
*/
goto __pyx_L4;
}
/* "View.MemoryView":1157
* memcpy(dst_data, src_data, itemsize * dst_extent)
* else:
* for i in range(dst_extent): # <<<<<<<<<<<<<<
* memcpy(dst_data, src_data, itemsize)
* src_data += src_stride
*/
/*else*/ {
__pyx_t_4 = __pyx_v_dst_extent;
__pyx_t_5 = __pyx_t_4;
for (__pyx_t_6 = 0; __pyx_t_6 < __pyx_t_5; __pyx_t_6+=1) {
__pyx_v_i = __pyx_t_6;
/* "View.MemoryView":1158
* else:
* for i in range(dst_extent):
* memcpy(dst_data, src_data, itemsize) # <<<<<<<<<<<<<<
* src_data += src_stride
* dst_data += dst_stride
*/
(void)(memcpy(__pyx_v_dst_data, __pyx_v_src_data, __pyx_v_itemsize));
/* "View.MemoryView":1159
* for i in range(dst_extent):
* memcpy(dst_data, src_data, itemsize)
* src_data += src_stride # <<<<<<<<<<<<<<
* dst_data += dst_stride
* else:
*/
__pyx_v_src_data = (__pyx_v_src_data + __pyx_v_src_stride);
/* "View.MemoryView":1160
* memcpy(dst_data, src_data, itemsize)
* src_data += src_stride
* dst_data += dst_stride # <<<<<<<<<<<<<<
* else:
* for i in range(dst_extent):
*/
__pyx_v_dst_data = (__pyx_v_dst_data + __pyx_v_dst_stride);
}
}
__pyx_L4:;
/* "View.MemoryView":1152
* cdef Py_ssize_t dst_stride = dst_strides[0]
*
* if ndim == 1: # <<<<<<<<<<<<<<
* if (src_stride > 0 and dst_stride > 0 and
* <size_t> src_stride == itemsize == <size_t> dst_stride):
*/
goto __pyx_L3;
}
/* "View.MemoryView":1162
* dst_data += dst_stride
* else:
* for i in range(dst_extent): # <<<<<<<<<<<<<<
* _copy_strided_to_strided(src_data, src_strides + 1,
* dst_data, dst_strides + 1,
*/
/*else*/ {
__pyx_t_4 = __pyx_v_dst_extent;
__pyx_t_5 = __pyx_t_4;
for (__pyx_t_6 = 0; __pyx_t_6 < __pyx_t_5; __pyx_t_6+=1) {
__pyx_v_i = __pyx_t_6;
/* "View.MemoryView":1163
* else:
* for i in range(dst_extent):
* _copy_strided_to_strided(src_data, src_strides + 1, # <<<<<<<<<<<<<<
* dst_data, dst_strides + 1,
* src_shape + 1, dst_shape + 1,
*/
_copy_strided_to_strided(__pyx_v_src_data, (__pyx_v_src_strides + 1), __pyx_v_dst_data, (__pyx_v_dst_strides + 1), (__pyx_v_src_shape + 1), (__pyx_v_dst_shape + 1), (__pyx_v_ndim - 1), __pyx_v_itemsize);
/* "View.MemoryView":1167
* src_shape + 1, dst_shape + 1,
* ndim - 1, itemsize)
* src_data += src_stride # <<<<<<<<<<<<<<
* dst_data += dst_stride
*
*/
__pyx_v_src_data = (__pyx_v_src_data + __pyx_v_src_stride);
/* "View.MemoryView":1168
* ndim - 1, itemsize)
* src_data += src_stride
* dst_data += dst_stride # <<<<<<<<<<<<<<
*
* cdef void copy_strided_to_strided(__Pyx_memviewslice *src,
*/
__pyx_v_dst_data = (__pyx_v_dst_data + __pyx_v_dst_stride);
}
}
__pyx_L3:;
/* "View.MemoryView":1140
*
* @cython.cdivision(True)
* cdef void _copy_strided_to_strided(char *src_data, Py_ssize_t *src_strides, # <<<<<<<<<<<<<<
* char *dst_data, Py_ssize_t *dst_strides,
* Py_ssize_t *src_shape, Py_ssize_t *dst_shape,
*/
/* function exit code */
}
/* "View.MemoryView":1170
* dst_data += dst_stride
*
* cdef void copy_strided_to_strided(__Pyx_memviewslice *src, # <<<<<<<<<<<<<<
* __Pyx_memviewslice *dst,
* int ndim, size_t itemsize) nogil:
*/
static void copy_strided_to_strided(__Pyx_memviewslice *__pyx_v_src, __Pyx_memviewslice *__pyx_v_dst, int __pyx_v_ndim, size_t __pyx_v_itemsize) {
__Pyx_TraceDeclarations
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_TraceCall("copy_strided_to_strided", __pyx_f[1], 1170, 1, __PYX_ERR(1, 1170, __pyx_L1_error));
/* "View.MemoryView":1173
* __Pyx_memviewslice *dst,
* int ndim, size_t itemsize) nogil:
* _copy_strided_to_strided(src.data, src.strides, dst.data, dst.strides, # <<<<<<<<<<<<<<
* src.shape, dst.shape, ndim, itemsize)
*
*/
_copy_strided_to_strided(__pyx_v_src->data, __pyx_v_src->strides, __pyx_v_dst->data, __pyx_v_dst->strides, __pyx_v_src->shape, __pyx_v_dst->shape, __pyx_v_ndim, __pyx_v_itemsize);
/* "View.MemoryView":1170
* dst_data += dst_stride
*
* cdef void copy_strided_to_strided(__Pyx_memviewslice *src, # <<<<<<<<<<<<<<
* __Pyx_memviewslice *dst,
* int ndim, size_t itemsize) nogil:
*/
/* function exit code */
goto __pyx_L0;
__pyx_L1_error:;
__Pyx_WriteUnraisable("View.MemoryView.copy_strided_to_strided", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 1);
__pyx_L0:;
__Pyx_TraceReturn(Py_None, 1);
}
/* "View.MemoryView":1177
*
* @cname('__pyx_memoryview_slice_get_size')
* cdef Py_ssize_t slice_get_size(__Pyx_memviewslice *src, int ndim) nogil: # <<<<<<<<<<<<<<
* "Return the size of the memory occupied by the slice in number of bytes"
* cdef Py_ssize_t shape, size = src.memview.view.itemsize
*/
static Py_ssize_t __pyx_memoryview_slice_get_size(__Pyx_memviewslice *__pyx_v_src, int __pyx_v_ndim) {
Py_ssize_t __pyx_v_shape;
Py_ssize_t __pyx_v_size;
Py_ssize_t __pyx_r;
__Pyx_TraceDeclarations
Py_ssize_t __pyx_t_1;
Py_ssize_t *__pyx_t_2;
Py_ssize_t *__pyx_t_3;
Py_ssize_t *__pyx_t_4;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_TraceCall("slice_get_size", __pyx_f[1], 1177, 1, __PYX_ERR(1, 1177, __pyx_L1_error));
/* "View.MemoryView":1179
* cdef Py_ssize_t slice_get_size(__Pyx_memviewslice *src, int ndim) nogil:
* "Return the size of the memory occupied by the slice in number of bytes"
* cdef Py_ssize_t shape, size = src.memview.view.itemsize # <<<<<<<<<<<<<<
*
* for shape in src.shape[:ndim]:
*/
__pyx_t_1 = __pyx_v_src->memview->view.itemsize;
__pyx_v_size = __pyx_t_1;
/* "View.MemoryView":1181
* cdef Py_ssize_t shape, size = src.memview.view.itemsize
*
* for shape in src.shape[:ndim]: # <<<<<<<<<<<<<<
* size *= shape
*
*/
__pyx_t_3 = (__pyx_v_src->shape + __pyx_v_ndim);
for (__pyx_t_4 = __pyx_v_src->shape; __pyx_t_4 < __pyx_t_3; __pyx_t_4++) {
__pyx_t_2 = __pyx_t_4;
__pyx_v_shape = (__pyx_t_2[0]);
/* "View.MemoryView":1182
*
* for shape in src.shape[:ndim]:
* size *= shape # <<<<<<<<<<<<<<
*
* return size
*/
__pyx_v_size = (__pyx_v_size * __pyx_v_shape);
}
/* "View.MemoryView":1184
* size *= shape
*
* return size # <<<<<<<<<<<<<<
*
* @cname('__pyx_fill_contig_strides_array')
*/
__pyx_r = __pyx_v_size;
goto __pyx_L0;
/* "View.MemoryView":1177
*
* @cname('__pyx_memoryview_slice_get_size')
* cdef Py_ssize_t slice_get_size(__Pyx_memviewslice *src, int ndim) nogil: # <<<<<<<<<<<<<<
* "Return the size of the memory occupied by the slice in number of bytes"
* cdef Py_ssize_t shape, size = src.memview.view.itemsize
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_WriteUnraisable("View.MemoryView.slice_get_size", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 1);
__pyx_r = 0;
__pyx_L0:;
__Pyx_TraceReturn(Py_None, 1);
return __pyx_r;
}
/* "View.MemoryView":1187
*
* @cname('__pyx_fill_contig_strides_array')
* cdef Py_ssize_t fill_contig_strides_array( # <<<<<<<<<<<<<<
* Py_ssize_t *shape, Py_ssize_t *strides, Py_ssize_t stride,
* int ndim, char order) nogil:
*/
static Py_ssize_t __pyx_fill_contig_strides_array(Py_ssize_t *__pyx_v_shape, Py_ssize_t *__pyx_v_strides, Py_ssize_t __pyx_v_stride, int __pyx_v_ndim, char __pyx_v_order) {
int __pyx_v_idx;
Py_ssize_t __pyx_r;
__Pyx_TraceDeclarations
int __pyx_t_1;
int __pyx_t_2;
int __pyx_t_3;
int __pyx_t_4;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_TraceCall("fill_contig_strides_array", __pyx_f[1], 1187, 1, __PYX_ERR(1, 1187, __pyx_L1_error));
/* "View.MemoryView":1196
* cdef int idx
*
* if order == 'F': # <<<<<<<<<<<<<<
* for idx in range(ndim):
* strides[idx] = stride
*/
__pyx_t_1 = ((__pyx_v_order == 'F') != 0);
if (__pyx_t_1) {
/* "View.MemoryView":1197
*
* if order == 'F':
* for idx in range(ndim): # <<<<<<<<<<<<<<
* strides[idx] = stride
* stride *= shape[idx]
*/
__pyx_t_2 = __pyx_v_ndim;
__pyx_t_3 = __pyx_t_2;
for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) {
__pyx_v_idx = __pyx_t_4;
/* "View.MemoryView":1198
* if order == 'F':
* for idx in range(ndim):
* strides[idx] = stride # <<<<<<<<<<<<<<
* stride *= shape[idx]
* else:
*/
(__pyx_v_strides[__pyx_v_idx]) = __pyx_v_stride;
/* "View.MemoryView":1199
* for idx in range(ndim):
* strides[idx] = stride
* stride *= shape[idx] # <<<<<<<<<<<<<<
* else:
* for idx in range(ndim - 1, -1, -1):
*/
__pyx_v_stride = (__pyx_v_stride * (__pyx_v_shape[__pyx_v_idx]));
}
/* "View.MemoryView":1196
* cdef int idx
*
* if order == 'F': # <<<<<<<<<<<<<<
* for idx in range(ndim):
* strides[idx] = stride
*/
goto __pyx_L3;
}
/* "View.MemoryView":1201
* stride *= shape[idx]
* else:
* for idx in range(ndim - 1, -1, -1): # <<<<<<<<<<<<<<
* strides[idx] = stride
* stride *= shape[idx]
*/
/*else*/ {
for (__pyx_t_2 = (__pyx_v_ndim - 1); __pyx_t_2 > -1; __pyx_t_2-=1) {
__pyx_v_idx = __pyx_t_2;
/* "View.MemoryView":1202
* else:
* for idx in range(ndim - 1, -1, -1):
* strides[idx] = stride # <<<<<<<<<<<<<<
* stride *= shape[idx]
*
*/
(__pyx_v_strides[__pyx_v_idx]) = __pyx_v_stride;
/* "View.MemoryView":1203
* for idx in range(ndim - 1, -1, -1):
* strides[idx] = stride
* stride *= shape[idx] # <<<<<<<<<<<<<<
*
* return stride
*/
__pyx_v_stride = (__pyx_v_stride * (__pyx_v_shape[__pyx_v_idx]));
}
}
__pyx_L3:;
/* "View.MemoryView":1205
* stride *= shape[idx]
*
* return stride # <<<<<<<<<<<<<<
*
* @cname('__pyx_memoryview_copy_data_to_temp')
*/
__pyx_r = __pyx_v_stride;
goto __pyx_L0;
/* "View.MemoryView":1187
*
* @cname('__pyx_fill_contig_strides_array')
* cdef Py_ssize_t fill_contig_strides_array( # <<<<<<<<<<<<<<
* Py_ssize_t *shape, Py_ssize_t *strides, Py_ssize_t stride,
* int ndim, char order) nogil:
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_WriteUnraisable("View.MemoryView.fill_contig_strides_array", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 1);
__pyx_r = 0;
__pyx_L0:;
__Pyx_TraceReturn(Py_None, 1);
return __pyx_r;
}
/* "View.MemoryView":1208
*
* @cname('__pyx_memoryview_copy_data_to_temp')
* cdef void *copy_data_to_temp(__Pyx_memviewslice *src, # <<<<<<<<<<<<<<
* __Pyx_memviewslice *tmpslice,
* char order,
*/
static void *__pyx_memoryview_copy_data_to_temp(__Pyx_memviewslice *__pyx_v_src, __Pyx_memviewslice *__pyx_v_tmpslice, char __pyx_v_order, int __pyx_v_ndim) {
int __pyx_v_i;
void *__pyx_v_result;
size_t __pyx_v_itemsize;
size_t __pyx_v_size;
void *__pyx_r;
__Pyx_TraceDeclarations
Py_ssize_t __pyx_t_1;
int __pyx_t_2;
int __pyx_t_3;
struct __pyx_memoryview_obj *__pyx_t_4;
int __pyx_t_5;
int __pyx_t_6;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_TraceCall("copy_data_to_temp", __pyx_f[1], 1208, 1, __PYX_ERR(1, 1208, __pyx_L1_error));
/* "View.MemoryView":1219
* cdef void *result
*
* cdef size_t itemsize = src.memview.view.itemsize # <<<<<<<<<<<<<<
* cdef size_t size = slice_get_size(src, ndim)
*
*/
__pyx_t_1 = __pyx_v_src->memview->view.itemsize;
__pyx_v_itemsize = __pyx_t_1;
/* "View.MemoryView":1220
*
* cdef size_t itemsize = src.memview.view.itemsize
* cdef size_t size = slice_get_size(src, ndim) # <<<<<<<<<<<<<<
*
* result = malloc(size)
*/
__pyx_v_size = __pyx_memoryview_slice_get_size(__pyx_v_src, __pyx_v_ndim);
/* "View.MemoryView":1222
* cdef size_t size = slice_get_size(src, ndim)
*
* result = malloc(size) # <<<<<<<<<<<<<<
* if not result:
* _err(MemoryError, NULL)
*/
__pyx_v_result = malloc(__pyx_v_size);
/* "View.MemoryView":1223
*
* result = malloc(size)
* if not result: # <<<<<<<<<<<<<<
* _err(MemoryError, NULL)
*
*/
__pyx_t_2 = ((!(__pyx_v_result != 0)) != 0);
if (__pyx_t_2) {
/* "View.MemoryView":1224
* result = malloc(size)
* if not result:
* _err(MemoryError, NULL) # <<<<<<<<<<<<<<
*
*
*/
__pyx_t_3 = __pyx_memoryview_err(__pyx_builtin_MemoryError, NULL); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(1, 1224, __pyx_L1_error)
/* "View.MemoryView":1223
*
* result = malloc(size)
* if not result: # <<<<<<<<<<<<<<
* _err(MemoryError, NULL)
*
*/
}
/* "View.MemoryView":1227
*
*
* tmpslice.data = <char *> result # <<<<<<<<<<<<<<
* tmpslice.memview = src.memview
* for i in range(ndim):
*/
__pyx_v_tmpslice->data = ((char *)__pyx_v_result);
/* "View.MemoryView":1228
*
* tmpslice.data = <char *> result
* tmpslice.memview = src.memview # <<<<<<<<<<<<<<
* for i in range(ndim):
* tmpslice.shape[i] = src.shape[i]
*/
__pyx_t_4 = __pyx_v_src->memview;
__pyx_v_tmpslice->memview = __pyx_t_4;
/* "View.MemoryView":1229
* tmpslice.data = <char *> result
* tmpslice.memview = src.memview
* for i in range(ndim): # <<<<<<<<<<<<<<
* tmpslice.shape[i] = src.shape[i]
* tmpslice.suboffsets[i] = -1
*/
__pyx_t_3 = __pyx_v_ndim;
__pyx_t_5 = __pyx_t_3;
for (__pyx_t_6 = 0; __pyx_t_6 < __pyx_t_5; __pyx_t_6+=1) {
__pyx_v_i = __pyx_t_6;
/* "View.MemoryView":1230
* tmpslice.memview = src.memview
* for i in range(ndim):
* tmpslice.shape[i] = src.shape[i] # <<<<<<<<<<<<<<
* tmpslice.suboffsets[i] = -1
*
*/
(__pyx_v_tmpslice->shape[__pyx_v_i]) = (__pyx_v_src->shape[__pyx_v_i]);
/* "View.MemoryView":1231
* for i in range(ndim):
* tmpslice.shape[i] = src.shape[i]
* tmpslice.suboffsets[i] = -1 # <<<<<<<<<<<<<<
*
* fill_contig_strides_array(&tmpslice.shape[0], &tmpslice.strides[0], itemsize,
*/
(__pyx_v_tmpslice->suboffsets[__pyx_v_i]) = -1L;
}
/* "View.MemoryView":1233
* tmpslice.suboffsets[i] = -1
*
* fill_contig_strides_array(&tmpslice.shape[0], &tmpslice.strides[0], itemsize, # <<<<<<<<<<<<<<
* ndim, order)
*
*/
(void)(__pyx_fill_contig_strides_array((&(__pyx_v_tmpslice->shape[0])), (&(__pyx_v_tmpslice->strides[0])), __pyx_v_itemsize, __pyx_v_ndim, __pyx_v_order));
/* "View.MemoryView":1237
*
*
* for i in range(ndim): # <<<<<<<<<<<<<<
* if tmpslice.shape[i] == 1:
* tmpslice.strides[i] = 0
*/
__pyx_t_3 = __pyx_v_ndim;
__pyx_t_5 = __pyx_t_3;
for (__pyx_t_6 = 0; __pyx_t_6 < __pyx_t_5; __pyx_t_6+=1) {
__pyx_v_i = __pyx_t_6;
/* "View.MemoryView":1238
*
* for i in range(ndim):
* if tmpslice.shape[i] == 1: # <<<<<<<<<<<<<<
* tmpslice.strides[i] = 0
*
*/
__pyx_t_2 = (((__pyx_v_tmpslice->shape[__pyx_v_i]) == 1) != 0);
if (__pyx_t_2) {
/* "View.MemoryView":1239
* for i in range(ndim):
* if tmpslice.shape[i] == 1:
* tmpslice.strides[i] = 0 # <<<<<<<<<<<<<<
*
* if slice_is_contig(src[0], order, ndim):
*/
(__pyx_v_tmpslice->strides[__pyx_v_i]) = 0;
/* "View.MemoryView":1238
*
* for i in range(ndim):
* if tmpslice.shape[i] == 1: # <<<<<<<<<<<<<<
* tmpslice.strides[i] = 0
*
*/
}
}
/* "View.MemoryView":1241
* tmpslice.strides[i] = 0
*
* if slice_is_contig(src[0], order, ndim): # <<<<<<<<<<<<<<
* memcpy(result, src.data, size)
* else:
*/
__pyx_t_2 = (__pyx_memviewslice_is_contig((__pyx_v_src[0]), __pyx_v_order, __pyx_v_ndim) != 0);
if (__pyx_t_2) {
/* "View.MemoryView":1242
*
* if slice_is_contig(src[0], order, ndim):
* memcpy(result, src.data, size) # <<<<<<<<<<<<<<
* else:
* copy_strided_to_strided(src, tmpslice, ndim, itemsize)
*/
(void)(memcpy(__pyx_v_result, __pyx_v_src->data, __pyx_v_size));
/* "View.MemoryView":1241
* tmpslice.strides[i] = 0
*
* if slice_is_contig(src[0], order, ndim): # <<<<<<<<<<<<<<
* memcpy(result, src.data, size)
* else:
*/
goto __pyx_L9;
}
/* "View.MemoryView":1244
* memcpy(result, src.data, size)
* else:
* copy_strided_to_strided(src, tmpslice, ndim, itemsize) # <<<<<<<<<<<<<<
*
* return result
*/
/*else*/ {
copy_strided_to_strided(__pyx_v_src, __pyx_v_tmpslice, __pyx_v_ndim, __pyx_v_itemsize);
}
__pyx_L9:;
/* "View.MemoryView":1246
* copy_strided_to_strided(src, tmpslice, ndim, itemsize)
*
* return result # <<<<<<<<<<<<<<
*
*
*/
__pyx_r = __pyx_v_result;
goto __pyx_L0;
/* "View.MemoryView":1208
*
* @cname('__pyx_memoryview_copy_data_to_temp')
* cdef void *copy_data_to_temp(__Pyx_memviewslice *src, # <<<<<<<<<<<<<<
* __Pyx_memviewslice *tmpslice,
* char order,
*/
/* function exit code */
__pyx_L1_error:;
{
#ifdef WITH_THREAD
PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
#endif
__Pyx_AddTraceback("View.MemoryView.copy_data_to_temp", __pyx_clineno, __pyx_lineno, __pyx_filename);
#ifdef WITH_THREAD
__Pyx_PyGILState_Release(__pyx_gilstate_save);
#endif
}
__pyx_r = NULL;
__pyx_L0:;
__Pyx_TraceReturn(Py_None, 1);
return __pyx_r;
}
/* "View.MemoryView":1251
*
* @cname('__pyx_memoryview_err_extents')
* cdef int _err_extents(int i, Py_ssize_t extent1, # <<<<<<<<<<<<<<
* Py_ssize_t extent2) except -1 with gil:
* raise ValueError("got differing extents in dimension %d (got %d and %d)" %
*/
static int __pyx_memoryview_err_extents(int __pyx_v_i, Py_ssize_t __pyx_v_extent1, Py_ssize_t __pyx_v_extent2) {
int __pyx_r;
__Pyx_TraceDeclarations
__Pyx_RefNannyDeclarations
PyObject *__pyx_t_1 = NULL;
PyObject *__pyx_t_2 = NULL;
PyObject *__pyx_t_3 = NULL;
PyObject *__pyx_t_4 = NULL;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
#ifdef WITH_THREAD
PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
#endif
__Pyx_RefNannySetupContext("_err_extents", 0);
__Pyx_TraceCall("_err_extents", __pyx_f[1], 1251, 0, __PYX_ERR(1, 1251, __pyx_L1_error));
/* "View.MemoryView":1254
* Py_ssize_t extent2) except -1 with gil:
* raise ValueError("got differing extents in dimension %d (got %d and %d)" %
* (i, extent1, extent2)) # <<<<<<<<<<<<<<
*
* @cname('__pyx_memoryview_err_dim')
*/
__pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_i); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1254, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_t_2 = PyInt_FromSsize_t(__pyx_v_extent1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1254, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__pyx_t_3 = PyInt_FromSsize_t(__pyx_v_extent2); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1254, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__pyx_t_4 = PyTuple_New(3); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1254, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_GIVEREF(__pyx_t_1);
PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_1);
__Pyx_GIVEREF(__pyx_t_2);
PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_2);
__Pyx_GIVEREF(__pyx_t_3);
PyTuple_SET_ITEM(__pyx_t_4, 2, __pyx_t_3);
__pyx_t_1 = 0;
__pyx_t_2 = 0;
__pyx_t_3 = 0;
/* "View.MemoryView":1253
* cdef int _err_extents(int i, Py_ssize_t extent1,
* Py_ssize_t extent2) except -1 with gil:
* raise ValueError("got differing extents in dimension %d (got %d and %d)" % # <<<<<<<<<<<<<<
* (i, extent1, extent2))
*
*/
__pyx_t_3 = __Pyx_PyString_Format(__pyx_kp_s_got_differing_extents_in_dimensi, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1253, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1253, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__Pyx_Raise(__pyx_t_4, 0, 0, 0);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__PYX_ERR(1, 1253, __pyx_L1_error)
/* "View.MemoryView":1251
*
* @cname('__pyx_memoryview_err_extents')
* cdef int _err_extents(int i, Py_ssize_t extent1, # <<<<<<<<<<<<<<
* Py_ssize_t extent2) except -1 with gil:
* raise ValueError("got differing extents in dimension %d (got %d and %d)" %
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_1);
__Pyx_XDECREF(__pyx_t_2);
__Pyx_XDECREF(__pyx_t_3);
__Pyx_XDECREF(__pyx_t_4);
__Pyx_AddTraceback("View.MemoryView._err_extents", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = -1;
__Pyx_TraceReturn(Py_None, 0);
__Pyx_RefNannyFinishContext();
#ifdef WITH_THREAD
__Pyx_PyGILState_Release(__pyx_gilstate_save);
#endif
return __pyx_r;
}
/* "View.MemoryView":1257
*
* @cname('__pyx_memoryview_err_dim')
* cdef int _err_dim(object error, char *msg, int dim) except -1 with gil: # <<<<<<<<<<<<<<
* raise error(msg.decode('ascii') % dim)
*
*/
static int __pyx_memoryview_err_dim(PyObject *__pyx_v_error, char *__pyx_v_msg, int __pyx_v_dim) {
int __pyx_r;
__Pyx_TraceDeclarations
__Pyx_RefNannyDeclarations
PyObject *__pyx_t_1 = NULL;
PyObject *__pyx_t_2 = NULL;
PyObject *__pyx_t_3 = NULL;
PyObject *__pyx_t_4 = NULL;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
#ifdef WITH_THREAD
PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
#endif
__Pyx_RefNannySetupContext("_err_dim", 0);
__Pyx_TraceCall("_err_dim", __pyx_f[1], 1257, 0, __PYX_ERR(1, 1257, __pyx_L1_error));
__Pyx_INCREF(__pyx_v_error);
/* "View.MemoryView":1258
* @cname('__pyx_memoryview_err_dim')
* cdef int _err_dim(object error, char *msg, int dim) except -1 with gil:
* raise error(msg.decode('ascii') % dim) # <<<<<<<<<<<<<<
*
* @cname('__pyx_memoryview_err')
*/
__pyx_t_2 = __Pyx_decode_c_string(__pyx_v_msg, 0, strlen(__pyx_v_msg), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1258, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_dim); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1258, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__pyx_t_4 = PyUnicode_Format(__pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1258, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__Pyx_INCREF(__pyx_v_error);
__pyx_t_3 = __pyx_v_error; __pyx_t_2 = NULL;
if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
__pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3);
if (likely(__pyx_t_2)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
__Pyx_INCREF(__pyx_t_2);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_3, function);
}
}
__pyx_t_1 = (__pyx_t_2) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_2, __pyx_t_4) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4);
__Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1258, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__Pyx_Raise(__pyx_t_1, 0, 0, 0);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__PYX_ERR(1, 1258, __pyx_L1_error)
/* "View.MemoryView":1257
*
* @cname('__pyx_memoryview_err_dim')
* cdef int _err_dim(object error, char *msg, int dim) except -1 with gil: # <<<<<<<<<<<<<<
* raise error(msg.decode('ascii') % dim)
*
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_1);
__Pyx_XDECREF(__pyx_t_2);
__Pyx_XDECREF(__pyx_t_3);
__Pyx_XDECREF(__pyx_t_4);
__Pyx_AddTraceback("View.MemoryView._err_dim", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = -1;
__Pyx_XDECREF(__pyx_v_error);
__Pyx_TraceReturn(Py_None, 0);
__Pyx_RefNannyFinishContext();
#ifdef WITH_THREAD
__Pyx_PyGILState_Release(__pyx_gilstate_save);
#endif
return __pyx_r;
}
/* "View.MemoryView":1261
*
* @cname('__pyx_memoryview_err')
* cdef int _err(object error, char *msg) except -1 with gil: # <<<<<<<<<<<<<<
* if msg != NULL:
* raise error(msg.decode('ascii'))
*/
static int __pyx_memoryview_err(PyObject *__pyx_v_error, char *__pyx_v_msg) {
int __pyx_r;
__Pyx_TraceDeclarations
__Pyx_RefNannyDeclarations
int __pyx_t_1;
PyObject *__pyx_t_2 = NULL;
PyObject *__pyx_t_3 = NULL;
PyObject *__pyx_t_4 = NULL;
PyObject *__pyx_t_5 = NULL;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
#ifdef WITH_THREAD
PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
#endif
__Pyx_RefNannySetupContext("_err", 0);
__Pyx_TraceCall("_err", __pyx_f[1], 1261, 0, __PYX_ERR(1, 1261, __pyx_L1_error));
__Pyx_INCREF(__pyx_v_error);
/* "View.MemoryView":1262
* @cname('__pyx_memoryview_err')
* cdef int _err(object error, char *msg) except -1 with gil:
* if msg != NULL: # <<<<<<<<<<<<<<
* raise error(msg.decode('ascii'))
* else:
*/
__pyx_t_1 = ((__pyx_v_msg != NULL) != 0);
if (unlikely(__pyx_t_1)) {
/* "View.MemoryView":1263
* cdef int _err(object error, char *msg) except -1 with gil:
* if msg != NULL:
* raise error(msg.decode('ascii')) # <<<<<<<<<<<<<<
* else:
* raise error
*/
__pyx_t_3 = __Pyx_decode_c_string(__pyx_v_msg, 0, strlen(__pyx_v_msg), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1263, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_INCREF(__pyx_v_error);
__pyx_t_4 = __pyx_v_error; __pyx_t_5 = NULL;
if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) {
__pyx_t_5 = PyMethod_GET_SELF(__pyx_t_4);
if (likely(__pyx_t_5)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
__Pyx_INCREF(__pyx_t_5);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_4, function);
}
}
__pyx_t_2 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_4, __pyx_t_5, __pyx_t_3) : __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_3);
__Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1263, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_Raise(__pyx_t_2, 0, 0, 0);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__PYX_ERR(1, 1263, __pyx_L1_error)
/* "View.MemoryView":1262
* @cname('__pyx_memoryview_err')
* cdef int _err(object error, char *msg) except -1 with gil:
* if msg != NULL: # <<<<<<<<<<<<<<
* raise error(msg.decode('ascii'))
* else:
*/
}
/* "View.MemoryView":1265
* raise error(msg.decode('ascii'))
* else:
* raise error # <<<<<<<<<<<<<<
*
* @cname('__pyx_memoryview_copy_contents')
*/
/*else*/ {
__Pyx_Raise(__pyx_v_error, 0, 0, 0);
__PYX_ERR(1, 1265, __pyx_L1_error)
}
/* "View.MemoryView":1261
*
* @cname('__pyx_memoryview_err')
* cdef int _err(object error, char *msg) except -1 with gil: # <<<<<<<<<<<<<<
* if msg != NULL:
* raise error(msg.decode('ascii'))
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_2);
__Pyx_XDECREF(__pyx_t_3);
__Pyx_XDECREF(__pyx_t_4);
__Pyx_XDECREF(__pyx_t_5);
__Pyx_AddTraceback("View.MemoryView._err", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = -1;
__Pyx_XDECREF(__pyx_v_error);
__Pyx_TraceReturn(Py_None, 0);
__Pyx_RefNannyFinishContext();
#ifdef WITH_THREAD
__Pyx_PyGILState_Release(__pyx_gilstate_save);
#endif
return __pyx_r;
}
/* "View.MemoryView":1268
*
* @cname('__pyx_memoryview_copy_contents')
* cdef int memoryview_copy_contents(__Pyx_memviewslice src, # <<<<<<<<<<<<<<
* __Pyx_memviewslice dst,
* int src_ndim, int dst_ndim,
*/
static int __pyx_memoryview_copy_contents(__Pyx_memviewslice __pyx_v_src, __Pyx_memviewslice __pyx_v_dst, int __pyx_v_src_ndim, int __pyx_v_dst_ndim, int __pyx_v_dtype_is_object) {
void *__pyx_v_tmpdata;
size_t __pyx_v_itemsize;
int __pyx_v_i;
char __pyx_v_order;
int __pyx_v_broadcasting;
int __pyx_v_direct_copy;
__Pyx_memviewslice __pyx_v_tmp;
int __pyx_v_ndim;
int __pyx_r;
__Pyx_TraceDeclarations
Py_ssize_t __pyx_t_1;
int __pyx_t_2;
int __pyx_t_3;
int __pyx_t_4;
int __pyx_t_5;
int __pyx_t_6;
void *__pyx_t_7;
int __pyx_t_8;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_TraceCall("memoryview_copy_contents", __pyx_f[1], 1268, 1, __PYX_ERR(1, 1268, __pyx_L1_error));
/* "View.MemoryView":1276
* Check for overlapping memory and verify the shapes.
* """
* cdef void *tmpdata = NULL # <<<<<<<<<<<<<<
* cdef size_t itemsize = src.memview.view.itemsize
* cdef int i
*/
__pyx_v_tmpdata = NULL;
/* "View.MemoryView":1277
* """
* cdef void *tmpdata = NULL
* cdef size_t itemsize = src.memview.view.itemsize # <<<<<<<<<<<<<<
* cdef int i
* cdef char order = get_best_order(&src, src_ndim)
*/
__pyx_t_1 = __pyx_v_src.memview->view.itemsize;
__pyx_v_itemsize = __pyx_t_1;
/* "View.MemoryView":1279
* cdef size_t itemsize = src.memview.view.itemsize
* cdef int i
* cdef char order = get_best_order(&src, src_ndim) # <<<<<<<<<<<<<<
* cdef bint broadcasting = False
* cdef bint direct_copy = False
*/
__pyx_v_order = __pyx_get_best_slice_order((&__pyx_v_src), __pyx_v_src_ndim);
/* "View.MemoryView":1280
* cdef int i
* cdef char order = get_best_order(&src, src_ndim)
* cdef bint broadcasting = False # <<<<<<<<<<<<<<
* cdef bint direct_copy = False
* cdef __Pyx_memviewslice tmp
*/
__pyx_v_broadcasting = 0;
/* "View.MemoryView":1281
* cdef char order = get_best_order(&src, src_ndim)
* cdef bint broadcasting = False
* cdef bint direct_copy = False # <<<<<<<<<<<<<<
* cdef __Pyx_memviewslice tmp
*
*/
__pyx_v_direct_copy = 0;
/* "View.MemoryView":1284
* cdef __Pyx_memviewslice tmp
*
* if src_ndim < dst_ndim: # <<<<<<<<<<<<<<
* broadcast_leading(&src, src_ndim, dst_ndim)
* elif dst_ndim < src_ndim:
*/
__pyx_t_2 = ((__pyx_v_src_ndim < __pyx_v_dst_ndim) != 0);
if (__pyx_t_2) {
/* "View.MemoryView":1285
*
* if src_ndim < dst_ndim:
* broadcast_leading(&src, src_ndim, dst_ndim) # <<<<<<<<<<<<<<
* elif dst_ndim < src_ndim:
* broadcast_leading(&dst, dst_ndim, src_ndim)
*/
__pyx_memoryview_broadcast_leading((&__pyx_v_src), __pyx_v_src_ndim, __pyx_v_dst_ndim);
/* "View.MemoryView":1284
* cdef __Pyx_memviewslice tmp
*
* if src_ndim < dst_ndim: # <<<<<<<<<<<<<<
* broadcast_leading(&src, src_ndim, dst_ndim)
* elif dst_ndim < src_ndim:
*/
goto __pyx_L3;
}
/* "View.MemoryView":1286
* if src_ndim < dst_ndim:
* broadcast_leading(&src, src_ndim, dst_ndim)
* elif dst_ndim < src_ndim: # <<<<<<<<<<<<<<
* broadcast_leading(&dst, dst_ndim, src_ndim)
*
*/
__pyx_t_2 = ((__pyx_v_dst_ndim < __pyx_v_src_ndim) != 0);
if (__pyx_t_2) {
/* "View.MemoryView":1287
* broadcast_leading(&src, src_ndim, dst_ndim)
* elif dst_ndim < src_ndim:
* broadcast_leading(&dst, dst_ndim, src_ndim) # <<<<<<<<<<<<<<
*
* cdef int ndim = max(src_ndim, dst_ndim)
*/
__pyx_memoryview_broadcast_leading((&__pyx_v_dst), __pyx_v_dst_ndim, __pyx_v_src_ndim);
/* "View.MemoryView":1286
* if src_ndim < dst_ndim:
* broadcast_leading(&src, src_ndim, dst_ndim)
* elif dst_ndim < src_ndim: # <<<<<<<<<<<<<<
* broadcast_leading(&dst, dst_ndim, src_ndim)
*
*/
}
__pyx_L3:;
/* "View.MemoryView":1289
* broadcast_leading(&dst, dst_ndim, src_ndim)
*
* cdef int ndim = max(src_ndim, dst_ndim) # <<<<<<<<<<<<<<
*
* for i in range(ndim):
*/
__pyx_t_3 = __pyx_v_dst_ndim;
__pyx_t_4 = __pyx_v_src_ndim;
if (((__pyx_t_3 > __pyx_t_4) != 0)) {
__pyx_t_5 = __pyx_t_3;
} else {
__pyx_t_5 = __pyx_t_4;
}
__pyx_v_ndim = __pyx_t_5;
/* "View.MemoryView":1291
* cdef int ndim = max(src_ndim, dst_ndim)
*
* for i in range(ndim): # <<<<<<<<<<<<<<
* if src.shape[i] != dst.shape[i]:
* if src.shape[i] == 1:
*/
__pyx_t_5 = __pyx_v_ndim;
__pyx_t_3 = __pyx_t_5;
for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) {
__pyx_v_i = __pyx_t_4;
/* "View.MemoryView":1292
*
* for i in range(ndim):
* if src.shape[i] != dst.shape[i]: # <<<<<<<<<<<<<<
* if src.shape[i] == 1:
* broadcasting = True
*/
__pyx_t_2 = (((__pyx_v_src.shape[__pyx_v_i]) != (__pyx_v_dst.shape[__pyx_v_i])) != 0);
if (__pyx_t_2) {
/* "View.MemoryView":1293
* for i in range(ndim):
* if src.shape[i] != dst.shape[i]:
* if src.shape[i] == 1: # <<<<<<<<<<<<<<
* broadcasting = True
* src.strides[i] = 0
*/
__pyx_t_2 = (((__pyx_v_src.shape[__pyx_v_i]) == 1) != 0);
if (__pyx_t_2) {
/* "View.MemoryView":1294
* if src.shape[i] != dst.shape[i]:
* if src.shape[i] == 1:
* broadcasting = True # <<<<<<<<<<<<<<
* src.strides[i] = 0
* else:
*/
__pyx_v_broadcasting = 1;
/* "View.MemoryView":1295
* if src.shape[i] == 1:
* broadcasting = True
* src.strides[i] = 0 # <<<<<<<<<<<<<<
* else:
* _err_extents(i, dst.shape[i], src.shape[i])
*/
(__pyx_v_src.strides[__pyx_v_i]) = 0;
/* "View.MemoryView":1293
* for i in range(ndim):
* if src.shape[i] != dst.shape[i]:
* if src.shape[i] == 1: # <<<<<<<<<<<<<<
* broadcasting = True
* src.strides[i] = 0
*/
goto __pyx_L7;
}
/* "View.MemoryView":1297
* src.strides[i] = 0
* else:
* _err_extents(i, dst.shape[i], src.shape[i]) # <<<<<<<<<<<<<<
*
* if src.suboffsets[i] >= 0:
*/
/*else*/ {
__pyx_t_6 = __pyx_memoryview_err_extents(__pyx_v_i, (__pyx_v_dst.shape[__pyx_v_i]), (__pyx_v_src.shape[__pyx_v_i])); if (unlikely(__pyx_t_6 == ((int)-1))) __PYX_ERR(1, 1297, __pyx_L1_error)
}
__pyx_L7:;
/* "View.MemoryView":1292
*
* for i in range(ndim):
* if src.shape[i] != dst.shape[i]: # <<<<<<<<<<<<<<
* if src.shape[i] == 1:
* broadcasting = True
*/
}
/* "View.MemoryView":1299
* _err_extents(i, dst.shape[i], src.shape[i])
*
* if src.suboffsets[i] >= 0: # <<<<<<<<<<<<<<
* _err_dim(ValueError, "Dimension %d is not direct", i)
*
*/
__pyx_t_2 = (((__pyx_v_src.suboffsets[__pyx_v_i]) >= 0) != 0);
if (__pyx_t_2) {
/* "View.MemoryView":1300
*
* if src.suboffsets[i] >= 0:
* _err_dim(ValueError, "Dimension %d is not direct", i) # <<<<<<<<<<<<<<
*
* if slices_overlap(&src, &dst, ndim, itemsize):
*/
__pyx_t_6 = __pyx_memoryview_err_dim(__pyx_builtin_ValueError, ((char *)"Dimension %d is not direct"), __pyx_v_i); if (unlikely(__pyx_t_6 == ((int)-1))) __PYX_ERR(1, 1300, __pyx_L1_error)
/* "View.MemoryView":1299
* _err_extents(i, dst.shape[i], src.shape[i])
*
* if src.suboffsets[i] >= 0: # <<<<<<<<<<<<<<
* _err_dim(ValueError, "Dimension %d is not direct", i)
*
*/
}
}
/* "View.MemoryView":1302
* _err_dim(ValueError, "Dimension %d is not direct", i)
*
* if slices_overlap(&src, &dst, ndim, itemsize): # <<<<<<<<<<<<<<
*
* if not slice_is_contig(src, order, ndim):
*/
__pyx_t_2 = (__pyx_slices_overlap((&__pyx_v_src), (&__pyx_v_dst), __pyx_v_ndim, __pyx_v_itemsize) != 0);
if (__pyx_t_2) {
/* "View.MemoryView":1304
* if slices_overlap(&src, &dst, ndim, itemsize):
*
* if not slice_is_contig(src, order, ndim): # <<<<<<<<<<<<<<
* order = get_best_order(&dst, ndim)
*
*/
__pyx_t_2 = ((!(__pyx_memviewslice_is_contig(__pyx_v_src, __pyx_v_order, __pyx_v_ndim) != 0)) != 0);
if (__pyx_t_2) {
/* "View.MemoryView":1305
*
* if not slice_is_contig(src, order, ndim):
* order = get_best_order(&dst, ndim) # <<<<<<<<<<<<<<
*
* tmpdata = copy_data_to_temp(&src, &tmp, order, ndim)
*/
__pyx_v_order = __pyx_get_best_slice_order((&__pyx_v_dst), __pyx_v_ndim);
/* "View.MemoryView":1304
* if slices_overlap(&src, &dst, ndim, itemsize):
*
* if not slice_is_contig(src, order, ndim): # <<<<<<<<<<<<<<
* order = get_best_order(&dst, ndim)
*
*/
}
/* "View.MemoryView":1307
* order = get_best_order(&dst, ndim)
*
* tmpdata = copy_data_to_temp(&src, &tmp, order, ndim) # <<<<<<<<<<<<<<
* src = tmp
*
*/
__pyx_t_7 = __pyx_memoryview_copy_data_to_temp((&__pyx_v_src), (&__pyx_v_tmp), __pyx_v_order, __pyx_v_ndim); if (unlikely(__pyx_t_7 == ((void *)NULL))) __PYX_ERR(1, 1307, __pyx_L1_error)
__pyx_v_tmpdata = __pyx_t_7;
/* "View.MemoryView":1308
*
* tmpdata = copy_data_to_temp(&src, &tmp, order, ndim)
* src = tmp # <<<<<<<<<<<<<<
*
* if not broadcasting:
*/
__pyx_v_src = __pyx_v_tmp;
/* "View.MemoryView":1302
* _err_dim(ValueError, "Dimension %d is not direct", i)
*
* if slices_overlap(&src, &dst, ndim, itemsize): # <<<<<<<<<<<<<<
*
* if not slice_is_contig(src, order, ndim):
*/
}
/* "View.MemoryView":1310
* src = tmp
*
* if not broadcasting: # <<<<<<<<<<<<<<
*
*
*/
__pyx_t_2 = ((!(__pyx_v_broadcasting != 0)) != 0);
if (__pyx_t_2) {
/* "View.MemoryView":1313
*
*
* if slice_is_contig(src, 'C', ndim): # <<<<<<<<<<<<<<
* direct_copy = slice_is_contig(dst, 'C', ndim)
* elif slice_is_contig(src, 'F', ndim):
*/
__pyx_t_2 = (__pyx_memviewslice_is_contig(__pyx_v_src, 'C', __pyx_v_ndim) != 0);
if (__pyx_t_2) {
/* "View.MemoryView":1314
*
* if slice_is_contig(src, 'C', ndim):
* direct_copy = slice_is_contig(dst, 'C', ndim) # <<<<<<<<<<<<<<
* elif slice_is_contig(src, 'F', ndim):
* direct_copy = slice_is_contig(dst, 'F', ndim)
*/
__pyx_v_direct_copy = __pyx_memviewslice_is_contig(__pyx_v_dst, 'C', __pyx_v_ndim);
/* "View.MemoryView":1313
*
*
* if slice_is_contig(src, 'C', ndim): # <<<<<<<<<<<<<<
* direct_copy = slice_is_contig(dst, 'C', ndim)
* elif slice_is_contig(src, 'F', ndim):
*/
goto __pyx_L12;
}
/* "View.MemoryView":1315
* if slice_is_contig(src, 'C', ndim):
* direct_copy = slice_is_contig(dst, 'C', ndim)
* elif slice_is_contig(src, 'F', ndim): # <<<<<<<<<<<<<<
* direct_copy = slice_is_contig(dst, 'F', ndim)
*
*/
__pyx_t_2 = (__pyx_memviewslice_is_contig(__pyx_v_src, 'F', __pyx_v_ndim) != 0);
if (__pyx_t_2) {
/* "View.MemoryView":1316
* direct_copy = slice_is_contig(dst, 'C', ndim)
* elif slice_is_contig(src, 'F', ndim):
* direct_copy = slice_is_contig(dst, 'F', ndim) # <<<<<<<<<<<<<<
*
* if direct_copy:
*/
__pyx_v_direct_copy = __pyx_memviewslice_is_contig(__pyx_v_dst, 'F', __pyx_v_ndim);
/* "View.MemoryView":1315
* if slice_is_contig(src, 'C', ndim):
* direct_copy = slice_is_contig(dst, 'C', ndim)
* elif slice_is_contig(src, 'F', ndim): # <<<<<<<<<<<<<<
* direct_copy = slice_is_contig(dst, 'F', ndim)
*
*/
}
__pyx_L12:;
/* "View.MemoryView":1318
* direct_copy = slice_is_contig(dst, 'F', ndim)
*
* if direct_copy: # <<<<<<<<<<<<<<
*
* refcount_copying(&dst, dtype_is_object, ndim, False)
*/
__pyx_t_2 = (__pyx_v_direct_copy != 0);
if (__pyx_t_2) {
/* "View.MemoryView":1320
* if direct_copy:
*
* refcount_copying(&dst, dtype_is_object, ndim, False) # <<<<<<<<<<<<<<
* memcpy(dst.data, src.data, slice_get_size(&src, ndim))
* refcount_copying(&dst, dtype_is_object, ndim, True)
*/
__pyx_memoryview_refcount_copying((&__pyx_v_dst), __pyx_v_dtype_is_object, __pyx_v_ndim, 0);
/* "View.MemoryView":1321
*
* refcount_copying(&dst, dtype_is_object, ndim, False)
* memcpy(dst.data, src.data, slice_get_size(&src, ndim)) # <<<<<<<<<<<<<<
* refcount_copying(&dst, dtype_is_object, ndim, True)
* free(tmpdata)
*/
(void)(memcpy(__pyx_v_dst.data, __pyx_v_src.data, __pyx_memoryview_slice_get_size((&__pyx_v_src), __pyx_v_ndim)));
/* "View.MemoryView":1322
* refcount_copying(&dst, dtype_is_object, ndim, False)
* memcpy(dst.data, src.data, slice_get_size(&src, ndim))
* refcount_copying(&dst, dtype_is_object, ndim, True) # <<<<<<<<<<<<<<
* free(tmpdata)
* return 0
*/
__pyx_memoryview_refcount_copying((&__pyx_v_dst), __pyx_v_dtype_is_object, __pyx_v_ndim, 1);
/* "View.MemoryView":1323
* memcpy(dst.data, src.data, slice_get_size(&src, ndim))
* refcount_copying(&dst, dtype_is_object, ndim, True)
* free(tmpdata) # <<<<<<<<<<<<<<
* return 0
*
*/
free(__pyx_v_tmpdata);
/* "View.MemoryView":1324
* refcount_copying(&dst, dtype_is_object, ndim, True)
* free(tmpdata)
* return 0 # <<<<<<<<<<<<<<
*
* if order == 'F' == get_best_order(&dst, ndim):
*/
__pyx_r = 0;
goto __pyx_L0;
/* "View.MemoryView":1318
* direct_copy = slice_is_contig(dst, 'F', ndim)
*
* if direct_copy: # <<<<<<<<<<<<<<
*
* refcount_copying(&dst, dtype_is_object, ndim, False)
*/
}
/* "View.MemoryView":1310
* src = tmp
*
* if not broadcasting: # <<<<<<<<<<<<<<
*
*
*/
}
/* "View.MemoryView":1326
* return 0
*
* if order == 'F' == get_best_order(&dst, ndim): # <<<<<<<<<<<<<<
*
*
*/
__pyx_t_2 = (__pyx_v_order == 'F');
if (__pyx_t_2) {
__pyx_t_2 = ('F' == __pyx_get_best_slice_order((&__pyx_v_dst), __pyx_v_ndim));
}
__pyx_t_8 = (__pyx_t_2 != 0);
if (__pyx_t_8) {
/* "View.MemoryView":1329
*
*
* transpose_memslice(&src) # <<<<<<<<<<<<<<
* transpose_memslice(&dst)
*
*/
__pyx_t_5 = __pyx_memslice_transpose((&__pyx_v_src)); if (unlikely(__pyx_t_5 == ((int)0))) __PYX_ERR(1, 1329, __pyx_L1_error)
/* "View.MemoryView":1330
*
* transpose_memslice(&src)
* transpose_memslice(&dst) # <<<<<<<<<<<<<<
*
* refcount_copying(&dst, dtype_is_object, ndim, False)
*/
__pyx_t_5 = __pyx_memslice_transpose((&__pyx_v_dst)); if (unlikely(__pyx_t_5 == ((int)0))) __PYX_ERR(1, 1330, __pyx_L1_error)
/* "View.MemoryView":1326
* return 0
*
* if order == 'F' == get_best_order(&dst, ndim): # <<<<<<<<<<<<<<
*
*
*/
}
/* "View.MemoryView":1332
* transpose_memslice(&dst)
*
* refcount_copying(&dst, dtype_is_object, ndim, False) # <<<<<<<<<<<<<<
* copy_strided_to_strided(&src, &dst, ndim, itemsize)
* refcount_copying(&dst, dtype_is_object, ndim, True)
*/
__pyx_memoryview_refcount_copying((&__pyx_v_dst), __pyx_v_dtype_is_object, __pyx_v_ndim, 0);
/* "View.MemoryView":1333
*
* refcount_copying(&dst, dtype_is_object, ndim, False)
* copy_strided_to_strided(&src, &dst, ndim, itemsize) # <<<<<<<<<<<<<<
* refcount_copying(&dst, dtype_is_object, ndim, True)
*
*/
copy_strided_to_strided((&__pyx_v_src), (&__pyx_v_dst), __pyx_v_ndim, __pyx_v_itemsize);
/* "View.MemoryView":1334
* refcount_copying(&dst, dtype_is_object, ndim, False)
* copy_strided_to_strided(&src, &dst, ndim, itemsize)
* refcount_copying(&dst, dtype_is_object, ndim, True) # <<<<<<<<<<<<<<
*
* free(tmpdata)
*/
__pyx_memoryview_refcount_copying((&__pyx_v_dst), __pyx_v_dtype_is_object, __pyx_v_ndim, 1);
/* "View.MemoryView":1336
* refcount_copying(&dst, dtype_is_object, ndim, True)
*
* free(tmpdata) # <<<<<<<<<<<<<<
* return 0
*
*/
free(__pyx_v_tmpdata);
/* "View.MemoryView":1337
*
* free(tmpdata)
* return 0 # <<<<<<<<<<<<<<
*
* @cname('__pyx_memoryview_broadcast_leading')
*/
__pyx_r = 0;
goto __pyx_L0;
/* "View.MemoryView":1268
*
* @cname('__pyx_memoryview_copy_contents')
* cdef int memoryview_copy_contents(__Pyx_memviewslice src, # <<<<<<<<<<<<<<
* __Pyx_memviewslice dst,
* int src_ndim, int dst_ndim,
*/
/* function exit code */
__pyx_L1_error:;
{
#ifdef WITH_THREAD
PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
#endif
__Pyx_AddTraceback("View.MemoryView.memoryview_copy_contents", __pyx_clineno, __pyx_lineno, __pyx_filename);
#ifdef WITH_THREAD
__Pyx_PyGILState_Release(__pyx_gilstate_save);
#endif
}
__pyx_r = -1;
__pyx_L0:;
__Pyx_TraceReturn(Py_None, 1);
return __pyx_r;
}
/* "View.MemoryView":1340
*
* @cname('__pyx_memoryview_broadcast_leading')
* cdef void broadcast_leading(__Pyx_memviewslice *mslice, # <<<<<<<<<<<<<<
* int ndim,
* int ndim_other) nogil:
*/
static void __pyx_memoryview_broadcast_leading(__Pyx_memviewslice *__pyx_v_mslice, int __pyx_v_ndim, int __pyx_v_ndim_other) {
int __pyx_v_i;
int __pyx_v_offset;
__Pyx_TraceDeclarations
int __pyx_t_1;
int __pyx_t_2;
int __pyx_t_3;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_TraceCall("broadcast_leading", __pyx_f[1], 1340, 1, __PYX_ERR(1, 1340, __pyx_L1_error));
/* "View.MemoryView":1344
* int ndim_other) nogil:
* cdef int i
* cdef int offset = ndim_other - ndim # <<<<<<<<<<<<<<
*
* for i in range(ndim - 1, -1, -1):
*/
__pyx_v_offset = (__pyx_v_ndim_other - __pyx_v_ndim);
/* "View.MemoryView":1346
* cdef int offset = ndim_other - ndim
*
* for i in range(ndim - 1, -1, -1): # <<<<<<<<<<<<<<
* mslice.shape[i + offset] = mslice.shape[i]
* mslice.strides[i + offset] = mslice.strides[i]
*/
for (__pyx_t_1 = (__pyx_v_ndim - 1); __pyx_t_1 > -1; __pyx_t_1-=1) {
__pyx_v_i = __pyx_t_1;
/* "View.MemoryView":1347
*
* for i in range(ndim - 1, -1, -1):
* mslice.shape[i + offset] = mslice.shape[i] # <<<<<<<<<<<<<<
* mslice.strides[i + offset] = mslice.strides[i]
* mslice.suboffsets[i + offset] = mslice.suboffsets[i]
*/
(__pyx_v_mslice->shape[(__pyx_v_i + __pyx_v_offset)]) = (__pyx_v_mslice->shape[__pyx_v_i]);
/* "View.MemoryView":1348
* for i in range(ndim - 1, -1, -1):
* mslice.shape[i + offset] = mslice.shape[i]
* mslice.strides[i + offset] = mslice.strides[i] # <<<<<<<<<<<<<<
* mslice.suboffsets[i + offset] = mslice.suboffsets[i]
*
*/
(__pyx_v_mslice->strides[(__pyx_v_i + __pyx_v_offset)]) = (__pyx_v_mslice->strides[__pyx_v_i]);
/* "View.MemoryView":1349
* mslice.shape[i + offset] = mslice.shape[i]
* mslice.strides[i + offset] = mslice.strides[i]
* mslice.suboffsets[i + offset] = mslice.suboffsets[i] # <<<<<<<<<<<<<<
*
* for i in range(offset):
*/
(__pyx_v_mslice->suboffsets[(__pyx_v_i + __pyx_v_offset)]) = (__pyx_v_mslice->suboffsets[__pyx_v_i]);
}
/* "View.MemoryView":1351
* mslice.suboffsets[i + offset] = mslice.suboffsets[i]
*
* for i in range(offset): # <<<<<<<<<<<<<<
* mslice.shape[i] = 1
* mslice.strides[i] = mslice.strides[0]
*/
__pyx_t_1 = __pyx_v_offset;
__pyx_t_2 = __pyx_t_1;
for (__pyx_t_3 = 0; __pyx_t_3 < __pyx_t_2; __pyx_t_3+=1) {
__pyx_v_i = __pyx_t_3;
/* "View.MemoryView":1352
*
* for i in range(offset):
* mslice.shape[i] = 1 # <<<<<<<<<<<<<<
* mslice.strides[i] = mslice.strides[0]
* mslice.suboffsets[i] = -1
*/
(__pyx_v_mslice->shape[__pyx_v_i]) = 1;
/* "View.MemoryView":1353
* for i in range(offset):
* mslice.shape[i] = 1
* mslice.strides[i] = mslice.strides[0] # <<<<<<<<<<<<<<
* mslice.suboffsets[i] = -1
*
*/
(__pyx_v_mslice->strides[__pyx_v_i]) = (__pyx_v_mslice->strides[0]);
/* "View.MemoryView":1354
* mslice.shape[i] = 1
* mslice.strides[i] = mslice.strides[0]
* mslice.suboffsets[i] = -1 # <<<<<<<<<<<<<<
*
*
*/
(__pyx_v_mslice->suboffsets[__pyx_v_i]) = -1L;
}
/* "View.MemoryView":1340
*
* @cname('__pyx_memoryview_broadcast_leading')
* cdef void broadcast_leading(__Pyx_memviewslice *mslice, # <<<<<<<<<<<<<<
* int ndim,
* int ndim_other) nogil:
*/
/* function exit code */
goto __pyx_L0;
__pyx_L1_error:;
__Pyx_WriteUnraisable("View.MemoryView.broadcast_leading", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 1);
__pyx_L0:;
__Pyx_TraceReturn(Py_None, 1);
}
/* "View.MemoryView":1362
*
* @cname('__pyx_memoryview_refcount_copying')
* cdef void refcount_copying(__Pyx_memviewslice *dst, bint dtype_is_object, # <<<<<<<<<<<<<<
* int ndim, bint inc) nogil:
*
*/
static void __pyx_memoryview_refcount_copying(__Pyx_memviewslice *__pyx_v_dst, int __pyx_v_dtype_is_object, int __pyx_v_ndim, int __pyx_v_inc) {
__Pyx_TraceDeclarations
int __pyx_t_1;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_TraceCall("refcount_copying", __pyx_f[1], 1362, 1, __PYX_ERR(1, 1362, __pyx_L1_error));
/* "View.MemoryView":1366
*
*
* if dtype_is_object: # <<<<<<<<<<<<<<
* refcount_objects_in_slice_with_gil(dst.data, dst.shape,
* dst.strides, ndim, inc)
*/
__pyx_t_1 = (__pyx_v_dtype_is_object != 0);
if (__pyx_t_1) {
/* "View.MemoryView":1367
*
* if dtype_is_object:
* refcount_objects_in_slice_with_gil(dst.data, dst.shape, # <<<<<<<<<<<<<<
* dst.strides, ndim, inc)
*
*/
__pyx_memoryview_refcount_objects_in_slice_with_gil(__pyx_v_dst->data, __pyx_v_dst->shape, __pyx_v_dst->strides, __pyx_v_ndim, __pyx_v_inc);
/* "View.MemoryView":1366
*
*
* if dtype_is_object: # <<<<<<<<<<<<<<
* refcount_objects_in_slice_with_gil(dst.data, dst.shape,
* dst.strides, ndim, inc)
*/
}
/* "View.MemoryView":1362
*
* @cname('__pyx_memoryview_refcount_copying')
* cdef void refcount_copying(__Pyx_memviewslice *dst, bint dtype_is_object, # <<<<<<<<<<<<<<
* int ndim, bint inc) nogil:
*
*/
/* function exit code */
goto __pyx_L0;
__pyx_L1_error:;
__Pyx_WriteUnraisable("View.MemoryView.refcount_copying", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 1);
__pyx_L0:;
__Pyx_TraceReturn(Py_None, 1);
}
/* "View.MemoryView":1371
*
* @cname('__pyx_memoryview_refcount_objects_in_slice_with_gil')
* cdef void refcount_objects_in_slice_with_gil(char *data, Py_ssize_t *shape, # <<<<<<<<<<<<<<
* Py_ssize_t *strides, int ndim,
* bint inc) with gil:
*/
static void __pyx_memoryview_refcount_objects_in_slice_with_gil(char *__pyx_v_data, Py_ssize_t *__pyx_v_shape, Py_ssize_t *__pyx_v_strides, int __pyx_v_ndim, int __pyx_v_inc) {
__Pyx_TraceDeclarations
__Pyx_RefNannyDeclarations
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
#ifdef WITH_THREAD
PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
#endif
__Pyx_RefNannySetupContext("refcount_objects_in_slice_with_gil", 0);
__Pyx_TraceCall("refcount_objects_in_slice_with_gil", __pyx_f[1], 1371, 0, __PYX_ERR(1, 1371, __pyx_L1_error));
/* "View.MemoryView":1374
* Py_ssize_t *strides, int ndim,
* bint inc) with gil:
* refcount_objects_in_slice(data, shape, strides, ndim, inc) # <<<<<<<<<<<<<<
*
* @cname('__pyx_memoryview_refcount_objects_in_slice')
*/
__pyx_memoryview_refcount_objects_in_slice(__pyx_v_data, __pyx_v_shape, __pyx_v_strides, __pyx_v_ndim, __pyx_v_inc);
/* "View.MemoryView":1371
*
* @cname('__pyx_memoryview_refcount_objects_in_slice_with_gil')
* cdef void refcount_objects_in_slice_with_gil(char *data, Py_ssize_t *shape, # <<<<<<<<<<<<<<
* Py_ssize_t *strides, int ndim,
* bint inc) with gil:
*/
/* function exit code */
goto __pyx_L0;
__pyx_L1_error:;
__Pyx_WriteUnraisable("View.MemoryView.refcount_objects_in_slice_with_gil", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0);
__pyx_L0:;
__Pyx_TraceReturn(Py_None, 0);
__Pyx_RefNannyFinishContext();
#ifdef WITH_THREAD
__Pyx_PyGILState_Release(__pyx_gilstate_save);
#endif
}
/* "View.MemoryView":1377
*
* @cname('__pyx_memoryview_refcount_objects_in_slice')
* cdef void refcount_objects_in_slice(char *data, Py_ssize_t *shape, # <<<<<<<<<<<<<<
* Py_ssize_t *strides, int ndim, bint inc):
* cdef Py_ssize_t i
*/
static void __pyx_memoryview_refcount_objects_in_slice(char *__pyx_v_data, Py_ssize_t *__pyx_v_shape, Py_ssize_t *__pyx_v_strides, int __pyx_v_ndim, int __pyx_v_inc) {
CYTHON_UNUSED Py_ssize_t __pyx_v_i;
__Pyx_TraceDeclarations
__Pyx_RefNannyDeclarations
Py_ssize_t __pyx_t_1;
Py_ssize_t __pyx_t_2;
Py_ssize_t __pyx_t_3;
int __pyx_t_4;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("refcount_objects_in_slice", 0);
__Pyx_TraceCall("refcount_objects_in_slice", __pyx_f[1], 1377, 0, __PYX_ERR(1, 1377, __pyx_L1_error));
/* "View.MemoryView":1381
* cdef Py_ssize_t i
*
* for i in range(shape[0]): # <<<<<<<<<<<<<<
* if ndim == 1:
* if inc:
*/
__pyx_t_1 = (__pyx_v_shape[0]);
__pyx_t_2 = __pyx_t_1;
for (__pyx_t_3 = 0; __pyx_t_3 < __pyx_t_2; __pyx_t_3+=1) {
__pyx_v_i = __pyx_t_3;
/* "View.MemoryView":1382
*
* for i in range(shape[0]):
* if ndim == 1: # <<<<<<<<<<<<<<
* if inc:
* Py_INCREF((<PyObject **> data)[0])
*/
__pyx_t_4 = ((__pyx_v_ndim == 1) != 0);
if (__pyx_t_4) {
/* "View.MemoryView":1383
* for i in range(shape[0]):
* if ndim == 1:
* if inc: # <<<<<<<<<<<<<<
* Py_INCREF((<PyObject **> data)[0])
* else:
*/
__pyx_t_4 = (__pyx_v_inc != 0);
if (__pyx_t_4) {
/* "View.MemoryView":1384
* if ndim == 1:
* if inc:
* Py_INCREF((<PyObject **> data)[0]) # <<<<<<<<<<<<<<
* else:
* Py_DECREF((<PyObject **> data)[0])
*/
Py_INCREF((((PyObject **)__pyx_v_data)[0]));
/* "View.MemoryView":1383
* for i in range(shape[0]):
* if ndim == 1:
* if inc: # <<<<<<<<<<<<<<
* Py_INCREF((<PyObject **> data)[0])
* else:
*/
goto __pyx_L6;
}
/* "View.MemoryView":1386
* Py_INCREF((<PyObject **> data)[0])
* else:
* Py_DECREF((<PyObject **> data)[0]) # <<<<<<<<<<<<<<
* else:
* refcount_objects_in_slice(data, shape + 1, strides + 1,
*/
/*else*/ {
Py_DECREF((((PyObject **)__pyx_v_data)[0]));
}
__pyx_L6:;
/* "View.MemoryView":1382
*
* for i in range(shape[0]):
* if ndim == 1: # <<<<<<<<<<<<<<
* if inc:
* Py_INCREF((<PyObject **> data)[0])
*/
goto __pyx_L5;
}
/* "View.MemoryView":1388
* Py_DECREF((<PyObject **> data)[0])
* else:
* refcount_objects_in_slice(data, shape + 1, strides + 1, # <<<<<<<<<<<<<<
* ndim - 1, inc)
*
*/
/*else*/ {
/* "View.MemoryView":1389
* else:
* refcount_objects_in_slice(data, shape + 1, strides + 1,
* ndim - 1, inc) # <<<<<<<<<<<<<<
*
* data += strides[0]
*/
__pyx_memoryview_refcount_objects_in_slice(__pyx_v_data, (__pyx_v_shape + 1), (__pyx_v_strides + 1), (__pyx_v_ndim - 1), __pyx_v_inc);
}
__pyx_L5:;
/* "View.MemoryView":1391
* ndim - 1, inc)
*
* data += strides[0] # <<<<<<<<<<<<<<
*
*
*/
__pyx_v_data = (__pyx_v_data + (__pyx_v_strides[0]));
}
/* "View.MemoryView":1377
*
* @cname('__pyx_memoryview_refcount_objects_in_slice')
* cdef void refcount_objects_in_slice(char *data, Py_ssize_t *shape, # <<<<<<<<<<<<<<
* Py_ssize_t *strides, int ndim, bint inc):
* cdef Py_ssize_t i
*/
/* function exit code */
goto __pyx_L0;
__pyx_L1_error:;
__Pyx_WriteUnraisable("View.MemoryView.refcount_objects_in_slice", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0);
__pyx_L0:;
__Pyx_TraceReturn(Py_None, 0);
__Pyx_RefNannyFinishContext();
}
/* "View.MemoryView":1397
*
* @cname('__pyx_memoryview_slice_assign_scalar')
* cdef void slice_assign_scalar(__Pyx_memviewslice *dst, int ndim, # <<<<<<<<<<<<<<
* size_t itemsize, void *item,
* bint dtype_is_object) nogil:
*/
static void __pyx_memoryview_slice_assign_scalar(__Pyx_memviewslice *__pyx_v_dst, int __pyx_v_ndim, size_t __pyx_v_itemsize, void *__pyx_v_item, int __pyx_v_dtype_is_object) {
__Pyx_TraceDeclarations
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_TraceCall("slice_assign_scalar", __pyx_f[1], 1397, 1, __PYX_ERR(1, 1397, __pyx_L1_error));
/* "View.MemoryView":1400
* size_t itemsize, void *item,
* bint dtype_is_object) nogil:
* refcount_copying(dst, dtype_is_object, ndim, False) # <<<<<<<<<<<<<<
* _slice_assign_scalar(dst.data, dst.shape, dst.strides, ndim,
* itemsize, item)
*/
__pyx_memoryview_refcount_copying(__pyx_v_dst, __pyx_v_dtype_is_object, __pyx_v_ndim, 0);
/* "View.MemoryView":1401
* bint dtype_is_object) nogil:
* refcount_copying(dst, dtype_is_object, ndim, False)
* _slice_assign_scalar(dst.data, dst.shape, dst.strides, ndim, # <<<<<<<<<<<<<<
* itemsize, item)
* refcount_copying(dst, dtype_is_object, ndim, True)
*/
__pyx_memoryview__slice_assign_scalar(__pyx_v_dst->data, __pyx_v_dst->shape, __pyx_v_dst->strides, __pyx_v_ndim, __pyx_v_itemsize, __pyx_v_item);
/* "View.MemoryView":1403
* _slice_assign_scalar(dst.data, dst.shape, dst.strides, ndim,
* itemsize, item)
* refcount_copying(dst, dtype_is_object, ndim, True) # <<<<<<<<<<<<<<
*
*
*/
__pyx_memoryview_refcount_copying(__pyx_v_dst, __pyx_v_dtype_is_object, __pyx_v_ndim, 1);
/* "View.MemoryView":1397
*
* @cname('__pyx_memoryview_slice_assign_scalar')
* cdef void slice_assign_scalar(__Pyx_memviewslice *dst, int ndim, # <<<<<<<<<<<<<<
* size_t itemsize, void *item,
* bint dtype_is_object) nogil:
*/
/* function exit code */
goto __pyx_L0;
__pyx_L1_error:;
__Pyx_WriteUnraisable("View.MemoryView.slice_assign_scalar", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 1);
__pyx_L0:;
__Pyx_TraceReturn(Py_None, 1);
}
/* "View.MemoryView":1407
*
* @cname('__pyx_memoryview__slice_assign_scalar')
* cdef void _slice_assign_scalar(char *data, Py_ssize_t *shape, # <<<<<<<<<<<<<<
* Py_ssize_t *strides, int ndim,
* size_t itemsize, void *item) nogil:
*/
static void __pyx_memoryview__slice_assign_scalar(char *__pyx_v_data, Py_ssize_t *__pyx_v_shape, Py_ssize_t *__pyx_v_strides, int __pyx_v_ndim, size_t __pyx_v_itemsize, void *__pyx_v_item) {
CYTHON_UNUSED Py_ssize_t __pyx_v_i;
Py_ssize_t __pyx_v_stride;
Py_ssize_t __pyx_v_extent;
__Pyx_TraceDeclarations
int __pyx_t_1;
Py_ssize_t __pyx_t_2;
Py_ssize_t __pyx_t_3;
Py_ssize_t __pyx_t_4;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_TraceCall("_slice_assign_scalar", __pyx_f[1], 1407, 1, __PYX_ERR(1, 1407, __pyx_L1_error));
/* "View.MemoryView":1411
* size_t itemsize, void *item) nogil:
* cdef Py_ssize_t i
* cdef Py_ssize_t stride = strides[0] # <<<<<<<<<<<<<<
* cdef Py_ssize_t extent = shape[0]
*
*/
__pyx_v_stride = (__pyx_v_strides[0]);
/* "View.MemoryView":1412
* cdef Py_ssize_t i
* cdef Py_ssize_t stride = strides[0]
* cdef Py_ssize_t extent = shape[0] # <<<<<<<<<<<<<<
*
* if ndim == 1:
*/
__pyx_v_extent = (__pyx_v_shape[0]);
/* "View.MemoryView":1414
* cdef Py_ssize_t extent = shape[0]
*
* if ndim == 1: # <<<<<<<<<<<<<<
* for i in range(extent):
* memcpy(data, item, itemsize)
*/
__pyx_t_1 = ((__pyx_v_ndim == 1) != 0);
if (__pyx_t_1) {
/* "View.MemoryView":1415
*
* if ndim == 1:
* for i in range(extent): # <<<<<<<<<<<<<<
* memcpy(data, item, itemsize)
* data += stride
*/
__pyx_t_2 = __pyx_v_extent;
__pyx_t_3 = __pyx_t_2;
for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) {
__pyx_v_i = __pyx_t_4;
/* "View.MemoryView":1416
* if ndim == 1:
* for i in range(extent):
* memcpy(data, item, itemsize) # <<<<<<<<<<<<<<
* data += stride
* else:
*/
(void)(memcpy(__pyx_v_data, __pyx_v_item, __pyx_v_itemsize));
/* "View.MemoryView":1417
* for i in range(extent):
* memcpy(data, item, itemsize)
* data += stride # <<<<<<<<<<<<<<
* else:
* for i in range(extent):
*/
__pyx_v_data = (__pyx_v_data + __pyx_v_stride);
}
/* "View.MemoryView":1414
* cdef Py_ssize_t extent = shape[0]
*
* if ndim == 1: # <<<<<<<<<<<<<<
* for i in range(extent):
* memcpy(data, item, itemsize)
*/
goto __pyx_L3;
}
/* "View.MemoryView":1419
* data += stride
* else:
* for i in range(extent): # <<<<<<<<<<<<<<
* _slice_assign_scalar(data, shape + 1, strides + 1,
* ndim - 1, itemsize, item)
*/
/*else*/ {
__pyx_t_2 = __pyx_v_extent;
__pyx_t_3 = __pyx_t_2;
for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) {
__pyx_v_i = __pyx_t_4;
/* "View.MemoryView":1420
* else:
* for i in range(extent):
* _slice_assign_scalar(data, shape + 1, strides + 1, # <<<<<<<<<<<<<<
* ndim - 1, itemsize, item)
* data += stride
*/
__pyx_memoryview__slice_assign_scalar(__pyx_v_data, (__pyx_v_shape + 1), (__pyx_v_strides + 1), (__pyx_v_ndim - 1), __pyx_v_itemsize, __pyx_v_item);
/* "View.MemoryView":1422
* _slice_assign_scalar(data, shape + 1, strides + 1,
* ndim - 1, itemsize, item)
* data += stride # <<<<<<<<<<<<<<
*
*
*/
__pyx_v_data = (__pyx_v_data + __pyx_v_stride);
}
}
__pyx_L3:;
/* "View.MemoryView":1407
*
* @cname('__pyx_memoryview__slice_assign_scalar')
* cdef void _slice_assign_scalar(char *data, Py_ssize_t *shape, # <<<<<<<<<<<<<<
* Py_ssize_t *strides, int ndim,
* size_t itemsize, void *item) nogil:
*/
/* function exit code */
goto __pyx_L0;
__pyx_L1_error:;
__Pyx_WriteUnraisable("View.MemoryView._slice_assign_scalar", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 1);
__pyx_L0:;
__Pyx_TraceReturn(Py_None, 1);
}
/* "(tree fragment)":1
* def __pyx_unpickle_Enum(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<<
* cdef object __pyx_PickleError
* cdef object __pyx_result
*/
/* Python wrapper */
static PyObject *__pyx_pw_15View_dot_MemoryView_1__pyx_unpickle_Enum(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static PyMethodDef __pyx_mdef_15View_dot_MemoryView_1__pyx_unpickle_Enum = {"__pyx_unpickle_Enum", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_15View_dot_MemoryView_1__pyx_unpickle_Enum, METH_VARARGS|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_15View_dot_MemoryView_1__pyx_unpickle_Enum(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
PyObject *__pyx_v___pyx_type = 0;
long __pyx_v___pyx_checksum;
PyObject *__pyx_v___pyx_state = 0;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
PyObject *__pyx_r = 0;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("__pyx_unpickle_Enum (wrapper)", 0);
{
static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_type,&__pyx_n_s_pyx_checksum,&__pyx_n_s_pyx_state,0};
PyObject* values[3] = {0,0,0};
if (unlikely(__pyx_kwds)) {
Py_ssize_t kw_args;
const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
switch (pos_args) {
case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
CYTHON_FALLTHROUGH;
case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
CYTHON_FALLTHROUGH;
case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
CYTHON_FALLTHROUGH;
case 0: break;
default: goto __pyx_L5_argtuple_error;
}
kw_args = PyDict_Size(__pyx_kwds);
switch (pos_args) {
case 0:
if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_pyx_type)) != 0)) kw_args--;
else goto __pyx_L5_argtuple_error;
CYTHON_FALLTHROUGH;
case 1:
if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_pyx_checksum)) != 0)) kw_args--;
else {
__Pyx_RaiseArgtupleInvalid("__pyx_unpickle_Enum", 1, 3, 3, 1); __PYX_ERR(1, 1, __pyx_L3_error)
}
CYTHON_FALLTHROUGH;
case 2:
if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_pyx_state)) != 0)) kw_args--;
else {
__Pyx_RaiseArgtupleInvalid("__pyx_unpickle_Enum", 1, 3, 3, 2); __PYX_ERR(1, 1, __pyx_L3_error)
}
}
if (unlikely(kw_args > 0)) {
if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__pyx_unpickle_Enum") < 0)) __PYX_ERR(1, 1, __pyx_L3_error)
}
} else if (PyTuple_GET_SIZE(__pyx_args) != 3) {
goto __pyx_L5_argtuple_error;
} else {
values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
}
__pyx_v___pyx_type = values[0];
__pyx_v___pyx_checksum = __Pyx_PyInt_As_long(values[1]); if (unlikely((__pyx_v___pyx_checksum == (long)-1) && PyErr_Occurred())) __PYX_ERR(1, 1, __pyx_L3_error)
__pyx_v___pyx_state = values[2];
}
goto __pyx_L4_argument_unpacking_done;
__pyx_L5_argtuple_error:;
__Pyx_RaiseArgtupleInvalid("__pyx_unpickle_Enum", 1, 3, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 1, __pyx_L3_error)
__pyx_L3_error:;
__Pyx_AddTraceback("View.MemoryView.__pyx_unpickle_Enum", __pyx_clineno, __pyx_lineno, __pyx_filename);
__Pyx_RefNannyFinishContext();
return NULL;
__pyx_L4_argument_unpacking_done:;
__pyx_r = __pyx_pf_15View_dot_MemoryView___pyx_unpickle_Enum(__pyx_self, __pyx_v___pyx_type, __pyx_v___pyx_checksum, __pyx_v___pyx_state);
/* function exit code */
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
static PyObject *__pyx_pf_15View_dot_MemoryView___pyx_unpickle_Enum(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v___pyx_type, long __pyx_v___pyx_checksum, PyObject *__pyx_v___pyx_state) {
PyObject *__pyx_v___pyx_PickleError = 0;
PyObject *__pyx_v___pyx_result = 0;
PyObject *__pyx_r = NULL;
__Pyx_TraceDeclarations
__Pyx_RefNannyDeclarations
int __pyx_t_1;
PyObject *__pyx_t_2 = NULL;
PyObject *__pyx_t_3 = NULL;
PyObject *__pyx_t_4 = NULL;
PyObject *__pyx_t_5 = NULL;
int __pyx_t_6;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_TraceFrameInit(__pyx_codeobj__37)
__Pyx_RefNannySetupContext("__pyx_unpickle_Enum", 0);
__Pyx_TraceCall("__pyx_unpickle_Enum", __pyx_f[1], 1, 0, __PYX_ERR(1, 1, __pyx_L1_error));
/* "(tree fragment)":4
* cdef object __pyx_PickleError
* cdef object __pyx_result
* if __pyx_checksum != 0xb068931: # <<<<<<<<<<<<<<
* from pickle import PickleError as __pyx_PickleError
* raise __pyx_PickleError("Incompatible checksums (%s vs 0xb068931 = (name))" % __pyx_checksum)
*/
__pyx_t_1 = ((__pyx_v___pyx_checksum != 0xb068931) != 0);
if (__pyx_t_1) {
/* "(tree fragment)":5
* cdef object __pyx_result
* if __pyx_checksum != 0xb068931:
* from pickle import PickleError as __pyx_PickleError # <<<<<<<<<<<<<<
* raise __pyx_PickleError("Incompatible checksums (%s vs 0xb068931 = (name))" % __pyx_checksum)
* __pyx_result = Enum.__new__(__pyx_type)
*/
__pyx_t_2 = PyList_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 5, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_INCREF(__pyx_n_s_PickleError);
__Pyx_GIVEREF(__pyx_n_s_PickleError);
PyList_SET_ITEM(__pyx_t_2, 0, __pyx_n_s_PickleError);
__pyx_t_3 = __Pyx_Import(__pyx_n_s_pickle, __pyx_t_2, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 5, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__pyx_t_2 = __Pyx_ImportFrom(__pyx_t_3, __pyx_n_s_PickleError); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 5, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_INCREF(__pyx_t_2);
__pyx_v___pyx_PickleError = __pyx_t_2;
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
/* "(tree fragment)":6
* if __pyx_checksum != 0xb068931:
* from pickle import PickleError as __pyx_PickleError
* raise __pyx_PickleError("Incompatible checksums (%s vs 0xb068931 = (name))" % __pyx_checksum) # <<<<<<<<<<<<<<
* __pyx_result = Enum.__new__(__pyx_type)
* if __pyx_state is not None:
*/
__pyx_t_2 = __Pyx_PyInt_From_long(__pyx_v___pyx_checksum); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 6, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__pyx_t_4 = __Pyx_PyString_Format(__pyx_kp_s_Incompatible_checksums_s_vs_0xb0, __pyx_t_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 6, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__Pyx_INCREF(__pyx_v___pyx_PickleError);
__pyx_t_2 = __pyx_v___pyx_PickleError; __pyx_t_5 = NULL;
if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) {
__pyx_t_5 = PyMethod_GET_SELF(__pyx_t_2);
if (likely(__pyx_t_5)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
__Pyx_INCREF(__pyx_t_5);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_2, function);
}
}
__pyx_t_3 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_5, __pyx_t_4) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_4);
__Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 6, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__Pyx_Raise(__pyx_t_3, 0, 0, 0);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__PYX_ERR(1, 6, __pyx_L1_error)
/* "(tree fragment)":4
* cdef object __pyx_PickleError
* cdef object __pyx_result
* if __pyx_checksum != 0xb068931: # <<<<<<<<<<<<<<
* from pickle import PickleError as __pyx_PickleError
* raise __pyx_PickleError("Incompatible checksums (%s vs 0xb068931 = (name))" % __pyx_checksum)
*/
}
/* "(tree fragment)":7
* from pickle import PickleError as __pyx_PickleError
* raise __pyx_PickleError("Incompatible checksums (%s vs 0xb068931 = (name))" % __pyx_checksum)
* __pyx_result = Enum.__new__(__pyx_type) # <<<<<<<<<<<<<<
* if __pyx_state is not None:
* __pyx_unpickle_Enum__set_state(<Enum> __pyx_result, __pyx_state)
*/
__pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_MemviewEnum_type), __pyx_n_s_new); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 7, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__pyx_t_4 = NULL;
if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
__pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2);
if (likely(__pyx_t_4)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
__Pyx_INCREF(__pyx_t_4);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_2, function);
}
}
__pyx_t_3 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_4, __pyx_v___pyx_type) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_v___pyx_type);
__Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 7, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__pyx_v___pyx_result = __pyx_t_3;
__pyx_t_3 = 0;
/* "(tree fragment)":8
* raise __pyx_PickleError("Incompatible checksums (%s vs 0xb068931 = (name))" % __pyx_checksum)
* __pyx_result = Enum.__new__(__pyx_type)
* if __pyx_state is not None: # <<<<<<<<<<<<<<
* __pyx_unpickle_Enum__set_state(<Enum> __pyx_result, __pyx_state)
* return __pyx_result
*/
__pyx_t_1 = (__pyx_v___pyx_state != Py_None);
__pyx_t_6 = (__pyx_t_1 != 0);
if (__pyx_t_6) {
/* "(tree fragment)":9
* __pyx_result = Enum.__new__(__pyx_type)
* if __pyx_state is not None:
* __pyx_unpickle_Enum__set_state(<Enum> __pyx_result, __pyx_state) # <<<<<<<<<<<<<<
* return __pyx_result
* cdef __pyx_unpickle_Enum__set_state(Enum __pyx_result, tuple __pyx_state):
*/
if (!(likely(PyTuple_CheckExact(__pyx_v___pyx_state))||((__pyx_v___pyx_state) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "tuple", Py_TYPE(__pyx_v___pyx_state)->tp_name), 0))) __PYX_ERR(1, 9, __pyx_L1_error)
__pyx_t_3 = __pyx_unpickle_Enum__set_state(((struct __pyx_MemviewEnum_obj *)__pyx_v___pyx_result), ((PyObject*)__pyx_v___pyx_state)); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 9, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
/* "(tree fragment)":8
* raise __pyx_PickleError("Incompatible checksums (%s vs 0xb068931 = (name))" % __pyx_checksum)
* __pyx_result = Enum.__new__(__pyx_type)
* if __pyx_state is not None: # <<<<<<<<<<<<<<
* __pyx_unpickle_Enum__set_state(<Enum> __pyx_result, __pyx_state)
* return __pyx_result
*/
}
/* "(tree fragment)":10
* if __pyx_state is not None:
* __pyx_unpickle_Enum__set_state(<Enum> __pyx_result, __pyx_state)
* return __pyx_result # <<<<<<<<<<<<<<
* cdef __pyx_unpickle_Enum__set_state(Enum __pyx_result, tuple __pyx_state):
* __pyx_result.name = __pyx_state[0]
*/
__Pyx_XDECREF(__pyx_r);
__Pyx_INCREF(__pyx_v___pyx_result);
__pyx_r = __pyx_v___pyx_result;
goto __pyx_L0;
/* "(tree fragment)":1
* def __pyx_unpickle_Enum(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<<
* cdef object __pyx_PickleError
* cdef object __pyx_result
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_2);
__Pyx_XDECREF(__pyx_t_3);
__Pyx_XDECREF(__pyx_t_4);
__Pyx_XDECREF(__pyx_t_5);
__Pyx_AddTraceback("View.MemoryView.__pyx_unpickle_Enum", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = NULL;
__pyx_L0:;
__Pyx_XDECREF(__pyx_v___pyx_PickleError);
__Pyx_XDECREF(__pyx_v___pyx_result);
__Pyx_XGIVEREF(__pyx_r);
__Pyx_TraceReturn(__pyx_r, 0);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "(tree fragment)":11
* __pyx_unpickle_Enum__set_state(<Enum> __pyx_result, __pyx_state)
* return __pyx_result
* cdef __pyx_unpickle_Enum__set_state(Enum __pyx_result, tuple __pyx_state): # <<<<<<<<<<<<<<
* __pyx_result.name = __pyx_state[0]
* if len(__pyx_state) > 1 and hasattr(__pyx_result, '__dict__'):
*/
static PyObject *__pyx_unpickle_Enum__set_state(struct __pyx_MemviewEnum_obj *__pyx_v___pyx_result, PyObject *__pyx_v___pyx_state) {
PyObject *__pyx_r = NULL;
__Pyx_TraceDeclarations
__Pyx_RefNannyDeclarations
PyObject *__pyx_t_1 = NULL;
int __pyx_t_2;
Py_ssize_t __pyx_t_3;
int __pyx_t_4;
int __pyx_t_5;
PyObject *__pyx_t_6 = NULL;
PyObject *__pyx_t_7 = NULL;
PyObject *__pyx_t_8 = NULL;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("__pyx_unpickle_Enum__set_state", 0);
__Pyx_TraceCall("__pyx_unpickle_Enum__set_state", __pyx_f[1], 11, 0, __PYX_ERR(1, 11, __pyx_L1_error));
/* "(tree fragment)":12
* return __pyx_result
* cdef __pyx_unpickle_Enum__set_state(Enum __pyx_result, tuple __pyx_state):
* __pyx_result.name = __pyx_state[0] # <<<<<<<<<<<<<<
* if len(__pyx_state) > 1 and hasattr(__pyx_result, '__dict__'):
* __pyx_result.__dict__.update(__pyx_state[1])
*/
if (unlikely(__pyx_v___pyx_state == Py_None)) {
PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable");
__PYX_ERR(1, 12, __pyx_L1_error)
}
__pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 12, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_GIVEREF(__pyx_t_1);
__Pyx_GOTREF(__pyx_v___pyx_result->name);
__Pyx_DECREF(__pyx_v___pyx_result->name);
__pyx_v___pyx_result->name = __pyx_t_1;
__pyx_t_1 = 0;
/* "(tree fragment)":13
* cdef __pyx_unpickle_Enum__set_state(Enum __pyx_result, tuple __pyx_state):
* __pyx_result.name = __pyx_state[0]
* if len(__pyx_state) > 1 and hasattr(__pyx_result, '__dict__'): # <<<<<<<<<<<<<<
* __pyx_result.__dict__.update(__pyx_state[1])
*/
if (unlikely(__pyx_v___pyx_state == Py_None)) {
PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()");
__PYX_ERR(1, 13, __pyx_L1_error)
}
__pyx_t_3 = PyTuple_GET_SIZE(__pyx_v___pyx_state); if (unlikely(__pyx_t_3 == ((Py_ssize_t)-1))) __PYX_ERR(1, 13, __pyx_L1_error)
__pyx_t_4 = ((__pyx_t_3 > 1) != 0);
if (__pyx_t_4) {
} else {
__pyx_t_2 = __pyx_t_4;
goto __pyx_L4_bool_binop_done;
}
__pyx_t_4 = __Pyx_HasAttr(((PyObject *)__pyx_v___pyx_result), __pyx_n_s_dict); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(1, 13, __pyx_L1_error)
__pyx_t_5 = (__pyx_t_4 != 0);
__pyx_t_2 = __pyx_t_5;
__pyx_L4_bool_binop_done:;
if (__pyx_t_2) {
/* "(tree fragment)":14
* __pyx_result.name = __pyx_state[0]
* if len(__pyx_state) > 1 and hasattr(__pyx_result, '__dict__'):
* __pyx_result.__dict__.update(__pyx_state[1]) # <<<<<<<<<<<<<<
*/
__pyx_t_6 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v___pyx_result), __pyx_n_s_dict); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 14, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_update); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 14, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
if (unlikely(__pyx_v___pyx_state == Py_None)) {
PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable");
__PYX_ERR(1, 14, __pyx_L1_error)
}
__pyx_t_6 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 14, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__pyx_t_8 = NULL;
if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_7))) {
__pyx_t_8 = PyMethod_GET_SELF(__pyx_t_7);
if (likely(__pyx_t_8)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7);
__Pyx_INCREF(__pyx_t_8);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_7, function);
}
}
__pyx_t_1 = (__pyx_t_8) ? __Pyx_PyObject_Call2Args(__pyx_t_7, __pyx_t_8, __pyx_t_6) : __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_6);
__Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 14, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
/* "(tree fragment)":13
* cdef __pyx_unpickle_Enum__set_state(Enum __pyx_result, tuple __pyx_state):
* __pyx_result.name = __pyx_state[0]
* if len(__pyx_state) > 1 and hasattr(__pyx_result, '__dict__'): # <<<<<<<<<<<<<<
* __pyx_result.__dict__.update(__pyx_state[1])
*/
}
/* "(tree fragment)":11
* __pyx_unpickle_Enum__set_state(<Enum> __pyx_result, __pyx_state)
* return __pyx_result
* cdef __pyx_unpickle_Enum__set_state(Enum __pyx_result, tuple __pyx_state): # <<<<<<<<<<<<<<
* __pyx_result.name = __pyx_state[0]
* if len(__pyx_state) > 1 and hasattr(__pyx_result, '__dict__'):
*/
/* function exit code */
__pyx_r = Py_None; __Pyx_INCREF(Py_None);
goto __pyx_L0;
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_1);
__Pyx_XDECREF(__pyx_t_6);
__Pyx_XDECREF(__pyx_t_7);
__Pyx_XDECREF(__pyx_t_8);
__Pyx_AddTraceback("View.MemoryView.__pyx_unpickle_Enum__set_state", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = 0;
__pyx_L0:;
__Pyx_XGIVEREF(__pyx_r);
__Pyx_TraceReturn(__pyx_r, 0);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
static struct __pyx_vtabstruct_5spacy_6syntax_9arc_eager_ArcEager __pyx_vtable_5spacy_6syntax_9arc_eager_ArcEager;
static PyObject *__pyx_tp_new_5spacy_6syntax_9arc_eager_ArcEager(PyTypeObject *t, PyObject *a, PyObject *k) {
struct __pyx_obj_5spacy_6syntax_9arc_eager_ArcEager *p;
PyObject *o = __pyx_ptype_5spacy_6syntax_17transition_system_TransitionSystem->tp_new(t, a, k);
if (unlikely(!o)) return 0;
p = ((struct __pyx_obj_5spacy_6syntax_9arc_eager_ArcEager *)o);
p->__pyx_base.__pyx_vtab = (struct __pyx_vtabstruct_5spacy_6syntax_17transition_system_TransitionSystem*)__pyx_vtabptr_5spacy_6syntax_9arc_eager_ArcEager;
return o;
}
static void __pyx_tp_dealloc_5spacy_6syntax_9arc_eager_ArcEager(PyObject *o) {
#if CYTHON_USE_TP_FINALIZE
if (unlikely(PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE) && Py_TYPE(o)->tp_finalize) && !_PyGC_FINALIZED(o)) {
if (PyObject_CallFinalizerFromDealloc(o)) return;
}
#endif
PyObject_GC_UnTrack(o);
PyObject_GC_Track(o);
if (likely(__pyx_ptype_5spacy_6syntax_17transition_system_TransitionSystem)) __pyx_ptype_5spacy_6syntax_17transition_system_TransitionSystem->tp_dealloc(o); else __Pyx_call_next_tp_dealloc(o, __pyx_tp_dealloc_5spacy_6syntax_9arc_eager_ArcEager);
}
static int __pyx_tp_traverse_5spacy_6syntax_9arc_eager_ArcEager(PyObject *o, visitproc v, void *a) {
int e;
e = ((likely(__pyx_ptype_5spacy_6syntax_17transition_system_TransitionSystem)) ? ((__pyx_ptype_5spacy_6syntax_17transition_system_TransitionSystem->tp_traverse) ? __pyx_ptype_5spacy_6syntax_17transition_system_TransitionSystem->tp_traverse(o, v, a) : 0) : __Pyx_call_next_tp_traverse(o, v, a, __pyx_tp_traverse_5spacy_6syntax_9arc_eager_ArcEager)); if (e) return e;
return 0;
}
static int __pyx_tp_clear_5spacy_6syntax_9arc_eager_ArcEager(PyObject *o) {
if (likely(__pyx_ptype_5spacy_6syntax_17transition_system_TransitionSystem)) { if (__pyx_ptype_5spacy_6syntax_17transition_system_TransitionSystem->tp_clear) __pyx_ptype_5spacy_6syntax_17transition_system_TransitionSystem->tp_clear(o); } else __Pyx_call_next_tp_clear(o, __pyx_tp_clear_5spacy_6syntax_9arc_eager_ArcEager);
return 0;
}
static PyObject *__pyx_getprop_5spacy_6syntax_9arc_eager_8ArcEager_action_types(PyObject *o, CYTHON_UNUSED void *x) {
return __pyx_pw_5spacy_6syntax_9arc_eager_8ArcEager_12action_types_1__get__(o);
}
static PyMethodDef __pyx_methods_5spacy_6syntax_9arc_eager_ArcEager[] = {
{"get_actions", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5spacy_6syntax_9arc_eager_8ArcEager_3get_actions, METH_VARARGS|METH_KEYWORDS, 0},
{"get_cost", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5spacy_6syntax_9arc_eager_8ArcEager_5get_cost, METH_VARARGS|METH_KEYWORDS, 0},
{"transition", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5spacy_6syntax_9arc_eager_8ArcEager_7transition, METH_VARARGS|METH_KEYWORDS, 0},
{"is_gold_parse", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5spacy_6syntax_9arc_eager_8ArcEager_9is_gold_parse, METH_VARARGS|METH_KEYWORDS, 0},
{"has_gold", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5spacy_6syntax_9arc_eager_8ArcEager_11has_gold, METH_VARARGS|METH_KEYWORDS, 0},
{"preprocess_gold", (PyCFunction)__pyx_pw_5spacy_6syntax_9arc_eager_8ArcEager_13preprocess_gold, METH_O, 0},
{"get_beam_parses", (PyCFunction)__pyx_pw_5spacy_6syntax_9arc_eager_8ArcEager_15get_beam_parses, METH_O, 0},
{"move_name", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5spacy_6syntax_9arc_eager_8ArcEager_17move_name, METH_VARARGS|METH_KEYWORDS, 0},
{"class_name", (PyCFunction)__pyx_pw_5spacy_6syntax_9arc_eager_8ArcEager_19class_name, METH_O, 0},
{"finalize_doc", (PyCFunction)__pyx_pw_5spacy_6syntax_9arc_eager_8ArcEager_21finalize_doc, METH_O, 0},
{"get_beam_annot", (PyCFunction)__pyx_pw_5spacy_6syntax_9arc_eager_8ArcEager_23get_beam_annot, METH_O, 0},
{"__reduce_cython__", (PyCFunction)__pyx_pw_5spacy_6syntax_9arc_eager_8ArcEager_25__reduce_cython__, METH_NOARGS, 0},
{"__setstate_cython__", (PyCFunction)__pyx_pw_5spacy_6syntax_9arc_eager_8ArcEager_27__setstate_cython__, METH_O, 0},
{0, 0, 0, 0}
};
static struct PyGetSetDef __pyx_getsets_5spacy_6syntax_9arc_eager_ArcEager[] = {
{(char *)"action_types", __pyx_getprop_5spacy_6syntax_9arc_eager_8ArcEager_action_types, 0, (char *)0, 0},
{0, 0, 0, 0, 0}
};
static PyTypeObject __pyx_type_5spacy_6syntax_9arc_eager_ArcEager = {
PyVarObject_HEAD_INIT(0, 0)
"spacy.syntax.arc_eager.ArcEager", /*tp_name*/
sizeof(struct __pyx_obj_5spacy_6syntax_9arc_eager_ArcEager), /*tp_basicsize*/
0, /*tp_itemsize*/
__pyx_tp_dealloc_5spacy_6syntax_9arc_eager_ArcEager, /*tp_dealloc*/
#if PY_VERSION_HEX < 0x030800b4
0, /*tp_print*/
#endif
#if PY_VERSION_HEX >= 0x030800b4
0, /*tp_vectorcall_offset*/
#endif
0, /*tp_getattr*/
0, /*tp_setattr*/
#if PY_MAJOR_VERSION < 3
0, /*tp_compare*/
#endif
#if PY_MAJOR_VERSION >= 3
0, /*tp_as_async*/
#endif
0, /*tp_repr*/
0, /*tp_as_number*/
0, /*tp_as_sequence*/
0, /*tp_as_mapping*/
0, /*tp_hash*/
0, /*tp_call*/
0, /*tp_str*/
0, /*tp_getattro*/
0, /*tp_setattro*/
0, /*tp_as_buffer*/
Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, /*tp_flags*/
0, /*tp_doc*/
__pyx_tp_traverse_5spacy_6syntax_9arc_eager_ArcEager, /*tp_traverse*/
__pyx_tp_clear_5spacy_6syntax_9arc_eager_ArcEager, /*tp_clear*/
0, /*tp_richcompare*/
0, /*tp_weaklistoffset*/
0, /*tp_iter*/
0, /*tp_iternext*/
__pyx_methods_5spacy_6syntax_9arc_eager_ArcEager, /*tp_methods*/
0, /*tp_members*/
__pyx_getsets_5spacy_6syntax_9arc_eager_ArcEager, /*tp_getset*/
0, /*tp_base*/
0, /*tp_dict*/
0, /*tp_descr_get*/
0, /*tp_descr_set*/
0, /*tp_dictoffset*/
__pyx_pw_5spacy_6syntax_9arc_eager_8ArcEager_1__init__, /*tp_init*/
0, /*tp_alloc*/
__pyx_tp_new_5spacy_6syntax_9arc_eager_ArcEager, /*tp_new*/
0, /*tp_free*/
0, /*tp_is_gc*/
0, /*tp_bases*/
0, /*tp_mro*/
0, /*tp_cache*/
0, /*tp_subclasses*/
0, /*tp_weaklist*/
0, /*tp_del*/
0, /*tp_version_tag*/
#if PY_VERSION_HEX >= 0x030400a1
0, /*tp_finalize*/
#endif
#if PY_VERSION_HEX >= 0x030800b1
0, /*tp_vectorcall*/
#endif
#if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000
0, /*tp_print*/
#endif
};
static struct __pyx_vtabstruct_5spacy_6syntax_9arc_eager_Shift __pyx_vtable_5spacy_6syntax_9arc_eager_Shift;
static PyObject *__pyx_tp_new_5spacy_6syntax_9arc_eager_Shift(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) {
struct __pyx_obj_5spacy_6syntax_9arc_eager_Shift *p;
PyObject *o;
if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) {
o = (*t->tp_alloc)(t, 0);
} else {
o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0);
}
if (unlikely(!o)) return 0;
p = ((struct __pyx_obj_5spacy_6syntax_9arc_eager_Shift *)o);
p->__pyx_vtab = __pyx_vtabptr_5spacy_6syntax_9arc_eager_Shift;
return o;
}
static void __pyx_tp_dealloc_5spacy_6syntax_9arc_eager_Shift(PyObject *o) {
#if CYTHON_USE_TP_FINALIZE
if (unlikely(PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE) && Py_TYPE(o)->tp_finalize) && (!PyType_IS_GC(Py_TYPE(o)) || !_PyGC_FINALIZED(o))) {
if (PyObject_CallFinalizerFromDealloc(o)) return;
}
#endif
(*Py_TYPE(o)->tp_free)(o);
}
static PyMethodDef __pyx_methods_5spacy_6syntax_9arc_eager_Shift[] = {
{"__reduce_cython__", (PyCFunction)__pyx_pw_5spacy_6syntax_9arc_eager_5Shift_1__reduce_cython__, METH_NOARGS, 0},
{"__setstate_cython__", (PyCFunction)__pyx_pw_5spacy_6syntax_9arc_eager_5Shift_3__setstate_cython__, METH_O, 0},
{0, 0, 0, 0}
};
static PyTypeObject __pyx_type_5spacy_6syntax_9arc_eager_Shift = {
PyVarObject_HEAD_INIT(0, 0)
"spacy.syntax.arc_eager.Shift", /*tp_name*/
sizeof(struct __pyx_obj_5spacy_6syntax_9arc_eager_Shift), /*tp_basicsize*/
0, /*tp_itemsize*/
__pyx_tp_dealloc_5spacy_6syntax_9arc_eager_Shift, /*tp_dealloc*/
#if PY_VERSION_HEX < 0x030800b4
0, /*tp_print*/
#endif
#if PY_VERSION_HEX >= 0x030800b4
0, /*tp_vectorcall_offset*/
#endif
0, /*tp_getattr*/
0, /*tp_setattr*/
#if PY_MAJOR_VERSION < 3
0, /*tp_compare*/
#endif
#if PY_MAJOR_VERSION >= 3
0, /*tp_as_async*/
#endif
0, /*tp_repr*/
0, /*tp_as_number*/
0, /*tp_as_sequence*/
0, /*tp_as_mapping*/
0, /*tp_hash*/
0, /*tp_call*/
0, /*tp_str*/
0, /*tp_getattro*/
0, /*tp_setattro*/
0, /*tp_as_buffer*/
Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/
0, /*tp_doc*/
0, /*tp_traverse*/
0, /*tp_clear*/
0, /*tp_richcompare*/
0, /*tp_weaklistoffset*/
0, /*tp_iter*/
0, /*tp_iternext*/
__pyx_methods_5spacy_6syntax_9arc_eager_Shift, /*tp_methods*/
0, /*tp_members*/
0, /*tp_getset*/
0, /*tp_base*/
0, /*tp_dict*/
0, /*tp_descr_get*/
0, /*tp_descr_set*/
0, /*tp_dictoffset*/
0, /*tp_init*/
0, /*tp_alloc*/
__pyx_tp_new_5spacy_6syntax_9arc_eager_Shift, /*tp_new*/
0, /*tp_free*/
0, /*tp_is_gc*/
0, /*tp_bases*/
0, /*tp_mro*/
0, /*tp_cache*/
0, /*tp_subclasses*/
0, /*tp_weaklist*/
0, /*tp_del*/
0, /*tp_version_tag*/
#if PY_VERSION_HEX >= 0x030400a1
0, /*tp_finalize*/
#endif
#if PY_VERSION_HEX >= 0x030800b1
0, /*tp_vectorcall*/
#endif
#if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000
0, /*tp_print*/
#endif
};
static struct __pyx_vtabstruct_5spacy_6syntax_9arc_eager_Reduce __pyx_vtable_5spacy_6syntax_9arc_eager_Reduce;
static PyObject *__pyx_tp_new_5spacy_6syntax_9arc_eager_Reduce(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) {
struct __pyx_obj_5spacy_6syntax_9arc_eager_Reduce *p;
PyObject *o;
if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) {
o = (*t->tp_alloc)(t, 0);
} else {
o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0);
}
if (unlikely(!o)) return 0;
p = ((struct __pyx_obj_5spacy_6syntax_9arc_eager_Reduce *)o);
p->__pyx_vtab = __pyx_vtabptr_5spacy_6syntax_9arc_eager_Reduce;
return o;
}
static void __pyx_tp_dealloc_5spacy_6syntax_9arc_eager_Reduce(PyObject *o) {
#if CYTHON_USE_TP_FINALIZE
if (unlikely(PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE) && Py_TYPE(o)->tp_finalize) && (!PyType_IS_GC(Py_TYPE(o)) || !_PyGC_FINALIZED(o))) {
if (PyObject_CallFinalizerFromDealloc(o)) return;
}
#endif
(*Py_TYPE(o)->tp_free)(o);
}
static PyMethodDef __pyx_methods_5spacy_6syntax_9arc_eager_Reduce[] = {
{"__reduce_cython__", (PyCFunction)__pyx_pw_5spacy_6syntax_9arc_eager_6Reduce_1__reduce_cython__, METH_NOARGS, 0},
{"__setstate_cython__", (PyCFunction)__pyx_pw_5spacy_6syntax_9arc_eager_6Reduce_3__setstate_cython__, METH_O, 0},
{0, 0, 0, 0}
};
static PyTypeObject __pyx_type_5spacy_6syntax_9arc_eager_Reduce = {
PyVarObject_HEAD_INIT(0, 0)
"spacy.syntax.arc_eager.Reduce", /*tp_name*/
sizeof(struct __pyx_obj_5spacy_6syntax_9arc_eager_Reduce), /*tp_basicsize*/
0, /*tp_itemsize*/
__pyx_tp_dealloc_5spacy_6syntax_9arc_eager_Reduce, /*tp_dealloc*/
#if PY_VERSION_HEX < 0x030800b4
0, /*tp_print*/
#endif
#if PY_VERSION_HEX >= 0x030800b4
0, /*tp_vectorcall_offset*/
#endif
0, /*tp_getattr*/
0, /*tp_setattr*/
#if PY_MAJOR_VERSION < 3
0, /*tp_compare*/
#endif
#if PY_MAJOR_VERSION >= 3
0, /*tp_as_async*/
#endif
0, /*tp_repr*/
0, /*tp_as_number*/
0, /*tp_as_sequence*/
0, /*tp_as_mapping*/
0, /*tp_hash*/
0, /*tp_call*/
0, /*tp_str*/
0, /*tp_getattro*/
0, /*tp_setattro*/
0, /*tp_as_buffer*/
Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/
0, /*tp_doc*/
0, /*tp_traverse*/
0, /*tp_clear*/
0, /*tp_richcompare*/
0, /*tp_weaklistoffset*/
0, /*tp_iter*/
0, /*tp_iternext*/
__pyx_methods_5spacy_6syntax_9arc_eager_Reduce, /*tp_methods*/
0, /*tp_members*/
0, /*tp_getset*/
0, /*tp_base*/
0, /*tp_dict*/
0, /*tp_descr_get*/
0, /*tp_descr_set*/
0, /*tp_dictoffset*/
0, /*tp_init*/
0, /*tp_alloc*/
__pyx_tp_new_5spacy_6syntax_9arc_eager_Reduce, /*tp_new*/
0, /*tp_free*/
0, /*tp_is_gc*/
0, /*tp_bases*/
0, /*tp_mro*/
0, /*tp_cache*/
0, /*tp_subclasses*/
0, /*tp_weaklist*/
0, /*tp_del*/
0, /*tp_version_tag*/
#if PY_VERSION_HEX >= 0x030400a1
0, /*tp_finalize*/
#endif
#if PY_VERSION_HEX >= 0x030800b1
0, /*tp_vectorcall*/
#endif
#if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000
0, /*tp_print*/
#endif
};
static struct __pyx_vtabstruct_5spacy_6syntax_9arc_eager_LeftArc __pyx_vtable_5spacy_6syntax_9arc_eager_LeftArc;
static PyObject *__pyx_tp_new_5spacy_6syntax_9arc_eager_LeftArc(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) {
struct __pyx_obj_5spacy_6syntax_9arc_eager_LeftArc *p;
PyObject *o;
if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) {
o = (*t->tp_alloc)(t, 0);
} else {
o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0);
}
if (unlikely(!o)) return 0;
p = ((struct __pyx_obj_5spacy_6syntax_9arc_eager_LeftArc *)o);
p->__pyx_vtab = __pyx_vtabptr_5spacy_6syntax_9arc_eager_LeftArc;
return o;
}
static void __pyx_tp_dealloc_5spacy_6syntax_9arc_eager_LeftArc(PyObject *o) {
#if CYTHON_USE_TP_FINALIZE
if (unlikely(PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE) && Py_TYPE(o)->tp_finalize) && (!PyType_IS_GC(Py_TYPE(o)) || !_PyGC_FINALIZED(o))) {
if (PyObject_CallFinalizerFromDealloc(o)) return;
}
#endif
(*Py_TYPE(o)->tp_free)(o);
}
static PyMethodDef __pyx_methods_5spacy_6syntax_9arc_eager_LeftArc[] = {
{"__reduce_cython__", (PyCFunction)__pyx_pw_5spacy_6syntax_9arc_eager_7LeftArc_1__reduce_cython__, METH_NOARGS, 0},
{"__setstate_cython__", (PyCFunction)__pyx_pw_5spacy_6syntax_9arc_eager_7LeftArc_3__setstate_cython__, METH_O, 0},
{0, 0, 0, 0}
};
static PyTypeObject __pyx_type_5spacy_6syntax_9arc_eager_LeftArc = {
PyVarObject_HEAD_INIT(0, 0)
"spacy.syntax.arc_eager.LeftArc", /*tp_name*/
sizeof(struct __pyx_obj_5spacy_6syntax_9arc_eager_LeftArc), /*tp_basicsize*/
0, /*tp_itemsize*/
__pyx_tp_dealloc_5spacy_6syntax_9arc_eager_LeftArc, /*tp_dealloc*/
#if PY_VERSION_HEX < 0x030800b4
0, /*tp_print*/
#endif
#if PY_VERSION_HEX >= 0x030800b4
0, /*tp_vectorcall_offset*/
#endif
0, /*tp_getattr*/
0, /*tp_setattr*/
#if PY_MAJOR_VERSION < 3
0, /*tp_compare*/
#endif
#if PY_MAJOR_VERSION >= 3
0, /*tp_as_async*/
#endif
0, /*tp_repr*/
0, /*tp_as_number*/
0, /*tp_as_sequence*/
0, /*tp_as_mapping*/
0, /*tp_hash*/
0, /*tp_call*/
0, /*tp_str*/
0, /*tp_getattro*/
0, /*tp_setattro*/
0, /*tp_as_buffer*/
Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/
0, /*tp_doc*/
0, /*tp_traverse*/
0, /*tp_clear*/
0, /*tp_richcompare*/
0, /*tp_weaklistoffset*/
0, /*tp_iter*/
0, /*tp_iternext*/
__pyx_methods_5spacy_6syntax_9arc_eager_LeftArc, /*tp_methods*/
0, /*tp_members*/
0, /*tp_getset*/
0, /*tp_base*/
0, /*tp_dict*/
0, /*tp_descr_get*/
0, /*tp_descr_set*/
0, /*tp_dictoffset*/
0, /*tp_init*/
0, /*tp_alloc*/
__pyx_tp_new_5spacy_6syntax_9arc_eager_LeftArc, /*tp_new*/
0, /*tp_free*/
0, /*tp_is_gc*/
0, /*tp_bases*/
0, /*tp_mro*/
0, /*tp_cache*/
0, /*tp_subclasses*/
0, /*tp_weaklist*/
0, /*tp_del*/
0, /*tp_version_tag*/
#if PY_VERSION_HEX >= 0x030400a1
0, /*tp_finalize*/
#endif
#if PY_VERSION_HEX >= 0x030800b1
0, /*tp_vectorcall*/
#endif
#if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000
0, /*tp_print*/
#endif
};
static struct __pyx_vtabstruct_5spacy_6syntax_9arc_eager_RightArc __pyx_vtable_5spacy_6syntax_9arc_eager_RightArc;
static PyObject *__pyx_tp_new_5spacy_6syntax_9arc_eager_RightArc(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) {
struct __pyx_obj_5spacy_6syntax_9arc_eager_RightArc *p;
PyObject *o;
if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) {
o = (*t->tp_alloc)(t, 0);
} else {
o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0);
}
if (unlikely(!o)) return 0;
p = ((struct __pyx_obj_5spacy_6syntax_9arc_eager_RightArc *)o);
p->__pyx_vtab = __pyx_vtabptr_5spacy_6syntax_9arc_eager_RightArc;
return o;
}
static void __pyx_tp_dealloc_5spacy_6syntax_9arc_eager_RightArc(PyObject *o) {
#if CYTHON_USE_TP_FINALIZE
if (unlikely(PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE) && Py_TYPE(o)->tp_finalize) && (!PyType_IS_GC(Py_TYPE(o)) || !_PyGC_FINALIZED(o))) {
if (PyObject_CallFinalizerFromDealloc(o)) return;
}
#endif
(*Py_TYPE(o)->tp_free)(o);
}
static PyMethodDef __pyx_methods_5spacy_6syntax_9arc_eager_RightArc[] = {
{"__reduce_cython__", (PyCFunction)__pyx_pw_5spacy_6syntax_9arc_eager_8RightArc_1__reduce_cython__, METH_NOARGS, 0},
{"__setstate_cython__", (PyCFunction)__pyx_pw_5spacy_6syntax_9arc_eager_8RightArc_3__setstate_cython__, METH_O, 0},
{0, 0, 0, 0}
};
static PyTypeObject __pyx_type_5spacy_6syntax_9arc_eager_RightArc = {
PyVarObject_HEAD_INIT(0, 0)
"spacy.syntax.arc_eager.RightArc", /*tp_name*/
sizeof(struct __pyx_obj_5spacy_6syntax_9arc_eager_RightArc), /*tp_basicsize*/
0, /*tp_itemsize*/
__pyx_tp_dealloc_5spacy_6syntax_9arc_eager_RightArc, /*tp_dealloc*/
#if PY_VERSION_HEX < 0x030800b4
0, /*tp_print*/
#endif
#if PY_VERSION_HEX >= 0x030800b4
0, /*tp_vectorcall_offset*/
#endif
0, /*tp_getattr*/
0, /*tp_setattr*/
#if PY_MAJOR_VERSION < 3
0, /*tp_compare*/
#endif
#if PY_MAJOR_VERSION >= 3
0, /*tp_as_async*/
#endif
0, /*tp_repr*/
0, /*tp_as_number*/
0, /*tp_as_sequence*/
0, /*tp_as_mapping*/
0, /*tp_hash*/
0, /*tp_call*/
0, /*tp_str*/
0, /*tp_getattro*/
0, /*tp_setattro*/
0, /*tp_as_buffer*/
Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/
0, /*tp_doc*/
0, /*tp_traverse*/
0, /*tp_clear*/
0, /*tp_richcompare*/
0, /*tp_weaklistoffset*/
0, /*tp_iter*/
0, /*tp_iternext*/
__pyx_methods_5spacy_6syntax_9arc_eager_RightArc, /*tp_methods*/
0, /*tp_members*/
0, /*tp_getset*/
0, /*tp_base*/
0, /*tp_dict*/
0, /*tp_descr_get*/
0, /*tp_descr_set*/
0, /*tp_dictoffset*/
0, /*tp_init*/
0, /*tp_alloc*/
__pyx_tp_new_5spacy_6syntax_9arc_eager_RightArc, /*tp_new*/
0, /*tp_free*/
0, /*tp_is_gc*/
0, /*tp_bases*/
0, /*tp_mro*/
0, /*tp_cache*/
0, /*tp_subclasses*/
0, /*tp_weaklist*/
0, /*tp_del*/
0, /*tp_version_tag*/
#if PY_VERSION_HEX >= 0x030400a1
0, /*tp_finalize*/
#endif
#if PY_VERSION_HEX >= 0x030800b1
0, /*tp_vectorcall*/
#endif
#if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000
0, /*tp_print*/
#endif
};
static struct __pyx_vtabstruct_5spacy_6syntax_9arc_eager_Break __pyx_vtable_5spacy_6syntax_9arc_eager_Break;
static PyObject *__pyx_tp_new_5spacy_6syntax_9arc_eager_Break(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) {
struct __pyx_obj_5spacy_6syntax_9arc_eager_Break *p;
PyObject *o;
if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) {
o = (*t->tp_alloc)(t, 0);
} else {
o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0);
}
if (unlikely(!o)) return 0;
p = ((struct __pyx_obj_5spacy_6syntax_9arc_eager_Break *)o);
p->__pyx_vtab = __pyx_vtabptr_5spacy_6syntax_9arc_eager_Break;
return o;
}
static void __pyx_tp_dealloc_5spacy_6syntax_9arc_eager_Break(PyObject *o) {
#if CYTHON_USE_TP_FINALIZE
if (unlikely(PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE) && Py_TYPE(o)->tp_finalize) && (!PyType_IS_GC(Py_TYPE(o)) || !_PyGC_FINALIZED(o))) {
if (PyObject_CallFinalizerFromDealloc(o)) return;
}
#endif
(*Py_TYPE(o)->tp_free)(o);
}
static PyMethodDef __pyx_methods_5spacy_6syntax_9arc_eager_Break[] = {
{"__reduce_cython__", (PyCFunction)__pyx_pw_5spacy_6syntax_9arc_eager_5Break_1__reduce_cython__, METH_NOARGS, 0},
{"__setstate_cython__", (PyCFunction)__pyx_pw_5spacy_6syntax_9arc_eager_5Break_3__setstate_cython__, METH_O, 0},
{0, 0, 0, 0}
};
static PyTypeObject __pyx_type_5spacy_6syntax_9arc_eager_Break = {
PyVarObject_HEAD_INIT(0, 0)
"spacy.syntax.arc_eager.Break", /*tp_name*/
sizeof(struct __pyx_obj_5spacy_6syntax_9arc_eager_Break), /*tp_basicsize*/
0, /*tp_itemsize*/
__pyx_tp_dealloc_5spacy_6syntax_9arc_eager_Break, /*tp_dealloc*/
#if PY_VERSION_HEX < 0x030800b4
0, /*tp_print*/
#endif
#if PY_VERSION_HEX >= 0x030800b4
0, /*tp_vectorcall_offset*/
#endif
0, /*tp_getattr*/
0, /*tp_setattr*/
#if PY_MAJOR_VERSION < 3
0, /*tp_compare*/
#endif
#if PY_MAJOR_VERSION >= 3
0, /*tp_as_async*/
#endif
0, /*tp_repr*/
0, /*tp_as_number*/
0, /*tp_as_sequence*/
0, /*tp_as_mapping*/
0, /*tp_hash*/
0, /*tp_call*/
0, /*tp_str*/
0, /*tp_getattro*/
0, /*tp_setattro*/
0, /*tp_as_buffer*/
Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/
0, /*tp_doc*/
0, /*tp_traverse*/
0, /*tp_clear*/
0, /*tp_richcompare*/
0, /*tp_weaklistoffset*/
0, /*tp_iter*/
0, /*tp_iternext*/
__pyx_methods_5spacy_6syntax_9arc_eager_Break, /*tp_methods*/
0, /*tp_members*/
0, /*tp_getset*/
0, /*tp_base*/
0, /*tp_dict*/
0, /*tp_descr_get*/
0, /*tp_descr_set*/
0, /*tp_dictoffset*/
0, /*tp_init*/
0, /*tp_alloc*/
__pyx_tp_new_5spacy_6syntax_9arc_eager_Break, /*tp_new*/
0, /*tp_free*/
0, /*tp_is_gc*/
0, /*tp_bases*/
0, /*tp_mro*/
0, /*tp_cache*/
0, /*tp_subclasses*/
0, /*tp_weaklist*/
0, /*tp_del*/
0, /*tp_version_tag*/
#if PY_VERSION_HEX >= 0x030400a1
0, /*tp_finalize*/
#endif
#if PY_VERSION_HEX >= 0x030800b1
0, /*tp_vectorcall*/
#endif
#if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000
0, /*tp_print*/
#endif
};
static struct __pyx_vtabstruct_array __pyx_vtable_array;
static PyObject *__pyx_tp_new_array(PyTypeObject *t, PyObject *a, PyObject *k) {
struct __pyx_array_obj *p;
PyObject *o;
if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) {
o = (*t->tp_alloc)(t, 0);
} else {
o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0);
}
if (unlikely(!o)) return 0;
p = ((struct __pyx_array_obj *)o);
p->__pyx_vtab = __pyx_vtabptr_array;
p->mode = ((PyObject*)Py_None); Py_INCREF(Py_None);
p->_format = ((PyObject*)Py_None); Py_INCREF(Py_None);
if (unlikely(__pyx_array___cinit__(o, a, k) < 0)) goto bad;
return o;
bad:
Py_DECREF(o); o = 0;
return NULL;
}
static void __pyx_tp_dealloc_array(PyObject *o) {
struct __pyx_array_obj *p = (struct __pyx_array_obj *)o;
#if CYTHON_USE_TP_FINALIZE
if (unlikely(PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE) && Py_TYPE(o)->tp_finalize) && (!PyType_IS_GC(Py_TYPE(o)) || !_PyGC_FINALIZED(o))) {
if (PyObject_CallFinalizerFromDealloc(o)) return;
}
#endif
{
PyObject *etype, *eval, *etb;
PyErr_Fetch(&etype, &eval, &etb);
__Pyx_SET_REFCNT(o, Py_REFCNT(o) + 1);
__pyx_array___dealloc__(o);
__Pyx_SET_REFCNT(o, Py_REFCNT(o) - 1);
PyErr_Restore(etype, eval, etb);
}
Py_CLEAR(p->mode);
Py_CLEAR(p->_format);
(*Py_TYPE(o)->tp_free)(o);
}
static PyObject *__pyx_sq_item_array(PyObject *o, Py_ssize_t i) {
PyObject *r;
PyObject *x = PyInt_FromSsize_t(i); if(!x) return 0;
r = Py_TYPE(o)->tp_as_mapping->mp_subscript(o, x);
Py_DECREF(x);
return r;
}
static int __pyx_mp_ass_subscript_array(PyObject *o, PyObject *i, PyObject *v) {
if (v) {
return __pyx_array___setitem__(o, i, v);
}
else {
PyErr_Format(PyExc_NotImplementedError,
"Subscript deletion not supported by %.200s", Py_TYPE(o)->tp_name);
return -1;
}
}
static PyObject *__pyx_tp_getattro_array(PyObject *o, PyObject *n) {
PyObject *v = __Pyx_PyObject_GenericGetAttr(o, n);
if (!v && PyErr_ExceptionMatches(PyExc_AttributeError)) {
PyErr_Clear();
v = __pyx_array___getattr__(o, n);
}
return v;
}
static PyObject *__pyx_getprop___pyx_array_memview(PyObject *o, CYTHON_UNUSED void *x) {
return __pyx_pw_15View_dot_MemoryView_5array_7memview_1__get__(o);
}
static PyMethodDef __pyx_methods_array[] = {
{"__getattr__", (PyCFunction)__pyx_array___getattr__, METH_O|METH_COEXIST, 0},
{"__reduce_cython__", (PyCFunction)__pyx_pw___pyx_array_1__reduce_cython__, METH_NOARGS, 0},
{"__setstate_cython__", (PyCFunction)__pyx_pw___pyx_array_3__setstate_cython__, METH_O, 0},
{0, 0, 0, 0}
};
static struct PyGetSetDef __pyx_getsets_array[] = {
{(char *)"memview", __pyx_getprop___pyx_array_memview, 0, (char *)0, 0},
{0, 0, 0, 0, 0}
};
static PySequenceMethods __pyx_tp_as_sequence_array = {
__pyx_array___len__, /*sq_length*/
0, /*sq_concat*/
0, /*sq_repeat*/
__pyx_sq_item_array, /*sq_item*/
0, /*sq_slice*/
0, /*sq_ass_item*/
0, /*sq_ass_slice*/
0, /*sq_contains*/
0, /*sq_inplace_concat*/
0, /*sq_inplace_repeat*/
};
static PyMappingMethods __pyx_tp_as_mapping_array = {
__pyx_array___len__, /*mp_length*/
__pyx_array___getitem__, /*mp_subscript*/
__pyx_mp_ass_subscript_array, /*mp_ass_subscript*/
};
static PyBufferProcs __pyx_tp_as_buffer_array = {
#if PY_MAJOR_VERSION < 3
0, /*bf_getreadbuffer*/
#endif
#if PY_MAJOR_VERSION < 3
0, /*bf_getwritebuffer*/
#endif
#if PY_MAJOR_VERSION < 3
0, /*bf_getsegcount*/
#endif
#if PY_MAJOR_VERSION < 3
0, /*bf_getcharbuffer*/
#endif
__pyx_array_getbuffer, /*bf_getbuffer*/
0, /*bf_releasebuffer*/
};
static PyTypeObject __pyx_type___pyx_array = {
PyVarObject_HEAD_INIT(0, 0)
"spacy.syntax.arc_eager.array", /*tp_name*/
sizeof(struct __pyx_array_obj), /*tp_basicsize*/
0, /*tp_itemsize*/
__pyx_tp_dealloc_array, /*tp_dealloc*/
#if PY_VERSION_HEX < 0x030800b4
0, /*tp_print*/
#endif
#if PY_VERSION_HEX >= 0x030800b4
0, /*tp_vectorcall_offset*/
#endif
0, /*tp_getattr*/
0, /*tp_setattr*/
#if PY_MAJOR_VERSION < 3
0, /*tp_compare*/
#endif
#if PY_MAJOR_VERSION >= 3
0, /*tp_as_async*/
#endif
0, /*tp_repr*/
0, /*tp_as_number*/
&__pyx_tp_as_sequence_array, /*tp_as_sequence*/
&__pyx_tp_as_mapping_array, /*tp_as_mapping*/
0, /*tp_hash*/
0, /*tp_call*/
0, /*tp_str*/
__pyx_tp_getattro_array, /*tp_getattro*/
0, /*tp_setattro*/
&__pyx_tp_as_buffer_array, /*tp_as_buffer*/
Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/
0, /*tp_doc*/
0, /*tp_traverse*/
0, /*tp_clear*/
0, /*tp_richcompare*/
0, /*tp_weaklistoffset*/
0, /*tp_iter*/
0, /*tp_iternext*/
__pyx_methods_array, /*tp_methods*/
0, /*tp_members*/
__pyx_getsets_array, /*tp_getset*/
0, /*tp_base*/
0, /*tp_dict*/
0, /*tp_descr_get*/
0, /*tp_descr_set*/
0, /*tp_dictoffset*/
0, /*tp_init*/
0, /*tp_alloc*/
__pyx_tp_new_array, /*tp_new*/
0, /*tp_free*/
0, /*tp_is_gc*/
0, /*tp_bases*/
0, /*tp_mro*/
0, /*tp_cache*/
0, /*tp_subclasses*/
0, /*tp_weaklist*/
0, /*tp_del*/
0, /*tp_version_tag*/
#if PY_VERSION_HEX >= 0x030400a1
0, /*tp_finalize*/
#endif
#if PY_VERSION_HEX >= 0x030800b1
0, /*tp_vectorcall*/
#endif
#if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000
0, /*tp_print*/
#endif
};
static PyObject *__pyx_tp_new_Enum(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) {
struct __pyx_MemviewEnum_obj *p;
PyObject *o;
if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) {
o = (*t->tp_alloc)(t, 0);
} else {
o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0);
}
if (unlikely(!o)) return 0;
p = ((struct __pyx_MemviewEnum_obj *)o);
p->name = Py_None; Py_INCREF(Py_None);
return o;
}
static void __pyx_tp_dealloc_Enum(PyObject *o) {
struct __pyx_MemviewEnum_obj *p = (struct __pyx_MemviewEnum_obj *)o;
#if CYTHON_USE_TP_FINALIZE
if (unlikely(PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE) && Py_TYPE(o)->tp_finalize) && !_PyGC_FINALIZED(o)) {
if (PyObject_CallFinalizerFromDealloc(o)) return;
}
#endif
PyObject_GC_UnTrack(o);
Py_CLEAR(p->name);
(*Py_TYPE(o)->tp_free)(o);
}
static int __pyx_tp_traverse_Enum(PyObject *o, visitproc v, void *a) {
int e;
struct __pyx_MemviewEnum_obj *p = (struct __pyx_MemviewEnum_obj *)o;
if (p->name) {
e = (*v)(p->name, a); if (e) return e;
}
return 0;
}
static int __pyx_tp_clear_Enum(PyObject *o) {
PyObject* tmp;
struct __pyx_MemviewEnum_obj *p = (struct __pyx_MemviewEnum_obj *)o;
tmp = ((PyObject*)p->name);
p->name = Py_None; Py_INCREF(Py_None);
Py_XDECREF(tmp);
return 0;
}
static PyMethodDef __pyx_methods_Enum[] = {
{"__reduce_cython__", (PyCFunction)__pyx_pw___pyx_MemviewEnum_1__reduce_cython__, METH_NOARGS, 0},
{"__setstate_cython__", (PyCFunction)__pyx_pw___pyx_MemviewEnum_3__setstate_cython__, METH_O, 0},
{0, 0, 0, 0}
};
static PyTypeObject __pyx_type___pyx_MemviewEnum = {
PyVarObject_HEAD_INIT(0, 0)
"spacy.syntax.arc_eager.Enum", /*tp_name*/
sizeof(struct __pyx_MemviewEnum_obj), /*tp_basicsize*/
0, /*tp_itemsize*/
__pyx_tp_dealloc_Enum, /*tp_dealloc*/
#if PY_VERSION_HEX < 0x030800b4
0, /*tp_print*/
#endif
#if PY_VERSION_HEX >= 0x030800b4
0, /*tp_vectorcall_offset*/
#endif
0, /*tp_getattr*/
0, /*tp_setattr*/
#if PY_MAJOR_VERSION < 3
0, /*tp_compare*/
#endif
#if PY_MAJOR_VERSION >= 3
0, /*tp_as_async*/
#endif
__pyx_MemviewEnum___repr__, /*tp_repr*/
0, /*tp_as_number*/
0, /*tp_as_sequence*/
0, /*tp_as_mapping*/
0, /*tp_hash*/
0, /*tp_call*/
0, /*tp_str*/
0, /*tp_getattro*/
0, /*tp_setattro*/
0, /*tp_as_buffer*/
Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, /*tp_flags*/
0, /*tp_doc*/
__pyx_tp_traverse_Enum, /*tp_traverse*/
__pyx_tp_clear_Enum, /*tp_clear*/
0, /*tp_richcompare*/
0, /*tp_weaklistoffset*/
0, /*tp_iter*/
0, /*tp_iternext*/
__pyx_methods_Enum, /*tp_methods*/
0, /*tp_members*/
0, /*tp_getset*/
0, /*tp_base*/
0, /*tp_dict*/
0, /*tp_descr_get*/
0, /*tp_descr_set*/
0, /*tp_dictoffset*/
__pyx_MemviewEnum___init__, /*tp_init*/
0, /*tp_alloc*/
__pyx_tp_new_Enum, /*tp_new*/
0, /*tp_free*/
0, /*tp_is_gc*/
0, /*tp_bases*/
0, /*tp_mro*/
0, /*tp_cache*/
0, /*tp_subclasses*/
0, /*tp_weaklist*/
0, /*tp_del*/
0, /*tp_version_tag*/
#if PY_VERSION_HEX >= 0x030400a1
0, /*tp_finalize*/
#endif
#if PY_VERSION_HEX >= 0x030800b1
0, /*tp_vectorcall*/
#endif
#if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000
0, /*tp_print*/
#endif
};
static struct __pyx_vtabstruct_memoryview __pyx_vtable_memoryview;
static PyObject *__pyx_tp_new_memoryview(PyTypeObject *t, PyObject *a, PyObject *k) {
struct __pyx_memoryview_obj *p;
PyObject *o;
if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) {
o = (*t->tp_alloc)(t, 0);
} else {
o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0);
}
if (unlikely(!o)) return 0;
p = ((struct __pyx_memoryview_obj *)o);
p->__pyx_vtab = __pyx_vtabptr_memoryview;
p->obj = Py_None; Py_INCREF(Py_None);
p->_size = Py_None; Py_INCREF(Py_None);
p->_array_interface = Py_None; Py_INCREF(Py_None);
p->view.obj = NULL;
if (unlikely(__pyx_memoryview___cinit__(o, a, k) < 0)) goto bad;
return o;
bad:
Py_DECREF(o); o = 0;
return NULL;
}
static void __pyx_tp_dealloc_memoryview(PyObject *o) {
struct __pyx_memoryview_obj *p = (struct __pyx_memoryview_obj *)o;
#if CYTHON_USE_TP_FINALIZE
if (unlikely(PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE) && Py_TYPE(o)->tp_finalize) && !_PyGC_FINALIZED(o)) {
if (PyObject_CallFinalizerFromDealloc(o)) return;
}
#endif
PyObject_GC_UnTrack(o);
{
PyObject *etype, *eval, *etb;
PyErr_Fetch(&etype, &eval, &etb);
__Pyx_SET_REFCNT(o, Py_REFCNT(o) + 1);
__pyx_memoryview___dealloc__(o);
__Pyx_SET_REFCNT(o, Py_REFCNT(o) - 1);
PyErr_Restore(etype, eval, etb);
}
Py_CLEAR(p->obj);
Py_CLEAR(p->_size);
Py_CLEAR(p->_array_interface);
(*Py_TYPE(o)->tp_free)(o);
}
static int __pyx_tp_traverse_memoryview(PyObject *o, visitproc v, void *a) {
int e;
struct __pyx_memoryview_obj *p = (struct __pyx_memoryview_obj *)o;
if (p->obj) {
e = (*v)(p->obj, a); if (e) return e;
}
if (p->_size) {
e = (*v)(p->_size, a); if (e) return e;
}
if (p->_array_interface) {
e = (*v)(p->_array_interface, a); if (e) return e;
}
if (p->view.obj) {
e = (*v)(p->view.obj, a); if (e) return e;
}
return 0;
}
static int __pyx_tp_clear_memoryview(PyObject *o) {
PyObject* tmp;
struct __pyx_memoryview_obj *p = (struct __pyx_memoryview_obj *)o;
tmp = ((PyObject*)p->obj);
p->obj = Py_None; Py_INCREF(Py_None);
Py_XDECREF(tmp);
tmp = ((PyObject*)p->_size);
p->_size = Py_None; Py_INCREF(Py_None);
Py_XDECREF(tmp);
tmp = ((PyObject*)p->_array_interface);
p->_array_interface = Py_None; Py_INCREF(Py_None);
Py_XDECREF(tmp);
Py_CLEAR(p->view.obj);
return 0;
}
static PyObject *__pyx_sq_item_memoryview(PyObject *o, Py_ssize_t i) {
PyObject *r;
PyObject *x = PyInt_FromSsize_t(i); if(!x) return 0;
r = Py_TYPE(o)->tp_as_mapping->mp_subscript(o, x);
Py_DECREF(x);
return r;
}
static int __pyx_mp_ass_subscript_memoryview(PyObject *o, PyObject *i, PyObject *v) {
if (v) {
return __pyx_memoryview___setitem__(o, i, v);
}
else {
PyErr_Format(PyExc_NotImplementedError,
"Subscript deletion not supported by %.200s", Py_TYPE(o)->tp_name);
return -1;
}
}
static PyObject *__pyx_getprop___pyx_memoryview_T(PyObject *o, CYTHON_UNUSED void *x) {
return __pyx_pw_15View_dot_MemoryView_10memoryview_1T_1__get__(o);
}
static PyObject *__pyx_getprop___pyx_memoryview_base(PyObject *o, CYTHON_UNUSED void *x) {
return __pyx_pw_15View_dot_MemoryView_10memoryview_4base_1__get__(o);
}
static PyObject *__pyx_getprop___pyx_memoryview_shape(PyObject *o, CYTHON_UNUSED void *x) {
return __pyx_pw_15View_dot_MemoryView_10memoryview_5shape_1__get__(o);
}
static PyObject *__pyx_getprop___pyx_memoryview_strides(PyObject *o, CYTHON_UNUSED void *x) {
return __pyx_pw_15View_dot_MemoryView_10memoryview_7strides_1__get__(o);
}
static PyObject *__pyx_getprop___pyx_memoryview_suboffsets(PyObject *o, CYTHON_UNUSED void *x) {
return __pyx_pw_15View_dot_MemoryView_10memoryview_10suboffsets_1__get__(o);
}
static PyObject *__pyx_getprop___pyx_memoryview_ndim(PyObject *o, CYTHON_UNUSED void *x) {
return __pyx_pw_15View_dot_MemoryView_10memoryview_4ndim_1__get__(o);
}
static PyObject *__pyx_getprop___pyx_memoryview_itemsize(PyObject *o, CYTHON_UNUSED void *x) {
return __pyx_pw_15View_dot_MemoryView_10memoryview_8itemsize_1__get__(o);
}
static PyObject *__pyx_getprop___pyx_memoryview_nbytes(PyObject *o, CYTHON_UNUSED void *x) {
return __pyx_pw_15View_dot_MemoryView_10memoryview_6nbytes_1__get__(o);
}
static PyObject *__pyx_getprop___pyx_memoryview_size(PyObject *o, CYTHON_UNUSED void *x) {
return __pyx_pw_15View_dot_MemoryView_10memoryview_4size_1__get__(o);
}
static PyMethodDef __pyx_methods_memoryview[] = {
{"is_c_contig", (PyCFunction)__pyx_memoryview_is_c_contig, METH_NOARGS, 0},
{"is_f_contig", (PyCFunction)__pyx_memoryview_is_f_contig, METH_NOARGS, 0},
{"copy", (PyCFunction)__pyx_memoryview_copy, METH_NOARGS, 0},
{"copy_fortran", (PyCFunction)__pyx_memoryview_copy_fortran, METH_NOARGS, 0},
{"__reduce_cython__", (PyCFunction)__pyx_pw___pyx_memoryview_1__reduce_cython__, METH_NOARGS, 0},
{"__setstate_cython__", (PyCFunction)__pyx_pw___pyx_memoryview_3__setstate_cython__, METH_O, 0},
{0, 0, 0, 0}
};
static struct PyGetSetDef __pyx_getsets_memoryview[] = {
{(char *)"T", __pyx_getprop___pyx_memoryview_T, 0, (char *)0, 0},
{(char *)"base", __pyx_getprop___pyx_memoryview_base, 0, (char *)0, 0},
{(char *)"shape", __pyx_getprop___pyx_memoryview_shape, 0, (char *)0, 0},
{(char *)"strides", __pyx_getprop___pyx_memoryview_strides, 0, (char *)0, 0},
{(char *)"suboffsets", __pyx_getprop___pyx_memoryview_suboffsets, 0, (char *)0, 0},
{(char *)"ndim", __pyx_getprop___pyx_memoryview_ndim, 0, (char *)0, 0},
{(char *)"itemsize", __pyx_getprop___pyx_memoryview_itemsize, 0, (char *)0, 0},
{(char *)"nbytes", __pyx_getprop___pyx_memoryview_nbytes, 0, (char *)0, 0},
{(char *)"size", __pyx_getprop___pyx_memoryview_size, 0, (char *)0, 0},
{0, 0, 0, 0, 0}
};
static PySequenceMethods __pyx_tp_as_sequence_memoryview = {
__pyx_memoryview___len__, /*sq_length*/
0, /*sq_concat*/
0, /*sq_repeat*/
__pyx_sq_item_memoryview, /*sq_item*/
0, /*sq_slice*/
0, /*sq_ass_item*/
0, /*sq_ass_slice*/
0, /*sq_contains*/
0, /*sq_inplace_concat*/
0, /*sq_inplace_repeat*/
};
static PyMappingMethods __pyx_tp_as_mapping_memoryview = {
__pyx_memoryview___len__, /*mp_length*/
__pyx_memoryview___getitem__, /*mp_subscript*/
__pyx_mp_ass_subscript_memoryview, /*mp_ass_subscript*/
};
static PyBufferProcs __pyx_tp_as_buffer_memoryview = {
#if PY_MAJOR_VERSION < 3
0, /*bf_getreadbuffer*/
#endif
#if PY_MAJOR_VERSION < 3
0, /*bf_getwritebuffer*/
#endif
#if PY_MAJOR_VERSION < 3
0, /*bf_getsegcount*/
#endif
#if PY_MAJOR_VERSION < 3
0, /*bf_getcharbuffer*/
#endif
__pyx_memoryview_getbuffer, /*bf_getbuffer*/
0, /*bf_releasebuffer*/
};
static PyTypeObject __pyx_type___pyx_memoryview = {
PyVarObject_HEAD_INIT(0, 0)
"spacy.syntax.arc_eager.memoryview", /*tp_name*/
sizeof(struct __pyx_memoryview_obj), /*tp_basicsize*/
0, /*tp_itemsize*/
__pyx_tp_dealloc_memoryview, /*tp_dealloc*/
#if PY_VERSION_HEX < 0x030800b4
0, /*tp_print*/
#endif
#if PY_VERSION_HEX >= 0x030800b4
0, /*tp_vectorcall_offset*/
#endif
0, /*tp_getattr*/
0, /*tp_setattr*/
#if PY_MAJOR_VERSION < 3
0, /*tp_compare*/
#endif
#if PY_MAJOR_VERSION >= 3
0, /*tp_as_async*/
#endif
__pyx_memoryview___repr__, /*tp_repr*/
0, /*tp_as_number*/
&__pyx_tp_as_sequence_memoryview, /*tp_as_sequence*/
&__pyx_tp_as_mapping_memoryview, /*tp_as_mapping*/
0, /*tp_hash*/
0, /*tp_call*/
__pyx_memoryview___str__, /*tp_str*/
0, /*tp_getattro*/
0, /*tp_setattro*/
&__pyx_tp_as_buffer_memoryview, /*tp_as_buffer*/
Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, /*tp_flags*/
0, /*tp_doc*/
__pyx_tp_traverse_memoryview, /*tp_traverse*/
__pyx_tp_clear_memoryview, /*tp_clear*/
0, /*tp_richcompare*/
0, /*tp_weaklistoffset*/
0, /*tp_iter*/
0, /*tp_iternext*/
__pyx_methods_memoryview, /*tp_methods*/
0, /*tp_members*/
__pyx_getsets_memoryview, /*tp_getset*/
0, /*tp_base*/
0, /*tp_dict*/
0, /*tp_descr_get*/
0, /*tp_descr_set*/
0, /*tp_dictoffset*/
0, /*tp_init*/
0, /*tp_alloc*/
__pyx_tp_new_memoryview, /*tp_new*/
0, /*tp_free*/
0, /*tp_is_gc*/
0, /*tp_bases*/
0, /*tp_mro*/
0, /*tp_cache*/
0, /*tp_subclasses*/
0, /*tp_weaklist*/
0, /*tp_del*/
0, /*tp_version_tag*/
#if PY_VERSION_HEX >= 0x030400a1
0, /*tp_finalize*/
#endif
#if PY_VERSION_HEX >= 0x030800b1
0, /*tp_vectorcall*/
#endif
#if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000
0, /*tp_print*/
#endif
};
static struct __pyx_vtabstruct__memoryviewslice __pyx_vtable__memoryviewslice;
static PyObject *__pyx_tp_new__memoryviewslice(PyTypeObject *t, PyObject *a, PyObject *k) {
struct __pyx_memoryviewslice_obj *p;
PyObject *o = __pyx_tp_new_memoryview(t, a, k);
if (unlikely(!o)) return 0;
p = ((struct __pyx_memoryviewslice_obj *)o);
p->__pyx_base.__pyx_vtab = (struct __pyx_vtabstruct_memoryview*)__pyx_vtabptr__memoryviewslice;
p->from_object = Py_None; Py_INCREF(Py_None);
p->from_slice.memview = NULL;
return o;
}
static void __pyx_tp_dealloc__memoryviewslice(PyObject *o) {
struct __pyx_memoryviewslice_obj *p = (struct __pyx_memoryviewslice_obj *)o;
#if CYTHON_USE_TP_FINALIZE
if (unlikely(PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE) && Py_TYPE(o)->tp_finalize) && !_PyGC_FINALIZED(o)) {
if (PyObject_CallFinalizerFromDealloc(o)) return;
}
#endif
PyObject_GC_UnTrack(o);
{
PyObject *etype, *eval, *etb;
PyErr_Fetch(&etype, &eval, &etb);
__Pyx_SET_REFCNT(o, Py_REFCNT(o) + 1);
__pyx_memoryviewslice___dealloc__(o);
__Pyx_SET_REFCNT(o, Py_REFCNT(o) - 1);
PyErr_Restore(etype, eval, etb);
}
Py_CLEAR(p->from_object);
PyObject_GC_Track(o);
__pyx_tp_dealloc_memoryview(o);
}
static int __pyx_tp_traverse__memoryviewslice(PyObject *o, visitproc v, void *a) {
int e;
struct __pyx_memoryviewslice_obj *p = (struct __pyx_memoryviewslice_obj *)o;
e = __pyx_tp_traverse_memoryview(o, v, a); if (e) return e;
if (p->from_object) {
e = (*v)(p->from_object, a); if (e) return e;
}
return 0;
}
static int __pyx_tp_clear__memoryviewslice(PyObject *o) {
PyObject* tmp;
struct __pyx_memoryviewslice_obj *p = (struct __pyx_memoryviewslice_obj *)o;
__pyx_tp_clear_memoryview(o);
tmp = ((PyObject*)p->from_object);
p->from_object = Py_None; Py_INCREF(Py_None);
Py_XDECREF(tmp);
__PYX_XDEC_MEMVIEW(&p->from_slice, 1);
return 0;
}
static PyObject *__pyx_getprop___pyx_memoryviewslice_base(PyObject *o, CYTHON_UNUSED void *x) {
return __pyx_pw_15View_dot_MemoryView_16_memoryviewslice_4base_1__get__(o);
}
static PyMethodDef __pyx_methods__memoryviewslice[] = {
{"__reduce_cython__", (PyCFunction)__pyx_pw___pyx_memoryviewslice_1__reduce_cython__, METH_NOARGS, 0},
{"__setstate_cython__", (PyCFunction)__pyx_pw___pyx_memoryviewslice_3__setstate_cython__, METH_O, 0},
{0, 0, 0, 0}
};
static struct PyGetSetDef __pyx_getsets__memoryviewslice[] = {
{(char *)"base", __pyx_getprop___pyx_memoryviewslice_base, 0, (char *)0, 0},
{0, 0, 0, 0, 0}
};
static PyTypeObject __pyx_type___pyx_memoryviewslice = {
PyVarObject_HEAD_INIT(0, 0)
"spacy.syntax.arc_eager._memoryviewslice", /*tp_name*/
sizeof(struct __pyx_memoryviewslice_obj), /*tp_basicsize*/
0, /*tp_itemsize*/
__pyx_tp_dealloc__memoryviewslice, /*tp_dealloc*/
#if PY_VERSION_HEX < 0x030800b4
0, /*tp_print*/
#endif
#if PY_VERSION_HEX >= 0x030800b4
0, /*tp_vectorcall_offset*/
#endif
0, /*tp_getattr*/
0, /*tp_setattr*/
#if PY_MAJOR_VERSION < 3
0, /*tp_compare*/
#endif
#if PY_MAJOR_VERSION >= 3
0, /*tp_as_async*/
#endif
#if CYTHON_COMPILING_IN_PYPY
__pyx_memoryview___repr__, /*tp_repr*/
#else
0, /*tp_repr*/
#endif
0, /*tp_as_number*/
0, /*tp_as_sequence*/
0, /*tp_as_mapping*/
0, /*tp_hash*/
0, /*tp_call*/
#if CYTHON_COMPILING_IN_PYPY
__pyx_memoryview___str__, /*tp_str*/
#else
0, /*tp_str*/
#endif
0, /*tp_getattro*/
0, /*tp_setattro*/
0, /*tp_as_buffer*/
Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, /*tp_flags*/
"Internal class for passing memoryview slices to Python", /*tp_doc*/
__pyx_tp_traverse__memoryviewslice, /*tp_traverse*/
__pyx_tp_clear__memoryviewslice, /*tp_clear*/
0, /*tp_richcompare*/
0, /*tp_weaklistoffset*/
0, /*tp_iter*/
0, /*tp_iternext*/
__pyx_methods__memoryviewslice, /*tp_methods*/
0, /*tp_members*/
__pyx_getsets__memoryviewslice, /*tp_getset*/
0, /*tp_base*/
0, /*tp_dict*/
0, /*tp_descr_get*/
0, /*tp_descr_set*/
0, /*tp_dictoffset*/
0, /*tp_init*/
0, /*tp_alloc*/
__pyx_tp_new__memoryviewslice, /*tp_new*/
0, /*tp_free*/
0, /*tp_is_gc*/
0, /*tp_bases*/
0, /*tp_mro*/
0, /*tp_cache*/
0, /*tp_subclasses*/
0, /*tp_weaklist*/
0, /*tp_del*/
0, /*tp_version_tag*/
#if PY_VERSION_HEX >= 0x030400a1
0, /*tp_finalize*/
#endif
#if PY_VERSION_HEX >= 0x030800b1
0, /*tp_vectorcall*/
#endif
#if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000
0, /*tp_print*/
#endif
};
static PyMethodDef __pyx_methods[] = {
{0, 0, 0, 0}
};
#if PY_MAJOR_VERSION >= 3
#if CYTHON_PEP489_MULTI_PHASE_INIT
static PyObject* __pyx_pymod_create(PyObject *spec, PyModuleDef *def); /*proto*/
static int __pyx_pymod_exec_arc_eager(PyObject* module); /*proto*/
static PyModuleDef_Slot __pyx_moduledef_slots[] = {
{Py_mod_create, (void*)__pyx_pymod_create},
{Py_mod_exec, (void*)__pyx_pymod_exec_arc_eager},
{0, NULL}
};
#endif
static struct PyModuleDef __pyx_moduledef = {
PyModuleDef_HEAD_INIT,
"arc_eager",
0, /* m_doc */
#if CYTHON_PEP489_MULTI_PHASE_INIT
0, /* m_size */
#else
-1, /* m_size */
#endif
__pyx_methods /* m_methods */,
#if CYTHON_PEP489_MULTI_PHASE_INIT
__pyx_moduledef_slots, /* m_slots */
#else
NULL, /* m_reload */
#endif
NULL, /* m_traverse */
NULL, /* m_clear */
NULL /* m_free */
};
#endif
#ifndef CYTHON_SMALL_CODE
#if defined(__clang__)
#define CYTHON_SMALL_CODE
#elif defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3))
#define CYTHON_SMALL_CODE __attribute__((cold))
#else
#define CYTHON_SMALL_CODE
#endif
#endif
static __Pyx_StringTabEntry __pyx_string_tab[] = {
{&__pyx_n_s_, __pyx_k_, sizeof(__pyx_k_), 0, 0, 1, 1},
{&__pyx_kp_u_, __pyx_k_, sizeof(__pyx_k_), 0, 1, 0, 0},
{&__pyx_n_s_ASCII, __pyx_k_ASCII, sizeof(__pyx_k_ASCII), 0, 0, 1, 1},
{&__pyx_n_s_ArcEager, __pyx_k_ArcEager, sizeof(__pyx_k_ArcEager), 0, 0, 1, 1},
{&__pyx_n_u_B, __pyx_k_B, sizeof(__pyx_k_B), 0, 1, 0, 1},
{&__pyx_n_s_Break, __pyx_k_Break, sizeof(__pyx_k_Break), 0, 0, 1, 1},
{&__pyx_kp_s_Buffer_view_does_not_expose_stri, __pyx_k_Buffer_view_does_not_expose_stri, sizeof(__pyx_k_Buffer_view_does_not_expose_stri), 0, 0, 1, 0},
{&__pyx_kp_s_Can_only_create_a_buffer_that_is, __pyx_k_Can_only_create_a_buffer_that_is, sizeof(__pyx_k_Can_only_create_a_buffer_that_is), 0, 0, 1, 0},
{&__pyx_kp_s_Cannot_assign_to_read_only_memor, __pyx_k_Cannot_assign_to_read_only_memor, sizeof(__pyx_k_Cannot_assign_to_read_only_memor), 0, 0, 1, 0},
{&__pyx_kp_s_Cannot_create_writable_memory_vi, __pyx_k_Cannot_create_writable_memory_vi, sizeof(__pyx_k_Cannot_create_writable_memory_vi), 0, 0, 1, 0},
{&__pyx_kp_s_Cannot_index_with_type_s, __pyx_k_Cannot_index_with_type_s, sizeof(__pyx_k_Cannot_index_with_type_s), 0, 0, 1, 0},
{&__pyx_n_s_Counter, __pyx_k_Counter, sizeof(__pyx_k_Counter), 0, 0, 1, 1},
{&__pyx_n_u_D, __pyx_k_D, sizeof(__pyx_k_D), 0, 1, 0, 1},
{&__pyx_n_s_E019, __pyx_k_E019, sizeof(__pyx_k_E019), 0, 0, 1, 1},
{&__pyx_n_s_E020, __pyx_k_E020, sizeof(__pyx_k_E020), 0, 0, 1, 1},
{&__pyx_n_s_E021, __pyx_k_E021, sizeof(__pyx_k_E021), 0, 0, 1, 1},
{&__pyx_n_s_Ellipsis, __pyx_k_Ellipsis, sizeof(__pyx_k_Ellipsis), 0, 0, 1, 1},
{&__pyx_kp_s_Empty_shape_tuple_for_cython_arr, __pyx_k_Empty_shape_tuple_for_cython_arr, sizeof(__pyx_k_Empty_shape_tuple_for_cython_arr), 0, 0, 1, 0},
{&__pyx_n_s_Errors, __pyx_k_Errors, sizeof(__pyx_k_Errors), 0, 0, 1, 1},
{&__pyx_kp_u_Format_string_allocated_too_shor, __pyx_k_Format_string_allocated_too_shor, sizeof(__pyx_k_Format_string_allocated_too_shor), 0, 1, 0, 0},
{&__pyx_kp_u_Format_string_allocated_too_shor_2, __pyx_k_Format_string_allocated_too_shor_2, sizeof(__pyx_k_Format_string_allocated_too_shor_2), 0, 1, 0, 0},
{&__pyx_n_s_ImportError, __pyx_k_ImportError, sizeof(__pyx_k_ImportError), 0, 0, 1, 1},
{&__pyx_kp_s_Incompatible_checksums_s_vs_0xb0, __pyx_k_Incompatible_checksums_s_vs_0xb0, sizeof(__pyx_k_Incompatible_checksums_s_vs_0xb0), 0, 0, 1, 0},
{&__pyx_kp_s_Incompatible_checksums_s_vs_0xd4, __pyx_k_Incompatible_checksums_s_vs_0xd4, sizeof(__pyx_k_Incompatible_checksums_s_vs_0xd4), 0, 0, 1, 0},
{&__pyx_n_s_IndexError, __pyx_k_IndexError, sizeof(__pyx_k_IndexError), 0, 0, 1, 1},
{&__pyx_kp_s_Indirect_dimensions_not_supporte, __pyx_k_Indirect_dimensions_not_supporte, sizeof(__pyx_k_Indirect_dimensions_not_supporte), 0, 0, 1, 0},
{&__pyx_kp_s_Invalid_mode_expected_c_or_fortr, __pyx_k_Invalid_mode_expected_c_or_fortr, sizeof(__pyx_k_Invalid_mode_expected_c_or_fortr), 0, 0, 1, 0},
{&__pyx_kp_s_Invalid_shape_in_axis_d_d, __pyx_k_Invalid_shape_in_axis_d_d, sizeof(__pyx_k_Invalid_shape_in_axis_d_d), 0, 0, 1, 0},
{&__pyx_n_u_L, __pyx_k_L, sizeof(__pyx_k_L), 0, 1, 0, 1},
{&__pyx_n_s_LeftArc, __pyx_k_LeftArc, sizeof(__pyx_k_LeftArc), 0, 0, 1, 1},
{&__pyx_n_s_MISSING, __pyx_k_MISSING, sizeof(__pyx_k_MISSING), 0, 0, 1, 1},
{&__pyx_n_s_MOVE_NAMES, __pyx_k_MOVE_NAMES, sizeof(__pyx_k_MOVE_NAMES), 0, 0, 1, 1},
{&__pyx_n_s_MemoryError, __pyx_k_MemoryError, sizeof(__pyx_k_MemoryError), 0, 0, 1, 1},
{&__pyx_kp_s_MemoryView_of_r_at_0x_x, __pyx_k_MemoryView_of_r_at_0x_x, sizeof(__pyx_k_MemoryView_of_r_at_0x_x), 0, 0, 1, 0},
{&__pyx_kp_s_MemoryView_of_r_object, __pyx_k_MemoryView_of_r_object, sizeof(__pyx_k_MemoryView_of_r_object), 0, 0, 1, 0},
{&__pyx_kp_u_Non_native_byte_order_not_suppor, __pyx_k_Non_native_byte_order_not_suppor, sizeof(__pyx_k_Non_native_byte_order_not_suppor), 0, 1, 0, 0},
{&__pyx_n_b_O, __pyx_k_O, sizeof(__pyx_k_O), 0, 0, 0, 1},
{&__pyx_n_s_OrderedDict, __pyx_k_OrderedDict, sizeof(__pyx_k_OrderedDict), 0, 0, 1, 1},
{&__pyx_kp_s_Out_of_bounds_on_buffer_access_a, __pyx_k_Out_of_bounds_on_buffer_access_a, sizeof(__pyx_k_Out_of_bounds_on_buffer_access_a), 0, 0, 1, 0},
{&__pyx_n_s_PickleError, __pyx_k_PickleError, sizeof(__pyx_k_PickleError), 0, 0, 1, 1},
{&__pyx_n_u_R, __pyx_k_R, sizeof(__pyx_k_R), 0, 1, 0, 1},
{&__pyx_n_u_ROOT, __pyx_k_ROOT, sizeof(__pyx_k_ROOT), 0, 1, 0, 1},
{&__pyx_n_s_Reduce, __pyx_k_Reduce, sizeof(__pyx_k_Reduce), 0, 0, 1, 1},
{&__pyx_n_s_RightArc, __pyx_k_RightArc, sizeof(__pyx_k_RightArc), 0, 0, 1, 1},
{&__pyx_n_s_RuntimeError, __pyx_k_RuntimeError, sizeof(__pyx_k_RuntimeError), 0, 0, 1, 1},
{&__pyx_n_u_S, __pyx_k_S, sizeof(__pyx_k_S), 0, 1, 0, 1},
{&__pyx_n_s_Shift, __pyx_k_Shift, sizeof(__pyx_k_Shift), 0, 0, 1, 1},
{&__pyx_n_s_TypeError, __pyx_k_TypeError, sizeof(__pyx_k_TypeError), 0, 0, 1, 1},
{&__pyx_kp_s_Unable_to_convert_item_to_object, __pyx_k_Unable_to_convert_item_to_object, sizeof(__pyx_k_Unable_to_convert_item_to_object), 0, 0, 1, 0},
{&__pyx_n_s_ValueError, __pyx_k_ValueError, sizeof(__pyx_k_ValueError), 0, 0, 1, 1},
{&__pyx_n_s_View_MemoryView, __pyx_k_View_MemoryView, sizeof(__pyx_k_View_MemoryView), 0, 0, 1, 1},
{&__pyx_kp_u__5, __pyx_k__5, sizeof(__pyx_k__5), 0, 1, 0, 0},
{&__pyx_n_s_action, __pyx_k_action, sizeof(__pyx_k_action), 0, 0, 1, 1},
{&__pyx_n_s_add, __pyx_k_add, sizeof(__pyx_k_add), 0, 0, 1, 1},
{&__pyx_n_s_all, __pyx_k_all, sizeof(__pyx_k_all), 0, 0, 1, 1},
{&__pyx_n_s_allocate_buffer, __pyx_k_allocate_buffer, sizeof(__pyx_k_allocate_buffer), 0, 0, 1, 1},
{&__pyx_n_u_arc_eager, __pyx_k_arc_eager, sizeof(__pyx_k_arc_eager), 0, 1, 0, 1},
{&__pyx_n_s_base, __pyx_k_base, sizeof(__pyx_k_base), 0, 0, 1, 1},
{&__pyx_n_s_c, __pyx_k_c, sizeof(__pyx_k_c), 0, 0, 1, 1},
{&__pyx_n_u_c, __pyx_k_c, sizeof(__pyx_k_c), 0, 1, 0, 1},
{&__pyx_n_s_clas, __pyx_k_clas, sizeof(__pyx_k_clas), 0, 0, 1, 1},
{&__pyx_n_s_class, __pyx_k_class, sizeof(__pyx_k_class), 0, 0, 1, 1},
{&__pyx_n_s_cline_in_traceback, __pyx_k_cline_in_traceback, sizeof(__pyx_k_cline_in_traceback), 0, 0, 1, 1},
{&__pyx_n_s_collections, __pyx_k_collections, sizeof(__pyx_k_collections), 0, 0, 1, 1},
{&__pyx_kp_s_contiguous_and_direct, __pyx_k_contiguous_and_direct, sizeof(__pyx_k_contiguous_and_direct), 0, 0, 1, 0},
{&__pyx_kp_s_contiguous_and_indirect, __pyx_k_contiguous_and_indirect, sizeof(__pyx_k_contiguous_and_indirect), 0, 0, 1, 0},
{&__pyx_n_s_decompose, __pyx_k_decompose, sizeof(__pyx_k_decompose), 0, 0, 1, 1},
{&__pyx_n_s_defaultdict, __pyx_k_defaultdict, sizeof(__pyx_k_defaultdict), 0, 0, 1, 1},
{&__pyx_n_u_dep, __pyx_k_dep, sizeof(__pyx_k_dep), 0, 1, 0, 1},
{&__pyx_n_s_dict, __pyx_k_dict, sizeof(__pyx_k_dict), 0, 0, 1, 1},
{&__pyx_n_s_dtype_is_object, __pyx_k_dtype_is_object, sizeof(__pyx_k_dtype_is_object), 0, 0, 1, 1},
{&__pyx_n_s_encode, __pyx_k_encode, sizeof(__pyx_k_encode), 0, 0, 1, 1},
{&__pyx_n_s_end, __pyx_k_end, sizeof(__pyx_k_end), 0, 0, 1, 1},
{&__pyx_n_s_enumerate, __pyx_k_enumerate, sizeof(__pyx_k_enumerate), 0, 0, 1, 1},
{&__pyx_n_s_error, __pyx_k_error, sizeof(__pyx_k_error), 0, 0, 1, 1},
{&__pyx_n_s_errors, __pyx_k_errors, sizeof(__pyx_k_errors), 0, 0, 1, 1},
{&__pyx_n_s_flags, __pyx_k_flags, sizeof(__pyx_k_flags), 0, 0, 1, 1},
{&__pyx_n_s_format, __pyx_k_format, sizeof(__pyx_k_format), 0, 0, 1, 1},
{&__pyx_n_s_fortran, __pyx_k_fortran, sizeof(__pyx_k_fortran), 0, 0, 1, 1},
{&__pyx_n_u_fortran, __pyx_k_fortran, sizeof(__pyx_k_fortran), 0, 1, 0, 1},
{&__pyx_n_s_get, __pyx_k_get, sizeof(__pyx_k_get), 0, 0, 1, 1},
{&__pyx_n_s_get_actions, __pyx_k_get_actions, sizeof(__pyx_k_get_actions), 0, 0, 1, 1},
{&__pyx_n_s_get_actions_locals_lambda, __pyx_k_get_actions_locals_lambda, sizeof(__pyx_k_get_actions_locals_lambda), 0, 0, 1, 1},
{&__pyx_n_s_getstate, __pyx_k_getstate, sizeof(__pyx_k_getstate), 0, 0, 1, 1},
{&__pyx_n_s_gold, __pyx_k_gold, sizeof(__pyx_k_gold), 0, 0, 1, 1},
{&__pyx_n_u_gold_parses, __pyx_k_gold_parses, sizeof(__pyx_k_gold_parses), 0, 1, 0, 1},
{&__pyx_kp_s_got_differing_extents_in_dimensi, __pyx_k_got_differing_extents_in_dimensi, sizeof(__pyx_k_got_differing_extents_in_dimensi), 0, 0, 1, 0},
{&__pyx_n_s_has_gold, __pyx_k_has_gold, sizeof(__pyx_k_has_gold), 0, 0, 1, 1},
{&__pyx_n_s_id, __pyx_k_id, sizeof(__pyx_k_id), 0, 0, 1, 1},
{&__pyx_n_s_import, __pyx_k_import, sizeof(__pyx_k_import), 0, 0, 1, 1},
{&__pyx_n_s_index, __pyx_k_index, sizeof(__pyx_k_index), 0, 0, 1, 1},
{&__pyx_n_s_init, __pyx_k_init, sizeof(__pyx_k_init), 0, 0, 1, 1},
{&__pyx_n_s_is_decorated, __pyx_k_is_decorated, sizeof(__pyx_k_is_decorated), 0, 0, 1, 1},
{&__pyx_n_s_is_nonproj_tree, __pyx_k_is_nonproj_tree, sizeof(__pyx_k_is_nonproj_tree), 0, 0, 1, 1},
{&__pyx_n_s_items, __pyx_k_items, sizeof(__pyx_k_items), 0, 0, 1, 1},
{&__pyx_n_s_itemsize, __pyx_k_itemsize, sizeof(__pyx_k_itemsize), 0, 0, 1, 1},
{&__pyx_kp_s_itemsize_0_for_cython_array, __pyx_k_itemsize_0_for_cython_array, sizeof(__pyx_k_itemsize_0_for_cython_array), 0, 0, 1, 0},
{&__pyx_n_s_json, __pyx_k_json, sizeof(__pyx_k_json), 0, 0, 1, 1},
{&__pyx_n_s_label, __pyx_k_label, sizeof(__pyx_k_label), 0, 0, 1, 1},
{&__pyx_n_u_learn_tokens, __pyx_k_learn_tokens, sizeof(__pyx_k_learn_tokens), 0, 1, 0, 1},
{&__pyx_n_u_left_labels, __pyx_k_left_labels, sizeof(__pyx_k_left_labels), 0, 1, 0, 1},
{&__pyx_n_s_main, __pyx_k_main, sizeof(__pyx_k_main), 0, 0, 1, 1},
{&__pyx_n_s_memview, __pyx_k_memview, sizeof(__pyx_k_memview), 0, 0, 1, 1},
{&__pyx_n_u_min_freq, __pyx_k_min_freq, sizeof(__pyx_k_min_freq), 0, 1, 0, 1},
{&__pyx_n_s_mode, __pyx_k_mode, sizeof(__pyx_k_mode), 0, 0, 1, 1},
{&__pyx_n_s_move, __pyx_k_move, sizeof(__pyx_k_move), 0, 0, 1, 1},
{&__pyx_n_s_move_name, __pyx_k_move_name, sizeof(__pyx_k_move_name), 0, 0, 1, 1},
{&__pyx_n_s_n_actions, __pyx_k_n_actions, sizeof(__pyx_k_n_actions), 0, 0, 1, 1},
{&__pyx_n_s_name, __pyx_k_name, sizeof(__pyx_k_name), 0, 0, 1, 1},
{&__pyx_n_s_name_2, __pyx_k_name_2, sizeof(__pyx_k_name_2), 0, 0, 1, 1},
{&__pyx_n_s_ndim, __pyx_k_ndim, sizeof(__pyx_k_ndim), 0, 0, 1, 1},
{&__pyx_n_s_new, __pyx_k_new, sizeof(__pyx_k_new), 0, 0, 1, 1},
{&__pyx_kp_s_no_default___reduce___due_to_non, __pyx_k_no_default___reduce___due_to_non, sizeof(__pyx_k_no_default___reduce___due_to_non), 0, 0, 1, 0},
{&__pyx_n_s_nonproj, __pyx_k_nonproj, sizeof(__pyx_k_nonproj), 0, 0, 1, 1},
{&__pyx_kp_s_numpy_core_multiarray_failed_to, __pyx_k_numpy_core_multiarray_failed_to, sizeof(__pyx_k_numpy_core_multiarray_failed_to), 0, 0, 1, 0},
{&__pyx_kp_s_numpy_core_umath_failed_to_impor, __pyx_k_numpy_core_umath_failed_to_impor, sizeof(__pyx_k_numpy_core_umath_failed_to_impor), 0, 0, 1, 0},
{&__pyx_n_s_obj, __pyx_k_obj, sizeof(__pyx_k_obj), 0, 0, 1, 1},
{&__pyx_n_s_pack, __pyx_k_pack, sizeof(__pyx_k_pack), 0, 0, 1, 1},
{&__pyx_n_s_pickle, __pyx_k_pickle, sizeof(__pyx_k_pickle), 0, 0, 1, 1},
{&__pyx_n_s_pop, __pyx_k_pop, sizeof(__pyx_k_pop), 0, 0, 1, 1},
{&__pyx_n_s_print_state, __pyx_k_print_state, sizeof(__pyx_k_print_state), 0, 0, 1, 1},
{&__pyx_n_s_probs, __pyx_k_probs, sizeof(__pyx_k_probs), 0, 0, 1, 1},
{&__pyx_n_s_projectivize, __pyx_k_projectivize, sizeof(__pyx_k_projectivize), 0, 0, 1, 1},
{&__pyx_n_s_pyx_PickleError, __pyx_k_pyx_PickleError, sizeof(__pyx_k_pyx_PickleError), 0, 0, 1, 1},
{&__pyx_n_s_pyx_checksum, __pyx_k_pyx_checksum, sizeof(__pyx_k_pyx_checksum), 0, 0, 1, 1},
{&__pyx_n_s_pyx_getbuffer, __pyx_k_pyx_getbuffer, sizeof(__pyx_k_pyx_getbuffer), 0, 0, 1, 1},
{&__pyx_n_s_pyx_result, __pyx_k_pyx_result, sizeof(__pyx_k_pyx_result), 0, 0, 1, 1},
{&__pyx_n_s_pyx_state, __pyx_k_pyx_state, sizeof(__pyx_k_pyx_state), 0, 0, 1, 1},
{&__pyx_n_s_pyx_type, __pyx_k_pyx_type, sizeof(__pyx_k_pyx_type), 0, 0, 1, 1},
{&__pyx_n_s_pyx_unpickle_Break, __pyx_k_pyx_unpickle_Break, sizeof(__pyx_k_pyx_unpickle_Break), 0, 0, 1, 1},
{&__pyx_n_s_pyx_unpickle_Enum, __pyx_k_pyx_unpickle_Enum, sizeof(__pyx_k_pyx_unpickle_Enum), 0, 0, 1, 1},
{&__pyx_n_s_pyx_unpickle_LeftArc, __pyx_k_pyx_unpickle_LeftArc, sizeof(__pyx_k_pyx_unpickle_LeftArc), 0, 0, 1, 1},
{&__pyx_n_s_pyx_unpickle_Reduce, __pyx_k_pyx_unpickle_Reduce, sizeof(__pyx_k_pyx_unpickle_Reduce), 0, 0, 1, 1},
{&__pyx_n_s_pyx_unpickle_RightArc, __pyx_k_pyx_unpickle_RightArc, sizeof(__pyx_k_pyx_unpickle_RightArc), 0, 0, 1, 1},
{&__pyx_n_s_pyx_unpickle_Shift, __pyx_k_pyx_unpickle_Shift, sizeof(__pyx_k_pyx_unpickle_Shift), 0, 0, 1, 1},
{&__pyx_n_s_pyx_vtable, __pyx_k_pyx_vtable, sizeof(__pyx_k_pyx_vtable), 0, 0, 1, 1},
{&__pyx_n_s_range, __pyx_k_range, sizeof(__pyx_k_range), 0, 0, 1, 1},
{&__pyx_n_s_reduce, __pyx_k_reduce, sizeof(__pyx_k_reduce), 0, 0, 1, 1},
{&__pyx_n_s_reduce_cython, __pyx_k_reduce_cython, sizeof(__pyx_k_reduce_cython), 0, 0, 1, 1},
{&__pyx_n_s_reduce_ex, __pyx_k_reduce_ex, sizeof(__pyx_k_reduce_ex), 0, 0, 1, 1},
{&__pyx_n_u_right_labels, __pyx_k_right_labels, sizeof(__pyx_k_right_labels), 0, 1, 0, 1},
{&__pyx_kp_s_self_c_self_del_beam_state_self, __pyx_k_self_c_self_del_beam_state_self, sizeof(__pyx_k_self_c_self_del_beam_state_self), 0, 0, 1, 0},
{&__pyx_n_s_setdefault, __pyx_k_setdefault, sizeof(__pyx_k_setdefault), 0, 0, 1, 1},
{&__pyx_n_s_setstate, __pyx_k_setstate, sizeof(__pyx_k_setstate), 0, 0, 1, 1},
{&__pyx_n_s_setstate_cython, __pyx_k_setstate_cython, sizeof(__pyx_k_setstate_cython), 0, 0, 1, 1},
{&__pyx_n_s_shape, __pyx_k_shape, sizeof(__pyx_k_shape), 0, 0, 1, 1},
{&__pyx_n_s_size, __pyx_k_size, sizeof(__pyx_k_size), 0, 0, 1, 1},
{&__pyx_n_s_spacy_syntax_arc_eager, __pyx_k_spacy_syntax_arc_eager, sizeof(__pyx_k_spacy_syntax_arc_eager), 0, 0, 1, 1},
{&__pyx_n_s_split, __pyx_k_split, sizeof(__pyx_k_split), 0, 0, 1, 1},
{&__pyx_n_s_src, __pyx_k_src, sizeof(__pyx_k_src), 0, 0, 1, 1},
{&__pyx_n_s_start, __pyx_k_start, sizeof(__pyx_k_start), 0, 0, 1, 1},
{&__pyx_n_s_state, __pyx_k_state, sizeof(__pyx_k_state), 0, 0, 1, 1},
{&__pyx_n_s_step, __pyx_k_step, sizeof(__pyx_k_step), 0, 0, 1, 1},
{&__pyx_n_s_stop, __pyx_k_stop, sizeof(__pyx_k_stop), 0, 0, 1, 1},
{&__pyx_kp_s_strided_and_direct, __pyx_k_strided_and_direct, sizeof(__pyx_k_strided_and_direct), 0, 0, 1, 0},
{&__pyx_kp_s_strided_and_direct_or_indirect, __pyx_k_strided_and_direct_or_indirect, sizeof(__pyx_k_strided_and_direct_or_indirect), 0, 0, 1, 0},
{&__pyx_kp_s_strided_and_indirect, __pyx_k_strided_and_indirect, sizeof(__pyx_k_strided_and_indirect), 0, 0, 1, 0},
{&__pyx_kp_s_stringsource, __pyx_k_stringsource, sizeof(__pyx_k_stringsource), 0, 0, 1, 0},
{&__pyx_n_s_struct, __pyx_k_struct, sizeof(__pyx_k_struct), 0, 0, 1, 1},
{&__pyx_n_u_subtok, __pyx_k_subtok, sizeof(__pyx_k_subtok), 0, 1, 0, 1},
{&__pyx_n_s_test, __pyx_k_test, sizeof(__pyx_k_test), 0, 0, 1, 1},
{&__pyx_kp_s_unable_to_allocate_array_data, __pyx_k_unable_to_allocate_array_data, sizeof(__pyx_k_unable_to_allocate_array_data), 0, 0, 1, 0},
{&__pyx_kp_s_unable_to_allocate_shape_and_str, __pyx_k_unable_to_allocate_shape_and_str, sizeof(__pyx_k_unable_to_allocate_shape_and_str), 0, 0, 1, 0},
{&__pyx_kp_u_unknown_dtype_code_in_numpy_pxd, __pyx_k_unknown_dtype_code_in_numpy_pxd, sizeof(__pyx_k_unknown_dtype_code_in_numpy_pxd), 0, 1, 0, 0},
{&__pyx_n_s_unpack, __pyx_k_unpack, sizeof(__pyx_k_unpack), 0, 0, 1, 1},
{&__pyx_n_s_update, __pyx_k_update, sizeof(__pyx_k_update), 0, 0, 1, 1},
{&__pyx_n_s_upper, __pyx_k_upper, sizeof(__pyx_k_upper), 0, 0, 1, 1},
{&__pyx_n_s_zip, __pyx_k_zip, sizeof(__pyx_k_zip), 0, 0, 1, 1},
{0, 0, 0, 0, 0, 0, 0}
};
static CYTHON_SMALL_CODE int __Pyx_InitCachedBuiltins(void) {
__pyx_builtin_range = __Pyx_GetBuiltinName(__pyx_n_s_range); if (!__pyx_builtin_range) __PYX_ERR(0, 59, __pyx_L1_error)
__pyx_builtin_zip = __Pyx_GetBuiltinName(__pyx_n_s_zip); if (!__pyx_builtin_zip) __PYX_ERR(0, 353, __pyx_L1_error)
__pyx_builtin_all = __Pyx_GetBuiltinName(__pyx_n_s_all); if (!__pyx_builtin_all) __PYX_ERR(0, 412, __pyx_L1_error)
__pyx_builtin_enumerate = __Pyx_GetBuiltinName(__pyx_n_s_enumerate); if (!__pyx_builtin_enumerate) __PYX_ERR(0, 426, __pyx_L1_error)
__pyx_builtin_ValueError = __Pyx_GetBuiltinName(__pyx_n_s_ValueError); if (!__pyx_builtin_ValueError) __PYX_ERR(0, 533, __pyx_L1_error)
__pyx_builtin_TypeError = __Pyx_GetBuiltinName(__pyx_n_s_TypeError); if (!__pyx_builtin_TypeError) __PYX_ERR(1, 2, __pyx_L1_error)
__pyx_builtin_RuntimeError = __Pyx_GetBuiltinName(__pyx_n_s_RuntimeError); if (!__pyx_builtin_RuntimeError) __PYX_ERR(2, 777, __pyx_L1_error)
__pyx_builtin_ImportError = __Pyx_GetBuiltinName(__pyx_n_s_ImportError); if (!__pyx_builtin_ImportError) __PYX_ERR(2, 959, __pyx_L1_error)
__pyx_builtin_MemoryError = __Pyx_GetBuiltinName(__pyx_n_s_MemoryError); if (!__pyx_builtin_MemoryError) __PYX_ERR(4, 63, __pyx_L1_error)
__pyx_builtin_Ellipsis = __Pyx_GetBuiltinName(__pyx_n_s_Ellipsis); if (!__pyx_builtin_Ellipsis) __PYX_ERR(1, 404, __pyx_L1_error)
__pyx_builtin_id = __Pyx_GetBuiltinName(__pyx_n_s_id); if (!__pyx_builtin_id) __PYX_ERR(1, 613, __pyx_L1_error)
__pyx_builtin_IndexError = __Pyx_GetBuiltinName(__pyx_n_s_IndexError); if (!__pyx_builtin_IndexError) __PYX_ERR(1, 832, __pyx_L1_error)
return 0;
__pyx_L1_error:;
return -1;
}
static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) {
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("__Pyx_InitCachedConstants", 0);
/* "spacy/syntax/arc_eager.pyx":370
* label_freqs.pop(label)
* # Ensure these actions are present
* actions[BREAK].setdefault('ROOT', 0) # <<<<<<<<<<<<<<
* if kwargs.get("learn_tokens") is True:
* actions[RIGHT].setdefault('subtok', 0)
*/
__pyx_tuple__2 = PyTuple_Pack(2, __pyx_n_u_ROOT, __pyx_int_0); if (unlikely(!__pyx_tuple__2)) __PYX_ERR(0, 370, __pyx_L1_error)
__Pyx_GOTREF(__pyx_tuple__2);
__Pyx_GIVEREF(__pyx_tuple__2);
/* "spacy/syntax/arc_eager.pyx":372
* actions[BREAK].setdefault('ROOT', 0)
* if kwargs.get("learn_tokens") is True:
* actions[RIGHT].setdefault('subtok', 0) # <<<<<<<<<<<<<<
* actions[LEFT].setdefault('subtok', 0)
* # Used for backoff
*/
__pyx_tuple__3 = PyTuple_Pack(2, __pyx_n_u_subtok, __pyx_int_0); if (unlikely(!__pyx_tuple__3)) __PYX_ERR(0, 372, __pyx_L1_error)
__Pyx_GOTREF(__pyx_tuple__3);
__Pyx_GIVEREF(__pyx_tuple__3);
/* "spacy/syntax/arc_eager.pyx":375
* actions[LEFT].setdefault('subtok', 0)
* # Used for backoff
* actions[RIGHT].setdefault('dep', 0) # <<<<<<<<<<<<<<
* actions[LEFT].setdefault('dep', 0)
* return actions
*/
__pyx_tuple__4 = PyTuple_Pack(2, __pyx_n_u_dep, __pyx_int_0); if (unlikely(!__pyx_tuple__4)) __PYX_ERR(0, 375, __pyx_L1_error)
__Pyx_GOTREF(__pyx_tuple__4);
__Pyx_GIVEREF(__pyx_tuple__4);
/* "spacy/syntax/arc_eager.pyx":483
* name = name_or_id
* if '-' in name:
* move_str, label_str = name.split('-', 1) # <<<<<<<<<<<<<<
* label = self.strings[label_str]
* else:
*/
__pyx_tuple__6 = PyTuple_Pack(2, __pyx_kp_u__5, __pyx_int_1); if (unlikely(!__pyx_tuple__6)) __PYX_ERR(0, 483, __pyx_L1_error)
__Pyx_GOTREF(__pyx_tuple__6);
__Pyx_GIVEREF(__pyx_tuple__6);
/* "(tree fragment)":2
* def __reduce_cython__(self):
* raise TypeError("self.c,self.del_beam_state,self.init_beam_state cannot be converted to a Python object for pickling") # <<<<<<<<<<<<<<
* def __setstate_cython__(self, __pyx_state):
* raise TypeError("self.c,self.del_beam_state,self.init_beam_state cannot be converted to a Python object for pickling")
*/
__pyx_tuple__7 = PyTuple_Pack(1, __pyx_kp_s_self_c_self_del_beam_state_self); if (unlikely(!__pyx_tuple__7)) __PYX_ERR(1, 2, __pyx_L1_error)
__Pyx_GOTREF(__pyx_tuple__7);
__Pyx_GIVEREF(__pyx_tuple__7);
/* "(tree fragment)":4
* raise TypeError("self.c,self.del_beam_state,self.init_beam_state cannot be converted to a Python object for pickling")
* def __setstate_cython__(self, __pyx_state):
* raise TypeError("self.c,self.del_beam_state,self.init_beam_state cannot be converted to a Python object for pickling") # <<<<<<<<<<<<<<
*/
__pyx_tuple__8 = PyTuple_Pack(1, __pyx_kp_s_self_c_self_del_beam_state_self); if (unlikely(!__pyx_tuple__8)) __PYX_ERR(1, 4, __pyx_L1_error)
__Pyx_GOTREF(__pyx_tuple__8);
__Pyx_GIVEREF(__pyx_tuple__8);
/* "../../../../opt/python/cp37-cp37m/lib/python3.7/site-packages/numpy/__init__.pxd":777
*
* if (end - f) - <int>(new_offset - offset[0]) < 15:
* raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd") # <<<<<<<<<<<<<<
*
* if ((child.byteorder == c'>' and little_endian) or
*/
__pyx_tuple__14 = PyTuple_Pack(1, __pyx_kp_u_Format_string_allocated_too_shor); if (unlikely(!__pyx_tuple__14)) __PYX_ERR(2, 777, __pyx_L1_error)
__Pyx_GOTREF(__pyx_tuple__14);
__Pyx_GIVEREF(__pyx_tuple__14);
/* "../../../../opt/python/cp37-cp37m/lib/python3.7/site-packages/numpy/__init__.pxd":781
* if ((child.byteorder == c'>' and little_endian) or
* (child.byteorder == c'<' and not little_endian)):
* raise ValueError(u"Non-native byte order not supported") # <<<<<<<<<<<<<<
* # One could encode it in the format string and have Cython
* # complain instead, BUT: < and > in format strings also imply
*/
__pyx_tuple__15 = PyTuple_Pack(1, __pyx_kp_u_Non_native_byte_order_not_suppor); if (unlikely(!__pyx_tuple__15)) __PYX_ERR(2, 781, __pyx_L1_error)
__Pyx_GOTREF(__pyx_tuple__15);
__Pyx_GIVEREF(__pyx_tuple__15);
/* "../../../../opt/python/cp37-cp37m/lib/python3.7/site-packages/numpy/__init__.pxd":801
* t = child.type_num
* if end - f < 5:
* raise RuntimeError(u"Format string allocated too short.") # <<<<<<<<<<<<<<
*
* # Until ticket #99 is fixed, use integers to avoid warnings
*/
__pyx_tuple__16 = PyTuple_Pack(1, __pyx_kp_u_Format_string_allocated_too_shor_2); if (unlikely(!__pyx_tuple__16)) __PYX_ERR(2, 801, __pyx_L1_error)
__Pyx_GOTREF(__pyx_tuple__16);
__Pyx_GIVEREF(__pyx_tuple__16);
/* "../../../../opt/python/cp37-cp37m/lib/python3.7/site-packages/numpy/__init__.pxd":959
* __pyx_import_array()
* except Exception:
* raise ImportError("numpy.core.multiarray failed to import") # <<<<<<<<<<<<<<
*
* cdef inline int import_umath() except -1:
*/
__pyx_tuple__17 = PyTuple_Pack(1, __pyx_kp_s_numpy_core_multiarray_failed_to); if (unlikely(!__pyx_tuple__17)) __PYX_ERR(2, 959, __pyx_L1_error)
__Pyx_GOTREF(__pyx_tuple__17);
__Pyx_GIVEREF(__pyx_tuple__17);
/* "../../../../opt/python/cp37-cp37m/lib/python3.7/site-packages/numpy/__init__.pxd":965
* _import_umath()
* except Exception:
* raise ImportError("numpy.core.umath failed to import") # <<<<<<<<<<<<<<
*
* cdef inline int import_ufunc() except -1:
*/
__pyx_tuple__18 = PyTuple_Pack(1, __pyx_kp_s_numpy_core_umath_failed_to_impor); if (unlikely(!__pyx_tuple__18)) __PYX_ERR(2, 965, __pyx_L1_error)
__Pyx_GOTREF(__pyx_tuple__18);
__Pyx_GIVEREF(__pyx_tuple__18);
/* "View.MemoryView":133
*
* if not self.ndim:
* raise ValueError("Empty shape tuple for cython.array") # <<<<<<<<<<<<<<
*
* if itemsize <= 0:
*/
__pyx_tuple__19 = PyTuple_Pack(1, __pyx_kp_s_Empty_shape_tuple_for_cython_arr); if (unlikely(!__pyx_tuple__19)) __PYX_ERR(1, 133, __pyx_L1_error)
__Pyx_GOTREF(__pyx_tuple__19);
__Pyx_GIVEREF(__pyx_tuple__19);
/* "View.MemoryView":136
*
* if itemsize <= 0:
* raise ValueError("itemsize <= 0 for cython.array") # <<<<<<<<<<<<<<
*
* if not isinstance(format, bytes):
*/
__pyx_tuple__20 = PyTuple_Pack(1, __pyx_kp_s_itemsize_0_for_cython_array); if (unlikely(!__pyx_tuple__20)) __PYX_ERR(1, 136, __pyx_L1_error)
__Pyx_GOTREF(__pyx_tuple__20);
__Pyx_GIVEREF(__pyx_tuple__20);
/* "View.MemoryView":148
*
* if not self._shape:
* raise MemoryError("unable to allocate shape and strides.") # <<<<<<<<<<<<<<
*
*
*/
__pyx_tuple__21 = PyTuple_Pack(1, __pyx_kp_s_unable_to_allocate_shape_and_str); if (unlikely(!__pyx_tuple__21)) __PYX_ERR(1, 148, __pyx_L1_error)
__Pyx_GOTREF(__pyx_tuple__21);
__Pyx_GIVEREF(__pyx_tuple__21);
/* "View.MemoryView":176
* self.data = <char *>malloc(self.len)
* if not self.data:
* raise MemoryError("unable to allocate array data.") # <<<<<<<<<<<<<<
*
* if self.dtype_is_object:
*/
__pyx_tuple__22 = PyTuple_Pack(1, __pyx_kp_s_unable_to_allocate_array_data); if (unlikely(!__pyx_tuple__22)) __PYX_ERR(1, 176, __pyx_L1_error)
__Pyx_GOTREF(__pyx_tuple__22);
__Pyx_GIVEREF(__pyx_tuple__22);
/* "View.MemoryView":192
* bufmode = PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS
* if not (flags & bufmode):
* raise ValueError("Can only create a buffer that is contiguous in memory.") # <<<<<<<<<<<<<<
* info.buf = self.data
* info.len = self.len
*/
__pyx_tuple__23 = PyTuple_Pack(1, __pyx_kp_s_Can_only_create_a_buffer_that_is); if (unlikely(!__pyx_tuple__23)) __PYX_ERR(1, 192, __pyx_L1_error)
__Pyx_GOTREF(__pyx_tuple__23);
__Pyx_GIVEREF(__pyx_tuple__23);
/* "(tree fragment)":2
* def __reduce_cython__(self):
* raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<<
* def __setstate_cython__(self, __pyx_state):
* raise TypeError("no default __reduce__ due to non-trivial __cinit__")
*/
__pyx_tuple__24 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__24)) __PYX_ERR(1, 2, __pyx_L1_error)
__Pyx_GOTREF(__pyx_tuple__24);
__Pyx_GIVEREF(__pyx_tuple__24);
/* "(tree fragment)":4
* raise TypeError("no default __reduce__ due to non-trivial __cinit__")
* def __setstate_cython__(self, __pyx_state):
* raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<<
*/
__pyx_tuple__25 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__25)) __PYX_ERR(1, 4, __pyx_L1_error)
__Pyx_GOTREF(__pyx_tuple__25);
__Pyx_GIVEREF(__pyx_tuple__25);
/* "View.MemoryView":418
* def __setitem__(memoryview self, object index, object value):
* if self.view.readonly:
* raise TypeError("Cannot assign to read-only memoryview") # <<<<<<<<<<<<<<
*
* have_slices, index = _unellipsify(index, self.view.ndim)
*/
__pyx_tuple__26 = PyTuple_Pack(1, __pyx_kp_s_Cannot_assign_to_read_only_memor); if (unlikely(!__pyx_tuple__26)) __PYX_ERR(1, 418, __pyx_L1_error)
__Pyx_GOTREF(__pyx_tuple__26);
__Pyx_GIVEREF(__pyx_tuple__26);
/* "View.MemoryView":495
* result = struct.unpack(self.view.format, bytesitem)
* except struct.error:
* raise ValueError("Unable to convert item to object") # <<<<<<<<<<<<<<
* else:
* if len(self.view.format) == 1:
*/
__pyx_tuple__27 = PyTuple_Pack(1, __pyx_kp_s_Unable_to_convert_item_to_object); if (unlikely(!__pyx_tuple__27)) __PYX_ERR(1, 495, __pyx_L1_error)
__Pyx_GOTREF(__pyx_tuple__27);
__Pyx_GIVEREF(__pyx_tuple__27);
/* "View.MemoryView":520
* def __getbuffer__(self, Py_buffer *info, int flags):
* if flags & PyBUF_WRITABLE and self.view.readonly:
* raise ValueError("Cannot create writable memory view from read-only memoryview") # <<<<<<<<<<<<<<
*
* if flags & PyBUF_ND:
*/
__pyx_tuple__28 = PyTuple_Pack(1, __pyx_kp_s_Cannot_create_writable_memory_vi); if (unlikely(!__pyx_tuple__28)) __PYX_ERR(1, 520, __pyx_L1_error)
__Pyx_GOTREF(__pyx_tuple__28);
__Pyx_GIVEREF(__pyx_tuple__28);
/* "View.MemoryView":570
* if self.view.strides == NULL:
*
* raise ValueError("Buffer view does not expose strides") # <<<<<<<<<<<<<<
*
* return tuple([stride for stride in self.view.strides[:self.view.ndim]])
*/
__pyx_tuple__29 = PyTuple_Pack(1, __pyx_kp_s_Buffer_view_does_not_expose_stri); if (unlikely(!__pyx_tuple__29)) __PYX_ERR(1, 570, __pyx_L1_error)
__Pyx_GOTREF(__pyx_tuple__29);
__Pyx_GIVEREF(__pyx_tuple__29);
/* "View.MemoryView":577
* def suboffsets(self):
* if self.view.suboffsets == NULL:
* return (-1,) * self.view.ndim # <<<<<<<<<<<<<<
*
* return tuple([suboffset for suboffset in self.view.suboffsets[:self.view.ndim]])
*/
__pyx_tuple__30 = PyTuple_New(1); if (unlikely(!__pyx_tuple__30)) __PYX_ERR(1, 577, __pyx_L1_error)
__Pyx_GOTREF(__pyx_tuple__30);
__Pyx_INCREF(__pyx_int_neg_1);
__Pyx_GIVEREF(__pyx_int_neg_1);
PyTuple_SET_ITEM(__pyx_tuple__30, 0, __pyx_int_neg_1);
__Pyx_GIVEREF(__pyx_tuple__30);
/* "(tree fragment)":2
* def __reduce_cython__(self):
* raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<<
* def __setstate_cython__(self, __pyx_state):
* raise TypeError("no default __reduce__ due to non-trivial __cinit__")
*/
__pyx_tuple__31 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__31)) __PYX_ERR(1, 2, __pyx_L1_error)
__Pyx_GOTREF(__pyx_tuple__31);
__Pyx_GIVEREF(__pyx_tuple__31);
/* "(tree fragment)":4
* raise TypeError("no default __reduce__ due to non-trivial __cinit__")
* def __setstate_cython__(self, __pyx_state):
* raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<<
*/
__pyx_tuple__32 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__32)) __PYX_ERR(1, 4, __pyx_L1_error)
__Pyx_GOTREF(__pyx_tuple__32);
__Pyx_GIVEREF(__pyx_tuple__32);
/* "View.MemoryView":682
* if item is Ellipsis:
* if not seen_ellipsis:
* result.extend([slice(None)] * (ndim - len(tup) + 1)) # <<<<<<<<<<<<<<
* seen_ellipsis = True
* else:
*/
__pyx_slice__33 = PySlice_New(Py_None, Py_None, Py_None); if (unlikely(!__pyx_slice__33)) __PYX_ERR(1, 682, __pyx_L1_error)
__Pyx_GOTREF(__pyx_slice__33);
__Pyx_GIVEREF(__pyx_slice__33);
/* "View.MemoryView":703
* for suboffset in suboffsets[:ndim]:
* if suboffset >= 0:
* raise ValueError("Indirect dimensions not supported") # <<<<<<<<<<<<<<
*
*
*/
__pyx_tuple__34 = PyTuple_Pack(1, __pyx_kp_s_Indirect_dimensions_not_supporte); if (unlikely(!__pyx_tuple__34)) __PYX_ERR(1, 703, __pyx_L1_error)
__Pyx_GOTREF(__pyx_tuple__34);
__Pyx_GIVEREF(__pyx_tuple__34);
/* "(tree fragment)":2
* def __reduce_cython__(self):
* raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<<
* def __setstate_cython__(self, __pyx_state):
* raise TypeError("no default __reduce__ due to non-trivial __cinit__")
*/
__pyx_tuple__35 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__35)) __PYX_ERR(1, 2, __pyx_L1_error)
__Pyx_GOTREF(__pyx_tuple__35);
__Pyx_GIVEREF(__pyx_tuple__35);
/* "(tree fragment)":4
* raise TypeError("no default __reduce__ due to non-trivial __cinit__")
* def __setstate_cython__(self, __pyx_state):
* raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<<
*/
__pyx_tuple__36 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__36)) __PYX_ERR(1, 4, __pyx_L1_error)
__Pyx_GOTREF(__pyx_tuple__36);
__Pyx_GIVEREF(__pyx_tuple__36);
/* "(tree fragment)":1
* def __pyx_unpickle_Shift(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<<
* cdef object __pyx_PickleError
* cdef object __pyx_result
*/
__pyx_tuple__38 = PyTuple_Pack(5, __pyx_n_s_pyx_type, __pyx_n_s_pyx_checksum, __pyx_n_s_pyx_state, __pyx_n_s_pyx_PickleError, __pyx_n_s_pyx_result); if (unlikely(!__pyx_tuple__38)) __PYX_ERR(1, 1, __pyx_L1_error)
__Pyx_GOTREF(__pyx_tuple__38);
__Pyx_GIVEREF(__pyx_tuple__38);
__pyx_codeobj__9 = (PyObject*)__Pyx_PyCode_New(3, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__38, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_pyx_unpickle_Shift, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__9)) __PYX_ERR(1, 1, __pyx_L1_error)
__pyx_tuple__39 = PyTuple_Pack(5, __pyx_n_s_pyx_type, __pyx_n_s_pyx_checksum, __pyx_n_s_pyx_state, __pyx_n_s_pyx_PickleError, __pyx_n_s_pyx_result); if (unlikely(!__pyx_tuple__39)) __PYX_ERR(1, 1, __pyx_L1_error)
__Pyx_GOTREF(__pyx_tuple__39);
__Pyx_GIVEREF(__pyx_tuple__39);
__pyx_codeobj__10 = (PyObject*)__Pyx_PyCode_New(3, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__39, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_pyx_unpickle_Reduce, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__10)) __PYX_ERR(1, 1, __pyx_L1_error)
__pyx_tuple__40 = PyTuple_Pack(5, __pyx_n_s_pyx_type, __pyx_n_s_pyx_checksum, __pyx_n_s_pyx_state, __pyx_n_s_pyx_PickleError, __pyx_n_s_pyx_result); if (unlikely(!__pyx_tuple__40)) __PYX_ERR(1, 1, __pyx_L1_error)
__Pyx_GOTREF(__pyx_tuple__40);
__Pyx_GIVEREF(__pyx_tuple__40);
__pyx_codeobj__11 = (PyObject*)__Pyx_PyCode_New(3, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__40, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_pyx_unpickle_LeftArc, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__11)) __PYX_ERR(1, 1, __pyx_L1_error)
__pyx_tuple__41 = PyTuple_Pack(5, __pyx_n_s_pyx_type, __pyx_n_s_pyx_checksum, __pyx_n_s_pyx_state, __pyx_n_s_pyx_PickleError, __pyx_n_s_pyx_result); if (unlikely(!__pyx_tuple__41)) __PYX_ERR(1, 1, __pyx_L1_error)
__Pyx_GOTREF(__pyx_tuple__41);
__Pyx_GIVEREF(__pyx_tuple__41);
__pyx_codeobj__12 = (PyObject*)__Pyx_PyCode_New(3, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__41, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_pyx_unpickle_RightArc, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__12)) __PYX_ERR(1, 1, __pyx_L1_error)
__pyx_tuple__42 = PyTuple_Pack(5, __pyx_n_s_pyx_type, __pyx_n_s_pyx_checksum, __pyx_n_s_pyx_state, __pyx_n_s_pyx_PickleError, __pyx_n_s_pyx_result); if (unlikely(!__pyx_tuple__42)) __PYX_ERR(1, 1, __pyx_L1_error)
__Pyx_GOTREF(__pyx_tuple__42);
__Pyx_GIVEREF(__pyx_tuple__42);
__pyx_codeobj__13 = (PyObject*)__Pyx_PyCode_New(3, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__42, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_pyx_unpickle_Break, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__13)) __PYX_ERR(1, 1, __pyx_L1_error)
/* "View.MemoryView":286
* return self.name
*
* cdef generic = Enum("<strided and direct or indirect>") # <<<<<<<<<<<<<<
* cdef strided = Enum("<strided and direct>") # default
* cdef indirect = Enum("<strided and indirect>")
*/
__pyx_tuple__43 = PyTuple_Pack(1, __pyx_kp_s_strided_and_direct_or_indirect); if (unlikely(!__pyx_tuple__43)) __PYX_ERR(1, 286, __pyx_L1_error)
__Pyx_GOTREF(__pyx_tuple__43);
__Pyx_GIVEREF(__pyx_tuple__43);
/* "View.MemoryView":287
*
* cdef generic = Enum("<strided and direct or indirect>")
* cdef strided = Enum("<strided and direct>") # default # <<<<<<<<<<<<<<
* cdef indirect = Enum("<strided and indirect>")
*
*/
__pyx_tuple__44 = PyTuple_Pack(1, __pyx_kp_s_strided_and_direct); if (unlikely(!__pyx_tuple__44)) __PYX_ERR(1, 287, __pyx_L1_error)
__Pyx_GOTREF(__pyx_tuple__44);
__Pyx_GIVEREF(__pyx_tuple__44);
/* "View.MemoryView":288
* cdef generic = Enum("<strided and direct or indirect>")
* cdef strided = Enum("<strided and direct>") # default
* cdef indirect = Enum("<strided and indirect>") # <<<<<<<<<<<<<<
*
*
*/
__pyx_tuple__45 = PyTuple_Pack(1, __pyx_kp_s_strided_and_indirect); if (unlikely(!__pyx_tuple__45)) __PYX_ERR(1, 288, __pyx_L1_error)
__Pyx_GOTREF(__pyx_tuple__45);
__Pyx_GIVEREF(__pyx_tuple__45);
/* "View.MemoryView":291
*
*
* cdef contiguous = Enum("<contiguous and direct>") # <<<<<<<<<<<<<<
* cdef indirect_contiguous = Enum("<contiguous and indirect>")
*
*/
__pyx_tuple__46 = PyTuple_Pack(1, __pyx_kp_s_contiguous_and_direct); if (unlikely(!__pyx_tuple__46)) __PYX_ERR(1, 291, __pyx_L1_error)
__Pyx_GOTREF(__pyx_tuple__46);
__Pyx_GIVEREF(__pyx_tuple__46);
/* "View.MemoryView":292
*
* cdef contiguous = Enum("<contiguous and direct>")
* cdef indirect_contiguous = Enum("<contiguous and indirect>") # <<<<<<<<<<<<<<
*
*
*/
__pyx_tuple__47 = PyTuple_Pack(1, __pyx_kp_s_contiguous_and_indirect); if (unlikely(!__pyx_tuple__47)) __PYX_ERR(1, 292, __pyx_L1_error)
__Pyx_GOTREF(__pyx_tuple__47);
__Pyx_GIVEREF(__pyx_tuple__47);
/* "(tree fragment)":1
* def __pyx_unpickle_Enum(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<<
* cdef object __pyx_PickleError
* cdef object __pyx_result
*/
__pyx_tuple__48 = PyTuple_Pack(5, __pyx_n_s_pyx_type, __pyx_n_s_pyx_checksum, __pyx_n_s_pyx_state, __pyx_n_s_pyx_PickleError, __pyx_n_s_pyx_result); if (unlikely(!__pyx_tuple__48)) __PYX_ERR(1, 1, __pyx_L1_error)
__Pyx_GOTREF(__pyx_tuple__48);
__Pyx_GIVEREF(__pyx_tuple__48);
__pyx_codeobj__37 = (PyObject*)__Pyx_PyCode_New(3, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__48, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_pyx_unpickle_Enum, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__37)) __PYX_ERR(1, 1, __pyx_L1_error)
__Pyx_RefNannyFinishContext();
return 0;
__pyx_L1_error:;
__Pyx_RefNannyFinishContext();
return -1;
}
static CYTHON_SMALL_CODE int __Pyx_InitGlobals(void) {
__pyx_umethod_PyDict_Type_get.type = (PyObject*)&PyDict_Type;
if (__Pyx_InitStrings(__pyx_string_tab) < 0) __PYX_ERR(0, 1, __pyx_L1_error);
__pyx_float_0_0 = PyFloat_FromDouble(0.0); if (unlikely(!__pyx_float_0_0)) __PYX_ERR(0, 1, __pyx_L1_error)
__pyx_int_0 = PyInt_FromLong(0); if (unlikely(!__pyx_int_0)) __PYX_ERR(0, 1, __pyx_L1_error)
__pyx_int_1 = PyInt_FromLong(1); if (unlikely(!__pyx_int_1)) __PYX_ERR(0, 1, __pyx_L1_error)
__pyx_int_9000 = PyInt_FromLong(9000); if (unlikely(!__pyx_int_9000)) __PYX_ERR(0, 1, __pyx_L1_error)
__pyx_int_184977713 = PyInt_FromLong(184977713L); if (unlikely(!__pyx_int_184977713)) __PYX_ERR(0, 1, __pyx_L1_error)
__pyx_int_222419149 = PyInt_FromLong(222419149L); if (unlikely(!__pyx_int_222419149)) __PYX_ERR(0, 1, __pyx_L1_error)
__pyx_int_neg_1 = PyInt_FromLong(-1); if (unlikely(!__pyx_int_neg_1)) __PYX_ERR(0, 1, __pyx_L1_error)
return 0;
__pyx_L1_error:;
return -1;
}
static CYTHON_SMALL_CODE int __Pyx_modinit_global_init_code(void); /*proto*/
static CYTHON_SMALL_CODE int __Pyx_modinit_variable_export_code(void); /*proto*/
static CYTHON_SMALL_CODE int __Pyx_modinit_function_export_code(void); /*proto*/
static CYTHON_SMALL_CODE int __Pyx_modinit_type_init_code(void); /*proto*/
static CYTHON_SMALL_CODE int __Pyx_modinit_type_import_code(void); /*proto*/
static CYTHON_SMALL_CODE int __Pyx_modinit_variable_import_code(void); /*proto*/
static CYTHON_SMALL_CODE int __Pyx_modinit_function_import_code(void); /*proto*/
static int __Pyx_modinit_global_init_code(void) {
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("__Pyx_modinit_global_init_code", 0);
/*--- Global init code ---*/
generic = Py_None; Py_INCREF(Py_None);
strided = Py_None; Py_INCREF(Py_None);
indirect = Py_None; Py_INCREF(Py_None);
contiguous = Py_None; Py_INCREF(Py_None);
indirect_contiguous = Py_None; Py_INCREF(Py_None);
__Pyx_RefNannyFinishContext();
return 0;
}
static int __Pyx_modinit_variable_export_code(void) {
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("__Pyx_modinit_variable_export_code", 0);
/*--- Variable export code ---*/
__Pyx_RefNannyFinishContext();
return 0;
}
static int __Pyx_modinit_function_export_code(void) {
__Pyx_RefNannyDeclarations
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("__Pyx_modinit_function_export_code", 0);
/*--- Function export code ---*/
if (__Pyx_ExportFunction("push_cost", (void (*)(void))__pyx_f_5spacy_6syntax_9arc_eager_push_cost, "__pyx_t_5thinc_8typedefs_weight_t (struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *, struct __pyx_t_5spacy_4gold_GoldParseC const *, int)") < 0) __PYX_ERR(0, 1, __pyx_L1_error)
if (__Pyx_ExportFunction("arc_cost", (void (*)(void))__pyx_f_5spacy_6syntax_9arc_eager_arc_cost, "__pyx_t_5thinc_8typedefs_weight_t (struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *, struct __pyx_t_5spacy_4gold_GoldParseC const *, int, int)") < 0) __PYX_ERR(0, 1, __pyx_L1_error)
__Pyx_RefNannyFinishContext();
return 0;
__pyx_L1_error:;
__Pyx_RefNannyFinishContext();
return -1;
}
static int __Pyx_modinit_type_init_code(void) {
__Pyx_RefNannyDeclarations
PyObject *__pyx_t_1 = NULL;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("__Pyx_modinit_type_init_code", 0);
/*--- Type init code ---*/
__pyx_t_1 = PyImport_ImportModule("spacy.syntax.transition_system"); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_ptype_5spacy_6syntax_17transition_system_TransitionSystem = __Pyx_ImportType(__pyx_t_1, "spacy.syntax.transition_system", "TransitionSystem", sizeof(struct __pyx_obj_5spacy_6syntax_17transition_system_TransitionSystem), __Pyx_ImportType_CheckSize_Warn);
if (!__pyx_ptype_5spacy_6syntax_17transition_system_TransitionSystem) __PYX_ERR(0, 1, __pyx_L1_error)
__pyx_vtabptr_5spacy_6syntax_17transition_system_TransitionSystem = (struct __pyx_vtabstruct_5spacy_6syntax_17transition_system_TransitionSystem*)__Pyx_GetVtable(__pyx_ptype_5spacy_6syntax_17transition_system_TransitionSystem->tp_dict); if (unlikely(!__pyx_vtabptr_5spacy_6syntax_17transition_system_TransitionSystem)) __PYX_ERR(0, 1, __pyx_L1_error)
__pyx_vtabptr_5spacy_6syntax_9arc_eager_ArcEager = &__pyx_vtable_5spacy_6syntax_9arc_eager_ArcEager;
__pyx_vtable_5spacy_6syntax_9arc_eager_ArcEager.__pyx_base = *__pyx_vtabptr_5spacy_6syntax_17transition_system_TransitionSystem;
__pyx_vtable_5spacy_6syntax_9arc_eager_ArcEager.__pyx_base.initialize_state = (int (*)(struct __pyx_obj_5spacy_6syntax_17transition_system_TransitionSystem *, __pyx_t_5spacy_6syntax_6_state_StateC *))__pyx_f_5spacy_6syntax_9arc_eager_8ArcEager_initialize_state;
__pyx_vtable_5spacy_6syntax_9arc_eager_ArcEager.__pyx_base.finalize_state = (int (*)(struct __pyx_obj_5spacy_6syntax_17transition_system_TransitionSystem *, __pyx_t_5spacy_6syntax_6_state_StateC *))__pyx_f_5spacy_6syntax_9arc_eager_8ArcEager_finalize_state;
__pyx_vtable_5spacy_6syntax_9arc_eager_ArcEager.__pyx_base.lookup_transition = (struct __pyx_t_5spacy_6syntax_17transition_system_Transition (*)(struct __pyx_obj_5spacy_6syntax_17transition_system_TransitionSystem *, PyObject *))__pyx_f_5spacy_6syntax_9arc_eager_8ArcEager_lookup_transition;
__pyx_vtable_5spacy_6syntax_9arc_eager_ArcEager.__pyx_base.init_transition = (struct __pyx_t_5spacy_6syntax_17transition_system_Transition (*)(struct __pyx_obj_5spacy_6syntax_17transition_system_TransitionSystem *, int, int, __pyx_t_5spacy_8typedefs_attr_t))__pyx_f_5spacy_6syntax_9arc_eager_8ArcEager_init_transition;
__pyx_vtable_5spacy_6syntax_9arc_eager_ArcEager.__pyx_base.set_valid = (int (*)(struct __pyx_obj_5spacy_6syntax_17transition_system_TransitionSystem *, int *, __pyx_t_5spacy_6syntax_6_state_StateC const *))__pyx_f_5spacy_6syntax_9arc_eager_8ArcEager_set_valid;
__pyx_vtable_5spacy_6syntax_9arc_eager_ArcEager.__pyx_base.set_costs = (int (*)(struct __pyx_obj_5spacy_6syntax_17transition_system_TransitionSystem *, int *, __pyx_t_5thinc_8typedefs_weight_t *, struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *, struct __pyx_obj_5spacy_4gold_GoldParse *))__pyx_f_5spacy_6syntax_9arc_eager_8ArcEager_set_costs;
__pyx_type_5spacy_6syntax_9arc_eager_ArcEager.tp_base = __pyx_ptype_5spacy_6syntax_17transition_system_TransitionSystem;
if (PyType_Ready(&__pyx_type_5spacy_6syntax_9arc_eager_ArcEager) < 0) __PYX_ERR(0, 332, __pyx_L1_error)
#if PY_VERSION_HEX < 0x030800B1
__pyx_type_5spacy_6syntax_9arc_eager_ArcEager.tp_print = 0;
#endif
if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_5spacy_6syntax_9arc_eager_ArcEager.tp_dictoffset && __pyx_type_5spacy_6syntax_9arc_eager_ArcEager.tp_getattro == PyObject_GenericGetAttr)) {
__pyx_type_5spacy_6syntax_9arc_eager_ArcEager.tp_getattro = __Pyx_PyObject_GenericGetAttr;
}
if (__Pyx_SetVtable(__pyx_type_5spacy_6syntax_9arc_eager_ArcEager.tp_dict, __pyx_vtabptr_5spacy_6syntax_9arc_eager_ArcEager) < 0) __PYX_ERR(0, 332, __pyx_L1_error)
if (PyObject_SetAttr(__pyx_m, __pyx_n_s_ArcEager, (PyObject *)&__pyx_type_5spacy_6syntax_9arc_eager_ArcEager) < 0) __PYX_ERR(0, 332, __pyx_L1_error)
if (__Pyx_setup_reduce((PyObject*)&__pyx_type_5spacy_6syntax_9arc_eager_ArcEager) < 0) __PYX_ERR(0, 332, __pyx_L1_error)
__pyx_ptype_5spacy_6syntax_9arc_eager_ArcEager = &__pyx_type_5spacy_6syntax_9arc_eager_ArcEager;
__pyx_vtabptr_5spacy_6syntax_9arc_eager_Shift = &__pyx_vtable_5spacy_6syntax_9arc_eager_Shift;
__pyx_vtable_5spacy_6syntax_9arc_eager_Shift.is_valid = (int (*)(__pyx_t_5spacy_6syntax_6_state_StateC const *, __pyx_t_5spacy_8typedefs_attr_t))__pyx_f_5spacy_6syntax_9arc_eager_5Shift_is_valid;
__pyx_vtable_5spacy_6syntax_9arc_eager_Shift.transition = (int (*)(__pyx_t_5spacy_6syntax_6_state_StateC *, __pyx_t_5spacy_8typedefs_attr_t))__pyx_f_5spacy_6syntax_9arc_eager_5Shift_transition;
__pyx_vtable_5spacy_6syntax_9arc_eager_Shift.cost = (__pyx_t_5thinc_8typedefs_weight_t (*)(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *, struct __pyx_t_5spacy_4gold_GoldParseC const *, __pyx_t_5spacy_8typedefs_attr_t))__pyx_f_5spacy_6syntax_9arc_eager_5Shift_cost;
__pyx_vtable_5spacy_6syntax_9arc_eager_Shift.move_cost = (__pyx_t_5thinc_8typedefs_weight_t (*)(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *, struct __pyx_t_5spacy_4gold_GoldParseC const *))__pyx_f_5spacy_6syntax_9arc_eager_5Shift_move_cost;
__pyx_vtable_5spacy_6syntax_9arc_eager_Shift.label_cost = (__pyx_t_5thinc_8typedefs_weight_t (*)(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *, struct __pyx_t_5spacy_4gold_GoldParseC const *, __pyx_t_5spacy_8typedefs_attr_t))__pyx_f_5spacy_6syntax_9arc_eager_5Shift_label_cost;
if (PyType_Ready(&__pyx_type_5spacy_6syntax_9arc_eager_Shift) < 0) __PYX_ERR(0, 122, __pyx_L1_error)
#if PY_VERSION_HEX < 0x030800B1
__pyx_type_5spacy_6syntax_9arc_eager_Shift.tp_print = 0;
#endif
if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_5spacy_6syntax_9arc_eager_Shift.tp_dictoffset && __pyx_type_5spacy_6syntax_9arc_eager_Shift.tp_getattro == PyObject_GenericGetAttr)) {
__pyx_type_5spacy_6syntax_9arc_eager_Shift.tp_getattro = __Pyx_PyObject_GenericGetAttr;
}
if (__Pyx_SetVtable(__pyx_type_5spacy_6syntax_9arc_eager_Shift.tp_dict, __pyx_vtabptr_5spacy_6syntax_9arc_eager_Shift) < 0) __PYX_ERR(0, 122, __pyx_L1_error)
if (PyObject_SetAttr(__pyx_m, __pyx_n_s_Shift, (PyObject *)&__pyx_type_5spacy_6syntax_9arc_eager_Shift) < 0) __PYX_ERR(0, 122, __pyx_L1_error)
if (__Pyx_setup_reduce((PyObject*)&__pyx_type_5spacy_6syntax_9arc_eager_Shift) < 0) __PYX_ERR(0, 122, __pyx_L1_error)
__pyx_ptype_5spacy_6syntax_9arc_eager_Shift = &__pyx_type_5spacy_6syntax_9arc_eager_Shift;
__pyx_vtabptr_5spacy_6syntax_9arc_eager_Reduce = &__pyx_vtable_5spacy_6syntax_9arc_eager_Reduce;
__pyx_vtable_5spacy_6syntax_9arc_eager_Reduce.is_valid = (int (*)(__pyx_t_5spacy_6syntax_6_state_StateC const *, __pyx_t_5spacy_8typedefs_attr_t))__pyx_f_5spacy_6syntax_9arc_eager_6Reduce_is_valid;
__pyx_vtable_5spacy_6syntax_9arc_eager_Reduce.transition = (int (*)(__pyx_t_5spacy_6syntax_6_state_StateC *, __pyx_t_5spacy_8typedefs_attr_t))__pyx_f_5spacy_6syntax_9arc_eager_6Reduce_transition;
__pyx_vtable_5spacy_6syntax_9arc_eager_Reduce.cost = (__pyx_t_5thinc_8typedefs_weight_t (*)(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *, struct __pyx_t_5spacy_4gold_GoldParseC const *, __pyx_t_5spacy_8typedefs_attr_t))__pyx_f_5spacy_6syntax_9arc_eager_6Reduce_cost;
__pyx_vtable_5spacy_6syntax_9arc_eager_Reduce.move_cost = (__pyx_t_5thinc_8typedefs_weight_t (*)(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *, struct __pyx_t_5spacy_4gold_GoldParseC const *))__pyx_f_5spacy_6syntax_9arc_eager_6Reduce_move_cost;
__pyx_vtable_5spacy_6syntax_9arc_eager_Reduce.label_cost = (__pyx_t_5thinc_8typedefs_weight_t (*)(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *, struct __pyx_t_5spacy_4gold_GoldParseC const *, __pyx_t_5spacy_8typedefs_attr_t))__pyx_f_5spacy_6syntax_9arc_eager_6Reduce_label_cost;
if (PyType_Ready(&__pyx_type_5spacy_6syntax_9arc_eager_Reduce) < 0) __PYX_ERR(0, 146, __pyx_L1_error)
#if PY_VERSION_HEX < 0x030800B1
__pyx_type_5spacy_6syntax_9arc_eager_Reduce.tp_print = 0;
#endif
if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_5spacy_6syntax_9arc_eager_Reduce.tp_dictoffset && __pyx_type_5spacy_6syntax_9arc_eager_Reduce.tp_getattro == PyObject_GenericGetAttr)) {
__pyx_type_5spacy_6syntax_9arc_eager_Reduce.tp_getattro = __Pyx_PyObject_GenericGetAttr;
}
if (__Pyx_SetVtable(__pyx_type_5spacy_6syntax_9arc_eager_Reduce.tp_dict, __pyx_vtabptr_5spacy_6syntax_9arc_eager_Reduce) < 0) __PYX_ERR(0, 146, __pyx_L1_error)
if (PyObject_SetAttr(__pyx_m, __pyx_n_s_Reduce, (PyObject *)&__pyx_type_5spacy_6syntax_9arc_eager_Reduce) < 0) __PYX_ERR(0, 146, __pyx_L1_error)
if (__Pyx_setup_reduce((PyObject*)&__pyx_type_5spacy_6syntax_9arc_eager_Reduce) < 0) __PYX_ERR(0, 146, __pyx_L1_error)
__pyx_ptype_5spacy_6syntax_9arc_eager_Reduce = &__pyx_type_5spacy_6syntax_9arc_eager_Reduce;
__pyx_vtabptr_5spacy_6syntax_9arc_eager_LeftArc = &__pyx_vtable_5spacy_6syntax_9arc_eager_LeftArc;
__pyx_vtable_5spacy_6syntax_9arc_eager_LeftArc.is_valid = (int (*)(__pyx_t_5spacy_6syntax_6_state_StateC const *, __pyx_t_5spacy_8typedefs_attr_t))__pyx_f_5spacy_6syntax_9arc_eager_7LeftArc_is_valid;
__pyx_vtable_5spacy_6syntax_9arc_eager_LeftArc.transition = (int (*)(__pyx_t_5spacy_6syntax_6_state_StateC *, __pyx_t_5spacy_8typedefs_attr_t))__pyx_f_5spacy_6syntax_9arc_eager_7LeftArc_transition;
__pyx_vtable_5spacy_6syntax_9arc_eager_LeftArc.cost = (__pyx_t_5thinc_8typedefs_weight_t (*)(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *, struct __pyx_t_5spacy_4gold_GoldParseC const *, __pyx_t_5spacy_8typedefs_attr_t))__pyx_f_5spacy_6syntax_9arc_eager_7LeftArc_cost;
__pyx_vtable_5spacy_6syntax_9arc_eager_LeftArc.move_cost = (__pyx_t_5thinc_8typedefs_weight_t (*)(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *, struct __pyx_t_5spacy_4gold_GoldParseC const *))__pyx_f_5spacy_6syntax_9arc_eager_7LeftArc_move_cost;
__pyx_vtable_5spacy_6syntax_9arc_eager_LeftArc.label_cost = (__pyx_t_5thinc_8typedefs_weight_t (*)(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *, struct __pyx_t_5spacy_4gold_GoldParseC const *, __pyx_t_5spacy_8typedefs_attr_t))__pyx_f_5spacy_6syntax_9arc_eager_7LeftArc_label_cost;
if (PyType_Ready(&__pyx_type_5spacy_6syntax_9arc_eager_LeftArc) < 0) __PYX_ERR(0, 183, __pyx_L1_error)
#if PY_VERSION_HEX < 0x030800B1
__pyx_type_5spacy_6syntax_9arc_eager_LeftArc.tp_print = 0;
#endif
if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_5spacy_6syntax_9arc_eager_LeftArc.tp_dictoffset && __pyx_type_5spacy_6syntax_9arc_eager_LeftArc.tp_getattro == PyObject_GenericGetAttr)) {
__pyx_type_5spacy_6syntax_9arc_eager_LeftArc.tp_getattro = __Pyx_PyObject_GenericGetAttr;
}
if (__Pyx_SetVtable(__pyx_type_5spacy_6syntax_9arc_eager_LeftArc.tp_dict, __pyx_vtabptr_5spacy_6syntax_9arc_eager_LeftArc) < 0) __PYX_ERR(0, 183, __pyx_L1_error)
if (PyObject_SetAttr(__pyx_m, __pyx_n_s_LeftArc, (PyObject *)&__pyx_type_5spacy_6syntax_9arc_eager_LeftArc) < 0) __PYX_ERR(0, 183, __pyx_L1_error)
if (__Pyx_setup_reduce((PyObject*)&__pyx_type_5spacy_6syntax_9arc_eager_LeftArc) < 0) __PYX_ERR(0, 183, __pyx_L1_error)
__pyx_ptype_5spacy_6syntax_9arc_eager_LeftArc = &__pyx_type_5spacy_6syntax_9arc_eager_LeftArc;
__pyx_vtabptr_5spacy_6syntax_9arc_eager_RightArc = &__pyx_vtable_5spacy_6syntax_9arc_eager_RightArc;
__pyx_vtable_5spacy_6syntax_9arc_eager_RightArc.is_valid = (int (*)(__pyx_t_5spacy_6syntax_6_state_StateC const *, __pyx_t_5spacy_8typedefs_attr_t))__pyx_f_5spacy_6syntax_9arc_eager_8RightArc_is_valid;
__pyx_vtable_5spacy_6syntax_9arc_eager_RightArc.transition = (int (*)(__pyx_t_5spacy_6syntax_6_state_StateC *, __pyx_t_5spacy_8typedefs_attr_t))__pyx_f_5spacy_6syntax_9arc_eager_8RightArc_transition;
__pyx_vtable_5spacy_6syntax_9arc_eager_RightArc.cost = (__pyx_t_5thinc_8typedefs_weight_t (*)(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *, struct __pyx_t_5spacy_4gold_GoldParseC const *, __pyx_t_5spacy_8typedefs_attr_t))__pyx_f_5spacy_6syntax_9arc_eager_8RightArc_cost;
__pyx_vtable_5spacy_6syntax_9arc_eager_RightArc.move_cost = (__pyx_t_5thinc_8typedefs_weight_t (*)(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *, struct __pyx_t_5spacy_4gold_GoldParseC const *))__pyx_f_5spacy_6syntax_9arc_eager_8RightArc_move_cost;
__pyx_vtable_5spacy_6syntax_9arc_eager_RightArc.label_cost = (__pyx_t_5thinc_8typedefs_weight_t (*)(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *, struct __pyx_t_5spacy_4gold_GoldParseC const *, __pyx_t_5spacy_8typedefs_attr_t))__pyx_f_5spacy_6syntax_9arc_eager_8RightArc_label_cost;
if (PyType_Ready(&__pyx_type_5spacy_6syntax_9arc_eager_RightArc) < 0) __PYX_ERR(0, 220, __pyx_L1_error)
#if PY_VERSION_HEX < 0x030800B1
__pyx_type_5spacy_6syntax_9arc_eager_RightArc.tp_print = 0;
#endif
if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_5spacy_6syntax_9arc_eager_RightArc.tp_dictoffset && __pyx_type_5spacy_6syntax_9arc_eager_RightArc.tp_getattro == PyObject_GenericGetAttr)) {
__pyx_type_5spacy_6syntax_9arc_eager_RightArc.tp_getattro = __Pyx_PyObject_GenericGetAttr;
}
if (__Pyx_SetVtable(__pyx_type_5spacy_6syntax_9arc_eager_RightArc.tp_dict, __pyx_vtabptr_5spacy_6syntax_9arc_eager_RightArc) < 0) __PYX_ERR(0, 220, __pyx_L1_error)
if (PyObject_SetAttr(__pyx_m, __pyx_n_s_RightArc, (PyObject *)&__pyx_type_5spacy_6syntax_9arc_eager_RightArc) < 0) __PYX_ERR(0, 220, __pyx_L1_error)
if (__Pyx_setup_reduce((PyObject*)&__pyx_type_5spacy_6syntax_9arc_eager_RightArc) < 0) __PYX_ERR(0, 220, __pyx_L1_error)
__pyx_ptype_5spacy_6syntax_9arc_eager_RightArc = &__pyx_type_5spacy_6syntax_9arc_eager_RightArc;
__pyx_vtabptr_5spacy_6syntax_9arc_eager_Break = &__pyx_vtable_5spacy_6syntax_9arc_eager_Break;
__pyx_vtable_5spacy_6syntax_9arc_eager_Break.is_valid = (int (*)(__pyx_t_5spacy_6syntax_6_state_StateC const *, __pyx_t_5spacy_8typedefs_attr_t))__pyx_f_5spacy_6syntax_9arc_eager_5Break_is_valid;
__pyx_vtable_5spacy_6syntax_9arc_eager_Break.transition = (int (*)(__pyx_t_5spacy_6syntax_6_state_StateC *, __pyx_t_5spacy_8typedefs_attr_t))__pyx_f_5spacy_6syntax_9arc_eager_5Break_transition;
__pyx_vtable_5spacy_6syntax_9arc_eager_Break.cost = (__pyx_t_5thinc_8typedefs_weight_t (*)(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *, struct __pyx_t_5spacy_4gold_GoldParseC const *, __pyx_t_5spacy_8typedefs_attr_t))__pyx_f_5spacy_6syntax_9arc_eager_5Break_cost;
__pyx_vtable_5spacy_6syntax_9arc_eager_Break.move_cost = (__pyx_t_5thinc_8typedefs_weight_t (*)(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *, struct __pyx_t_5spacy_4gold_GoldParseC const *))__pyx_f_5spacy_6syntax_9arc_eager_5Break_move_cost;
__pyx_vtable_5spacy_6syntax_9arc_eager_Break.label_cost = (__pyx_t_5thinc_8typedefs_weight_t (*)(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass *, struct __pyx_t_5spacy_4gold_GoldParseC const *, __pyx_t_5spacy_8typedefs_attr_t))__pyx_f_5spacy_6syntax_9arc_eager_5Break_label_cost;
if (PyType_Ready(&__pyx_type_5spacy_6syntax_9arc_eager_Break) < 0) __PYX_ERR(0, 253, __pyx_L1_error)
#if PY_VERSION_HEX < 0x030800B1
__pyx_type_5spacy_6syntax_9arc_eager_Break.tp_print = 0;
#endif
if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_5spacy_6syntax_9arc_eager_Break.tp_dictoffset && __pyx_type_5spacy_6syntax_9arc_eager_Break.tp_getattro == PyObject_GenericGetAttr)) {
__pyx_type_5spacy_6syntax_9arc_eager_Break.tp_getattro = __Pyx_PyObject_GenericGetAttr;
}
if (__Pyx_SetVtable(__pyx_type_5spacy_6syntax_9arc_eager_Break.tp_dict, __pyx_vtabptr_5spacy_6syntax_9arc_eager_Break) < 0) __PYX_ERR(0, 253, __pyx_L1_error)
if (PyObject_SetAttr(__pyx_m, __pyx_n_s_Break, (PyObject *)&__pyx_type_5spacy_6syntax_9arc_eager_Break) < 0) __PYX_ERR(0, 253, __pyx_L1_error)
if (__Pyx_setup_reduce((PyObject*)&__pyx_type_5spacy_6syntax_9arc_eager_Break) < 0) __PYX_ERR(0, 253, __pyx_L1_error)
__pyx_ptype_5spacy_6syntax_9arc_eager_Break = &__pyx_type_5spacy_6syntax_9arc_eager_Break;
__pyx_vtabptr_array = &__pyx_vtable_array;
__pyx_vtable_array.get_memview = (PyObject *(*)(struct __pyx_array_obj *))__pyx_array_get_memview;
if (PyType_Ready(&__pyx_type___pyx_array) < 0) __PYX_ERR(1, 105, __pyx_L1_error)
#if PY_VERSION_HEX < 0x030800B1
__pyx_type___pyx_array.tp_print = 0;
#endif
if (__Pyx_SetVtable(__pyx_type___pyx_array.tp_dict, __pyx_vtabptr_array) < 0) __PYX_ERR(1, 105, __pyx_L1_error)
if (__Pyx_setup_reduce((PyObject*)&__pyx_type___pyx_array) < 0) __PYX_ERR(1, 105, __pyx_L1_error)
__pyx_array_type = &__pyx_type___pyx_array;
if (PyType_Ready(&__pyx_type___pyx_MemviewEnum) < 0) __PYX_ERR(1, 279, __pyx_L1_error)
#if PY_VERSION_HEX < 0x030800B1
__pyx_type___pyx_MemviewEnum.tp_print = 0;
#endif
if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type___pyx_MemviewEnum.tp_dictoffset && __pyx_type___pyx_MemviewEnum.tp_getattro == PyObject_GenericGetAttr)) {
__pyx_type___pyx_MemviewEnum.tp_getattro = __Pyx_PyObject_GenericGetAttr;
}
if (__Pyx_setup_reduce((PyObject*)&__pyx_type___pyx_MemviewEnum) < 0) __PYX_ERR(1, 279, __pyx_L1_error)
__pyx_MemviewEnum_type = &__pyx_type___pyx_MemviewEnum;
__pyx_vtabptr_memoryview = &__pyx_vtable_memoryview;
__pyx_vtable_memoryview.get_item_pointer = (char *(*)(struct __pyx_memoryview_obj *, PyObject *))__pyx_memoryview_get_item_pointer;
__pyx_vtable_memoryview.is_slice = (PyObject *(*)(struct __pyx_memoryview_obj *, PyObject *))__pyx_memoryview_is_slice;
__pyx_vtable_memoryview.setitem_slice_assignment = (PyObject *(*)(struct __pyx_memoryview_obj *, PyObject *, PyObject *))__pyx_memoryview_setitem_slice_assignment;
__pyx_vtable_memoryview.setitem_slice_assign_scalar = (PyObject *(*)(struct __pyx_memoryview_obj *, struct __pyx_memoryview_obj *, PyObject *))__pyx_memoryview_setitem_slice_assign_scalar;
__pyx_vtable_memoryview.setitem_indexed = (PyObject *(*)(struct __pyx_memoryview_obj *, PyObject *, PyObject *))__pyx_memoryview_setitem_indexed;
__pyx_vtable_memoryview.convert_item_to_object = (PyObject *(*)(struct __pyx_memoryview_obj *, char *))__pyx_memoryview_convert_item_to_object;
__pyx_vtable_memoryview.assign_item_from_object = (PyObject *(*)(struct __pyx_memoryview_obj *, char *, PyObject *))__pyx_memoryview_assign_item_from_object;
if (PyType_Ready(&__pyx_type___pyx_memoryview) < 0) __PYX_ERR(1, 330, __pyx_L1_error)
#if PY_VERSION_HEX < 0x030800B1
__pyx_type___pyx_memoryview.tp_print = 0;
#endif
if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type___pyx_memoryview.tp_dictoffset && __pyx_type___pyx_memoryview.tp_getattro == PyObject_GenericGetAttr)) {
__pyx_type___pyx_memoryview.tp_getattro = __Pyx_PyObject_GenericGetAttr;
}
if (__Pyx_SetVtable(__pyx_type___pyx_memoryview.tp_dict, __pyx_vtabptr_memoryview) < 0) __PYX_ERR(1, 330, __pyx_L1_error)
if (__Pyx_setup_reduce((PyObject*)&__pyx_type___pyx_memoryview) < 0) __PYX_ERR(1, 330, __pyx_L1_error)
__pyx_memoryview_type = &__pyx_type___pyx_memoryview;
__pyx_vtabptr__memoryviewslice = &__pyx_vtable__memoryviewslice;
__pyx_vtable__memoryviewslice.__pyx_base = *__pyx_vtabptr_memoryview;
__pyx_vtable__memoryviewslice.__pyx_base.convert_item_to_object = (PyObject *(*)(struct __pyx_memoryview_obj *, char *))__pyx_memoryviewslice_convert_item_to_object;
__pyx_vtable__memoryviewslice.__pyx_base.assign_item_from_object = (PyObject *(*)(struct __pyx_memoryview_obj *, char *, PyObject *))__pyx_memoryviewslice_assign_item_from_object;
__pyx_type___pyx_memoryviewslice.tp_base = __pyx_memoryview_type;
if (PyType_Ready(&__pyx_type___pyx_memoryviewslice) < 0) __PYX_ERR(1, 965, __pyx_L1_error)
#if PY_VERSION_HEX < 0x030800B1
__pyx_type___pyx_memoryviewslice.tp_print = 0;
#endif
if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type___pyx_memoryviewslice.tp_dictoffset && __pyx_type___pyx_memoryviewslice.tp_getattro == PyObject_GenericGetAttr)) {
__pyx_type___pyx_memoryviewslice.tp_getattro = __Pyx_PyObject_GenericGetAttr;
}
if (__Pyx_SetVtable(__pyx_type___pyx_memoryviewslice.tp_dict, __pyx_vtabptr__memoryviewslice) < 0) __PYX_ERR(1, 965, __pyx_L1_error)
if (__Pyx_setup_reduce((PyObject*)&__pyx_type___pyx_memoryviewslice) < 0) __PYX_ERR(1, 965, __pyx_L1_error)
__pyx_memoryviewslice_type = &__pyx_type___pyx_memoryviewslice;
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__Pyx_RefNannyFinishContext();
return 0;
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_1);
__Pyx_RefNannyFinishContext();
return -1;
}
static int __Pyx_modinit_type_import_code(void) {
__Pyx_RefNannyDeclarations
PyObject *__pyx_t_1 = NULL;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("__Pyx_modinit_type_import_code", 0);
/*--- Type import code ---*/
__pyx_t_1 = PyImport_ImportModule("cymem.cymem"); if (unlikely(!__pyx_t_1)) __PYX_ERR(7, 4, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_ptype_5cymem_5cymem_PyMalloc = __Pyx_ImportType(__pyx_t_1, "cymem.cymem", "PyMalloc", sizeof(struct __pyx_obj_5cymem_5cymem_PyMalloc), __Pyx_ImportType_CheckSize_Warn);
if (!__pyx_ptype_5cymem_5cymem_PyMalloc) __PYX_ERR(7, 4, __pyx_L1_error)
__pyx_vtabptr_5cymem_5cymem_PyMalloc = (struct __pyx_vtabstruct_5cymem_5cymem_PyMalloc*)__Pyx_GetVtable(__pyx_ptype_5cymem_5cymem_PyMalloc->tp_dict); if (unlikely(!__pyx_vtabptr_5cymem_5cymem_PyMalloc)) __PYX_ERR(7, 4, __pyx_L1_error)
__pyx_ptype_5cymem_5cymem_PyFree = __Pyx_ImportType(__pyx_t_1, "cymem.cymem", "PyFree", sizeof(struct __pyx_obj_5cymem_5cymem_PyFree), __Pyx_ImportType_CheckSize_Warn);
if (!__pyx_ptype_5cymem_5cymem_PyFree) __PYX_ERR(7, 10, __pyx_L1_error)
__pyx_vtabptr_5cymem_5cymem_PyFree = (struct __pyx_vtabstruct_5cymem_5cymem_PyFree*)__Pyx_GetVtable(__pyx_ptype_5cymem_5cymem_PyFree->tp_dict); if (unlikely(!__pyx_vtabptr_5cymem_5cymem_PyFree)) __PYX_ERR(7, 10, __pyx_L1_error)
__pyx_ptype_5cymem_5cymem_Pool = __Pyx_ImportType(__pyx_t_1, "cymem.cymem", "Pool", sizeof(struct __pyx_obj_5cymem_5cymem_Pool), __Pyx_ImportType_CheckSize_Warn);
if (!__pyx_ptype_5cymem_5cymem_Pool) __PYX_ERR(7, 16, __pyx_L1_error)
__pyx_vtabptr_5cymem_5cymem_Pool = (struct __pyx_vtabstruct_5cymem_5cymem_Pool*)__Pyx_GetVtable(__pyx_ptype_5cymem_5cymem_Pool->tp_dict); if (unlikely(!__pyx_vtabptr_5cymem_5cymem_Pool)) __PYX_ERR(7, 16, __pyx_L1_error)
__pyx_ptype_5cymem_5cymem_Address = __Pyx_ImportType(__pyx_t_1, "cymem.cymem", "Address", sizeof(struct __pyx_obj_5cymem_5cymem_Address), __Pyx_ImportType_CheckSize_Warn);
if (!__pyx_ptype_5cymem_5cymem_Address) __PYX_ERR(7, 28, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__pyx_t_1 = PyImport_ImportModule("preshed.maps"); if (unlikely(!__pyx_t_1)) __PYX_ERR(8, 45, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_ptype_7preshed_4maps_PreshMap = __Pyx_ImportType(__pyx_t_1, "preshed.maps", "PreshMap", sizeof(struct __pyx_obj_7preshed_4maps_PreshMap), __Pyx_ImportType_CheckSize_Warn);
if (!__pyx_ptype_7preshed_4maps_PreshMap) __PYX_ERR(8, 45, __pyx_L1_error)
__pyx_vtabptr_7preshed_4maps_PreshMap = (struct __pyx_vtabstruct_7preshed_4maps_PreshMap*)__Pyx_GetVtable(__pyx_ptype_7preshed_4maps_PreshMap->tp_dict); if (unlikely(!__pyx_vtabptr_7preshed_4maps_PreshMap)) __PYX_ERR(8, 45, __pyx_L1_error)
__pyx_ptype_7preshed_4maps_PreshMapArray = __Pyx_ImportType(__pyx_t_1, "preshed.maps", "PreshMapArray", sizeof(struct __pyx_obj_7preshed_4maps_PreshMapArray), __Pyx_ImportType_CheckSize_Warn);
if (!__pyx_ptype_7preshed_4maps_PreshMapArray) __PYX_ERR(8, 53, __pyx_L1_error)
__pyx_vtabptr_7preshed_4maps_PreshMapArray = (struct __pyx_vtabstruct_7preshed_4maps_PreshMapArray*)__Pyx_GetVtable(__pyx_ptype_7preshed_4maps_PreshMapArray->tp_dict); if (unlikely(!__pyx_vtabptr_7preshed_4maps_PreshMapArray)) __PYX_ERR(8, 53, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__pyx_t_1 = PyImport_ImportModule("spacy.strings"); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 23, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_ptype_5spacy_7strings_StringStore = __Pyx_ImportType(__pyx_t_1, "spacy.strings", "StringStore", sizeof(struct __pyx_obj_5spacy_7strings_StringStore), __Pyx_ImportType_CheckSize_Warn);
if (!__pyx_ptype_5spacy_7strings_StringStore) __PYX_ERR(9, 23, __pyx_L1_error)
__pyx_vtabptr_5spacy_7strings_StringStore = (struct __pyx_vtabstruct_5spacy_7strings_StringStore*)__Pyx_GetVtable(__pyx_ptype_5spacy_7strings_StringStore->tp_dict); if (unlikely(!__pyx_vtabptr_5spacy_7strings_StringStore)) __PYX_ERR(9, 23, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__pyx_t_1 = PyImport_ImportModule("spacy.morphology"); if (unlikely(!__pyx_t_1)) __PYX_ERR(10, 13, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_ptype_5spacy_10morphology_Morphology = __Pyx_ImportType(__pyx_t_1, "spacy.morphology", "Morphology", sizeof(struct __pyx_obj_5spacy_10morphology_Morphology), __Pyx_ImportType_CheckSize_Warn);
if (!__pyx_ptype_5spacy_10morphology_Morphology) __PYX_ERR(10, 13, __pyx_L1_error)
__pyx_vtabptr_5spacy_10morphology_Morphology = (struct __pyx_vtabstruct_5spacy_10morphology_Morphology*)__Pyx_GetVtable(__pyx_ptype_5spacy_10morphology_Morphology->tp_dict); if (unlikely(!__pyx_vtabptr_5spacy_10morphology_Morphology)) __PYX_ERR(10, 13, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__pyx_t_1 = PyImport_ImportModule("spacy.vocab"); if (unlikely(!__pyx_t_1)) __PYX_ERR(11, 27, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_ptype_5spacy_5vocab_Vocab = __Pyx_ImportType(__pyx_t_1, "spacy.vocab", "Vocab", sizeof(struct __pyx_obj_5spacy_5vocab_Vocab), __Pyx_ImportType_CheckSize_Warn);
if (!__pyx_ptype_5spacy_5vocab_Vocab) __PYX_ERR(11, 27, __pyx_L1_error)
__pyx_vtabptr_5spacy_5vocab_Vocab = (struct __pyx_vtabstruct_5spacy_5vocab_Vocab*)__Pyx_GetVtable(__pyx_ptype_5spacy_5vocab_Vocab->tp_dict); if (unlikely(!__pyx_vtabptr_5spacy_5vocab_Vocab)) __PYX_ERR(11, 27, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__pyx_t_1 = PyImport_ImportModule(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_t_1)) __PYX_ERR(12, 9, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_ptype_7cpython_4type_type = __Pyx_ImportType(__pyx_t_1, __Pyx_BUILTIN_MODULE_NAME, "type",
#if defined(PYPY_VERSION_NUM) && PYPY_VERSION_NUM < 0x050B0000
sizeof(PyTypeObject),
#else
sizeof(PyHeapTypeObject),
#endif
__Pyx_ImportType_CheckSize_Warn);
if (!__pyx_ptype_7cpython_4type_type) __PYX_ERR(12, 9, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__pyx_t_1 = PyImport_ImportModule("numpy"); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 207, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_ptype_5numpy_dtype = __Pyx_ImportType(__pyx_t_1, "numpy", "dtype", sizeof(PyArray_Descr), __Pyx_ImportType_CheckSize_Ignore);
if (!__pyx_ptype_5numpy_dtype) __PYX_ERR(2, 207, __pyx_L1_error)
__pyx_ptype_5numpy_flatiter = __Pyx_ImportType(__pyx_t_1, "numpy", "flatiter", sizeof(PyArrayIterObject), __Pyx_ImportType_CheckSize_Ignore);
if (!__pyx_ptype_5numpy_flatiter) __PYX_ERR(2, 230, __pyx_L1_error)
__pyx_ptype_5numpy_broadcast = __Pyx_ImportType(__pyx_t_1, "numpy", "broadcast", sizeof(PyArrayMultiIterObject), __Pyx_ImportType_CheckSize_Ignore);
if (!__pyx_ptype_5numpy_broadcast) __PYX_ERR(2, 234, __pyx_L1_error)
__pyx_ptype_5numpy_ndarray = __Pyx_ImportType(__pyx_t_1, "numpy", "ndarray", sizeof(PyArrayObject), __Pyx_ImportType_CheckSize_Ignore);
if (!__pyx_ptype_5numpy_ndarray) __PYX_ERR(2, 246, __pyx_L1_error)
__pyx_ptype_5numpy_ufunc = __Pyx_ImportType(__pyx_t_1, "numpy", "ufunc", sizeof(PyUFuncObject), __Pyx_ImportType_CheckSize_Ignore);
if (!__pyx_ptype_5numpy_ufunc) __PYX_ERR(2, 839, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__pyx_t_1 = PyImport_ImportModule("spacy.lexeme"); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 15, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_ptype_5spacy_6lexeme_Lexeme = __Pyx_ImportType(__pyx_t_1, "spacy.lexeme", "Lexeme", sizeof(struct __pyx_obj_5spacy_6lexeme_Lexeme), __Pyx_ImportType_CheckSize_Warn);
if (!__pyx_ptype_5spacy_6lexeme_Lexeme) __PYX_ERR(3, 15, __pyx_L1_error)
__pyx_vtabptr_5spacy_6lexeme_Lexeme = (struct __pyx_vtabstruct_5spacy_6lexeme_Lexeme*)__Pyx_GetVtable(__pyx_ptype_5spacy_6lexeme_Lexeme->tp_dict); if (unlikely(!__pyx_vtabptr_5spacy_6lexeme_Lexeme)) __PYX_ERR(3, 15, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__pyx_t_1 = PyImport_ImportModule("spacy.syntax.stateclass"); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 13, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_ptype_5spacy_6syntax_10stateclass_StateClass = __Pyx_ImportType(__pyx_t_1, "spacy.syntax.stateclass", "StateClass", sizeof(struct __pyx_obj_5spacy_6syntax_10stateclass_StateClass), __Pyx_ImportType_CheckSize_Warn);
if (!__pyx_ptype_5spacy_6syntax_10stateclass_StateClass) __PYX_ERR(5, 13, __pyx_L1_error)
__pyx_vtabptr_5spacy_6syntax_10stateclass_StateClass = (struct __pyx_vtabstruct_5spacy_6syntax_10stateclass_StateClass*)__Pyx_GetVtable(__pyx_ptype_5spacy_6syntax_10stateclass_StateClass->tp_dict); if (unlikely(!__pyx_vtabptr_5spacy_6syntax_10stateclass_StateClass)) __PYX_ERR(5, 13, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__pyx_t_1 = PyImport_ImportModule("spacy.gold"); if (unlikely(!__pyx_t_1)) __PYX_ERR(13, 18, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_ptype_5spacy_4gold_GoldParse = __Pyx_ImportType(__pyx_t_1, "spacy.gold", "GoldParse", sizeof(struct __pyx_obj_5spacy_4gold_GoldParse), __Pyx_ImportType_CheckSize_Warn);
if (!__pyx_ptype_5spacy_4gold_GoldParse) __PYX_ERR(13, 18, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__pyx_t_1 = PyImport_ImportModule("thinc.extra.search"); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 37, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_ptype_5thinc_5extra_6search_Beam = __Pyx_ImportType(__pyx_t_1, "thinc.extra.search", "Beam", sizeof(struct __pyx_obj_5thinc_5extra_6search_Beam), __Pyx_ImportType_CheckSize_Warn);
if (!__pyx_ptype_5thinc_5extra_6search_Beam) __PYX_ERR(6, 37, __pyx_L1_error)
__pyx_vtabptr_5thinc_5extra_6search_Beam = (struct __pyx_vtabstruct_5thinc_5extra_6search_Beam*)__Pyx_GetVtable(__pyx_ptype_5thinc_5extra_6search_Beam->tp_dict); if (unlikely(!__pyx_vtabptr_5thinc_5extra_6search_Beam)) __PYX_ERR(6, 37, __pyx_L1_error)
__pyx_ptype_5thinc_5extra_6search_MaxViolation = __Pyx_ImportType(__pyx_t_1, "thinc.extra.search", "MaxViolation", sizeof(struct __pyx_obj_5thinc_5extra_6search_MaxViolation), __Pyx_ImportType_CheckSize_Warn);
if (!__pyx_ptype_5thinc_5extra_6search_MaxViolation) __PYX_ERR(6, 75, __pyx_L1_error)
__pyx_vtabptr_5thinc_5extra_6search_MaxViolation = (struct __pyx_vtabstruct_5thinc_5extra_6search_MaxViolation*)__Pyx_GetVtable(__pyx_ptype_5thinc_5extra_6search_MaxViolation->tp_dict); if (unlikely(!__pyx_vtabptr_5thinc_5extra_6search_MaxViolation)) __PYX_ERR(6, 75, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__pyx_t_1 = PyImport_ImportModule("spacy.tokens.doc"); if (unlikely(!__pyx_t_1)) __PYX_ERR(14, 39, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_ptype_5spacy_6tokens_3doc_Doc = __Pyx_ImportType(__pyx_t_1, "spacy.tokens.doc", "Doc", sizeof(struct __pyx_obj_5spacy_6tokens_3doc_Doc), __Pyx_ImportType_CheckSize_Warn);
if (!__pyx_ptype_5spacy_6tokens_3doc_Doc) __PYX_ERR(14, 39, __pyx_L1_error)
__pyx_vtabptr_5spacy_6tokens_3doc_Doc = (struct __pyx_vtabstruct_5spacy_6tokens_3doc_Doc*)__Pyx_GetVtable(__pyx_ptype_5spacy_6tokens_3doc_Doc->tp_dict); if (unlikely(!__pyx_vtabptr_5spacy_6tokens_3doc_Doc)) __PYX_ERR(14, 39, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__Pyx_RefNannyFinishContext();
return 0;
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_1);
__Pyx_RefNannyFinishContext();
return -1;
}
static int __Pyx_modinit_variable_import_code(void) {
__Pyx_RefNannyDeclarations
PyObject *__pyx_t_1 = NULL;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("__Pyx_modinit_variable_import_code", 0);
/*--- Variable import code ---*/
__pyx_t_1 = PyImport_ImportModule("spacy.vocab"); if (!__pyx_t_1) __PYX_ERR(0, 1, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
if (__Pyx_ImportVoidPtr(__pyx_t_1, "EMPTY_LEXEME", (void **)&__pyx_vp_5spacy_5vocab_EMPTY_LEXEME, "struct __pyx_t_5spacy_7structs_LexemeC") < 0) __PYX_ERR(0, 1, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__pyx_t_1 = PyImport_ImportModule("spacy.lexeme"); if (!__pyx_t_1) __PYX_ERR(0, 1, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
if (__Pyx_ImportVoidPtr(__pyx_t_1, "EMPTY_LEXEME", (void **)&__pyx_vp_5spacy_6lexeme_EMPTY_LEXEME, "struct __pyx_t_5spacy_7structs_LexemeC") < 0) __PYX_ERR(0, 1, __pyx_L1_error)
if (__Pyx_ImportVoidPtr(__pyx_t_1, "OOV_RANK", (void **)&__pyx_vp_5spacy_6lexeme_OOV_RANK, "__pyx_t_5spacy_8typedefs_attr_t") < 0) __PYX_ERR(0, 1, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__Pyx_RefNannyFinishContext();
return 0;
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_1);
__Pyx_RefNannyFinishContext();
return -1;
}
static int __Pyx_modinit_function_import_code(void) {
__Pyx_RefNannyDeclarations
PyObject *__pyx_t_1 = NULL;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("__Pyx_modinit_function_import_code", 0);
/*--- Function import code ---*/
__pyx_t_1 = PyImport_ImportModule("murmurhash.mrmr"); if (!__pyx_t_1) __PYX_ERR(0, 1, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
if (__Pyx_ImportFunction(__pyx_t_1, "hash64", (void (**)(void))&__pyx_f_10murmurhash_4mrmr_hash64, "uint64_t (void *, int, uint64_t)") < 0) __PYX_ERR(0, 1, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__pyx_t_1 = PyImport_ImportModule("spacy.strings"); if (!__pyx_t_1) __PYX_ERR(0, 1, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
if (__Pyx_ImportFunction(__pyx_t_1, "hash_string", (void (**)(void))&__pyx_f_5spacy_7strings_hash_string, "__pyx_t_5spacy_8typedefs_hash_t (PyObject *, int __pyx_skip_dispatch)") < 0) __PYX_ERR(0, 1, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__pyx_t_1 = PyImport_ImportModule("spacy.tokens.doc"); if (!__pyx_t_1) __PYX_ERR(0, 1, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
if (__Pyx_ImportFunction(__pyx_t_1, "set_children_from_heads", (void (**)(void))&__pyx_f_5spacy_6tokens_3doc_set_children_from_heads, "int (struct __pyx_t_5spacy_7structs_TokenC *, int)") < 0) __PYX_ERR(0, 1, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__Pyx_RefNannyFinishContext();
return 0;
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_1);
__Pyx_RefNannyFinishContext();
return -1;
}
#ifndef CYTHON_NO_PYINIT_EXPORT
#define __Pyx_PyMODINIT_FUNC PyMODINIT_FUNC
#elif PY_MAJOR_VERSION < 3
#ifdef __cplusplus
#define __Pyx_PyMODINIT_FUNC extern "C" void
#else
#define __Pyx_PyMODINIT_FUNC void
#endif
#else
#ifdef __cplusplus
#define __Pyx_PyMODINIT_FUNC extern "C" PyObject *
#else
#define __Pyx_PyMODINIT_FUNC PyObject *
#endif
#endif
#if PY_MAJOR_VERSION < 3
__Pyx_PyMODINIT_FUNC initarc_eager(void) CYTHON_SMALL_CODE; /*proto*/
__Pyx_PyMODINIT_FUNC initarc_eager(void)
#else
__Pyx_PyMODINIT_FUNC PyInit_arc_eager(void) CYTHON_SMALL_CODE; /*proto*/
__Pyx_PyMODINIT_FUNC PyInit_arc_eager(void)
#if CYTHON_PEP489_MULTI_PHASE_INIT
{
return PyModuleDef_Init(&__pyx_moduledef);
}
static CYTHON_SMALL_CODE int __Pyx_check_single_interpreter(void) {
#if PY_VERSION_HEX >= 0x030700A1
static PY_INT64_T main_interpreter_id = -1;
PY_INT64_T current_id = PyInterpreterState_GetID(PyThreadState_Get()->interp);
if (main_interpreter_id == -1) {
main_interpreter_id = current_id;
return (unlikely(current_id == -1)) ? -1 : 0;
} else if (unlikely(main_interpreter_id != current_id))
#else
static PyInterpreterState *main_interpreter = NULL;
PyInterpreterState *current_interpreter = PyThreadState_Get()->interp;
if (!main_interpreter) {
main_interpreter = current_interpreter;
} else if (unlikely(main_interpreter != current_interpreter))
#endif
{
PyErr_SetString(
PyExc_ImportError,
"Interpreter change detected - this module can only be loaded into one interpreter per process.");
return -1;
}
return 0;
}
static CYTHON_SMALL_CODE int __Pyx_copy_spec_to_module(PyObject *spec, PyObject *moddict, const char* from_name, const char* to_name, int allow_none) {
PyObject *value = PyObject_GetAttrString(spec, from_name);
int result = 0;
if (likely(value)) {
if (allow_none || value != Py_None) {
result = PyDict_SetItemString(moddict, to_name, value);
}
Py_DECREF(value);
} else if (PyErr_ExceptionMatches(PyExc_AttributeError)) {
PyErr_Clear();
} else {
result = -1;
}
return result;
}
static CYTHON_SMALL_CODE PyObject* __pyx_pymod_create(PyObject *spec, CYTHON_UNUSED PyModuleDef *def) {
PyObject *module = NULL, *moddict, *modname;
if (__Pyx_check_single_interpreter())
return NULL;
if (__pyx_m)
return __Pyx_NewRef(__pyx_m);
modname = PyObject_GetAttrString(spec, "name");
if (unlikely(!modname)) goto bad;
module = PyModule_NewObject(modname);
Py_DECREF(modname);
if (unlikely(!module)) goto bad;
moddict = PyModule_GetDict(module);
if (unlikely(!moddict)) goto bad;
if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "loader", "__loader__", 1) < 0)) goto bad;
if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "origin", "__file__", 1) < 0)) goto bad;
if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "parent", "__package__", 1) < 0)) goto bad;
if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "submodule_search_locations", "__path__", 0) < 0)) goto bad;
return module;
bad:
Py_XDECREF(module);
return NULL;
}
static CYTHON_SMALL_CODE int __pyx_pymod_exec_arc_eager(PyObject *__pyx_pyinit_module)
#endif
#endif
{
__Pyx_TraceDeclarations
PyObject *__pyx_t_1 = NULL;
PyObject *__pyx_t_2 = NULL;
__pyx_t_5spacy_8typedefs_hash_t __pyx_t_3;
static PyThread_type_lock __pyx_t_4[8];
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
__Pyx_RefNannyDeclarations
#if CYTHON_PEP489_MULTI_PHASE_INIT
if (__pyx_m) {
if (__pyx_m == __pyx_pyinit_module) return 0;
PyErr_SetString(PyExc_RuntimeError, "Module 'arc_eager' has already been imported. Re-initialisation is not supported.");
return -1;
}
#elif PY_MAJOR_VERSION >= 3
if (__pyx_m) return __Pyx_NewRef(__pyx_m);
#endif
#if CYTHON_REFNANNY
__Pyx_RefNanny = __Pyx_RefNannyImportAPI("refnanny");
if (!__Pyx_RefNanny) {
PyErr_Clear();
__Pyx_RefNanny = __Pyx_RefNannyImportAPI("Cython.Runtime.refnanny");
if (!__Pyx_RefNanny)
Py_FatalError("failed to import 'refnanny' module");
}
#endif
__Pyx_RefNannySetupContext("__Pyx_PyMODINIT_FUNC PyInit_arc_eager(void)", 0);
if (__Pyx_check_binary_version() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
#ifdef __Pxy_PyFrame_Initialize_Offsets
__Pxy_PyFrame_Initialize_Offsets();
#endif
__pyx_empty_tuple = PyTuple_New(0); if (unlikely(!__pyx_empty_tuple)) __PYX_ERR(0, 1, __pyx_L1_error)
__pyx_empty_bytes = PyBytes_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_bytes)) __PYX_ERR(0, 1, __pyx_L1_error)
__pyx_empty_unicode = PyUnicode_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_unicode)) __PYX_ERR(0, 1, __pyx_L1_error)
#ifdef __Pyx_CyFunction_USED
if (__pyx_CyFunction_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
#endif
#ifdef __Pyx_FusedFunction_USED
if (__pyx_FusedFunction_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
#endif
#ifdef __Pyx_Coroutine_USED
if (__pyx_Coroutine_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
#endif
#ifdef __Pyx_Generator_USED
if (__pyx_Generator_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
#endif
#ifdef __Pyx_AsyncGen_USED
if (__pyx_AsyncGen_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
#endif
#ifdef __Pyx_StopAsyncIteration_USED
if (__pyx_StopAsyncIteration_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
#endif
/*--- Library function declarations ---*/
/*--- Threads initialization code ---*/
#if defined(__PYX_FORCE_INIT_THREADS) && __PYX_FORCE_INIT_THREADS
#ifdef WITH_THREAD /* Python build with threading support? */
PyEval_InitThreads();
#endif
#endif
/*--- Module creation code ---*/
#if CYTHON_PEP489_MULTI_PHASE_INIT
__pyx_m = __pyx_pyinit_module;
Py_INCREF(__pyx_m);
#else
#if PY_MAJOR_VERSION < 3
__pyx_m = Py_InitModule4("arc_eager", __pyx_methods, 0, 0, PYTHON_API_VERSION); Py_XINCREF(__pyx_m);
#else
__pyx_m = PyModule_Create(&__pyx_moduledef);
#endif
if (unlikely(!__pyx_m)) __PYX_ERR(0, 1, __pyx_L1_error)
#endif
__pyx_d = PyModule_GetDict(__pyx_m); if (unlikely(!__pyx_d)) __PYX_ERR(0, 1, __pyx_L1_error)
Py_INCREF(__pyx_d);
__pyx_b = PyImport_AddModule(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_b)) __PYX_ERR(0, 1, __pyx_L1_error)
Py_INCREF(__pyx_b);
__pyx_cython_runtime = PyImport_AddModule((char *) "cython_runtime"); if (unlikely(!__pyx_cython_runtime)) __PYX_ERR(0, 1, __pyx_L1_error)
Py_INCREF(__pyx_cython_runtime);
if (PyObject_SetAttrString(__pyx_m, "__builtins__", __pyx_b) < 0) __PYX_ERR(0, 1, __pyx_L1_error);
/*--- Initialize various global constants etc. ---*/
if (__Pyx_InitGlobals() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
#if PY_MAJOR_VERSION < 3 && (__PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT)
if (__Pyx_init_sys_getdefaultencoding_params() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
#endif
if (__pyx_module_is_main_spacy__syntax__arc_eager) {
if (PyObject_SetAttr(__pyx_m, __pyx_n_s_name_2, __pyx_n_s_main) < 0) __PYX_ERR(0, 1, __pyx_L1_error)
}
#if PY_MAJOR_VERSION >= 3
{
PyObject *modules = PyImport_GetModuleDict(); if (unlikely(!modules)) __PYX_ERR(0, 1, __pyx_L1_error)
if (!PyDict_GetItemString(modules, "spacy.syntax.arc_eager")) {
if (unlikely(PyDict_SetItemString(modules, "spacy.syntax.arc_eager", __pyx_m) < 0)) __PYX_ERR(0, 1, __pyx_L1_error)
}
}
#endif
/*--- Builtin init code ---*/
if (__Pyx_InitCachedBuiltins() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
/*--- Constants init code ---*/
if (__Pyx_InitCachedConstants() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
/*--- Global type/function init code ---*/
(void)__Pyx_modinit_global_init_code();
(void)__Pyx_modinit_variable_export_code();
if (unlikely(__Pyx_modinit_function_export_code() < 0)) __PYX_ERR(0, 1, __pyx_L1_error)
if (unlikely(__Pyx_modinit_type_init_code() < 0)) __PYX_ERR(0, 1, __pyx_L1_error)
if (unlikely(__Pyx_modinit_type_import_code() < 0)) __PYX_ERR(0, 1, __pyx_L1_error)
if (unlikely(__Pyx_modinit_variable_import_code() < 0)) __PYX_ERR(0, 1, __pyx_L1_error)
if (unlikely(__Pyx_modinit_function_import_code() < 0)) __PYX_ERR(0, 1, __pyx_L1_error)
/*--- Execution code ---*/
#if defined(__Pyx_Generator_USED) || defined(__Pyx_Coroutine_USED)
if (__Pyx_patch_abc() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
#endif
__Pyx_TraceCall("__Pyx_PyMODINIT_FUNC PyInit_arc_eager(void)", __pyx_f[0], 1, 0, __PYX_ERR(0, 1, __pyx_L1_error));
/* "spacy/syntax/arc_eager.pyx":9
* from cpython.ref cimport Py_INCREF
* from cymem.cymem cimport Pool
* from collections import OrderedDict, defaultdict, Counter # <<<<<<<<<<<<<<
* from thinc.extra.search cimport Beam
* import json
*/
__pyx_t_1 = PyList_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 9, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_INCREF(__pyx_n_s_OrderedDict);
__Pyx_GIVEREF(__pyx_n_s_OrderedDict);
PyList_SET_ITEM(__pyx_t_1, 0, __pyx_n_s_OrderedDict);
__Pyx_INCREF(__pyx_n_s_defaultdict);
__Pyx_GIVEREF(__pyx_n_s_defaultdict);
PyList_SET_ITEM(__pyx_t_1, 1, __pyx_n_s_defaultdict);
__Pyx_INCREF(__pyx_n_s_Counter);
__Pyx_GIVEREF(__pyx_n_s_Counter);
PyList_SET_ITEM(__pyx_t_1, 2, __pyx_n_s_Counter);
__pyx_t_2 = __Pyx_Import(__pyx_n_s_collections, __pyx_t_1, -1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 9, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__pyx_t_1 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_OrderedDict); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 9, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
if (PyDict_SetItem(__pyx_d, __pyx_n_s_OrderedDict, __pyx_t_1) < 0) __PYX_ERR(0, 9, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__pyx_t_1 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_defaultdict); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 9, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
if (PyDict_SetItem(__pyx_d, __pyx_n_s_defaultdict, __pyx_t_1) < 0) __PYX_ERR(0, 9, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__pyx_t_1 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_Counter); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 9, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
if (PyDict_SetItem(__pyx_d, __pyx_n_s_Counter, __pyx_t_1) < 0) __PYX_ERR(0, 9, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
/* "spacy/syntax/arc_eager.pyx":11
* from collections import OrderedDict, defaultdict, Counter
* from thinc.extra.search cimport Beam
* import json # <<<<<<<<<<<<<<
*
* from .nonproj import is_nonproj_tree
*/
__pyx_t_2 = __Pyx_Import(__pyx_n_s_json, 0, -1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 11, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
if (PyDict_SetItem(__pyx_d, __pyx_n_s_json, __pyx_t_2) < 0) __PYX_ERR(0, 11, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
/* "spacy/syntax/arc_eager.pyx":13
* import json
*
* from .nonproj import is_nonproj_tree # <<<<<<<<<<<<<<
* from ..typedefs cimport hash_t, attr_t
* from ..strings cimport hash_string
*/
__pyx_t_2 = PyList_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 13, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_INCREF(__pyx_n_s_is_nonproj_tree);
__Pyx_GIVEREF(__pyx_n_s_is_nonproj_tree);
PyList_SET_ITEM(__pyx_t_2, 0, __pyx_n_s_is_nonproj_tree);
__pyx_t_1 = __Pyx_Import(__pyx_n_s_nonproj, __pyx_t_2, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 13, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__pyx_t_2 = __Pyx_ImportFrom(__pyx_t_1, __pyx_n_s_is_nonproj_tree); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 13, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
if (PyDict_SetItem(__pyx_d, __pyx_n_s_is_nonproj_tree, __pyx_t_2) < 0) __PYX_ERR(0, 13, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
/* "spacy/syntax/arc_eager.pyx":18
* from .stateclass cimport StateClass
* from ._state cimport StateC
* from . import nonproj # <<<<<<<<<<<<<<
* from .transition_system cimport move_cost_func_t, label_cost_func_t
* from ..gold cimport GoldParse, GoldParseC
*/
__pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 18, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_INCREF(__pyx_n_s_nonproj);
__Pyx_GIVEREF(__pyx_n_s_nonproj);
PyList_SET_ITEM(__pyx_t_1, 0, __pyx_n_s_nonproj);
__pyx_t_2 = __Pyx_Import(__pyx_n_s_, __pyx_t_1, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 18, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__pyx_t_1 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_nonproj); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 18, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
if (PyDict_SetItem(__pyx_d, __pyx_n_s_nonproj, __pyx_t_1) < 0) __PYX_ERR(0, 18, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
/* "spacy/syntax/arc_eager.pyx":22
* from ..gold cimport GoldParse, GoldParseC
* from ..structs cimport TokenC
* from ..errors import Errors # <<<<<<<<<<<<<<
* from ..tokens.doc cimport Doc, set_children_from_heads
*
*/
__pyx_t_2 = PyList_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 22, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_INCREF(__pyx_n_s_Errors);
__Pyx_GIVEREF(__pyx_n_s_Errors);
PyList_SET_ITEM(__pyx_t_2, 0, __pyx_n_s_Errors);
__pyx_t_1 = __Pyx_Import(__pyx_n_s_errors, __pyx_t_2, 2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 22, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__pyx_t_2 = __Pyx_ImportFrom(__pyx_t_1, __pyx_n_s_Errors); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 22, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
if (PyDict_SetItem(__pyx_d, __pyx_n_s_Errors, __pyx_t_2) < 0) __PYX_ERR(0, 22, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
/* "spacy/syntax/arc_eager.pyx":26
*
* # Calculate cost as gold/not gold. We don't use scalar value anyway.
* cdef int BINARY_COSTS = 1 # <<<<<<<<<<<<<<
* cdef weight_t MIN_SCORE = -90000
* cdef attr_t SUBTOK_LABEL = hash_string('subtok')
*/
__pyx_v_5spacy_6syntax_9arc_eager_BINARY_COSTS = 1;
/* "spacy/syntax/arc_eager.pyx":27
* # Calculate cost as gold/not gold. We don't use scalar value anyway.
* cdef int BINARY_COSTS = 1
* cdef weight_t MIN_SCORE = -90000 # <<<<<<<<<<<<<<
* cdef attr_t SUBTOK_LABEL = hash_string('subtok')
*
*/
__pyx_v_5spacy_6syntax_9arc_eager_MIN_SCORE = -90000.0;
/* "spacy/syntax/arc_eager.pyx":28
* cdef int BINARY_COSTS = 1
* cdef weight_t MIN_SCORE = -90000
* cdef attr_t SUBTOK_LABEL = hash_string('subtok') # <<<<<<<<<<<<<<
*
* DEF NON_MONOTONIC = True
*/
__pyx_t_3 = __pyx_f_5spacy_7strings_hash_string(__pyx_n_u_subtok, 0); if (unlikely(__pyx_t_3 == ((__pyx_t_5spacy_8typedefs_hash_t)0))) __PYX_ERR(0, 28, __pyx_L1_error)
__pyx_v_5spacy_6syntax_9arc_eager_SUBTOK_LABEL = __pyx_t_3;
/* "spacy/syntax/arc_eager.pyx":46
*
*
* MOVE_NAMES = [None] * N_MOVES # <<<<<<<<<<<<<<
* MOVE_NAMES[SHIFT] = 'S'
* MOVE_NAMES[REDUCE] = 'D'
*/
__pyx_t_1 = PyList_New(1 * ((__pyx_e_5spacy_6syntax_9arc_eager_N_MOVES<0) ? 0:__pyx_e_5spacy_6syntax_9arc_eager_N_MOVES)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 46, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
{ Py_ssize_t __pyx_temp;
for (__pyx_temp=0; __pyx_temp < __pyx_e_5spacy_6syntax_9arc_eager_N_MOVES; __pyx_temp++) {
__Pyx_INCREF(Py_None);
__Pyx_GIVEREF(Py_None);
PyList_SET_ITEM(__pyx_t_1, __pyx_temp, Py_None);
}
}
if (PyDict_SetItem(__pyx_d, __pyx_n_s_MOVE_NAMES, __pyx_t_1) < 0) __PYX_ERR(0, 46, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
/* "spacy/syntax/arc_eager.pyx":47
*
* MOVE_NAMES = [None] * N_MOVES
* MOVE_NAMES[SHIFT] = 'S' # <<<<<<<<<<<<<<
* MOVE_NAMES[REDUCE] = 'D'
* MOVE_NAMES[LEFT] = 'L'
*/
__Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_MOVE_NAMES); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 47, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
if (unlikely(__Pyx_SetItemInt(__pyx_t_1, __pyx_e_5spacy_6syntax_9arc_eager_SHIFT, __pyx_n_u_S, int, 1, __Pyx_PyInt_From_int, 0, 1, 1) < 0)) __PYX_ERR(0, 47, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
/* "spacy/syntax/arc_eager.pyx":48
* MOVE_NAMES = [None] * N_MOVES
* MOVE_NAMES[SHIFT] = 'S'
* MOVE_NAMES[REDUCE] = 'D' # <<<<<<<<<<<<<<
* MOVE_NAMES[LEFT] = 'L'
* MOVE_NAMES[RIGHT] = 'R'
*/
__Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_MOVE_NAMES); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 48, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
if (unlikely(__Pyx_SetItemInt(__pyx_t_1, __pyx_e_5spacy_6syntax_9arc_eager_REDUCE, __pyx_n_u_D, int, 1, __Pyx_PyInt_From_int, 0, 1, 1) < 0)) __PYX_ERR(0, 48, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
/* "spacy/syntax/arc_eager.pyx":49
* MOVE_NAMES[SHIFT] = 'S'
* MOVE_NAMES[REDUCE] = 'D'
* MOVE_NAMES[LEFT] = 'L' # <<<<<<<<<<<<<<
* MOVE_NAMES[RIGHT] = 'R'
* MOVE_NAMES[BREAK] = 'B'
*/
__Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_MOVE_NAMES); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 49, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
if (unlikely(__Pyx_SetItemInt(__pyx_t_1, __pyx_e_5spacy_6syntax_9arc_eager_LEFT, __pyx_n_u_L, int, 1, __Pyx_PyInt_From_int, 0, 1, 1) < 0)) __PYX_ERR(0, 49, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
/* "spacy/syntax/arc_eager.pyx":50
* MOVE_NAMES[REDUCE] = 'D'
* MOVE_NAMES[LEFT] = 'L'
* MOVE_NAMES[RIGHT] = 'R' # <<<<<<<<<<<<<<
* MOVE_NAMES[BREAK] = 'B'
*
*/
__Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_MOVE_NAMES); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 50, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
if (unlikely(__Pyx_SetItemInt(__pyx_t_1, __pyx_e_5spacy_6syntax_9arc_eager_RIGHT, __pyx_n_u_R, int, 1, __Pyx_PyInt_From_int, 0, 1, 1) < 0)) __PYX_ERR(0, 50, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
/* "spacy/syntax/arc_eager.pyx":51
* MOVE_NAMES[LEFT] = 'L'
* MOVE_NAMES[RIGHT] = 'R'
* MOVE_NAMES[BREAK] = 'B' # <<<<<<<<<<<<<<
*
*
*/
__Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_MOVE_NAMES); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 51, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
if (unlikely(__Pyx_SetItemInt(__pyx_t_1, __pyx_e_5spacy_6syntax_9arc_eager_BREAK, __pyx_n_u_B, int, 1, __Pyx_PyInt_From_int, 0, 1, 1) < 0)) __PYX_ERR(0, 51, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
/* "spacy/syntax/arc_eager.pyx":339
*
* @classmethod
* def get_actions(cls, **kwargs): # <<<<<<<<<<<<<<
* min_freq = kwargs.get('min_freq', None)
* actions = defaultdict(lambda: Counter())
*/
__Pyx_GetNameInClass(__pyx_t_1, (PyObject *)__pyx_ptype_5spacy_6syntax_9arc_eager_ArcEager, __pyx_n_s_get_actions); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 339, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
/* "spacy/syntax/arc_eager.pyx":338
* self.del_beam_state = _del_state
*
* @classmethod # <<<<<<<<<<<<<<
* def get_actions(cls, **kwargs):
* min_freq = kwargs.get('min_freq', None)
*/
__pyx_t_2 = __Pyx_Method_ClassMethod(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 338, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
if (PyDict_SetItem((PyObject *)__pyx_ptype_5spacy_6syntax_9arc_eager_ArcEager->tp_dict, __pyx_n_s_get_actions, __pyx_t_2) < 0) __PYX_ERR(0, 339, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
PyType_Modified(__pyx_ptype_5spacy_6syntax_9arc_eager_ArcEager);
/* "(tree fragment)":1
* def __pyx_unpickle_Shift(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<<
* cdef object __pyx_PickleError
* cdef object __pyx_result
*/
__pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_5spacy_6syntax_9arc_eager_1__pyx_unpickle_Shift, NULL, __pyx_n_s_spacy_syntax_arc_eager); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
if (PyDict_SetItem(__pyx_d, __pyx_n_s_pyx_unpickle_Shift, __pyx_t_2) < 0) __PYX_ERR(1, 1, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
/* "(tree fragment)":11
* __pyx_unpickle_Shift__set_state(<Shift> __pyx_result, __pyx_state)
* return __pyx_result
* cdef __pyx_unpickle_Shift__set_state(Shift __pyx_result, tuple __pyx_state): # <<<<<<<<<<<<<<
* if len(__pyx_state) > 0 and hasattr(__pyx_result, '__dict__'):
* __pyx_result.__dict__.update(__pyx_state[0])
*/
__pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_5spacy_6syntax_9arc_eager_3__pyx_unpickle_Reduce, NULL, __pyx_n_s_spacy_syntax_arc_eager); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
if (PyDict_SetItem(__pyx_d, __pyx_n_s_pyx_unpickle_Reduce, __pyx_t_2) < 0) __PYX_ERR(1, 1, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
/* "(tree fragment)":1
* def __pyx_unpickle_LeftArc(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<<
* cdef object __pyx_PickleError
* cdef object __pyx_result
*/
__pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_5spacy_6syntax_9arc_eager_5__pyx_unpickle_LeftArc, NULL, __pyx_n_s_spacy_syntax_arc_eager); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
if (PyDict_SetItem(__pyx_d, __pyx_n_s_pyx_unpickle_LeftArc, __pyx_t_2) < 0) __PYX_ERR(1, 1, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
/* "(tree fragment)":11
* __pyx_unpickle_LeftArc__set_state(<LeftArc> __pyx_result, __pyx_state)
* return __pyx_result
* cdef __pyx_unpickle_LeftArc__set_state(LeftArc __pyx_result, tuple __pyx_state): # <<<<<<<<<<<<<<
* if len(__pyx_state) > 0 and hasattr(__pyx_result, '__dict__'):
* __pyx_result.__dict__.update(__pyx_state[0])
*/
__pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_5spacy_6syntax_9arc_eager_7__pyx_unpickle_RightArc, NULL, __pyx_n_s_spacy_syntax_arc_eager); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
if (PyDict_SetItem(__pyx_d, __pyx_n_s_pyx_unpickle_RightArc, __pyx_t_2) < 0) __PYX_ERR(1, 1, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
/* "(tree fragment)":1
* def __pyx_unpickle_Break(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<<
* cdef object __pyx_PickleError
* cdef object __pyx_result
*/
__pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_5spacy_6syntax_9arc_eager_9__pyx_unpickle_Break, NULL, __pyx_n_s_spacy_syntax_arc_eager); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
if (PyDict_SetItem(__pyx_d, __pyx_n_s_pyx_unpickle_Break, __pyx_t_2) < 0) __PYX_ERR(1, 1, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
/* "spacy/syntax/arc_eager.pyx":1
* # cython: profile=True # <<<<<<<<<<<<<<
* # cython: cdivision=True
* # cython: infer_types=True
*/
__pyx_t_2 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
if (PyDict_SetItem(__pyx_d, __pyx_n_s_test, __pyx_t_2) < 0) __PYX_ERR(0, 1, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
/* "View.MemoryView":209
* info.obj = self
*
* __pyx_getbuffer = capsule(<void *> &__pyx_array_getbuffer, "getbuffer(obj, view, flags)") # <<<<<<<<<<<<<<
*
* def __dealloc__(array self):
*/
__pyx_t_2 = __pyx_capsule_create(((void *)(&__pyx_array_getbuffer)), ((char *)"getbuffer(obj, view, flags)")); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 209, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
if (PyDict_SetItem((PyObject *)__pyx_array_type->tp_dict, __pyx_n_s_pyx_getbuffer, __pyx_t_2) < 0) __PYX_ERR(1, 209, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
PyType_Modified(__pyx_array_type);
/* "View.MemoryView":286
* return self.name
*
* cdef generic = Enum("<strided and direct or indirect>") # <<<<<<<<<<<<<<
* cdef strided = Enum("<strided and direct>") # default
* cdef indirect = Enum("<strided and indirect>")
*/
__pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_MemviewEnum_type), __pyx_tuple__43, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 286, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_XGOTREF(generic);
__Pyx_DECREF_SET(generic, __pyx_t_2);
__Pyx_GIVEREF(__pyx_t_2);
__pyx_t_2 = 0;
/* "View.MemoryView":287
*
* cdef generic = Enum("<strided and direct or indirect>")
* cdef strided = Enum("<strided and direct>") # default # <<<<<<<<<<<<<<
* cdef indirect = Enum("<strided and indirect>")
*
*/
__pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_MemviewEnum_type), __pyx_tuple__44, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 287, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_XGOTREF(strided);
__Pyx_DECREF_SET(strided, __pyx_t_2);
__Pyx_GIVEREF(__pyx_t_2);
__pyx_t_2 = 0;
/* "View.MemoryView":288
* cdef generic = Enum("<strided and direct or indirect>")
* cdef strided = Enum("<strided and direct>") # default
* cdef indirect = Enum("<strided and indirect>") # <<<<<<<<<<<<<<
*
*
*/
__pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_MemviewEnum_type), __pyx_tuple__45, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 288, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_XGOTREF(indirect);
__Pyx_DECREF_SET(indirect, __pyx_t_2);
__Pyx_GIVEREF(__pyx_t_2);
__pyx_t_2 = 0;
/* "View.MemoryView":291
*
*
* cdef contiguous = Enum("<contiguous and direct>") # <<<<<<<<<<<<<<
* cdef indirect_contiguous = Enum("<contiguous and indirect>")
*
*/
__pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_MemviewEnum_type), __pyx_tuple__46, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 291, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_XGOTREF(contiguous);
__Pyx_DECREF_SET(contiguous, __pyx_t_2);
__Pyx_GIVEREF(__pyx_t_2);
__pyx_t_2 = 0;
/* "View.MemoryView":292
*
* cdef contiguous = Enum("<contiguous and direct>")
* cdef indirect_contiguous = Enum("<contiguous and indirect>") # <<<<<<<<<<<<<<
*
*
*/
__pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_MemviewEnum_type), __pyx_tuple__47, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 292, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_XGOTREF(indirect_contiguous);
__Pyx_DECREF_SET(indirect_contiguous, __pyx_t_2);
__Pyx_GIVEREF(__pyx_t_2);
__pyx_t_2 = 0;
/* "View.MemoryView":316
*
* DEF THREAD_LOCKS_PREALLOCATED = 8
* cdef int __pyx_memoryview_thread_locks_used = 0 # <<<<<<<<<<<<<<
* cdef PyThread_type_lock[THREAD_LOCKS_PREALLOCATED] __pyx_memoryview_thread_locks = [
* PyThread_allocate_lock(),
*/
__pyx_memoryview_thread_locks_used = 0;
/* "View.MemoryView":317
* DEF THREAD_LOCKS_PREALLOCATED = 8
* cdef int __pyx_memoryview_thread_locks_used = 0
* cdef PyThread_type_lock[THREAD_LOCKS_PREALLOCATED] __pyx_memoryview_thread_locks = [ # <<<<<<<<<<<<<<
* PyThread_allocate_lock(),
* PyThread_allocate_lock(),
*/
__pyx_t_4[0] = PyThread_allocate_lock();
__pyx_t_4[1] = PyThread_allocate_lock();
__pyx_t_4[2] = PyThread_allocate_lock();
__pyx_t_4[3] = PyThread_allocate_lock();
__pyx_t_4[4] = PyThread_allocate_lock();
__pyx_t_4[5] = PyThread_allocate_lock();
__pyx_t_4[6] = PyThread_allocate_lock();
__pyx_t_4[7] = PyThread_allocate_lock();
memcpy(&(__pyx_memoryview_thread_locks[0]), __pyx_t_4, sizeof(__pyx_memoryview_thread_locks[0]) * (8));
/* "View.MemoryView":549
* info.obj = self
*
* __pyx_getbuffer = capsule(<void *> &__pyx_memoryview_getbuffer, "getbuffer(obj, view, flags)") # <<<<<<<<<<<<<<
*
*
*/
__pyx_t_2 = __pyx_capsule_create(((void *)(&__pyx_memoryview_getbuffer)), ((char *)"getbuffer(obj, view, flags)")); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 549, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
if (PyDict_SetItem((PyObject *)__pyx_memoryview_type->tp_dict, __pyx_n_s_pyx_getbuffer, __pyx_t_2) < 0) __PYX_ERR(1, 549, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
PyType_Modified(__pyx_memoryview_type);
/* "View.MemoryView":995
* return self.from_object
*
* __pyx_getbuffer = capsule(<void *> &__pyx_memoryview_getbuffer, "getbuffer(obj, view, flags)") # <<<<<<<<<<<<<<
*
*
*/
__pyx_t_2 = __pyx_capsule_create(((void *)(&__pyx_memoryview_getbuffer)), ((char *)"getbuffer(obj, view, flags)")); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 995, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
if (PyDict_SetItem((PyObject *)__pyx_memoryviewslice_type->tp_dict, __pyx_n_s_pyx_getbuffer, __pyx_t_2) < 0) __PYX_ERR(1, 995, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
PyType_Modified(__pyx_memoryviewslice_type);
/* "(tree fragment)":1
* def __pyx_unpickle_Enum(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<<
* cdef object __pyx_PickleError
* cdef object __pyx_result
*/
__pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_15View_dot_MemoryView_1__pyx_unpickle_Enum, NULL, __pyx_n_s_View_MemoryView); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
if (PyDict_SetItem(__pyx_d, __pyx_n_s_pyx_unpickle_Enum, __pyx_t_2) < 0) __PYX_ERR(1, 1, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
/* "(tree fragment)":11
* __pyx_unpickle_Enum__set_state(<Enum> __pyx_result, __pyx_state)
* return __pyx_result
* cdef __pyx_unpickle_Enum__set_state(Enum __pyx_result, tuple __pyx_state): # <<<<<<<<<<<<<<
* __pyx_result.name = __pyx_state[0]
* if len(__pyx_state) > 1 and hasattr(__pyx_result, '__dict__'):
*/
__Pyx_TraceReturn(Py_None, 0);
/*--- Wrapped vars code ---*/
goto __pyx_L0;
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_1);
__Pyx_XDECREF(__pyx_t_2);
if (__pyx_m) {
if (__pyx_d) {
__Pyx_AddTraceback("init spacy.syntax.arc_eager", __pyx_clineno, __pyx_lineno, __pyx_filename);
}
Py_CLEAR(__pyx_m);
} else if (!PyErr_Occurred()) {
PyErr_SetString(PyExc_ImportError, "init spacy.syntax.arc_eager");
}
__pyx_L0:;
__Pyx_RefNannyFinishContext();
#if CYTHON_PEP489_MULTI_PHASE_INIT
return (__pyx_m != NULL) ? 0 : -1;
#elif PY_MAJOR_VERSION >= 3
return __pyx_m;
#else
return;
#endif
}
/* --- Runtime support code --- */
/* Refnanny */
#if CYTHON_REFNANNY
static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname) {
PyObject *m = NULL, *p = NULL;
void *r = NULL;
m = PyImport_ImportModule(modname);
if (!m) goto end;
p = PyObject_GetAttrString(m, "RefNannyAPI");
if (!p) goto end;
r = PyLong_AsVoidPtr(p);
end:
Py_XDECREF(p);
Py_XDECREF(m);
return (__Pyx_RefNannyAPIStruct *)r;
}
#endif
/* PyObjectGetAttrStr */
#if CYTHON_USE_TYPE_SLOTS
static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name) {
PyTypeObject* tp = Py_TYPE(obj);
if (likely(tp->tp_getattro))
return tp->tp_getattro(obj, attr_name);
#if PY_MAJOR_VERSION < 3
if (likely(tp->tp_getattr))
return tp->tp_getattr(obj, PyString_AS_STRING(attr_name));
#endif
return PyObject_GetAttr(obj, attr_name);
}
#endif
/* GetBuiltinName */
static PyObject *__Pyx_GetBuiltinName(PyObject *name) {
PyObject* result = __Pyx_PyObject_GetAttrStr(__pyx_b, name);
if (unlikely(!result)) {
PyErr_Format(PyExc_NameError,
#if PY_MAJOR_VERSION >= 3
"name '%U' is not defined", name);
#else
"name '%.200s' is not defined", PyString_AS_STRING(name));
#endif
}
return result;
}
/* PyErrFetchRestore */
#if CYTHON_FAST_THREAD_STATE
static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) {
PyObject *tmp_type, *tmp_value, *tmp_tb;
tmp_type = tstate->curexc_type;
tmp_value = tstate->curexc_value;
tmp_tb = tstate->curexc_traceback;
tstate->curexc_type = type;
tstate->curexc_value = value;
tstate->curexc_traceback = tb;
Py_XDECREF(tmp_type);
Py_XDECREF(tmp_value);
Py_XDECREF(tmp_tb);
}
static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) {
*type = tstate->curexc_type;
*value = tstate->curexc_value;
*tb = tstate->curexc_traceback;
tstate->curexc_type = 0;
tstate->curexc_value = 0;
tstate->curexc_traceback = 0;
}
#endif
/* Profile */
#if CYTHON_PROFILE
static int __Pyx_TraceSetupAndCall(PyCodeObject** code,
PyFrameObject** frame,
PyThreadState* tstate,
const char *funcname,
const char *srcfile,
int firstlineno) {
PyObject *type, *value, *traceback;
int retval;
if (*frame == NULL || !CYTHON_PROFILE_REUSE_FRAME) {
if (*code == NULL) {
*code = __Pyx_createFrameCodeObject(funcname, srcfile, firstlineno);
if (*code == NULL) return 0;
}
*frame = PyFrame_New(
tstate, /*PyThreadState *tstate*/
*code, /*PyCodeObject *code*/
__pyx_d, /*PyObject *globals*/
0 /*PyObject *locals*/
);
if (*frame == NULL) return 0;
if (CYTHON_TRACE && (*frame)->f_trace == NULL) {
Py_INCREF(Py_None);
(*frame)->f_trace = Py_None;
}
#if PY_VERSION_HEX < 0x030400B1
} else {
(*frame)->f_tstate = tstate;
#endif
}
__Pyx_PyFrame_SetLineNumber(*frame, firstlineno);
retval = 1;
tstate->tracing++;
tstate->use_tracing = 0;
__Pyx_ErrFetchInState(tstate, &type, &value, &traceback);
#if CYTHON_TRACE
if (tstate->c_tracefunc)
retval = tstate->c_tracefunc(tstate->c_traceobj, *frame, PyTrace_CALL, NULL) == 0;
if (retval && tstate->c_profilefunc)
#endif
retval = tstate->c_profilefunc(tstate->c_profileobj, *frame, PyTrace_CALL, NULL) == 0;
tstate->use_tracing = (tstate->c_profilefunc ||
(CYTHON_TRACE && tstate->c_tracefunc));
tstate->tracing--;
if (retval) {
__Pyx_ErrRestoreInState(tstate, type, value, traceback);
return tstate->use_tracing && retval;
} else {
Py_XDECREF(type);
Py_XDECREF(value);
Py_XDECREF(traceback);
return -1;
}
}
static PyCodeObject *__Pyx_createFrameCodeObject(const char *funcname, const char *srcfile, int firstlineno) {
PyCodeObject *py_code = 0;
#if PY_MAJOR_VERSION >= 3
py_code = PyCode_NewEmpty(srcfile, funcname, firstlineno);
if (likely(py_code)) {
py_code->co_flags |= CO_OPTIMIZED | CO_NEWLOCALS;
}
#else
PyObject *py_srcfile = 0;
PyObject *py_funcname = 0;
py_funcname = PyString_FromString(funcname);
if (unlikely(!py_funcname)) goto bad;
py_srcfile = PyString_FromString(srcfile);
if (unlikely(!py_srcfile)) goto bad;
py_code = PyCode_New(
0,
0,
0,
CO_OPTIMIZED | CO_NEWLOCALS,
__pyx_empty_bytes, /*PyObject *code,*/
__pyx_empty_tuple, /*PyObject *consts,*/
__pyx_empty_tuple, /*PyObject *names,*/
__pyx_empty_tuple, /*PyObject *varnames,*/
__pyx_empty_tuple, /*PyObject *freevars,*/
__pyx_empty_tuple, /*PyObject *cellvars,*/
py_srcfile, /*PyObject *filename,*/
py_funcname, /*PyObject *name,*/
firstlineno,
__pyx_empty_bytes /*PyObject *lnotab*/
);
bad:
Py_XDECREF(py_srcfile);
Py_XDECREF(py_funcname);
#endif
return py_code;
}
#endif
/* WriteUnraisableException */
static void __Pyx_WriteUnraisable(const char *name, CYTHON_UNUSED int clineno,
CYTHON_UNUSED int lineno, CYTHON_UNUSED const char *filename,
int full_traceback, CYTHON_UNUSED int nogil) {
PyObject *old_exc, *old_val, *old_tb;
PyObject *ctx;
__Pyx_PyThreadState_declare
#ifdef WITH_THREAD
PyGILState_STATE state;
if (nogil)
state = PyGILState_Ensure();
#ifdef _MSC_VER
else state = (PyGILState_STATE)-1;
#endif
#endif
__Pyx_PyThreadState_assign
__Pyx_ErrFetch(&old_exc, &old_val, &old_tb);
if (full_traceback) {
Py_XINCREF(old_exc);
Py_XINCREF(old_val);
Py_XINCREF(old_tb);
__Pyx_ErrRestore(old_exc, old_val, old_tb);
PyErr_PrintEx(1);
}
#if PY_MAJOR_VERSION < 3
ctx = PyString_FromString(name);
#else
ctx = PyUnicode_FromString(name);
#endif
__Pyx_ErrRestore(old_exc, old_val, old_tb);
if (!ctx) {
PyErr_WriteUnraisable(Py_None);
} else {
PyErr_WriteUnraisable(ctx);
Py_DECREF(ctx);
}
#ifdef WITH_THREAD
if (nogil)
PyGILState_Release(state);
#endif
}
/* PyErrExceptionMatches */
#if CYTHON_FAST_THREAD_STATE
static int __Pyx_PyErr_ExceptionMatchesTuple(PyObject *exc_type, PyObject *tuple) {
Py_ssize_t i, n;
n = PyTuple_GET_SIZE(tuple);
#if PY_MAJOR_VERSION >= 3
for (i=0; i<n; i++) {
if (exc_type == PyTuple_GET_ITEM(tuple, i)) return 1;
}
#endif
for (i=0; i<n; i++) {
if (__Pyx_PyErr_GivenExceptionMatches(exc_type, PyTuple_GET_ITEM(tuple, i))) return 1;
}
return 0;
}
static CYTHON_INLINE int __Pyx_PyErr_ExceptionMatchesInState(PyThreadState* tstate, PyObject* err) {
PyObject *exc_type = tstate->curexc_type;
if (exc_type == err) return 1;
if (unlikely(!exc_type)) return 0;
if (unlikely(PyTuple_Check(err)))
return __Pyx_PyErr_ExceptionMatchesTuple(exc_type, err);
return __Pyx_PyErr_GivenExceptionMatches(exc_type, err);
}
#endif
/* GetAttr */
static CYTHON_INLINE PyObject *__Pyx_GetAttr(PyObject *o, PyObject *n) {
#if CYTHON_USE_TYPE_SLOTS
#if PY_MAJOR_VERSION >= 3
if (likely(PyUnicode_Check(n)))
#else
if (likely(PyString_Check(n)))
#endif
return __Pyx_PyObject_GetAttrStr(o, n);
#endif
return PyObject_GetAttr(o, n);
}
/* GetAttr3 */
static PyObject *__Pyx_GetAttr3Default(PyObject *d) {
__Pyx_PyThreadState_declare
__Pyx_PyThreadState_assign
if (unlikely(!__Pyx_PyErr_ExceptionMatches(PyExc_AttributeError)))
return NULL;
__Pyx_PyErr_Clear();
Py_INCREF(d);
return d;
}
static CYTHON_INLINE PyObject *__Pyx_GetAttr3(PyObject *o, PyObject *n, PyObject *d) {
PyObject *r = __Pyx_GetAttr(o, n);
return (likely(r)) ? r : __Pyx_GetAttr3Default(d);
}
/* PyDictVersioning */
#if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_TYPE_SLOTS
static CYTHON_INLINE PY_UINT64_T __Pyx_get_tp_dict_version(PyObject *obj) {
PyObject *dict = Py_TYPE(obj)->tp_dict;
return likely(dict) ? __PYX_GET_DICT_VERSION(dict) : 0;
}
static CYTHON_INLINE PY_UINT64_T __Pyx_get_object_dict_version(PyObject *obj) {
PyObject **dictptr = NULL;
Py_ssize_t offset = Py_TYPE(obj)->tp_dictoffset;
if (offset) {
#if CYTHON_COMPILING_IN_CPYTHON
dictptr = (likely(offset > 0)) ? (PyObject **) ((char *)obj + offset) : _PyObject_GetDictPtr(obj);
#else
dictptr = _PyObject_GetDictPtr(obj);
#endif
}
return (dictptr && *dictptr) ? __PYX_GET_DICT_VERSION(*dictptr) : 0;
}
static CYTHON_INLINE int __Pyx_object_dict_version_matches(PyObject* obj, PY_UINT64_T tp_dict_version, PY_UINT64_T obj_dict_version) {
PyObject *dict = Py_TYPE(obj)->tp_dict;
if (unlikely(!dict) || unlikely(tp_dict_version != __PYX_GET_DICT_VERSION(dict)))
return 0;
return obj_dict_version == __Pyx_get_object_dict_version(obj);
}
#endif
/* GetModuleGlobalName */
#if CYTHON_USE_DICT_VERSIONS
static PyObject *__Pyx__GetModuleGlobalName(PyObject *name, PY_UINT64_T *dict_version, PyObject **dict_cached_value)
#else
static CYTHON_INLINE PyObject *__Pyx__GetModuleGlobalName(PyObject *name)
#endif
{
PyObject *result;
#if !CYTHON_AVOID_BORROWED_REFS
#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030500A1
result = _PyDict_GetItem_KnownHash(__pyx_d, name, ((PyASCIIObject *) name)->hash);
__PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version)
if (likely(result)) {
return __Pyx_NewRef(result);
} else if (unlikely(PyErr_Occurred())) {
return NULL;
}
#else
result = PyDict_GetItem(__pyx_d, name);
__PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version)
if (likely(result)) {
return __Pyx_NewRef(result);
}
#endif
#else
result = PyObject_GetItem(__pyx_d, name);
__PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version)
if (likely(result)) {
return __Pyx_NewRef(result);
}
PyErr_Clear();
#endif
return __Pyx_GetBuiltinName(name);
}
/* KeywordStringCheck */
static int __Pyx_CheckKeywordStrings(
PyObject *kwdict,
const char* function_name,
int kw_allowed)
{
PyObject* key = 0;
Py_ssize_t pos = 0;
#if CYTHON_COMPILING_IN_PYPY
if (!kw_allowed && PyDict_Next(kwdict, &pos, &key, 0))
goto invalid_keyword;
return 1;
#else
while (PyDict_Next(kwdict, &pos, &key, 0)) {
#if PY_MAJOR_VERSION < 3
if (unlikely(!PyString_Check(key)))
#endif
if (unlikely(!PyUnicode_Check(key)))
goto invalid_keyword_type;
}
if ((!kw_allowed) && unlikely(key))
goto invalid_keyword;
return 1;
invalid_keyword_type:
PyErr_Format(PyExc_TypeError,
"%.200s() keywords must be strings", function_name);
return 0;
#endif
invalid_keyword:
PyErr_Format(PyExc_TypeError,
#if PY_MAJOR_VERSION < 3
"%.200s() got an unexpected keyword argument '%.200s'",
function_name, PyString_AsString(key));
#else
"%s() got an unexpected keyword argument '%U'",
function_name, key);
#endif
return 0;
}
/* PyObjectCall */
#if CYTHON_COMPILING_IN_CPYTHON
static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw) {
PyObject *result;
ternaryfunc call = func->ob_type->tp_call;
if (unlikely(!call))
return PyObject_Call(func, arg, kw);
if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object")))
return NULL;
result = (*call)(func, arg, kw);
Py_LeaveRecursiveCall();
if (unlikely(!result) && unlikely(!PyErr_Occurred())) {
PyErr_SetString(
PyExc_SystemError,
"NULL result without error in PyObject_Call");
}
return result;
}
#endif
/* RaiseArgTupleInvalid */
static void __Pyx_RaiseArgtupleInvalid(
const char* func_name,
int exact,
Py_ssize_t num_min,
Py_ssize_t num_max,
Py_ssize_t num_found)
{
Py_ssize_t num_expected;
const char *more_or_less;
if (num_found < num_min) {
num_expected = num_min;
more_or_less = "at least";
} else {
num_expected = num_max;
more_or_less = "at most";
}
if (exact) {
more_or_less = "exactly";
}
PyErr_Format(PyExc_TypeError,
"%.200s() takes %.8s %" CYTHON_FORMAT_SSIZE_T "d positional argument%.1s (%" CYTHON_FORMAT_SSIZE_T "d given)",
func_name, more_or_less, num_expected,
(num_expected == 1) ? "" : "s", num_found);
}
/* PyFunctionFastCall */
#if CYTHON_FAST_PYCALL
static PyObject* __Pyx_PyFunction_FastCallNoKw(PyCodeObject *co, PyObject **args, Py_ssize_t na,
PyObject *globals) {
PyFrameObject *f;
PyThreadState *tstate = __Pyx_PyThreadState_Current;
PyObject **fastlocals;
Py_ssize_t i;
PyObject *result;
assert(globals != NULL);
/* XXX Perhaps we should create a specialized
PyFrame_New() that doesn't take locals, but does
take builtins without sanity checking them.
*/
assert(tstate != NULL);
f = PyFrame_New(tstate, co, globals, NULL);
if (f == NULL) {
return NULL;
}
fastlocals = __Pyx_PyFrame_GetLocalsplus(f);
for (i = 0; i < na; i++) {
Py_INCREF(*args);
fastlocals[i] = *args++;
}
result = PyEval_EvalFrameEx(f,0);
++tstate->recursion_depth;
Py_DECREF(f);
--tstate->recursion_depth;
return result;
}
#if 1 || PY_VERSION_HEX < 0x030600B1
static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args, Py_ssize_t nargs, PyObject *kwargs) {
PyCodeObject *co = (PyCodeObject *)PyFunction_GET_CODE(func);
PyObject *globals = PyFunction_GET_GLOBALS(func);
PyObject *argdefs = PyFunction_GET_DEFAULTS(func);
PyObject *closure;
#if PY_MAJOR_VERSION >= 3
PyObject *kwdefs;
#endif
PyObject *kwtuple, **k;
PyObject **d;
Py_ssize_t nd;
Py_ssize_t nk;
PyObject *result;
assert(kwargs == NULL || PyDict_Check(kwargs));
nk = kwargs ? PyDict_Size(kwargs) : 0;
if (Py_EnterRecursiveCall((char*)" while calling a Python object")) {
return NULL;
}
if (
#if PY_MAJOR_VERSION >= 3
co->co_kwonlyargcount == 0 &&
#endif
likely(kwargs == NULL || nk == 0) &&
co->co_flags == (CO_OPTIMIZED | CO_NEWLOCALS | CO_NOFREE)) {
if (argdefs == NULL && co->co_argcount == nargs) {
result = __Pyx_PyFunction_FastCallNoKw(co, args, nargs, globals);
goto done;
}
else if (nargs == 0 && argdefs != NULL
&& co->co_argcount == Py_SIZE(argdefs)) {
/* function called with no arguments, but all parameters have
a default value: use default values as arguments .*/
args = &PyTuple_GET_ITEM(argdefs, 0);
result =__Pyx_PyFunction_FastCallNoKw(co, args, Py_SIZE(argdefs), globals);
goto done;
}
}
if (kwargs != NULL) {
Py_ssize_t pos, i;
kwtuple = PyTuple_New(2 * nk);
if (kwtuple == NULL) {
result = NULL;
goto done;
}
k = &PyTuple_GET_ITEM(kwtuple, 0);
pos = i = 0;
while (PyDict_Next(kwargs, &pos, &k[i], &k[i+1])) {
Py_INCREF(k[i]);
Py_INCREF(k[i+1]);
i += 2;
}
nk = i / 2;
}
else {
kwtuple = NULL;
k = NULL;
}
closure = PyFunction_GET_CLOSURE(func);
#if PY_MAJOR_VERSION >= 3
kwdefs = PyFunction_GET_KW_DEFAULTS(func);
#endif
if (argdefs != NULL) {
d = &PyTuple_GET_ITEM(argdefs, 0);
nd = Py_SIZE(argdefs);
}
else {
d = NULL;
nd = 0;
}
#if PY_MAJOR_VERSION >= 3
result = PyEval_EvalCodeEx((PyObject*)co, globals, (PyObject *)NULL,
args, (int)nargs,
k, (int)nk,
d, (int)nd, kwdefs, closure);
#else
result = PyEval_EvalCodeEx(co, globals, (PyObject *)NULL,
args, (int)nargs,
k, (int)nk,
d, (int)nd, closure);
#endif
Py_XDECREF(kwtuple);
done:
Py_LeaveRecursiveCall();
return result;
}
#endif
#endif
/* PyObjectCallMethO */
#if CYTHON_COMPILING_IN_CPYTHON
static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg) {
PyObject *self, *result;
PyCFunction cfunc;
cfunc = PyCFunction_GET_FUNCTION(func);
self = PyCFunction_GET_SELF(func);
if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object")))
return NULL;
result = cfunc(self, arg);
Py_LeaveRecursiveCall();
if (unlikely(!result) && unlikely(!PyErr_Occurred())) {
PyErr_SetString(
PyExc_SystemError,
"NULL result without error in PyObject_Call");
}
return result;
}
#endif
/* PyObjectCallNoArg */
#if CYTHON_COMPILING_IN_CPYTHON
static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func) {
#if CYTHON_FAST_PYCALL
if (PyFunction_Check(func)) {
return __Pyx_PyFunction_FastCall(func, NULL, 0);
}
#endif
#ifdef __Pyx_CyFunction_USED
if (likely(PyCFunction_Check(func) || __Pyx_CyFunction_Check(func)))
#else
if (likely(PyCFunction_Check(func)))
#endif
{
if (likely(PyCFunction_GET_FLAGS(func) & METH_NOARGS)) {
return __Pyx_PyObject_CallMethO(func, NULL);
}
}
return __Pyx_PyObject_Call(func, __pyx_empty_tuple, NULL);
}
#endif
/* PyCFunctionFastCall */
#if CYTHON_FAST_PYCCALL
static CYTHON_INLINE PyObject * __Pyx_PyCFunction_FastCall(PyObject *func_obj, PyObject **args, Py_ssize_t nargs) {
PyCFunctionObject *func = (PyCFunctionObject*)func_obj;
PyCFunction meth = PyCFunction_GET_FUNCTION(func);
PyObject *self = PyCFunction_GET_SELF(func);
int flags = PyCFunction_GET_FLAGS(func);
assert(PyCFunction_Check(func));
assert(METH_FASTCALL == (flags & ~(METH_CLASS | METH_STATIC | METH_COEXIST | METH_KEYWORDS | METH_STACKLESS)));
assert(nargs >= 0);
assert(nargs == 0 || args != NULL);
/* _PyCFunction_FastCallDict() must not be called with an exception set,
because it may clear it (directly or indirectly) and so the
caller loses its exception */
assert(!PyErr_Occurred());
if ((PY_VERSION_HEX < 0x030700A0) || unlikely(flags & METH_KEYWORDS)) {
return (*((__Pyx_PyCFunctionFastWithKeywords)(void*)meth)) (self, args, nargs, NULL);
} else {
return (*((__Pyx_PyCFunctionFast)(void*)meth)) (self, args, nargs);
}
}
#endif
/* PyObjectCallOneArg */
#if CYTHON_COMPILING_IN_CPYTHON
static PyObject* __Pyx__PyObject_CallOneArg(PyObject *func, PyObject *arg) {
PyObject *result;
PyObject *args = PyTuple_New(1);
if (unlikely(!args)) return NULL;
Py_INCREF(arg);
PyTuple_SET_ITEM(args, 0, arg);
result = __Pyx_PyObject_Call(func, args, NULL);
Py_DECREF(args);
return result;
}
static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) {
#if CYTHON_FAST_PYCALL
if (PyFunction_Check(func)) {
return __Pyx_PyFunction_FastCall(func, &arg, 1);
}
#endif
if (likely(PyCFunction_Check(func))) {
if (likely(PyCFunction_GET_FLAGS(func) & METH_O)) {
return __Pyx_PyObject_CallMethO(func, arg);
#if CYTHON_FAST_PYCCALL
} else if (PyCFunction_GET_FLAGS(func) & METH_FASTCALL) {
return __Pyx_PyCFunction_FastCall(func, &arg, 1);
#endif
}
}
return __Pyx__PyObject_CallOneArg(func, arg);
}
#else
static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) {
PyObject *result;
PyObject *args = PyTuple_Pack(1, arg);
if (unlikely(!args)) return NULL;
result = __Pyx_PyObject_Call(func, args, NULL);
Py_DECREF(args);
return result;
}
#endif
/* UnpackUnboundCMethod */
static int __Pyx_TryUnpackUnboundCMethod(__Pyx_CachedCFunction* target) {
PyObject *method;
method = __Pyx_PyObject_GetAttrStr(target->type, *target->method_name);
if (unlikely(!method))
return -1;
target->method = method;
#if CYTHON_COMPILING_IN_CPYTHON
#if PY_MAJOR_VERSION >= 3
if (likely(__Pyx_TypeCheck(method, &PyMethodDescr_Type)))
#endif
{
PyMethodDescrObject *descr = (PyMethodDescrObject*) method;
target->func = descr->d_method->ml_meth;
target->flag = descr->d_method->ml_flags & ~(METH_CLASS | METH_STATIC | METH_COEXIST | METH_STACKLESS);
}
#endif
return 0;
}
/* CallUnboundCMethod1 */
#if CYTHON_COMPILING_IN_CPYTHON
static CYTHON_INLINE PyObject* __Pyx_CallUnboundCMethod1(__Pyx_CachedCFunction* cfunc, PyObject* self, PyObject* arg) {
if (likely(cfunc->func)) {
int flag = cfunc->flag;
if (flag == METH_O) {
return (*(cfunc->func))(self, arg);
} else if (PY_VERSION_HEX >= 0x030600B1 && flag == METH_FASTCALL) {
if (PY_VERSION_HEX >= 0x030700A0) {
return (*(__Pyx_PyCFunctionFast)(void*)(PyCFunction)cfunc->func)(self, &arg, 1);
} else {
return (*(__Pyx_PyCFunctionFastWithKeywords)(void*)(PyCFunction)cfunc->func)(self, &arg, 1, NULL);
}
} else if (PY_VERSION_HEX >= 0x030700A0 && flag == (METH_FASTCALL | METH_KEYWORDS)) {
return (*(__Pyx_PyCFunctionFastWithKeywords)(void*)(PyCFunction)cfunc->func)(self, &arg, 1, NULL);
}
}
return __Pyx__CallUnboundCMethod1(cfunc, self, arg);
}
#endif
static PyObject* __Pyx__CallUnboundCMethod1(__Pyx_CachedCFunction* cfunc, PyObject* self, PyObject* arg){
PyObject *args, *result = NULL;
if (unlikely(!cfunc->func && !cfunc->method) && unlikely(__Pyx_TryUnpackUnboundCMethod(cfunc) < 0)) return NULL;
#if CYTHON_COMPILING_IN_CPYTHON
if (cfunc->func && (cfunc->flag & METH_VARARGS)) {
args = PyTuple_New(1);
if (unlikely(!args)) goto bad;
Py_INCREF(arg);
PyTuple_SET_ITEM(args, 0, arg);
if (cfunc->flag & METH_KEYWORDS)
result = (*(PyCFunctionWithKeywords)(void*)(PyCFunction)cfunc->func)(self, args, NULL);
else
result = (*cfunc->func)(self, args);
} else {
args = PyTuple_New(2);
if (unlikely(!args)) goto bad;
Py_INCREF(self);
PyTuple_SET_ITEM(args, 0, self);
Py_INCREF(arg);
PyTuple_SET_ITEM(args, 1, arg);
result = __Pyx_PyObject_Call(cfunc->method, args, NULL);
}
#else
args = PyTuple_Pack(2, self, arg);
if (unlikely(!args)) goto bad;
result = __Pyx_PyObject_Call(cfunc->method, args, NULL);
#endif
bad:
Py_XDECREF(args);
return result;
}
/* CallUnboundCMethod2 */
#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030600B1
static CYTHON_INLINE PyObject *__Pyx_CallUnboundCMethod2(__Pyx_CachedCFunction *cfunc, PyObject *self, PyObject *arg1, PyObject *arg2) {
if (likely(cfunc->func)) {
PyObject *args[2] = {arg1, arg2};
if (cfunc->flag == METH_FASTCALL) {
#if PY_VERSION_HEX >= 0x030700A0
return (*(__Pyx_PyCFunctionFast)(void*)(PyCFunction)cfunc->func)(self, args, 2);
#else
return (*(__Pyx_PyCFunctionFastWithKeywords)(void*)(PyCFunction)cfunc->func)(self, args, 2, NULL);
#endif
}
#if PY_VERSION_HEX >= 0x030700A0
if (cfunc->flag == (METH_FASTCALL | METH_KEYWORDS))
return (*(__Pyx_PyCFunctionFastWithKeywords)(void*)(PyCFunction)cfunc->func)(self, args, 2, NULL);
#endif
}
return __Pyx__CallUnboundCMethod2(cfunc, self, arg1, arg2);
}
#endif
static PyObject* __Pyx__CallUnboundCMethod2(__Pyx_CachedCFunction* cfunc, PyObject* self, PyObject* arg1, PyObject* arg2){
PyObject *args, *result = NULL;
if (unlikely(!cfunc->func && !cfunc->method) && unlikely(__Pyx_TryUnpackUnboundCMethod(cfunc) < 0)) return NULL;
#if CYTHON_COMPILING_IN_CPYTHON
if (cfunc->func && (cfunc->flag & METH_VARARGS)) {
args = PyTuple_New(2);
if (unlikely(!args)) goto bad;
Py_INCREF(arg1);
PyTuple_SET_ITEM(args, 0, arg1);
Py_INCREF(arg2);
PyTuple_SET_ITEM(args, 1, arg2);
if (cfunc->flag & METH_KEYWORDS)
result = (*(PyCFunctionWithKeywords)(void*)(PyCFunction)cfunc->func)(self, args, NULL);
else
result = (*cfunc->func)(self, args);
} else {
args = PyTuple_New(3);
if (unlikely(!args)) goto bad;
Py_INCREF(self);
PyTuple_SET_ITEM(args, 0, self);
Py_INCREF(arg1);
PyTuple_SET_ITEM(args, 1, arg1);
Py_INCREF(arg2);
PyTuple_SET_ITEM(args, 2, arg2);
result = __Pyx_PyObject_Call(cfunc->method, args, NULL);
}
#else
args = PyTuple_Pack(3, self, arg1, arg2);
if (unlikely(!args)) goto bad;
result = __Pyx_PyObject_Call(cfunc->method, args, NULL);
#endif
bad:
Py_XDECREF(args);
return result;
}
/* dict_getitem_default */
static PyObject* __Pyx_PyDict_GetItemDefault(PyObject* d, PyObject* key, PyObject* default_value) {
PyObject* value;
#if PY_MAJOR_VERSION >= 3 && !CYTHON_COMPILING_IN_PYPY
value = PyDict_GetItemWithError(d, key);
if (unlikely(!value)) {
if (unlikely(PyErr_Occurred()))
return NULL;
value = default_value;
}
Py_INCREF(value);
if ((1));
#else
if (PyString_CheckExact(key) || PyUnicode_CheckExact(key) || PyInt_CheckExact(key)) {
value = PyDict_GetItem(d, key);
if (unlikely(!value)) {
value = default_value;
}
Py_INCREF(value);
}
#endif
else {
if (default_value == Py_None)
value = __Pyx_CallUnboundCMethod1(&__pyx_umethod_PyDict_Type_get, d, key);
else
value = __Pyx_CallUnboundCMethod2(&__pyx_umethod_PyDict_Type_get, d, key, default_value);
}
return value;
}
/* FetchCommonType */
static PyTypeObject* __Pyx_FetchCommonType(PyTypeObject* type) {
PyObject* fake_module;
PyTypeObject* cached_type = NULL;
fake_module = PyImport_AddModule((char*) "_cython_" CYTHON_ABI);
if (!fake_module) return NULL;
Py_INCREF(fake_module);
cached_type = (PyTypeObject*) PyObject_GetAttrString(fake_module, type->tp_name);
if (cached_type) {
if (!PyType_Check((PyObject*)cached_type)) {
PyErr_Format(PyExc_TypeError,
"Shared Cython type %.200s is not a type object",
type->tp_name);
goto bad;
}
if (cached_type->tp_basicsize != type->tp_basicsize) {
PyErr_Format(PyExc_TypeError,
"Shared Cython type %.200s has the wrong size, try recompiling",
type->tp_name);
goto bad;
}
} else {
if (!PyErr_ExceptionMatches(PyExc_AttributeError)) goto bad;
PyErr_Clear();
if (PyType_Ready(type) < 0) goto bad;
if (PyObject_SetAttrString(fake_module, type->tp_name, (PyObject*) type) < 0)
goto bad;
Py_INCREF(type);
cached_type = type;
}
done:
Py_DECREF(fake_module);
return cached_type;
bad:
Py_XDECREF(cached_type);
cached_type = NULL;
goto done;
}
/* CythonFunctionShared */
#include <structmember.h>
static PyObject *
__Pyx_CyFunction_get_doc(__pyx_CyFunctionObject *op, CYTHON_UNUSED void *closure)
{
if (unlikely(op->func_doc == NULL)) {
if (op->func.m_ml->ml_doc) {
#if PY_MAJOR_VERSION >= 3
op->func_doc = PyUnicode_FromString(op->func.m_ml->ml_doc);
#else
op->func_doc = PyString_FromString(op->func.m_ml->ml_doc);
#endif
if (unlikely(op->func_doc == NULL))
return NULL;
} else {
Py_INCREF(Py_None);
return Py_None;
}
}
Py_INCREF(op->func_doc);
return op->func_doc;
}
static int
__Pyx_CyFunction_set_doc(__pyx_CyFunctionObject *op, PyObject *value, CYTHON_UNUSED void *context)
{
PyObject *tmp = op->func_doc;
if (value == NULL) {
value = Py_None;
}
Py_INCREF(value);
op->func_doc = value;
Py_XDECREF(tmp);
return 0;
}
static PyObject *
__Pyx_CyFunction_get_name(__pyx_CyFunctionObject *op, CYTHON_UNUSED void *context)
{
if (unlikely(op->func_name == NULL)) {
#if PY_MAJOR_VERSION >= 3
op->func_name = PyUnicode_InternFromString(op->func.m_ml->ml_name);
#else
op->func_name = PyString_InternFromString(op->func.m_ml->ml_name);
#endif
if (unlikely(op->func_name == NULL))
return NULL;
}
Py_INCREF(op->func_name);
return op->func_name;
}
static int
__Pyx_CyFunction_set_name(__pyx_CyFunctionObject *op, PyObject *value, CYTHON_UNUSED void *context)
{
PyObject *tmp;
#if PY_MAJOR_VERSION >= 3
if (unlikely(value == NULL || !PyUnicode_Check(value)))
#else
if (unlikely(value == NULL || !PyString_Check(value)))
#endif
{
PyErr_SetString(PyExc_TypeError,
"__name__ must be set to a string object");
return -1;
}
tmp = op->func_name;
Py_INCREF(value);
op->func_name = value;
Py_XDECREF(tmp);
return 0;
}
static PyObject *
__Pyx_CyFunction_get_qualname(__pyx_CyFunctionObject *op, CYTHON_UNUSED void *context)
{
Py_INCREF(op->func_qualname);
return op->func_qualname;
}
static int
__Pyx_CyFunction_set_qualname(__pyx_CyFunctionObject *op, PyObject *value, CYTHON_UNUSED void *context)
{
PyObject *tmp;
#if PY_MAJOR_VERSION >= 3
if (unlikely(value == NULL || !PyUnicode_Check(value)))
#else
if (unlikely(value == NULL || !PyString_Check(value)))
#endif
{
PyErr_SetString(PyExc_TypeError,
"__qualname__ must be set to a string object");
return -1;
}
tmp = op->func_qualname;
Py_INCREF(value);
op->func_qualname = value;
Py_XDECREF(tmp);
return 0;
}
static PyObject *
__Pyx_CyFunction_get_self(__pyx_CyFunctionObject *m, CYTHON_UNUSED void *closure)
{
PyObject *self;
self = m->func_closure;
if (self == NULL)
self = Py_None;
Py_INCREF(self);
return self;
}
static PyObject *
__Pyx_CyFunction_get_dict(__pyx_CyFunctionObject *op, CYTHON_UNUSED void *context)
{
if (unlikely(op->func_dict == NULL)) {
op->func_dict = PyDict_New();
if (unlikely(op->func_dict == NULL))
return NULL;
}
Py_INCREF(op->func_dict);
return op->func_dict;
}
static int
__Pyx_CyFunction_set_dict(__pyx_CyFunctionObject *op, PyObject *value, CYTHON_UNUSED void *context)
{
PyObject *tmp;
if (unlikely(value == NULL)) {
PyErr_SetString(PyExc_TypeError,
"function's dictionary may not be deleted");
return -1;
}
if (unlikely(!PyDict_Check(value))) {
PyErr_SetString(PyExc_TypeError,
"setting function's dictionary to a non-dict");
return -1;
}
tmp = op->func_dict;
Py_INCREF(value);
op->func_dict = value;
Py_XDECREF(tmp);
return 0;
}
static PyObject *
__Pyx_CyFunction_get_globals(__pyx_CyFunctionObject *op, CYTHON_UNUSED void *context)
{
Py_INCREF(op->func_globals);
return op->func_globals;
}
static PyObject *
__Pyx_CyFunction_get_closure(CYTHON_UNUSED __pyx_CyFunctionObject *op, CYTHON_UNUSED void *context)
{
Py_INCREF(Py_None);
return Py_None;
}
static PyObject *
__Pyx_CyFunction_get_code(__pyx_CyFunctionObject *op, CYTHON_UNUSED void *context)
{
PyObject* result = (op->func_code) ? op->func_code : Py_None;
Py_INCREF(result);
return result;
}
static int
__Pyx_CyFunction_init_defaults(__pyx_CyFunctionObject *op) {
int result = 0;
PyObject *res = op->defaults_getter((PyObject *) op);
if (unlikely(!res))
return -1;
#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
op->defaults_tuple = PyTuple_GET_ITEM(res, 0);
Py_INCREF(op->defaults_tuple);
op->defaults_kwdict = PyTuple_GET_ITEM(res, 1);
Py_INCREF(op->defaults_kwdict);
#else
op->defaults_tuple = PySequence_ITEM(res, 0);
if (unlikely(!op->defaults_tuple)) result = -1;
else {
op->defaults_kwdict = PySequence_ITEM(res, 1);
if (unlikely(!op->defaults_kwdict)) result = -1;
}
#endif
Py_DECREF(res);
return result;
}
static int
__Pyx_CyFunction_set_defaults(__pyx_CyFunctionObject *op, PyObject* value, CYTHON_UNUSED void *context) {
PyObject* tmp;
if (!value) {
value = Py_None;
} else if (value != Py_None && !PyTuple_Check(value)) {
PyErr_SetString(PyExc_TypeError,
"__defaults__ must be set to a tuple object");
return -1;
}
Py_INCREF(value);
tmp = op->defaults_tuple;
op->defaults_tuple = value;
Py_XDECREF(tmp);
return 0;
}
static PyObject *
__Pyx_CyFunction_get_defaults(__pyx_CyFunctionObject *op, CYTHON_UNUSED void *context) {
PyObject* result = op->defaults_tuple;
if (unlikely(!result)) {
if (op->defaults_getter) {
if (__Pyx_CyFunction_init_defaults(op) < 0) return NULL;
result = op->defaults_tuple;
} else {
result = Py_None;
}
}
Py_INCREF(result);
return result;
}
static int
__Pyx_CyFunction_set_kwdefaults(__pyx_CyFunctionObject *op, PyObject* value, CYTHON_UNUSED void *context) {
PyObject* tmp;
if (!value) {
value = Py_None;
} else if (value != Py_None && !PyDict_Check(value)) {
PyErr_SetString(PyExc_TypeError,
"__kwdefaults__ must be set to a dict object");
return -1;
}
Py_INCREF(value);
tmp = op->defaults_kwdict;
op->defaults_kwdict = value;
Py_XDECREF(tmp);
return 0;
}
static PyObject *
__Pyx_CyFunction_get_kwdefaults(__pyx_CyFunctionObject *op, CYTHON_UNUSED void *context) {
PyObject* result = op->defaults_kwdict;
if (unlikely(!result)) {
if (op->defaults_getter) {
if (__Pyx_CyFunction_init_defaults(op) < 0) return NULL;
result = op->defaults_kwdict;
} else {
result = Py_None;
}
}
Py_INCREF(result);
return result;
}
static int
__Pyx_CyFunction_set_annotations(__pyx_CyFunctionObject *op, PyObject* value, CYTHON_UNUSED void *context) {
PyObject* tmp;
if (!value || value == Py_None) {
value = NULL;
} else if (!PyDict_Check(value)) {
PyErr_SetString(PyExc_TypeError,
"__annotations__ must be set to a dict object");
return -1;
}
Py_XINCREF(value);
tmp = op->func_annotations;
op->func_annotations = value;
Py_XDECREF(tmp);
return 0;
}
static PyObject *
__Pyx_CyFunction_get_annotations(__pyx_CyFunctionObject *op, CYTHON_UNUSED void *context) {
PyObject* result = op->func_annotations;
if (unlikely(!result)) {
result = PyDict_New();
if (unlikely(!result)) return NULL;
op->func_annotations = result;
}
Py_INCREF(result);
return result;
}
static PyGetSetDef __pyx_CyFunction_getsets[] = {
{(char *) "func_doc", (getter)__Pyx_CyFunction_get_doc, (setter)__Pyx_CyFunction_set_doc, 0, 0},
{(char *) "__doc__", (getter)__Pyx_CyFunction_get_doc, (setter)__Pyx_CyFunction_set_doc, 0, 0},
{(char *) "func_name", (getter)__Pyx_CyFunction_get_name, (setter)__Pyx_CyFunction_set_name, 0, 0},
{(char *) "__name__", (getter)__Pyx_CyFunction_get_name, (setter)__Pyx_CyFunction_set_name, 0, 0},
{(char *) "__qualname__", (getter)__Pyx_CyFunction_get_qualname, (setter)__Pyx_CyFunction_set_qualname, 0, 0},
{(char *) "__self__", (getter)__Pyx_CyFunction_get_self, 0, 0, 0},
{(char *) "func_dict", (getter)__Pyx_CyFunction_get_dict, (setter)__Pyx_CyFunction_set_dict, 0, 0},
{(char *) "__dict__", (getter)__Pyx_CyFunction_get_dict, (setter)__Pyx_CyFunction_set_dict, 0, 0},
{(char *) "func_globals", (getter)__Pyx_CyFunction_get_globals, 0, 0, 0},
{(char *) "__globals__", (getter)__Pyx_CyFunction_get_globals, 0, 0, 0},
{(char *) "func_closure", (getter)__Pyx_CyFunction_get_closure, 0, 0, 0},
{(char *) "__closure__", (getter)__Pyx_CyFunction_get_closure, 0, 0, 0},
{(char *) "func_code", (getter)__Pyx_CyFunction_get_code, 0, 0, 0},
{(char *) "__code__", (getter)__Pyx_CyFunction_get_code, 0, 0, 0},
{(char *) "func_defaults", (getter)__Pyx_CyFunction_get_defaults, (setter)__Pyx_CyFunction_set_defaults, 0, 0},
{(char *) "__defaults__", (getter)__Pyx_CyFunction_get_defaults, (setter)__Pyx_CyFunction_set_defaults, 0, 0},
{(char *) "__kwdefaults__", (getter)__Pyx_CyFunction_get_kwdefaults, (setter)__Pyx_CyFunction_set_kwdefaults, 0, 0},
{(char *) "__annotations__", (getter)__Pyx_CyFunction_get_annotations, (setter)__Pyx_CyFunction_set_annotations, 0, 0},
{0, 0, 0, 0, 0}
};
static PyMemberDef __pyx_CyFunction_members[] = {
{(char *) "__module__", T_OBJECT, offsetof(PyCFunctionObject, m_module), PY_WRITE_RESTRICTED, 0},
{0, 0, 0, 0, 0}
};
static PyObject *
__Pyx_CyFunction_reduce(__pyx_CyFunctionObject *m, CYTHON_UNUSED PyObject *args)
{
#if PY_MAJOR_VERSION >= 3
return PyUnicode_FromString(m->func.m_ml->ml_name);
#else
return PyString_FromString(m->func.m_ml->ml_name);
#endif
}
static PyMethodDef __pyx_CyFunction_methods[] = {
{"__reduce__", (PyCFunction)__Pyx_CyFunction_reduce, METH_VARARGS, 0},
{0, 0, 0, 0}
};
#if PY_VERSION_HEX < 0x030500A0
#define __Pyx_CyFunction_weakreflist(cyfunc) ((cyfunc)->func_weakreflist)
#else
#define __Pyx_CyFunction_weakreflist(cyfunc) ((cyfunc)->func.m_weakreflist)
#endif
static PyObject *__Pyx_CyFunction_Init(__pyx_CyFunctionObject *op, PyMethodDef *ml, int flags, PyObject* qualname,
PyObject *closure, PyObject *module, PyObject* globals, PyObject* code) {
if (unlikely(op == NULL))
return NULL;
op->flags = flags;
__Pyx_CyFunction_weakreflist(op) = NULL;
op->func.m_ml = ml;
op->func.m_self = (PyObject *) op;
Py_XINCREF(closure);
op->func_closure = closure;
Py_XINCREF(module);
op->func.m_module = module;
op->func_dict = NULL;
op->func_name = NULL;
Py_INCREF(qualname);
op->func_qualname = qualname;
op->func_doc = NULL;
op->func_classobj = NULL;
op->func_globals = globals;
Py_INCREF(op->func_globals);
Py_XINCREF(code);
op->func_code = code;
op->defaults_pyobjects = 0;
op->defaults_size = 0;
op->defaults = NULL;
op->defaults_tuple = NULL;
op->defaults_kwdict = NULL;
op->defaults_getter = NULL;
op->func_annotations = NULL;
return (PyObject *) op;
}
static int
__Pyx_CyFunction_clear(__pyx_CyFunctionObject *m)
{
Py_CLEAR(m->func_closure);
Py_CLEAR(m->func.m_module);
Py_CLEAR(m->func_dict);
Py_CLEAR(m->func_name);
Py_CLEAR(m->func_qualname);
Py_CLEAR(m->func_doc);
Py_CLEAR(m->func_globals);
Py_CLEAR(m->func_code);
Py_CLEAR(m->func_classobj);
Py_CLEAR(m->defaults_tuple);
Py_CLEAR(m->defaults_kwdict);
Py_CLEAR(m->func_annotations);
if (m->defaults) {
PyObject **pydefaults = __Pyx_CyFunction_Defaults(PyObject *, m);
int i;
for (i = 0; i < m->defaults_pyobjects; i++)
Py_XDECREF(pydefaults[i]);
PyObject_Free(m->defaults);
m->defaults = NULL;
}
return 0;
}
static void __Pyx__CyFunction_dealloc(__pyx_CyFunctionObject *m)
{
if (__Pyx_CyFunction_weakreflist(m) != NULL)
PyObject_ClearWeakRefs((PyObject *) m);
__Pyx_CyFunction_clear(m);
PyObject_GC_Del(m);
}
static void __Pyx_CyFunction_dealloc(__pyx_CyFunctionObject *m)
{
PyObject_GC_UnTrack(m);
__Pyx__CyFunction_dealloc(m);
}
static int __Pyx_CyFunction_traverse(__pyx_CyFunctionObject *m, visitproc visit, void *arg)
{
Py_VISIT(m->func_closure);
Py_VISIT(m->func.m_module);
Py_VISIT(m->func_dict);
Py_VISIT(m->func_name);
Py_VISIT(m->func_qualname);
Py_VISIT(m->func_doc);
Py_VISIT(m->func_globals);
Py_VISIT(m->func_code);
Py_VISIT(m->func_classobj);
Py_VISIT(m->defaults_tuple);
Py_VISIT(m->defaults_kwdict);
if (m->defaults) {
PyObject **pydefaults = __Pyx_CyFunction_Defaults(PyObject *, m);
int i;
for (i = 0; i < m->defaults_pyobjects; i++)
Py_VISIT(pydefaults[i]);
}
return 0;
}
static PyObject *__Pyx_CyFunction_descr_get(PyObject *func, PyObject *obj, PyObject *type)
{
#if PY_MAJOR_VERSION < 3
__pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func;
if (m->flags & __Pyx_CYFUNCTION_STATICMETHOD) {
Py_INCREF(func);
return func;
}
if (m->flags & __Pyx_CYFUNCTION_CLASSMETHOD) {
if (type == NULL)
type = (PyObject *)(Py_TYPE(obj));
return __Pyx_PyMethod_New(func, type, (PyObject *)(Py_TYPE(type)));
}
if (obj == Py_None)
obj = NULL;
#endif
return __Pyx_PyMethod_New(func, obj, type);
}
static PyObject*
__Pyx_CyFunction_repr(__pyx_CyFunctionObject *op)
{
#if PY_MAJOR_VERSION >= 3
return PyUnicode_FromFormat("<cyfunction %U at %p>",
op->func_qualname, (void *)op);
#else
return PyString_FromFormat("<cyfunction %s at %p>",
PyString_AsString(op->func_qualname), (void *)op);
#endif
}
static PyObject * __Pyx_CyFunction_CallMethod(PyObject *func, PyObject *self, PyObject *arg, PyObject *kw) {
PyCFunctionObject* f = (PyCFunctionObject*)func;
PyCFunction meth = f->m_ml->ml_meth;
Py_ssize_t size;
switch (f->m_ml->ml_flags & (METH_VARARGS | METH_KEYWORDS | METH_NOARGS | METH_O)) {
case METH_VARARGS:
if (likely(kw == NULL || PyDict_Size(kw) == 0))
return (*meth)(self, arg);
break;
case METH_VARARGS | METH_KEYWORDS:
return (*(PyCFunctionWithKeywords)(void*)meth)(self, arg, kw);
case METH_NOARGS:
if (likely(kw == NULL || PyDict_Size(kw) == 0)) {
size = PyTuple_GET_SIZE(arg);
if (likely(size == 0))
return (*meth)(self, NULL);
PyErr_Format(PyExc_TypeError,
"%.200s() takes no arguments (%" CYTHON_FORMAT_SSIZE_T "d given)",
f->m_ml->ml_name, size);
return NULL;
}
break;
case METH_O:
if (likely(kw == NULL || PyDict_Size(kw) == 0)) {
size = PyTuple_GET_SIZE(arg);
if (likely(size == 1)) {
PyObject *result, *arg0;
#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
arg0 = PyTuple_GET_ITEM(arg, 0);
#else
arg0 = PySequence_ITEM(arg, 0); if (unlikely(!arg0)) return NULL;
#endif
result = (*meth)(self, arg0);
#if !(CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS)
Py_DECREF(arg0);
#endif
return result;
}
PyErr_Format(PyExc_TypeError,
"%.200s() takes exactly one argument (%" CYTHON_FORMAT_SSIZE_T "d given)",
f->m_ml->ml_name, size);
return NULL;
}
break;
default:
PyErr_SetString(PyExc_SystemError, "Bad call flags in "
"__Pyx_CyFunction_Call. METH_OLDARGS is no "
"longer supported!");
return NULL;
}
PyErr_Format(PyExc_TypeError, "%.200s() takes no keyword arguments",
f->m_ml->ml_name);
return NULL;
}
static CYTHON_INLINE PyObject *__Pyx_CyFunction_Call(PyObject *func, PyObject *arg, PyObject *kw) {
return __Pyx_CyFunction_CallMethod(func, ((PyCFunctionObject*)func)->m_self, arg, kw);
}
static PyObject *__Pyx_CyFunction_CallAsMethod(PyObject *func, PyObject *args, PyObject *kw) {
PyObject *result;
__pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *) func;
if ((cyfunc->flags & __Pyx_CYFUNCTION_CCLASS) && !(cyfunc->flags & __Pyx_CYFUNCTION_STATICMETHOD)) {
Py_ssize_t argc;
PyObject *new_args;
PyObject *self;
argc = PyTuple_GET_SIZE(args);
new_args = PyTuple_GetSlice(args, 1, argc);
if (unlikely(!new_args))
return NULL;
self = PyTuple_GetItem(args, 0);
if (unlikely(!self)) {
Py_DECREF(new_args);
return NULL;
}
result = __Pyx_CyFunction_CallMethod(func, self, new_args, kw);
Py_DECREF(new_args);
} else {
result = __Pyx_CyFunction_Call(func, args, kw);
}
return result;
}
static PyTypeObject __pyx_CyFunctionType_type = {
PyVarObject_HEAD_INIT(0, 0)
"cython_function_or_method",
sizeof(__pyx_CyFunctionObject),
0,
(destructor) __Pyx_CyFunction_dealloc,
0,
0,
0,
#if PY_MAJOR_VERSION < 3
0,
#else
0,
#endif
(reprfunc) __Pyx_CyFunction_repr,
0,
0,
0,
0,
__Pyx_CyFunction_CallAsMethod,
0,
0,
0,
0,
Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC,
0,
(traverseproc) __Pyx_CyFunction_traverse,
(inquiry) __Pyx_CyFunction_clear,
0,
#if PY_VERSION_HEX < 0x030500A0
offsetof(__pyx_CyFunctionObject, func_weakreflist),
#else
offsetof(PyCFunctionObject, m_weakreflist),
#endif
0,
0,
__pyx_CyFunction_methods,
__pyx_CyFunction_members,
__pyx_CyFunction_getsets,
0,
0,
__Pyx_CyFunction_descr_get,
0,
offsetof(__pyx_CyFunctionObject, func_dict),
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
#if PY_VERSION_HEX >= 0x030400a1
0,
#endif
#if PY_VERSION_HEX >= 0x030800b1
0,
#endif
#if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000
0,
#endif
};
static int __pyx_CyFunction_init(void) {
__pyx_CyFunctionType = __Pyx_FetchCommonType(&__pyx_CyFunctionType_type);
if (unlikely(__pyx_CyFunctionType == NULL)) {
return -1;
}
return 0;
}
static CYTHON_INLINE void *__Pyx_CyFunction_InitDefaults(PyObject *func, size_t size, int pyobjects) {
__pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func;
m->defaults = PyObject_Malloc(size);
if (unlikely(!m->defaults))
return PyErr_NoMemory();
memset(m->defaults, 0, size);
m->defaults_pyobjects = pyobjects;
m->defaults_size = size;
return m->defaults;
}
static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsTuple(PyObject *func, PyObject *tuple) {
__pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func;
m->defaults_tuple = tuple;
Py_INCREF(tuple);
}
static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsKwDict(PyObject *func, PyObject *dict) {
__pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func;
m->defaults_kwdict = dict;
Py_INCREF(dict);
}
static CYTHON_INLINE void __Pyx_CyFunction_SetAnnotationsDict(PyObject *func, PyObject *dict) {
__pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func;
m->func_annotations = dict;
Py_INCREF(dict);
}
/* CythonFunction */
static PyObject *__Pyx_CyFunction_New(PyMethodDef *ml, int flags, PyObject* qualname,
PyObject *closure, PyObject *module, PyObject* globals, PyObject* code) {
PyObject *op = __Pyx_CyFunction_Init(
PyObject_GC_New(__pyx_CyFunctionObject, __pyx_CyFunctionType),
ml, flags, qualname, closure, module, globals, code
);
if (likely(op)) {
PyObject_GC_Track(op);
}
return op;
}
/* PyObjectCall2Args */
static CYTHON_UNUSED PyObject* __Pyx_PyObject_Call2Args(PyObject* function, PyObject* arg1, PyObject* arg2) {
PyObject *args, *result = NULL;
#if CYTHON_FAST_PYCALL
if (PyFunction_Check(function)) {
PyObject *args[2] = {arg1, arg2};
return __Pyx_PyFunction_FastCall(function, args, 2);
}
#endif
#if CYTHON_FAST_PYCCALL
if (__Pyx_PyFastCFunction_Check(function)) {
PyObject *args[2] = {arg1, arg2};
return __Pyx_PyCFunction_FastCall(function, args, 2);
}
#endif
args = PyTuple_New(2);
if (unlikely(!args)) goto done;
Py_INCREF(arg1);
PyTuple_SET_ITEM(args, 0, arg1);
Py_INCREF(arg2);
PyTuple_SET_ITEM(args, 1, arg2);
Py_INCREF(function);
result = __Pyx_PyObject_Call(function, args, NULL);
Py_DECREF(args);
Py_DECREF(function);
done:
return result;
}
/* GetItemInt */
static PyObject *__Pyx_GetItemInt_Generic(PyObject *o, PyObject* j) {
PyObject *r;
if (!j) return NULL;
r = PyObject_GetItem(o, j);
Py_DECREF(j);
return r;
}
static CYTHON_INLINE PyObject *__Pyx_GetItemInt_List_Fast(PyObject *o, Py_ssize_t i,
CYTHON_NCP_UNUSED int wraparound,
CYTHON_NCP_UNUSED int boundscheck) {
#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
Py_ssize_t wrapped_i = i;
if (wraparound & unlikely(i < 0)) {
wrapped_i += PyList_GET_SIZE(o);
}
if ((!boundscheck) || likely(__Pyx_is_valid_index(wrapped_i, PyList_GET_SIZE(o)))) {
PyObject *r = PyList_GET_ITEM(o, wrapped_i);
Py_INCREF(r);
return r;
}
return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i));
#else
return PySequence_GetItem(o, i);
#endif
}
static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Tuple_Fast(PyObject *o, Py_ssize_t i,
CYTHON_NCP_UNUSED int wraparound,
CYTHON_NCP_UNUSED int boundscheck) {
#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
Py_ssize_t wrapped_i = i;
if (wraparound & unlikely(i < 0)) {
wrapped_i += PyTuple_GET_SIZE(o);
}
if ((!boundscheck) || likely(__Pyx_is_valid_index(wrapped_i, PyTuple_GET_SIZE(o)))) {
PyObject *r = PyTuple_GET_ITEM(o, wrapped_i);
Py_INCREF(r);
return r;
}
return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i));
#else
return PySequence_GetItem(o, i);
#endif
}
static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Fast(PyObject *o, Py_ssize_t i, int is_list,
CYTHON_NCP_UNUSED int wraparound,
CYTHON_NCP_UNUSED int boundscheck) {
#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS && CYTHON_USE_TYPE_SLOTS
if (is_list || PyList_CheckExact(o)) {
Py_ssize_t n = ((!wraparound) | likely(i >= 0)) ? i : i + PyList_GET_SIZE(o);
if ((!boundscheck) || (likely(__Pyx_is_valid_index(n, PyList_GET_SIZE(o))))) {
PyObject *r = PyList_GET_ITEM(o, n);
Py_INCREF(r);
return r;
}
}
else if (PyTuple_CheckExact(o)) {
Py_ssize_t n = ((!wraparound) | likely(i >= 0)) ? i : i + PyTuple_GET_SIZE(o);
if ((!boundscheck) || likely(__Pyx_is_valid_index(n, PyTuple_GET_SIZE(o)))) {
PyObject *r = PyTuple_GET_ITEM(o, n);
Py_INCREF(r);
return r;
}
} else {
PySequenceMethods *m = Py_TYPE(o)->tp_as_sequence;
if (likely(m && m->sq_item)) {
if (wraparound && unlikely(i < 0) && likely(m->sq_length)) {
Py_ssize_t l = m->sq_length(o);
if (likely(l >= 0)) {
i += l;
} else {
if (!PyErr_ExceptionMatches(PyExc_OverflowError))
return NULL;
PyErr_Clear();
}
}
return m->sq_item(o, i);
}
}
#else
if (is_list || PySequence_Check(o)) {
return PySequence_GetItem(o, i);
}
#endif
return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i));
}
/* RaiseTooManyValuesToUnpack */
static CYTHON_INLINE void __Pyx_RaiseTooManyValuesError(Py_ssize_t expected) {
PyErr_Format(PyExc_ValueError,
"too many values to unpack (expected %" CYTHON_FORMAT_SSIZE_T "d)", expected);
}
/* RaiseNeedMoreValuesToUnpack */
static CYTHON_INLINE void __Pyx_RaiseNeedMoreValuesError(Py_ssize_t index) {
PyErr_Format(PyExc_ValueError,
"need more than %" CYTHON_FORMAT_SSIZE_T "d value%.1s to unpack",
index, (index == 1) ? "" : "s");
}
/* IterFinish */
static CYTHON_INLINE int __Pyx_IterFinish(void) {
#if CYTHON_FAST_THREAD_STATE
PyThreadState *tstate = __Pyx_PyThreadState_Current;
PyObject* exc_type = tstate->curexc_type;
if (unlikely(exc_type)) {
if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) {
PyObject *exc_value, *exc_tb;
exc_value = tstate->curexc_value;
exc_tb = tstate->curexc_traceback;
tstate->curexc_type = 0;
tstate->curexc_value = 0;
tstate->curexc_traceback = 0;
Py_DECREF(exc_type);
Py_XDECREF(exc_value);
Py_XDECREF(exc_tb);
return 0;
} else {
return -1;
}
}
return 0;
#else
if (unlikely(PyErr_Occurred())) {
if (likely(PyErr_ExceptionMatches(PyExc_StopIteration))) {
PyErr_Clear();
return 0;
} else {
return -1;
}
}
return 0;
#endif
}
/* UnpackItemEndCheck */
static int __Pyx_IternextUnpackEndCheck(PyObject *retval, Py_ssize_t expected) {
if (unlikely(retval)) {
Py_DECREF(retval);
__Pyx_RaiseTooManyValuesError(expected);
return -1;
} else {
return __Pyx_IterFinish();
}
return 0;
}
/* BytesEquals */
static CYTHON_INLINE int __Pyx_PyBytes_Equals(PyObject* s1, PyObject* s2, int equals) {
#if CYTHON_COMPILING_IN_PYPY
return PyObject_RichCompareBool(s1, s2, equals);
#else
if (s1 == s2) {
return (equals == Py_EQ);
} else if (PyBytes_CheckExact(s1) & PyBytes_CheckExact(s2)) {
const char *ps1, *ps2;
Py_ssize_t length = PyBytes_GET_SIZE(s1);
if (length != PyBytes_GET_SIZE(s2))
return (equals == Py_NE);
ps1 = PyBytes_AS_STRING(s1);
ps2 = PyBytes_AS_STRING(s2);
if (ps1[0] != ps2[0]) {
return (equals == Py_NE);
} else if (length == 1) {
return (equals == Py_EQ);
} else {
int result;
#if CYTHON_USE_UNICODE_INTERNALS
Py_hash_t hash1, hash2;
hash1 = ((PyBytesObject*)s1)->ob_shash;
hash2 = ((PyBytesObject*)s2)->ob_shash;
if (hash1 != hash2 && hash1 != -1 && hash2 != -1) {
return (equals == Py_NE);
}
#endif
result = memcmp(ps1, ps2, (size_t)length);
return (equals == Py_EQ) ? (result == 0) : (result != 0);
}
} else if ((s1 == Py_None) & PyBytes_CheckExact(s2)) {
return (equals == Py_NE);
} else if ((s2 == Py_None) & PyBytes_CheckExact(s1)) {
return (equals == Py_NE);
} else {
int result;
PyObject* py_result = PyObject_RichCompare(s1, s2, equals);
if (!py_result)
return -1;
result = __Pyx_PyObject_IsTrue(py_result);
Py_DECREF(py_result);
return result;
}
#endif
}
/* UnicodeEquals */
static CYTHON_INLINE int __Pyx_PyUnicode_Equals(PyObject* s1, PyObject* s2, int equals) {
#if CYTHON_COMPILING_IN_PYPY
return PyObject_RichCompareBool(s1, s2, equals);
#else
#if PY_MAJOR_VERSION < 3
PyObject* owned_ref = NULL;
#endif
int s1_is_unicode, s2_is_unicode;
if (s1 == s2) {
goto return_eq;
}
s1_is_unicode = PyUnicode_CheckExact(s1);
s2_is_unicode = PyUnicode_CheckExact(s2);
#if PY_MAJOR_VERSION < 3
if ((s1_is_unicode & (!s2_is_unicode)) && PyString_CheckExact(s2)) {
owned_ref = PyUnicode_FromObject(s2);
if (unlikely(!owned_ref))
return -1;
s2 = owned_ref;
s2_is_unicode = 1;
} else if ((s2_is_unicode & (!s1_is_unicode)) && PyString_CheckExact(s1)) {
owned_ref = PyUnicode_FromObject(s1);
if (unlikely(!owned_ref))
return -1;
s1 = owned_ref;
s1_is_unicode = 1;
} else if (((!s2_is_unicode) & (!s1_is_unicode))) {
return __Pyx_PyBytes_Equals(s1, s2, equals);
}
#endif
if (s1_is_unicode & s2_is_unicode) {
Py_ssize_t length;
int kind;
void *data1, *data2;
if (unlikely(__Pyx_PyUnicode_READY(s1) < 0) || unlikely(__Pyx_PyUnicode_READY(s2) < 0))
return -1;
length = __Pyx_PyUnicode_GET_LENGTH(s1);
if (length != __Pyx_PyUnicode_GET_LENGTH(s2)) {
goto return_ne;
}
#if CYTHON_USE_UNICODE_INTERNALS
{
Py_hash_t hash1, hash2;
#if CYTHON_PEP393_ENABLED
hash1 = ((PyASCIIObject*)s1)->hash;
hash2 = ((PyASCIIObject*)s2)->hash;
#else
hash1 = ((PyUnicodeObject*)s1)->hash;
hash2 = ((PyUnicodeObject*)s2)->hash;
#endif
if (hash1 != hash2 && hash1 != -1 && hash2 != -1) {
goto return_ne;
}
}
#endif
kind = __Pyx_PyUnicode_KIND(s1);
if (kind != __Pyx_PyUnicode_KIND(s2)) {
goto return_ne;
}
data1 = __Pyx_PyUnicode_DATA(s1);
data2 = __Pyx_PyUnicode_DATA(s2);
if (__Pyx_PyUnicode_READ(kind, data1, 0) != __Pyx_PyUnicode_READ(kind, data2, 0)) {
goto return_ne;
} else if (length == 1) {
goto return_eq;
} else {
int result = memcmp(data1, data2, (size_t)(length * kind));
#if PY_MAJOR_VERSION < 3
Py_XDECREF(owned_ref);
#endif
return (equals == Py_EQ) ? (result == 0) : (result != 0);
}
} else if ((s1 == Py_None) & s2_is_unicode) {
goto return_ne;
} else if ((s2 == Py_None) & s1_is_unicode) {
goto return_ne;
} else {
int result;
PyObject* py_result = PyObject_RichCompare(s1, s2, equals);
#if PY_MAJOR_VERSION < 3
Py_XDECREF(owned_ref);
#endif
if (!py_result)
return -1;
result = __Pyx_PyObject_IsTrue(py_result);
Py_DECREF(py_result);
return result;
}
return_eq:
#if PY_MAJOR_VERSION < 3
Py_XDECREF(owned_ref);
#endif
return (equals == Py_EQ);
return_ne:
#if PY_MAJOR_VERSION < 3
Py_XDECREF(owned_ref);
#endif
return (equals == Py_NE);
#endif
}
/* PyIntBinop */
#if !CYTHON_COMPILING_IN_PYPY
static PyObject* __Pyx_PyInt_AddObjC(PyObject *op1, PyObject *op2, CYTHON_UNUSED long intval, int inplace, int zerodivision_check) {
(void)inplace;
(void)zerodivision_check;
#if PY_MAJOR_VERSION < 3
if (likely(PyInt_CheckExact(op1))) {
const long b = intval;
long x;
long a = PyInt_AS_LONG(op1);
x = (long)((unsigned long)a + b);
if (likely((x^a) >= 0 || (x^b) >= 0))
return PyInt_FromLong(x);
return PyLong_Type.tp_as_number->nb_add(op1, op2);
}
#endif
#if CYTHON_USE_PYLONG_INTERNALS
if (likely(PyLong_CheckExact(op1))) {
const long b = intval;
long a, x;
#ifdef HAVE_LONG_LONG
const PY_LONG_LONG llb = intval;
PY_LONG_LONG lla, llx;
#endif
const digit* digits = ((PyLongObject*)op1)->ob_digit;
const Py_ssize_t size = Py_SIZE(op1);
if (likely(__Pyx_sst_abs(size) <= 1)) {
a = likely(size) ? digits[0] : 0;
if (size == -1) a = -a;
} else {
switch (size) {
case -2:
if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) {
a = -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]));
break;
#ifdef HAVE_LONG_LONG
} else if (8 * sizeof(PY_LONG_LONG) - 1 > 2 * PyLong_SHIFT) {
lla = -(PY_LONG_LONG) (((((unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0]));
goto long_long;
#endif
}
CYTHON_FALLTHROUGH;
case 2:
if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) {
a = (long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]));
break;
#ifdef HAVE_LONG_LONG
} else if (8 * sizeof(PY_LONG_LONG) - 1 > 2 * PyLong_SHIFT) {
lla = (PY_LONG_LONG) (((((unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0]));
goto long_long;
#endif
}
CYTHON_FALLTHROUGH;
case -3:
if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) {
a = -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]));
break;
#ifdef HAVE_LONG_LONG
} else if (8 * sizeof(PY_LONG_LONG) - 1 > 3 * PyLong_SHIFT) {
lla = -(PY_LONG_LONG) (((((((unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0]));
goto long_long;
#endif
}
CYTHON_FALLTHROUGH;
case 3:
if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) {
a = (long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]));
break;
#ifdef HAVE_LONG_LONG
} else if (8 * sizeof(PY_LONG_LONG) - 1 > 3 * PyLong_SHIFT) {
lla = (PY_LONG_LONG) (((((((unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0]));
goto long_long;
#endif
}
CYTHON_FALLTHROUGH;
case -4:
if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) {
a = -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]));
break;
#ifdef HAVE_LONG_LONG
} else if (8 * sizeof(PY_LONG_LONG) - 1 > 4 * PyLong_SHIFT) {
lla = -(PY_LONG_LONG) (((((((((unsigned PY_LONG_LONG)digits[3]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0]));
goto long_long;
#endif
}
CYTHON_FALLTHROUGH;
case 4:
if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) {
a = (long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]));
break;
#ifdef HAVE_LONG_LONG
} else if (8 * sizeof(PY_LONG_LONG) - 1 > 4 * PyLong_SHIFT) {
lla = (PY_LONG_LONG) (((((((((unsigned PY_LONG_LONG)digits[3]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0]));
goto long_long;
#endif
}
CYTHON_FALLTHROUGH;
default: return PyLong_Type.tp_as_number->nb_add(op1, op2);
}
}
x = a + b;
return PyLong_FromLong(x);
#ifdef HAVE_LONG_LONG
long_long:
llx = lla + llb;
return PyLong_FromLongLong(llx);
#endif
}
#endif
if (PyFloat_CheckExact(op1)) {
const long b = intval;
double a = PyFloat_AS_DOUBLE(op1);
double result;
PyFPE_START_PROTECT("add", return NULL)
result = ((double)a) + (double)b;
PyFPE_END_PROTECT(result)
return PyFloat_FromDouble(result);
}
return (inplace ? PyNumber_InPlaceAdd : PyNumber_Add)(op1, op2);
}
#endif
/* ObjectGetItem */
#if CYTHON_USE_TYPE_SLOTS
static PyObject *__Pyx_PyObject_GetIndex(PyObject *obj, PyObject* index) {
PyObject *runerr;
Py_ssize_t key_value;
PySequenceMethods *m = Py_TYPE(obj)->tp_as_sequence;
if (unlikely(!(m && m->sq_item))) {
PyErr_Format(PyExc_TypeError, "'%.200s' object is not subscriptable", Py_TYPE(obj)->tp_name);
return NULL;
}
key_value = __Pyx_PyIndex_AsSsize_t(index);
if (likely(key_value != -1 || !(runerr = PyErr_Occurred()))) {
return __Pyx_GetItemInt_Fast(obj, key_value, 0, 1, 1);
}
if (PyErr_GivenExceptionMatches(runerr, PyExc_OverflowError)) {
PyErr_Clear();
PyErr_Format(PyExc_IndexError, "cannot fit '%.200s' into an index-sized integer", Py_TYPE(index)->tp_name);
}
return NULL;
}
static PyObject *__Pyx_PyObject_GetItem(PyObject *obj, PyObject* key) {
PyMappingMethods *m = Py_TYPE(obj)->tp_as_mapping;
if (likely(m && m->mp_subscript)) {
return m->mp_subscript(obj, key);
}
return __Pyx_PyObject_GetIndex(obj, key);
}
#endif
/* DictGetItem */
#if PY_MAJOR_VERSION >= 3 && !CYTHON_COMPILING_IN_PYPY
static PyObject *__Pyx_PyDict_GetItem(PyObject *d, PyObject* key) {
PyObject *value;
value = PyDict_GetItemWithError(d, key);
if (unlikely(!value)) {
if (!PyErr_Occurred()) {
if (unlikely(PyTuple_Check(key))) {
PyObject* args = PyTuple_Pack(1, key);
if (likely(args)) {
PyErr_SetObject(PyExc_KeyError, args);
Py_DECREF(args);
}
} else {
PyErr_SetObject(PyExc_KeyError, key);
}
}
return NULL;
}
Py_INCREF(value);
return value;
}
#endif
/* RaiseDoubleKeywords */
static void __Pyx_RaiseDoubleKeywordsError(
const char* func_name,
PyObject* kw_name)
{
PyErr_Format(PyExc_TypeError,
#if PY_MAJOR_VERSION >= 3
"%s() got multiple values for keyword argument '%U'", func_name, kw_name);
#else
"%s() got multiple values for keyword argument '%s'", func_name,
PyString_AsString(kw_name));
#endif
}
/* ParseKeywords */
static int __Pyx_ParseOptionalKeywords(
PyObject *kwds,
PyObject **argnames[],
PyObject *kwds2,
PyObject *values[],
Py_ssize_t num_pos_args,
const char* function_name)
{
PyObject *key = 0, *value = 0;
Py_ssize_t pos = 0;
PyObject*** name;
PyObject*** first_kw_arg = argnames + num_pos_args;
while (PyDict_Next(kwds, &pos, &key, &value)) {
name = first_kw_arg;
while (*name && (**name != key)) name++;
if (*name) {
values[name-argnames] = value;
continue;
}
name = first_kw_arg;
#if PY_MAJOR_VERSION < 3
if (likely(PyString_Check(key))) {
while (*name) {
if ((CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**name) == PyString_GET_SIZE(key))
&& _PyString_Eq(**name, key)) {
values[name-argnames] = value;
break;
}
name++;
}
if (*name) continue;
else {
PyObject*** argname = argnames;
while (argname != first_kw_arg) {
if ((**argname == key) || (
(CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**argname) == PyString_GET_SIZE(key))
&& _PyString_Eq(**argname, key))) {
goto arg_passed_twice;
}
argname++;
}
}
} else
#endif
if (likely(PyUnicode_Check(key))) {
while (*name) {
int cmp = (**name == key) ? 0 :
#if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3
(__Pyx_PyUnicode_GET_LENGTH(**name) != __Pyx_PyUnicode_GET_LENGTH(key)) ? 1 :
#endif
PyUnicode_Compare(**name, key);
if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad;
if (cmp == 0) {
values[name-argnames] = value;
break;
}
name++;
}
if (*name) continue;
else {
PyObject*** argname = argnames;
while (argname != first_kw_arg) {
int cmp = (**argname == key) ? 0 :
#if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3
(__Pyx_PyUnicode_GET_LENGTH(**argname) != __Pyx_PyUnicode_GET_LENGTH(key)) ? 1 :
#endif
PyUnicode_Compare(**argname, key);
if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad;
if (cmp == 0) goto arg_passed_twice;
argname++;
}
}
} else
goto invalid_keyword_type;
if (kwds2) {
if (unlikely(PyDict_SetItem(kwds2, key, value))) goto bad;
} else {
goto invalid_keyword;
}
}
return 0;
arg_passed_twice:
__Pyx_RaiseDoubleKeywordsError(function_name, key);
goto bad;
invalid_keyword_type:
PyErr_Format(PyExc_TypeError,
"%.200s() keywords must be strings", function_name);
goto bad;
invalid_keyword:
PyErr_Format(PyExc_TypeError,
#if PY_MAJOR_VERSION < 3
"%.200s() got an unexpected keyword argument '%.200s'",
function_name, PyString_AsString(key));
#else
"%s() got an unexpected keyword argument '%U'",
function_name, key);
#endif
bad:
return -1;
}
/* ArgTypeTest */
static int __Pyx__ArgTypeTest(PyObject *obj, PyTypeObject *type, const char *name, int exact)
{
if (unlikely(!type)) {
PyErr_SetString(PyExc_SystemError, "Missing type object");
return 0;
}
else if (exact) {
#if PY_MAJOR_VERSION == 2
if ((type == &PyBaseString_Type) && likely(__Pyx_PyBaseString_CheckExact(obj))) return 1;
#endif
}
else {
if (likely(__Pyx_TypeCheck(obj, type))) return 1;
}
PyErr_Format(PyExc_TypeError,
"Argument '%.200s' has incorrect type (expected %.200s, got %.200s)",
name, type->tp_name, Py_TYPE(obj)->tp_name);
return 0;
}
/* SliceTupleAndList */
#if CYTHON_COMPILING_IN_CPYTHON
static CYTHON_INLINE void __Pyx_crop_slice(Py_ssize_t* _start, Py_ssize_t* _stop, Py_ssize_t* _length) {
Py_ssize_t start = *_start, stop = *_stop, length = *_length;
if (start < 0) {
start += length;
if (start < 0)
start = 0;
}
if (stop < 0)
stop += length;
else if (stop > length)
stop = length;
*_length = stop - start;
*_start = start;
*_stop = stop;
}
static CYTHON_INLINE void __Pyx_copy_object_array(PyObject** CYTHON_RESTRICT src, PyObject** CYTHON_RESTRICT dest, Py_ssize_t length) {
PyObject *v;
Py_ssize_t i;
for (i = 0; i < length; i++) {
v = dest[i] = src[i];
Py_INCREF(v);
}
}
static CYTHON_INLINE PyObject* __Pyx_PyList_GetSlice(
PyObject* src, Py_ssize_t start, Py_ssize_t stop) {
PyObject* dest;
Py_ssize_t length = PyList_GET_SIZE(src);
__Pyx_crop_slice(&start, &stop, &length);
if (unlikely(length <= 0))
return PyList_New(0);
dest = PyList_New(length);
if (unlikely(!dest))
return NULL;
__Pyx_copy_object_array(
((PyListObject*)src)->ob_item + start,
((PyListObject*)dest)->ob_item,
length);
return dest;
}
static CYTHON_INLINE PyObject* __Pyx_PyTuple_GetSlice(
PyObject* src, Py_ssize_t start, Py_ssize_t stop) {
PyObject* dest;
Py_ssize_t length = PyTuple_GET_SIZE(src);
__Pyx_crop_slice(&start, &stop, &length);
if (unlikely(length <= 0))
return PyTuple_New(0);
dest = PyTuple_New(length);
if (unlikely(!dest))
return NULL;
__Pyx_copy_object_array(
((PyTupleObject*)src)->ob_item + start,
((PyTupleObject*)dest)->ob_item,
length);
return dest;
}
#endif
/* RaiseException */
#if PY_MAJOR_VERSION < 3
static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb,
CYTHON_UNUSED PyObject *cause) {
__Pyx_PyThreadState_declare
Py_XINCREF(type);
if (!value || value == Py_None)
value = NULL;
else
Py_INCREF(value);
if (!tb || tb == Py_None)
tb = NULL;
else {
Py_INCREF(tb);
if (!PyTraceBack_Check(tb)) {
PyErr_SetString(PyExc_TypeError,
"raise: arg 3 must be a traceback or None");
goto raise_error;
}
}
if (PyType_Check(type)) {
#if CYTHON_COMPILING_IN_PYPY
if (!value) {
Py_INCREF(Py_None);
value = Py_None;
}
#endif
PyErr_NormalizeException(&type, &value, &tb);
} else {
if (value) {
PyErr_SetString(PyExc_TypeError,
"instance exception may not have a separate value");
goto raise_error;
}
value = type;
type = (PyObject*) Py_TYPE(type);
Py_INCREF(type);
if (!PyType_IsSubtype((PyTypeObject *)type, (PyTypeObject *)PyExc_BaseException)) {
PyErr_SetString(PyExc_TypeError,
"raise: exception class must be a subclass of BaseException");
goto raise_error;
}
}
__Pyx_PyThreadState_assign
__Pyx_ErrRestore(type, value, tb);
return;
raise_error:
Py_XDECREF(value);
Py_XDECREF(type);
Py_XDECREF(tb);
return;
}
#else
static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause) {
PyObject* owned_instance = NULL;
if (tb == Py_None) {
tb = 0;
} else if (tb && !PyTraceBack_Check(tb)) {
PyErr_SetString(PyExc_TypeError,
"raise: arg 3 must be a traceback or None");
goto bad;
}
if (value == Py_None)
value = 0;
if (PyExceptionInstance_Check(type)) {
if (value) {
PyErr_SetString(PyExc_TypeError,
"instance exception may not have a separate value");
goto bad;
}
value = type;
type = (PyObject*) Py_TYPE(value);
} else if (PyExceptionClass_Check(type)) {
PyObject *instance_class = NULL;
if (value && PyExceptionInstance_Check(value)) {
instance_class = (PyObject*) Py_TYPE(value);
if (instance_class != type) {
int is_subclass = PyObject_IsSubclass(instance_class, type);
if (!is_subclass) {
instance_class = NULL;
} else if (unlikely(is_subclass == -1)) {
goto bad;
} else {
type = instance_class;
}
}
}
if (!instance_class) {
PyObject *args;
if (!value)
args = PyTuple_New(0);
else if (PyTuple_Check(value)) {
Py_INCREF(value);
args = value;
} else
args = PyTuple_Pack(1, value);
if (!args)
goto bad;
owned_instance = PyObject_Call(type, args, NULL);
Py_DECREF(args);
if (!owned_instance)
goto bad;
value = owned_instance;
if (!PyExceptionInstance_Check(value)) {
PyErr_Format(PyExc_TypeError,
"calling %R should have returned an instance of "
"BaseException, not %R",
type, Py_TYPE(value));
goto bad;
}
}
} else {
PyErr_SetString(PyExc_TypeError,
"raise: exception class must be a subclass of BaseException");
goto bad;
}
if (cause) {
PyObject *fixed_cause;
if (cause == Py_None) {
fixed_cause = NULL;
} else if (PyExceptionClass_Check(cause)) {
fixed_cause = PyObject_CallObject(cause, NULL);
if (fixed_cause == NULL)
goto bad;
} else if (PyExceptionInstance_Check(cause)) {
fixed_cause = cause;
Py_INCREF(fixed_cause);
} else {
PyErr_SetString(PyExc_TypeError,
"exception causes must derive from "
"BaseException");
goto bad;
}
PyException_SetCause(value, fixed_cause);
}
PyErr_SetObject(type, value);
if (tb) {
#if CYTHON_COMPILING_IN_PYPY
PyObject *tmp_type, *tmp_value, *tmp_tb;
PyErr_Fetch(&tmp_type, &tmp_value, &tmp_tb);
Py_INCREF(tb);
PyErr_Restore(tmp_type, tmp_value, tb);
Py_XDECREF(tmp_tb);
#else
PyThreadState *tstate = __Pyx_PyThreadState_Current;
PyObject* tmp_tb = tstate->curexc_traceback;
if (tb != tmp_tb) {
Py_INCREF(tb);
tstate->curexc_traceback = tb;
Py_XDECREF(tmp_tb);
}
#endif
}
bad:
Py_XDECREF(owned_instance);
return;
}
#endif
/* SetItemInt */
static int __Pyx_SetItemInt_Generic(PyObject *o, PyObject *j, PyObject *v) {
int r;
if (!j) return -1;
r = PyObject_SetItem(o, j, v);
Py_DECREF(j);
return r;
}
static CYTHON_INLINE int __Pyx_SetItemInt_Fast(PyObject *o, Py_ssize_t i, PyObject *v, int is_list,
CYTHON_NCP_UNUSED int wraparound, CYTHON_NCP_UNUSED int boundscheck) {
#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS && CYTHON_USE_TYPE_SLOTS
if (is_list || PyList_CheckExact(o)) {
Py_ssize_t n = (!wraparound) ? i : ((likely(i >= 0)) ? i : i + PyList_GET_SIZE(o));
if ((!boundscheck) || likely(__Pyx_is_valid_index(n, PyList_GET_SIZE(o)))) {
PyObject* old = PyList_GET_ITEM(o, n);
Py_INCREF(v);
PyList_SET_ITEM(o, n, v);
Py_DECREF(old);
return 1;
}
} else {
PySequenceMethods *m = Py_TYPE(o)->tp_as_sequence;
if (likely(m && m->sq_ass_item)) {
if (wraparound && unlikely(i < 0) && likely(m->sq_length)) {
Py_ssize_t l = m->sq_length(o);
if (likely(l >= 0)) {
i += l;
} else {
if (!PyErr_ExceptionMatches(PyExc_OverflowError))
return -1;
PyErr_Clear();
}
}
return m->sq_ass_item(o, i, v);
}
}
#else
#if CYTHON_COMPILING_IN_PYPY
if (is_list || (PySequence_Check(o) && !PyDict_Check(o)))
#else
if (is_list || PySequence_Check(o))
#endif
{
return PySequence_SetItem(o, i, v);
}
#endif
return __Pyx_SetItemInt_Generic(o, PyInt_FromSsize_t(i), v);
}
/* Import */
static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level) {
PyObject *empty_list = 0;
PyObject *module = 0;
PyObject *global_dict = 0;
PyObject *empty_dict = 0;
PyObject *list;
#if PY_MAJOR_VERSION < 3
PyObject *py_import;
py_import = __Pyx_PyObject_GetAttrStr(__pyx_b, __pyx_n_s_import);
if (!py_import)
goto bad;
#endif
if (from_list)
list = from_list;
else {
empty_list = PyList_New(0);
if (!empty_list)
goto bad;
list = empty_list;
}
global_dict = PyModule_GetDict(__pyx_m);
if (!global_dict)
goto bad;
empty_dict = PyDict_New();
if (!empty_dict)
goto bad;
{
#if PY_MAJOR_VERSION >= 3
if (level == -1) {
if ((1) && (strchr(__Pyx_MODULE_NAME, '.'))) {
module = PyImport_ImportModuleLevelObject(
name, global_dict, empty_dict, list, 1);
if (!module) {
if (!PyErr_ExceptionMatches(PyExc_ImportError))
goto bad;
PyErr_Clear();
}
}
level = 0;
}
#endif
if (!module) {
#if PY_MAJOR_VERSION < 3
PyObject *py_level = PyInt_FromLong(level);
if (!py_level)
goto bad;
module = PyObject_CallFunctionObjArgs(py_import,
name, global_dict, empty_dict, list, py_level, (PyObject *)NULL);
Py_DECREF(py_level);
#else
module = PyImport_ImportModuleLevelObject(
name, global_dict, empty_dict, list, level);
#endif
}
}
bad:
#if PY_MAJOR_VERSION < 3
Py_XDECREF(py_import);
#endif
Py_XDECREF(empty_list);
Py_XDECREF(empty_dict);
return module;
}
/* ImportFrom */
static PyObject* __Pyx_ImportFrom(PyObject* module, PyObject* name) {
PyObject* value = __Pyx_PyObject_GetAttrStr(module, name);
if (unlikely(!value) && PyErr_ExceptionMatches(PyExc_AttributeError)) {
PyErr_Format(PyExc_ImportError,
#if PY_MAJOR_VERSION < 3
"cannot import name %.230s", PyString_AS_STRING(name));
#else
"cannot import name %S", name);
#endif
}
return value;
}
/* HasAttr */
static CYTHON_INLINE int __Pyx_HasAttr(PyObject *o, PyObject *n) {
PyObject *r;
if (unlikely(!__Pyx_PyBaseString_Check(n))) {
PyErr_SetString(PyExc_TypeError,
"hasattr(): attribute name must be string");
return -1;
}
r = __Pyx_GetAttr(o, n);
if (unlikely(!r)) {
PyErr_Clear();
return 0;
} else {
Py_DECREF(r);
return 1;
}
}
/* RaiseNoneIterError */
static CYTHON_INLINE void __Pyx_RaiseNoneNotIterableError(void) {
PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable");
}
/* ExtTypeTest */
static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type) {
if (unlikely(!type)) {
PyErr_SetString(PyExc_SystemError, "Missing type object");
return 0;
}
if (likely(__Pyx_TypeCheck(obj, type)))
return 1;
PyErr_Format(PyExc_TypeError, "Cannot convert %.200s to %.200s",
Py_TYPE(obj)->tp_name, type->tp_name);
return 0;
}
/* GetTopmostException */
#if CYTHON_USE_EXC_INFO_STACK
static _PyErr_StackItem *
__Pyx_PyErr_GetTopmostException(PyThreadState *tstate)
{
_PyErr_StackItem *exc_info = tstate->exc_info;
while ((exc_info->exc_type == NULL || exc_info->exc_type == Py_None) &&
exc_info->previous_item != NULL)
{
exc_info = exc_info->previous_item;
}
return exc_info;
}
#endif
/* SaveResetException */
#if CYTHON_FAST_THREAD_STATE
static CYTHON_INLINE void __Pyx__ExceptionSave(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) {
#if CYTHON_USE_EXC_INFO_STACK
_PyErr_StackItem *exc_info = __Pyx_PyErr_GetTopmostException(tstate);
*type = exc_info->exc_type;
*value = exc_info->exc_value;
*tb = exc_info->exc_traceback;
#else
*type = tstate->exc_type;
*value = tstate->exc_value;
*tb = tstate->exc_traceback;
#endif
Py_XINCREF(*type);
Py_XINCREF(*value);
Py_XINCREF(*tb);
}
static CYTHON_INLINE void __Pyx__ExceptionReset(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) {
PyObject *tmp_type, *tmp_value, *tmp_tb;
#if CYTHON_USE_EXC_INFO_STACK
_PyErr_StackItem *exc_info = tstate->exc_info;
tmp_type = exc_info->exc_type;
tmp_value = exc_info->exc_value;
tmp_tb = exc_info->exc_traceback;
exc_info->exc_type = type;
exc_info->exc_value = value;
exc_info->exc_traceback = tb;
#else
tmp_type = tstate->exc_type;
tmp_value = tstate->exc_value;
tmp_tb = tstate->exc_traceback;
tstate->exc_type = type;
tstate->exc_value = value;
tstate->exc_traceback = tb;
#endif
Py_XDECREF(tmp_type);
Py_XDECREF(tmp_value);
Py_XDECREF(tmp_tb);
}
#endif
/* GetException */
#if CYTHON_FAST_THREAD_STATE
static int __Pyx__GetException(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb)
#else
static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb)
#endif
{
PyObject *local_type, *local_value, *local_tb;
#if CYTHON_FAST_THREAD_STATE
PyObject *tmp_type, *tmp_value, *tmp_tb;
local_type = tstate->curexc_type;
local_value = tstate->curexc_value;
local_tb = tstate->curexc_traceback;
tstate->curexc_type = 0;
tstate->curexc_value = 0;
tstate->curexc_traceback = 0;
#else
PyErr_Fetch(&local_type, &local_value, &local_tb);
#endif
PyErr_NormalizeException(&local_type, &local_value, &local_tb);
#if CYTHON_FAST_THREAD_STATE
if (unlikely(tstate->curexc_type))
#else
if (unlikely(PyErr_Occurred()))
#endif
goto bad;
#if PY_MAJOR_VERSION >= 3
if (local_tb) {
if (unlikely(PyException_SetTraceback(local_value, local_tb) < 0))
goto bad;
}
#endif
Py_XINCREF(local_tb);
Py_XINCREF(local_type);
Py_XINCREF(local_value);
*type = local_type;
*value = local_value;
*tb = local_tb;
#if CYTHON_FAST_THREAD_STATE
#if CYTHON_USE_EXC_INFO_STACK
{
_PyErr_StackItem *exc_info = tstate->exc_info;
tmp_type = exc_info->exc_type;
tmp_value = exc_info->exc_value;
tmp_tb = exc_info->exc_traceback;
exc_info->exc_type = local_type;
exc_info->exc_value = local_value;
exc_info->exc_traceback = local_tb;
}
#else
tmp_type = tstate->exc_type;
tmp_value = tstate->exc_value;
tmp_tb = tstate->exc_traceback;
tstate->exc_type = local_type;
tstate->exc_value = local_value;
tstate->exc_traceback = local_tb;
#endif
Py_XDECREF(tmp_type);
Py_XDECREF(tmp_value);
Py_XDECREF(tmp_tb);
#else
PyErr_SetExcInfo(local_type, local_value, local_tb);
#endif
return 0;
bad:
*type = 0;
*value = 0;
*tb = 0;
Py_XDECREF(local_type);
Py_XDECREF(local_value);
Py_XDECREF(local_tb);
return -1;
}
/* decode_c_string */
static CYTHON_INLINE PyObject* __Pyx_decode_c_string(
const char* cstring, Py_ssize_t start, Py_ssize_t stop,
const char* encoding, const char* errors,
PyObject* (*decode_func)(const char *s, Py_ssize_t size, const char *errors)) {
Py_ssize_t length;
if (unlikely((start < 0) | (stop < 0))) {
size_t slen = strlen(cstring);
if (unlikely(slen > (size_t) PY_SSIZE_T_MAX)) {
PyErr_SetString(PyExc_OverflowError,
"c-string too long to convert to Python");
return NULL;
}
length = (Py_ssize_t) slen;
if (start < 0) {
start += length;
if (start < 0)
start = 0;
}
if (stop < 0)
stop += length;
}
if (unlikely(stop <= start))
return __Pyx_NewRef(__pyx_empty_unicode);
length = stop - start;
cstring += start;
if (decode_func) {
return decode_func(cstring, length, errors);
} else {
return PyUnicode_Decode(cstring, length, encoding, errors);
}
}
/* SwapException */
#if CYTHON_FAST_THREAD_STATE
static CYTHON_INLINE void __Pyx__ExceptionSwap(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) {
PyObject *tmp_type, *tmp_value, *tmp_tb;
#if CYTHON_USE_EXC_INFO_STACK
_PyErr_StackItem *exc_info = tstate->exc_info;
tmp_type = exc_info->exc_type;
tmp_value = exc_info->exc_value;
tmp_tb = exc_info->exc_traceback;
exc_info->exc_type = *type;
exc_info->exc_value = *value;
exc_info->exc_traceback = *tb;
#else
tmp_type = tstate->exc_type;
tmp_value = tstate->exc_value;
tmp_tb = tstate->exc_traceback;
tstate->exc_type = *type;
tstate->exc_value = *value;
tstate->exc_traceback = *tb;
#endif
*type = tmp_type;
*value = tmp_value;
*tb = tmp_tb;
}
#else
static CYTHON_INLINE void __Pyx_ExceptionSwap(PyObject **type, PyObject **value, PyObject **tb) {
PyObject *tmp_type, *tmp_value, *tmp_tb;
PyErr_GetExcInfo(&tmp_type, &tmp_value, &tmp_tb);
PyErr_SetExcInfo(*type, *value, *tb);
*type = tmp_type;
*value = tmp_value;
*tb = tmp_tb;
}
#endif
/* FastTypeChecks */
#if CYTHON_COMPILING_IN_CPYTHON
static int __Pyx_InBases(PyTypeObject *a, PyTypeObject *b) {
while (a) {
a = a->tp_base;
if (a == b)
return 1;
}
return b == &PyBaseObject_Type;
}
static CYTHON_INLINE int __Pyx_IsSubtype(PyTypeObject *a, PyTypeObject *b) {
PyObject *mro;
if (a == b) return 1;
mro = a->tp_mro;
if (likely(mro)) {
Py_ssize_t i, n;
n = PyTuple_GET_SIZE(mro);
for (i = 0; i < n; i++) {
if (PyTuple_GET_ITEM(mro, i) == (PyObject *)b)
return 1;
}
return 0;
}
return __Pyx_InBases(a, b);
}
#if PY_MAJOR_VERSION == 2
static int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc_type1, PyObject* exc_type2) {
PyObject *exception, *value, *tb;
int res;
__Pyx_PyThreadState_declare
__Pyx_PyThreadState_assign
__Pyx_ErrFetch(&exception, &value, &tb);
res = exc_type1 ? PyObject_IsSubclass(err, exc_type1) : 0;
if (unlikely(res == -1)) {
PyErr_WriteUnraisable(err);
res = 0;
}
if (!res) {
res = PyObject_IsSubclass(err, exc_type2);
if (unlikely(res == -1)) {
PyErr_WriteUnraisable(err);
res = 0;
}
}
__Pyx_ErrRestore(exception, value, tb);
return res;
}
#else
static CYTHON_INLINE int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc_type1, PyObject *exc_type2) {
int res = exc_type1 ? __Pyx_IsSubtype((PyTypeObject*)err, (PyTypeObject*)exc_type1) : 0;
if (!res) {
res = __Pyx_IsSubtype((PyTypeObject*)err, (PyTypeObject*)exc_type2);
}
return res;
}
#endif
static int __Pyx_PyErr_GivenExceptionMatchesTuple(PyObject *exc_type, PyObject *tuple) {
Py_ssize_t i, n;
assert(PyExceptionClass_Check(exc_type));
n = PyTuple_GET_SIZE(tuple);
#if PY_MAJOR_VERSION >= 3
for (i=0; i<n; i++) {
if (exc_type == PyTuple_GET_ITEM(tuple, i)) return 1;
}
#endif
for (i=0; i<n; i++) {
PyObject *t = PyTuple_GET_ITEM(tuple, i);
#if PY_MAJOR_VERSION < 3
if (likely(exc_type == t)) return 1;
#endif
if (likely(PyExceptionClass_Check(t))) {
if (__Pyx_inner_PyErr_GivenExceptionMatches2(exc_type, NULL, t)) return 1;
} else {
}
}
return 0;
}
static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches(PyObject *err, PyObject* exc_type) {
if (likely(err == exc_type)) return 1;
if (likely(PyExceptionClass_Check(err))) {
if (likely(PyExceptionClass_Check(exc_type))) {
return __Pyx_inner_PyErr_GivenExceptionMatches2(err, NULL, exc_type);
} else if (likely(PyTuple_Check(exc_type))) {
return __Pyx_PyErr_GivenExceptionMatchesTuple(err, exc_type);
} else {
}
}
return PyErr_GivenExceptionMatches(err, exc_type);
}
static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches2(PyObject *err, PyObject *exc_type1, PyObject *exc_type2) {
assert(PyExceptionClass_Check(exc_type1));
assert(PyExceptionClass_Check(exc_type2));
if (likely(err == exc_type1 || err == exc_type2)) return 1;
if (likely(PyExceptionClass_Check(err))) {
return __Pyx_inner_PyErr_GivenExceptionMatches2(err, exc_type1, exc_type2);
}
return (PyErr_GivenExceptionMatches(err, exc_type1) || PyErr_GivenExceptionMatches(err, exc_type2));
}
#endif
/* None */
static CYTHON_INLINE void __Pyx_RaiseUnboundLocalError(const char *varname) {
PyErr_Format(PyExc_UnboundLocalError, "local variable '%s' referenced before assignment", varname);
}
/* CallNextTpDealloc */
static void __Pyx_call_next_tp_dealloc(PyObject* obj, destructor current_tp_dealloc) {
PyTypeObject* type = Py_TYPE(obj);
while (type && type->tp_dealloc != current_tp_dealloc)
type = type->tp_base;
while (type && type->tp_dealloc == current_tp_dealloc)
type = type->tp_base;
if (type)
type->tp_dealloc(obj);
}
/* CallNextTpTraverse */
static int __Pyx_call_next_tp_traverse(PyObject* obj, visitproc v, void *a, traverseproc current_tp_traverse) {
PyTypeObject* type = Py_TYPE(obj);
while (type && type->tp_traverse != current_tp_traverse)
type = type->tp_base;
while (type && type->tp_traverse == current_tp_traverse)
type = type->tp_base;
if (type && type->tp_traverse)
return type->tp_traverse(obj, v, a);
return 0;
}
/* CallNextTpClear */
static void __Pyx_call_next_tp_clear(PyObject* obj, inquiry current_tp_clear) {
PyTypeObject* type = Py_TYPE(obj);
while (type && type->tp_clear != current_tp_clear)
type = type->tp_base;
while (type && type->tp_clear == current_tp_clear)
type = type->tp_base;
if (type && type->tp_clear)
type->tp_clear(obj);
}
/* PyObject_GenericGetAttrNoDict */
#if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000
static PyObject *__Pyx_RaiseGenericGetAttributeError(PyTypeObject *tp, PyObject *attr_name) {
PyErr_Format(PyExc_AttributeError,
#if PY_MAJOR_VERSION >= 3
"'%.50s' object has no attribute '%U'",
tp->tp_name, attr_name);
#else
"'%.50s' object has no attribute '%.400s'",
tp->tp_name, PyString_AS_STRING(attr_name));
#endif
return NULL;
}
static CYTHON_INLINE PyObject* __Pyx_PyObject_GenericGetAttrNoDict(PyObject* obj, PyObject* attr_name) {
PyObject *descr;
PyTypeObject *tp = Py_TYPE(obj);
if (unlikely(!PyString_Check(attr_name))) {
return PyObject_GenericGetAttr(obj, attr_name);
}
assert(!tp->tp_dictoffset);
descr = _PyType_Lookup(tp, attr_name);
if (unlikely(!descr)) {
return __Pyx_RaiseGenericGetAttributeError(tp, attr_name);
}
Py_INCREF(descr);
#if PY_MAJOR_VERSION < 3
if (likely(PyType_HasFeature(Py_TYPE(descr), Py_TPFLAGS_HAVE_CLASS)))
#endif
{
descrgetfunc f = Py_TYPE(descr)->tp_descr_get;
if (unlikely(f)) {
PyObject *res = f(descr, obj, (PyObject *)tp);
Py_DECREF(descr);
return res;
}
}
return descr;
}
#endif
/* PyObject_GenericGetAttr */
#if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000
static PyObject* __Pyx_PyObject_GenericGetAttr(PyObject* obj, PyObject* attr_name) {
if (unlikely(Py_TYPE(obj)->tp_dictoffset)) {
return PyObject_GenericGetAttr(obj, attr_name);
}
return __Pyx_PyObject_GenericGetAttrNoDict(obj, attr_name);
}
#endif
/* TypeImport */
#ifndef __PYX_HAVE_RT_ImportType
#define __PYX_HAVE_RT_ImportType
static PyTypeObject *__Pyx_ImportType(PyObject *module, const char *module_name, const char *class_name,
size_t size, enum __Pyx_ImportType_CheckSize check_size)
{
PyObject *result = 0;
char warning[200];
Py_ssize_t basicsize;
#ifdef Py_LIMITED_API
PyObject *py_basicsize;
#endif
result = PyObject_GetAttrString(module, class_name);
if (!result)
goto bad;
if (!PyType_Check(result)) {
PyErr_Format(PyExc_TypeError,
"%.200s.%.200s is not a type object",
module_name, class_name);
goto bad;
}
#ifndef Py_LIMITED_API
basicsize = ((PyTypeObject *)result)->tp_basicsize;
#else
py_basicsize = PyObject_GetAttrString(result, "__basicsize__");
if (!py_basicsize)
goto bad;
basicsize = PyLong_AsSsize_t(py_basicsize);
Py_DECREF(py_basicsize);
py_basicsize = 0;
if (basicsize == (Py_ssize_t)-1 && PyErr_Occurred())
goto bad;
#endif
if ((size_t)basicsize < size) {
PyErr_Format(PyExc_ValueError,
"%.200s.%.200s size changed, may indicate binary incompatibility. "
"Expected %zd from C header, got %zd from PyObject",
module_name, class_name, size, basicsize);
goto bad;
}
if (check_size == __Pyx_ImportType_CheckSize_Error && (size_t)basicsize != size) {
PyErr_Format(PyExc_ValueError,
"%.200s.%.200s size changed, may indicate binary incompatibility. "
"Expected %zd from C header, got %zd from PyObject",
module_name, class_name, size, basicsize);
goto bad;
}
else if (check_size == __Pyx_ImportType_CheckSize_Warn && (size_t)basicsize > size) {
PyOS_snprintf(warning, sizeof(warning),
"%s.%s size changed, may indicate binary incompatibility. "
"Expected %zd from C header, got %zd from PyObject",
module_name, class_name, size, basicsize);
if (PyErr_WarnEx(NULL, warning, 0) < 0) goto bad;
}
return (PyTypeObject *)result;
bad:
Py_XDECREF(result);
return NULL;
}
#endif
/* GetVTable */
static void* __Pyx_GetVtable(PyObject *dict) {
void* ptr;
PyObject *ob = PyObject_GetItem(dict, __pyx_n_s_pyx_vtable);
if (!ob)
goto bad;
#if PY_VERSION_HEX >= 0x02070000
ptr = PyCapsule_GetPointer(ob, 0);
#else
ptr = PyCObject_AsVoidPtr(ob);
#endif
if (!ptr && !PyErr_Occurred())
PyErr_SetString(PyExc_RuntimeError, "invalid vtable found for imported type");
Py_DECREF(ob);
return ptr;
bad:
Py_XDECREF(ob);
return NULL;
}
/* SetVTable */
static int __Pyx_SetVtable(PyObject *dict, void *vtable) {
#if PY_VERSION_HEX >= 0x02070000
PyObject *ob = PyCapsule_New(vtable, 0, 0);
#else
PyObject *ob = PyCObject_FromVoidPtr(vtable, 0);
#endif
if (!ob)
goto bad;
if (PyDict_SetItem(dict, __pyx_n_s_pyx_vtable, ob) < 0)
goto bad;
Py_DECREF(ob);
return 0;
bad:
Py_XDECREF(ob);
return -1;
}
/* PyObjectGetAttrStrNoError */
static void __Pyx_PyObject_GetAttrStr_ClearAttributeError(void) {
__Pyx_PyThreadState_declare
__Pyx_PyThreadState_assign
if (likely(__Pyx_PyErr_ExceptionMatches(PyExc_AttributeError)))
__Pyx_PyErr_Clear();
}
static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStrNoError(PyObject* obj, PyObject* attr_name) {
PyObject *result;
#if CYTHON_COMPILING_IN_CPYTHON && CYTHON_USE_TYPE_SLOTS && PY_VERSION_HEX >= 0x030700B1
PyTypeObject* tp = Py_TYPE(obj);
if (likely(tp->tp_getattro == PyObject_GenericGetAttr)) {
return _PyObject_GenericGetAttrWithDict(obj, attr_name, NULL, 1);
}
#endif
result = __Pyx_PyObject_GetAttrStr(obj, attr_name);
if (unlikely(!result)) {
__Pyx_PyObject_GetAttrStr_ClearAttributeError();
}
return result;
}
/* SetupReduce */
static int __Pyx_setup_reduce_is_named(PyObject* meth, PyObject* name) {
int ret;
PyObject *name_attr;
name_attr = __Pyx_PyObject_GetAttrStr(meth, __pyx_n_s_name_2);
if (likely(name_attr)) {
ret = PyObject_RichCompareBool(name_attr, name, Py_EQ);
} else {
ret = -1;
}
if (unlikely(ret < 0)) {
PyErr_Clear();
ret = 0;
}
Py_XDECREF(name_attr);
return ret;
}
static int __Pyx_setup_reduce(PyObject* type_obj) {
int ret = 0;
PyObject *object_reduce = NULL;
PyObject *object_reduce_ex = NULL;
PyObject *reduce = NULL;
PyObject *reduce_ex = NULL;
PyObject *reduce_cython = NULL;
PyObject *setstate = NULL;
PyObject *setstate_cython = NULL;
#if CYTHON_USE_PYTYPE_LOOKUP
if (_PyType_Lookup((PyTypeObject*)type_obj, __pyx_n_s_getstate)) goto __PYX_GOOD;
#else
if (PyObject_HasAttr(type_obj, __pyx_n_s_getstate)) goto __PYX_GOOD;
#endif
#if CYTHON_USE_PYTYPE_LOOKUP
object_reduce_ex = _PyType_Lookup(&PyBaseObject_Type, __pyx_n_s_reduce_ex); if (!object_reduce_ex) goto __PYX_BAD;
#else
object_reduce_ex = __Pyx_PyObject_GetAttrStr((PyObject*)&PyBaseObject_Type, __pyx_n_s_reduce_ex); if (!object_reduce_ex) goto __PYX_BAD;
#endif
reduce_ex = __Pyx_PyObject_GetAttrStr(type_obj, __pyx_n_s_reduce_ex); if (unlikely(!reduce_ex)) goto __PYX_BAD;
if (reduce_ex == object_reduce_ex) {
#if CYTHON_USE_PYTYPE_LOOKUP
object_reduce = _PyType_Lookup(&PyBaseObject_Type, __pyx_n_s_reduce); if (!object_reduce) goto __PYX_BAD;
#else
object_reduce = __Pyx_PyObject_GetAttrStr((PyObject*)&PyBaseObject_Type, __pyx_n_s_reduce); if (!object_reduce) goto __PYX_BAD;
#endif
reduce = __Pyx_PyObject_GetAttrStr(type_obj, __pyx_n_s_reduce); if (unlikely(!reduce)) goto __PYX_BAD;
if (reduce == object_reduce || __Pyx_setup_reduce_is_named(reduce, __pyx_n_s_reduce_cython)) {
reduce_cython = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_n_s_reduce_cython);
if (likely(reduce_cython)) {
ret = PyDict_SetItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_reduce, reduce_cython); if (unlikely(ret < 0)) goto __PYX_BAD;
ret = PyDict_DelItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_reduce_cython); if (unlikely(ret < 0)) goto __PYX_BAD;
} else if (reduce == object_reduce || PyErr_Occurred()) {
goto __PYX_BAD;
}
setstate = __Pyx_PyObject_GetAttrStr(type_obj, __pyx_n_s_setstate);
if (!setstate) PyErr_Clear();
if (!setstate || __Pyx_setup_reduce_is_named(setstate, __pyx_n_s_setstate_cython)) {
setstate_cython = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_n_s_setstate_cython);
if (likely(setstate_cython)) {
ret = PyDict_SetItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_setstate, setstate_cython); if (unlikely(ret < 0)) goto __PYX_BAD;
ret = PyDict_DelItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_setstate_cython); if (unlikely(ret < 0)) goto __PYX_BAD;
} else if (!setstate || PyErr_Occurred()) {
goto __PYX_BAD;
}
}
PyType_Modified((PyTypeObject*)type_obj);
}
}
goto __PYX_GOOD;
__PYX_BAD:
if (!PyErr_Occurred())
PyErr_Format(PyExc_RuntimeError, "Unable to initialize pickling for %s", ((PyTypeObject*)type_obj)->tp_name);
ret = -1;
__PYX_GOOD:
#if !CYTHON_USE_PYTYPE_LOOKUP
Py_XDECREF(object_reduce);
Py_XDECREF(object_reduce_ex);
#endif
Py_XDECREF(reduce);
Py_XDECREF(reduce_ex);
Py_XDECREF(reduce_cython);
Py_XDECREF(setstate);
Py_XDECREF(setstate_cython);
return ret;
}
/* ClassMethod */
static PyObject* __Pyx_Method_ClassMethod(PyObject *method) {
#if CYTHON_COMPILING_IN_PYPY && PYPY_VERSION_NUM <= 0x05080000
if (PyObject_TypeCheck(method, &PyWrapperDescr_Type)) {
return PyClassMethod_New(method);
}
#else
#if CYTHON_COMPILING_IN_PYSTON || CYTHON_COMPILING_IN_PYPY
if (PyMethodDescr_Check(method))
#else
#if PY_MAJOR_VERSION == 2
static PyTypeObject *methoddescr_type = NULL;
if (methoddescr_type == NULL) {
PyObject *meth = PyObject_GetAttrString((PyObject*)&PyList_Type, "append");
if (!meth) return NULL;
methoddescr_type = Py_TYPE(meth);
Py_DECREF(meth);
}
#else
PyTypeObject *methoddescr_type = &PyMethodDescr_Type;
#endif
if (__Pyx_TypeCheck(method, methoddescr_type))
#endif
{
PyMethodDescrObject *descr = (PyMethodDescrObject *)method;
#if PY_VERSION_HEX < 0x03020000
PyTypeObject *d_type = descr->d_type;
#else
PyTypeObject *d_type = descr->d_common.d_type;
#endif
return PyDescr_NewClassMethod(d_type, descr->d_method);
}
#endif
else if (PyMethod_Check(method)) {
return PyClassMethod_New(PyMethod_GET_FUNCTION(method));
}
else {
return PyClassMethod_New(method);
}
}
/* GetNameInClass */
static PyObject *__Pyx_GetGlobalNameAfterAttributeLookup(PyObject *name) {
PyObject *result;
__Pyx_PyThreadState_declare
__Pyx_PyThreadState_assign
if (unlikely(!__Pyx_PyErr_ExceptionMatches(PyExc_AttributeError)))
return NULL;
__Pyx_PyErr_Clear();
__Pyx_GetModuleGlobalNameUncached(result, name);
return result;
}
static PyObject *__Pyx__GetNameInClass(PyObject *nmspace, PyObject *name) {
PyObject *result;
result = __Pyx_PyObject_GetAttrStr(nmspace, name);
if (!result) {
result = __Pyx_GetGlobalNameAfterAttributeLookup(name);
}
return result;
}
/* CLineInTraceback */
#ifndef CYTHON_CLINE_IN_TRACEBACK
static int __Pyx_CLineForTraceback(CYTHON_NCP_UNUSED PyThreadState *tstate, int c_line) {
PyObject *use_cline;
PyObject *ptype, *pvalue, *ptraceback;
#if CYTHON_COMPILING_IN_CPYTHON
PyObject **cython_runtime_dict;
#endif
if (unlikely(!__pyx_cython_runtime)) {
return c_line;
}
__Pyx_ErrFetchInState(tstate, &ptype, &pvalue, &ptraceback);
#if CYTHON_COMPILING_IN_CPYTHON
cython_runtime_dict = _PyObject_GetDictPtr(__pyx_cython_runtime);
if (likely(cython_runtime_dict)) {
__PYX_PY_DICT_LOOKUP_IF_MODIFIED(
use_cline, *cython_runtime_dict,
__Pyx_PyDict_GetItemStr(*cython_runtime_dict, __pyx_n_s_cline_in_traceback))
} else
#endif
{
PyObject *use_cline_obj = __Pyx_PyObject_GetAttrStr(__pyx_cython_runtime, __pyx_n_s_cline_in_traceback);
if (use_cline_obj) {
use_cline = PyObject_Not(use_cline_obj) ? Py_False : Py_True;
Py_DECREF(use_cline_obj);
} else {
PyErr_Clear();
use_cline = NULL;
}
}
if (!use_cline) {
c_line = 0;
PyObject_SetAttr(__pyx_cython_runtime, __pyx_n_s_cline_in_traceback, Py_False);
}
else if (use_cline == Py_False || (use_cline != Py_True && PyObject_Not(use_cline) != 0)) {
c_line = 0;
}
__Pyx_ErrRestoreInState(tstate, ptype, pvalue, ptraceback);
return c_line;
}
#endif
/* CodeObjectCache */
static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line) {
int start = 0, mid = 0, end = count - 1;
if (end >= 0 && code_line > entries[end].code_line) {
return count;
}
while (start < end) {
mid = start + (end - start) / 2;
if (code_line < entries[mid].code_line) {
end = mid;
} else if (code_line > entries[mid].code_line) {
start = mid + 1;
} else {
return mid;
}
}
if (code_line <= entries[mid].code_line) {
return mid;
} else {
return mid + 1;
}
}
static PyCodeObject *__pyx_find_code_object(int code_line) {
PyCodeObject* code_object;
int pos;
if (unlikely(!code_line) || unlikely(!__pyx_code_cache.entries)) {
return NULL;
}
pos = __pyx_bisect_code_objects(__pyx_code_cache.entries, __pyx_code_cache.count, code_line);
if (unlikely(pos >= __pyx_code_cache.count) || unlikely(__pyx_code_cache.entries[pos].code_line != code_line)) {
return NULL;
}
code_object = __pyx_code_cache.entries[pos].code_object;
Py_INCREF(code_object);
return code_object;
}
static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object) {
int pos, i;
__Pyx_CodeObjectCacheEntry* entries = __pyx_code_cache.entries;
if (unlikely(!code_line)) {
return;
}
if (unlikely(!entries)) {
entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Malloc(64*sizeof(__Pyx_CodeObjectCacheEntry));
if (likely(entries)) {
__pyx_code_cache.entries = entries;
__pyx_code_cache.max_count = 64;
__pyx_code_cache.count = 1;
entries[0].code_line = code_line;
entries[0].code_object = code_object;
Py_INCREF(code_object);
}
return;
}
pos = __pyx_bisect_code_objects(__pyx_code_cache.entries, __pyx_code_cache.count, code_line);
if ((pos < __pyx_code_cache.count) && unlikely(__pyx_code_cache.entries[pos].code_line == code_line)) {
PyCodeObject* tmp = entries[pos].code_object;
entries[pos].code_object = code_object;
Py_DECREF(tmp);
return;
}
if (__pyx_code_cache.count == __pyx_code_cache.max_count) {
int new_max = __pyx_code_cache.max_count + 64;
entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Realloc(
__pyx_code_cache.entries, ((size_t)new_max) * sizeof(__Pyx_CodeObjectCacheEntry));
if (unlikely(!entries)) {
return;
}
__pyx_code_cache.entries = entries;
__pyx_code_cache.max_count = new_max;
}
for (i=__pyx_code_cache.count; i>pos; i--) {
entries[i] = entries[i-1];
}
entries[pos].code_line = code_line;
entries[pos].code_object = code_object;
__pyx_code_cache.count++;
Py_INCREF(code_object);
}
/* AddTraceback */
#include "compile.h"
#include "frameobject.h"
#include "traceback.h"
static PyCodeObject* __Pyx_CreateCodeObjectForTraceback(
const char *funcname, int c_line,
int py_line, const char *filename) {
PyCodeObject *py_code = 0;
PyObject *py_srcfile = 0;
PyObject *py_funcname = 0;
#if PY_MAJOR_VERSION < 3
py_srcfile = PyString_FromString(filename);
#else
py_srcfile = PyUnicode_FromString(filename);
#endif
if (!py_srcfile) goto bad;
if (c_line) {
#if PY_MAJOR_VERSION < 3
py_funcname = PyString_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line);
#else
py_funcname = PyUnicode_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line);
#endif
}
else {
#if PY_MAJOR_VERSION < 3
py_funcname = PyString_FromString(funcname);
#else
py_funcname = PyUnicode_FromString(funcname);
#endif
}
if (!py_funcname) goto bad;
py_code = __Pyx_PyCode_New(
0,
0,
0,
0,
0,
__pyx_empty_bytes, /*PyObject *code,*/
__pyx_empty_tuple, /*PyObject *consts,*/
__pyx_empty_tuple, /*PyObject *names,*/
__pyx_empty_tuple, /*PyObject *varnames,*/
__pyx_empty_tuple, /*PyObject *freevars,*/
__pyx_empty_tuple, /*PyObject *cellvars,*/
py_srcfile, /*PyObject *filename,*/
py_funcname, /*PyObject *name,*/
py_line,
__pyx_empty_bytes /*PyObject *lnotab*/
);
Py_DECREF(py_srcfile);
Py_DECREF(py_funcname);
return py_code;
bad:
Py_XDECREF(py_srcfile);
Py_XDECREF(py_funcname);
return NULL;
}
static void __Pyx_AddTraceback(const char *funcname, int c_line,
int py_line, const char *filename) {
PyCodeObject *py_code = 0;
PyFrameObject *py_frame = 0;
PyThreadState *tstate = __Pyx_PyThreadState_Current;
if (c_line) {
c_line = __Pyx_CLineForTraceback(tstate, c_line);
}
py_code = __pyx_find_code_object(c_line ? -c_line : py_line);
if (!py_code) {
py_code = __Pyx_CreateCodeObjectForTraceback(
funcname, c_line, py_line, filename);
if (!py_code) goto bad;
__pyx_insert_code_object(c_line ? -c_line : py_line, py_code);
}
py_frame = PyFrame_New(
tstate, /*PyThreadState *tstate,*/
py_code, /*PyCodeObject *code,*/
__pyx_d, /*PyObject *globals,*/
0 /*PyObject *locals*/
);
if (!py_frame) goto bad;
__Pyx_PyFrame_SetLineNumber(py_frame, py_line);
PyTraceBack_Here(py_frame);
bad:
Py_XDECREF(py_code);
Py_XDECREF(py_frame);
}
/* CIntToPy */
static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value) {
const int neg_one = (int) ((int) 0 - (int) 1), const_zero = (int) 0;
const int is_unsigned = neg_one > const_zero;
if (is_unsigned) {
if (sizeof(int) < sizeof(long)) {
return PyInt_FromLong((long) value);
} else if (sizeof(int) <= sizeof(unsigned long)) {
return PyLong_FromUnsignedLong((unsigned long) value);
#ifdef HAVE_LONG_LONG
} else if (sizeof(int) <= sizeof(unsigned PY_LONG_LONG)) {
return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value);
#endif
}
} else {
if (sizeof(int) <= sizeof(long)) {
return PyInt_FromLong((long) value);
#ifdef HAVE_LONG_LONG
} else if (sizeof(int) <= sizeof(PY_LONG_LONG)) {
return PyLong_FromLongLong((PY_LONG_LONG) value);
#endif
}
}
{
int one = 1; int little = (int)*(unsigned char *)&one;
unsigned char *bytes = (unsigned char *)&value;
return _PyLong_FromByteArray(bytes, sizeof(int),
little, !is_unsigned);
}
}
/* CIntFromPyVerify */
#define __PYX_VERIFY_RETURN_INT(target_type, func_type, func_value)\
__PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, 0)
#define __PYX_VERIFY_RETURN_INT_EXC(target_type, func_type, func_value)\
__PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, 1)
#define __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, exc)\
{\
func_type value = func_value;\
if (sizeof(target_type) < sizeof(func_type)) {\
if (unlikely(value != (func_type) (target_type) value)) {\
func_type zero = 0;\
if (exc && unlikely(value == (func_type)-1 && PyErr_Occurred()))\
return (target_type) -1;\
if (is_unsigned && unlikely(value < zero))\
goto raise_neg_overflow;\
else\
goto raise_overflow;\
}\
}\
return (target_type) value;\
}
/* CIntToPy */
static CYTHON_INLINE PyObject* __Pyx_PyInt_From_uint64_t(uint64_t value) {
const uint64_t neg_one = (uint64_t) ((uint64_t) 0 - (uint64_t) 1), const_zero = (uint64_t) 0;
const int is_unsigned = neg_one > const_zero;
if (is_unsigned) {
if (sizeof(uint64_t) < sizeof(long)) {
return PyInt_FromLong((long) value);
} else if (sizeof(uint64_t) <= sizeof(unsigned long)) {
return PyLong_FromUnsignedLong((unsigned long) value);
#ifdef HAVE_LONG_LONG
} else if (sizeof(uint64_t) <= sizeof(unsigned PY_LONG_LONG)) {
return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value);
#endif
}
} else {
if (sizeof(uint64_t) <= sizeof(long)) {
return PyInt_FromLong((long) value);
#ifdef HAVE_LONG_LONG
} else if (sizeof(uint64_t) <= sizeof(PY_LONG_LONG)) {
return PyLong_FromLongLong((PY_LONG_LONG) value);
#endif
}
}
{
int one = 1; int little = (int)*(unsigned char *)&one;
unsigned char *bytes = (unsigned char *)&value;
return _PyLong_FromByteArray(bytes, sizeof(uint64_t),
little, !is_unsigned);
}
}
/* CIntToPy */
static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value) {
const long neg_one = (long) ((long) 0 - (long) 1), const_zero = (long) 0;
const int is_unsigned = neg_one > const_zero;
if (is_unsigned) {
if (sizeof(long) < sizeof(long)) {
return PyInt_FromLong((long) value);
} else if (sizeof(long) <= sizeof(unsigned long)) {
return PyLong_FromUnsignedLong((unsigned long) value);
#ifdef HAVE_LONG_LONG
} else if (sizeof(long) <= sizeof(unsigned PY_LONG_LONG)) {
return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value);
#endif
}
} else {
if (sizeof(long) <= sizeof(long)) {
return PyInt_FromLong((long) value);
#ifdef HAVE_LONG_LONG
} else if (sizeof(long) <= sizeof(PY_LONG_LONG)) {
return PyLong_FromLongLong((PY_LONG_LONG) value);
#endif
}
}
{
int one = 1; int little = (int)*(unsigned char *)&one;
unsigned char *bytes = (unsigned char *)&value;
return _PyLong_FromByteArray(bytes, sizeof(long),
little, !is_unsigned);
}
}
/* CIntToPy */
static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int32_t(int32_t value) {
const int32_t neg_one = (int32_t) ((int32_t) 0 - (int32_t) 1), const_zero = (int32_t) 0;
const int is_unsigned = neg_one > const_zero;
if (is_unsigned) {
if (sizeof(int32_t) < sizeof(long)) {
return PyInt_FromLong((long) value);
} else if (sizeof(int32_t) <= sizeof(unsigned long)) {
return PyLong_FromUnsignedLong((unsigned long) value);
#ifdef HAVE_LONG_LONG
} else if (sizeof(int32_t) <= sizeof(unsigned PY_LONG_LONG)) {
return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value);
#endif
}
} else {
if (sizeof(int32_t) <= sizeof(long)) {
return PyInt_FromLong((long) value);
#ifdef HAVE_LONG_LONG
} else if (sizeof(int32_t) <= sizeof(PY_LONG_LONG)) {
return PyLong_FromLongLong((PY_LONG_LONG) value);
#endif
}
}
{
int one = 1; int little = (int)*(unsigned char *)&one;
unsigned char *bytes = (unsigned char *)&value;
return _PyLong_FromByteArray(bytes, sizeof(int32_t),
little, !is_unsigned);
}
}
/* Declarations */
#if CYTHON_CCOMPLEX
#ifdef __cplusplus
static CYTHON_INLINE __pyx_t_float_complex __pyx_t_float_complex_from_parts(float x, float y) {
return ::std::complex< float >(x, y);
}
#else
static CYTHON_INLINE __pyx_t_float_complex __pyx_t_float_complex_from_parts(float x, float y) {
return x + y*(__pyx_t_float_complex)_Complex_I;
}
#endif
#else
static CYTHON_INLINE __pyx_t_float_complex __pyx_t_float_complex_from_parts(float x, float y) {
__pyx_t_float_complex z;
z.real = x;
z.imag = y;
return z;
}
#endif
/* Arithmetic */
#if CYTHON_CCOMPLEX
#else
static CYTHON_INLINE int __Pyx_c_eq_float(__pyx_t_float_complex a, __pyx_t_float_complex b) {
return (a.real == b.real) && (a.imag == b.imag);
}
static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_sum_float(__pyx_t_float_complex a, __pyx_t_float_complex b) {
__pyx_t_float_complex z;
z.real = a.real + b.real;
z.imag = a.imag + b.imag;
return z;
}
static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_diff_float(__pyx_t_float_complex a, __pyx_t_float_complex b) {
__pyx_t_float_complex z;
z.real = a.real - b.real;
z.imag = a.imag - b.imag;
return z;
}
static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_prod_float(__pyx_t_float_complex a, __pyx_t_float_complex b) {
__pyx_t_float_complex z;
z.real = a.real * b.real - a.imag * b.imag;
z.imag = a.real * b.imag + a.imag * b.real;
return z;
}
#if 1
static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_quot_float(__pyx_t_float_complex a, __pyx_t_float_complex b) {
if (b.imag == 0) {
return __pyx_t_float_complex_from_parts(a.real / b.real, a.imag / b.real);
} else if (fabsf(b.real) >= fabsf(b.imag)) {
if (b.real == 0 && b.imag == 0) {
return __pyx_t_float_complex_from_parts(a.real / b.real, a.imag / b.imag);
} else {
float r = b.imag / b.real;
float s = (float)(1.0) / (b.real + b.imag * r);
return __pyx_t_float_complex_from_parts(
(a.real + a.imag * r) * s, (a.imag - a.real * r) * s);
}
} else {
float r = b.real / b.imag;
float s = (float)(1.0) / (b.imag + b.real * r);
return __pyx_t_float_complex_from_parts(
(a.real * r + a.imag) * s, (a.imag * r - a.real) * s);
}
}
#else
static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_quot_float(__pyx_t_float_complex a, __pyx_t_float_complex b) {
if (b.imag == 0) {
return __pyx_t_float_complex_from_parts(a.real / b.real, a.imag / b.real);
} else {
float denom = b.real * b.real + b.imag * b.imag;
return __pyx_t_float_complex_from_parts(
(a.real * b.real + a.imag * b.imag) / denom,
(a.imag * b.real - a.real * b.imag) / denom);
}
}
#endif
static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_neg_float(__pyx_t_float_complex a) {
__pyx_t_float_complex z;
z.real = -a.real;
z.imag = -a.imag;
return z;
}
static CYTHON_INLINE int __Pyx_c_is_zero_float(__pyx_t_float_complex a) {
return (a.real == 0) && (a.imag == 0);
}
static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_conj_float(__pyx_t_float_complex a) {
__pyx_t_float_complex z;
z.real = a.real;
z.imag = -a.imag;
return z;
}
#if 1
static CYTHON_INLINE float __Pyx_c_abs_float(__pyx_t_float_complex z) {
#if !defined(HAVE_HYPOT) || defined(_MSC_VER)
return sqrtf(z.real*z.real + z.imag*z.imag);
#else
return hypotf(z.real, z.imag);
#endif
}
static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_pow_float(__pyx_t_float_complex a, __pyx_t_float_complex b) {
__pyx_t_float_complex z;
float r, lnr, theta, z_r, z_theta;
if (b.imag == 0 && b.real == (int)b.real) {
if (b.real < 0) {
float denom = a.real * a.real + a.imag * a.imag;
a.real = a.real / denom;
a.imag = -a.imag / denom;
b.real = -b.real;
}
switch ((int)b.real) {
case 0:
z.real = 1;
z.imag = 0;
return z;
case 1:
return a;
case 2:
return __Pyx_c_prod_float(a, a);
case 3:
z = __Pyx_c_prod_float(a, a);
return __Pyx_c_prod_float(z, a);
case 4:
z = __Pyx_c_prod_float(a, a);
return __Pyx_c_prod_float(z, z);
}
}
if (a.imag == 0) {
if (a.real == 0) {
return a;
} else if (b.imag == 0) {
z.real = powf(a.real, b.real);
z.imag = 0;
return z;
} else if (a.real > 0) {
r = a.real;
theta = 0;
} else {
r = -a.real;
theta = atan2f(0.0, -1.0);
}
} else {
r = __Pyx_c_abs_float(a);
theta = atan2f(a.imag, a.real);
}
lnr = logf(r);
z_r = expf(lnr * b.real - theta * b.imag);
z_theta = theta * b.real + lnr * b.imag;
z.real = z_r * cosf(z_theta);
z.imag = z_r * sinf(z_theta);
return z;
}
#endif
#endif
/* Declarations */
#if CYTHON_CCOMPLEX
#ifdef __cplusplus
static CYTHON_INLINE __pyx_t_double_complex __pyx_t_double_complex_from_parts(double x, double y) {
return ::std::complex< double >(x, y);
}
#else
static CYTHON_INLINE __pyx_t_double_complex __pyx_t_double_complex_from_parts(double x, double y) {
return x + y*(__pyx_t_double_complex)_Complex_I;
}
#endif
#else
static CYTHON_INLINE __pyx_t_double_complex __pyx_t_double_complex_from_parts(double x, double y) {
__pyx_t_double_complex z;
z.real = x;
z.imag = y;
return z;
}
#endif
/* Arithmetic */
#if CYTHON_CCOMPLEX
#else
static CYTHON_INLINE int __Pyx_c_eq_double(__pyx_t_double_complex a, __pyx_t_double_complex b) {
return (a.real == b.real) && (a.imag == b.imag);
}
static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_sum_double(__pyx_t_double_complex a, __pyx_t_double_complex b) {
__pyx_t_double_complex z;
z.real = a.real + b.real;
z.imag = a.imag + b.imag;
return z;
}
static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_diff_double(__pyx_t_double_complex a, __pyx_t_double_complex b) {
__pyx_t_double_complex z;
z.real = a.real - b.real;
z.imag = a.imag - b.imag;
return z;
}
static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_prod_double(__pyx_t_double_complex a, __pyx_t_double_complex b) {
__pyx_t_double_complex z;
z.real = a.real * b.real - a.imag * b.imag;
z.imag = a.real * b.imag + a.imag * b.real;
return z;
}
#if 1
static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_quot_double(__pyx_t_double_complex a, __pyx_t_double_complex b) {
if (b.imag == 0) {
return __pyx_t_double_complex_from_parts(a.real / b.real, a.imag / b.real);
} else if (fabs(b.real) >= fabs(b.imag)) {
if (b.real == 0 && b.imag == 0) {
return __pyx_t_double_complex_from_parts(a.real / b.real, a.imag / b.imag);
} else {
double r = b.imag / b.real;
double s = (double)(1.0) / (b.real + b.imag * r);
return __pyx_t_double_complex_from_parts(
(a.real + a.imag * r) * s, (a.imag - a.real * r) * s);
}
} else {
double r = b.real / b.imag;
double s = (double)(1.0) / (b.imag + b.real * r);
return __pyx_t_double_complex_from_parts(
(a.real * r + a.imag) * s, (a.imag * r - a.real) * s);
}
}
#else
static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_quot_double(__pyx_t_double_complex a, __pyx_t_double_complex b) {
if (b.imag == 0) {
return __pyx_t_double_complex_from_parts(a.real / b.real, a.imag / b.real);
} else {
double denom = b.real * b.real + b.imag * b.imag;
return __pyx_t_double_complex_from_parts(
(a.real * b.real + a.imag * b.imag) / denom,
(a.imag * b.real - a.real * b.imag) / denom);
}
}
#endif
static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_neg_double(__pyx_t_double_complex a) {
__pyx_t_double_complex z;
z.real = -a.real;
z.imag = -a.imag;
return z;
}
static CYTHON_INLINE int __Pyx_c_is_zero_double(__pyx_t_double_complex a) {
return (a.real == 0) && (a.imag == 0);
}
static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_conj_double(__pyx_t_double_complex a) {
__pyx_t_double_complex z;
z.real = a.real;
z.imag = -a.imag;
return z;
}
#if 1
static CYTHON_INLINE double __Pyx_c_abs_double(__pyx_t_double_complex z) {
#if !defined(HAVE_HYPOT) || defined(_MSC_VER)
return sqrt(z.real*z.real + z.imag*z.imag);
#else
return hypot(z.real, z.imag);
#endif
}
static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_pow_double(__pyx_t_double_complex a, __pyx_t_double_complex b) {
__pyx_t_double_complex z;
double r, lnr, theta, z_r, z_theta;
if (b.imag == 0 && b.real == (int)b.real) {
if (b.real < 0) {
double denom = a.real * a.real + a.imag * a.imag;
a.real = a.real / denom;
a.imag = -a.imag / denom;
b.real = -b.real;
}
switch ((int)b.real) {
case 0:
z.real = 1;
z.imag = 0;
return z;
case 1:
return a;
case 2:
return __Pyx_c_prod_double(a, a);
case 3:
z = __Pyx_c_prod_double(a, a);
return __Pyx_c_prod_double(z, a);
case 4:
z = __Pyx_c_prod_double(a, a);
return __Pyx_c_prod_double(z, z);
}
}
if (a.imag == 0) {
if (a.real == 0) {
return a;
} else if (b.imag == 0) {
z.real = pow(a.real, b.real);
z.imag = 0;
return z;
} else if (a.real > 0) {
r = a.real;
theta = 0;
} else {
r = -a.real;
theta = atan2(0.0, -1.0);
}
} else {
r = __Pyx_c_abs_double(a);
theta = atan2(a.imag, a.real);
}
lnr = log(r);
z_r = exp(lnr * b.real - theta * b.imag);
z_theta = theta * b.real + lnr * b.imag;
z.real = z_r * cos(z_theta);
z.imag = z_r * sin(z_theta);
return z;
}
#endif
#endif
/* CIntToPy */
static CYTHON_INLINE PyObject* __Pyx_PyInt_From_enum__NPY_TYPES(enum NPY_TYPES value) {
const enum NPY_TYPES neg_one = (enum NPY_TYPES) ((enum NPY_TYPES) 0 - (enum NPY_TYPES) 1), const_zero = (enum NPY_TYPES) 0;
const int is_unsigned = neg_one > const_zero;
if (is_unsigned) {
if (sizeof(enum NPY_TYPES) < sizeof(long)) {
return PyInt_FromLong((long) value);
} else if (sizeof(enum NPY_TYPES) <= sizeof(unsigned long)) {
return PyLong_FromUnsignedLong((unsigned long) value);
#ifdef HAVE_LONG_LONG
} else if (sizeof(enum NPY_TYPES) <= sizeof(unsigned PY_LONG_LONG)) {
return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value);
#endif
}
} else {
if (sizeof(enum NPY_TYPES) <= sizeof(long)) {
return PyInt_FromLong((long) value);
#ifdef HAVE_LONG_LONG
} else if (sizeof(enum NPY_TYPES) <= sizeof(PY_LONG_LONG)) {
return PyLong_FromLongLong((PY_LONG_LONG) value);
#endif
}
}
{
int one = 1; int little = (int)*(unsigned char *)&one;
unsigned char *bytes = (unsigned char *)&value;
return _PyLong_FromByteArray(bytes, sizeof(enum NPY_TYPES),
little, !is_unsigned);
}
}
#if PY_MAJOR_VERSION < 3
static int __Pyx_GetBuffer(PyObject *obj, Py_buffer *view, int flags) {
if (PyObject_CheckBuffer(obj)) return PyObject_GetBuffer(obj, view, flags);
if (__Pyx_TypeCheck(obj, __pyx_array_type)) return __pyx_array_getbuffer(obj, view, flags);
if (__Pyx_TypeCheck(obj, __pyx_memoryview_type)) return __pyx_memoryview_getbuffer(obj, view, flags);
PyErr_Format(PyExc_TypeError, "'%.200s' does not have the buffer interface", Py_TYPE(obj)->tp_name);
return -1;
}
static void __Pyx_ReleaseBuffer(Py_buffer *view) {
PyObject *obj = view->obj;
if (!obj) return;
if (PyObject_CheckBuffer(obj)) {
PyBuffer_Release(view);
return;
}
if ((0)) {}
view->obj = NULL;
Py_DECREF(obj);
}
#endif
/* MemviewSliceIsContig */
static int
__pyx_memviewslice_is_contig(const __Pyx_memviewslice mvs, char order, int ndim)
{
int i, index, step, start;
Py_ssize_t itemsize = mvs.memview->view.itemsize;
if (order == 'F') {
step = 1;
start = 0;
} else {
step = -1;
start = ndim - 1;
}
for (i = 0; i < ndim; i++) {
index = start + step * i;
if (mvs.suboffsets[index] >= 0 || mvs.strides[index] != itemsize)
return 0;
itemsize *= mvs.shape[index];
}
return 1;
}
/* OverlappingSlices */
static void
__pyx_get_array_memory_extents(__Pyx_memviewslice *slice,
void **out_start, void **out_end,
int ndim, size_t itemsize)
{
char *start, *end;
int i;
start = end = slice->data;
for (i = 0; i < ndim; i++) {
Py_ssize_t stride = slice->strides[i];
Py_ssize_t extent = slice->shape[i];
if (extent == 0) {
*out_start = *out_end = start;
return;
} else {
if (stride > 0)
end += stride * (extent - 1);
else
start += stride * (extent - 1);
}
}
*out_start = start;
*out_end = end + itemsize;
}
static int
__pyx_slices_overlap(__Pyx_memviewslice *slice1,
__Pyx_memviewslice *slice2,
int ndim, size_t itemsize)
{
void *start1, *end1, *start2, *end2;
__pyx_get_array_memory_extents(slice1, &start1, &end1, ndim, itemsize);
__pyx_get_array_memory_extents(slice2, &start2, &end2, ndim, itemsize);
return (start1 < end2) && (start2 < end1);
}
/* Capsule */
static CYTHON_INLINE PyObject *
__pyx_capsule_create(void *p, CYTHON_UNUSED const char *sig)
{
PyObject *cobj;
#if PY_VERSION_HEX >= 0x02070000
cobj = PyCapsule_New(p, sig, NULL);
#else
cobj = PyCObject_FromVoidPtr(p, NULL);
#endif
return cobj;
}
/* CIntFromPy */
static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) {
const int neg_one = (int) ((int) 0 - (int) 1), const_zero = (int) 0;
const int is_unsigned = neg_one > const_zero;
#if PY_MAJOR_VERSION < 3
if (likely(PyInt_Check(x))) {
if (sizeof(int) < sizeof(long)) {
__PYX_VERIFY_RETURN_INT(int, long, PyInt_AS_LONG(x))
} else {
long val = PyInt_AS_LONG(x);
if (is_unsigned && unlikely(val < 0)) {
goto raise_neg_overflow;
}
return (int) val;
}
} else
#endif
if (likely(PyLong_Check(x))) {
if (is_unsigned) {
#if CYTHON_USE_PYLONG_INTERNALS
const digit* digits = ((PyLongObject*)x)->ob_digit;
switch (Py_SIZE(x)) {
case 0: return (int) 0;
case 1: __PYX_VERIFY_RETURN_INT(int, digit, digits[0])
case 2:
if (8 * sizeof(int) > 1 * PyLong_SHIFT) {
if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
__PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
} else if (8 * sizeof(int) >= 2 * PyLong_SHIFT) {
return (int) (((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]));
}
}
break;
case 3:
if (8 * sizeof(int) > 2 * PyLong_SHIFT) {
if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
__PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
} else if (8 * sizeof(int) >= 3 * PyLong_SHIFT) {
return (int) (((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]));
}
}
break;
case 4:
if (8 * sizeof(int) > 3 * PyLong_SHIFT) {
if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
__PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
} else if (8 * sizeof(int) >= 4 * PyLong_SHIFT) {
return (int) (((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]));
}
}
break;
}
#endif
#if CYTHON_COMPILING_IN_CPYTHON
if (unlikely(Py_SIZE(x) < 0)) {
goto raise_neg_overflow;
}
#else
{
int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
if (unlikely(result < 0))
return (int) -1;
if (unlikely(result == 1))
goto raise_neg_overflow;
}
#endif
if (sizeof(int) <= sizeof(unsigned long)) {
__PYX_VERIFY_RETURN_INT_EXC(int, unsigned long, PyLong_AsUnsignedLong(x))
#ifdef HAVE_LONG_LONG
} else if (sizeof(int) <= sizeof(unsigned PY_LONG_LONG)) {
__PYX_VERIFY_RETURN_INT_EXC(int, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
#endif
}
} else {
#if CYTHON_USE_PYLONG_INTERNALS
const digit* digits = ((PyLongObject*)x)->ob_digit;
switch (Py_SIZE(x)) {
case 0: return (int) 0;
case -1: __PYX_VERIFY_RETURN_INT(int, sdigit, (sdigit) (-(sdigit)digits[0]))
case 1: __PYX_VERIFY_RETURN_INT(int, digit, +digits[0])
case -2:
if (8 * sizeof(int) - 1 > 1 * PyLong_SHIFT) {
if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
__PYX_VERIFY_RETURN_INT(int, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
} else if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) {
return (int) (((int)-1)*(((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
}
}
break;
case 2:
if (8 * sizeof(int) > 1 * PyLong_SHIFT) {
if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
__PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
} else if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) {
return (int) ((((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
}
}
break;
case -3:
if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) {
if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
__PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
} else if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) {
return (int) (((int)-1)*(((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
}
}
break;
case 3:
if (8 * sizeof(int) > 2 * PyLong_SHIFT) {
if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
__PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
} else if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) {
return (int) ((((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
}
}
break;
case -4:
if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) {
if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
__PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
} else if (8 * sizeof(int) - 1 > 4 * PyLong_SHIFT) {
return (int) (((int)-1)*(((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
}
}
break;
case 4:
if (8 * sizeof(int) > 3 * PyLong_SHIFT) {
if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
__PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
} else if (8 * sizeof(int) - 1 > 4 * PyLong_SHIFT) {
return (int) ((((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
}
}
break;
}
#endif
if (sizeof(int) <= sizeof(long)) {
__PYX_VERIFY_RETURN_INT_EXC(int, long, PyLong_AsLong(x))
#ifdef HAVE_LONG_LONG
} else if (sizeof(int) <= sizeof(PY_LONG_LONG)) {
__PYX_VERIFY_RETURN_INT_EXC(int, PY_LONG_LONG, PyLong_AsLongLong(x))
#endif
}
}
{
#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray)
PyErr_SetString(PyExc_RuntimeError,
"_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers");
#else
int val;
PyObject *v = __Pyx_PyNumber_IntOrLong(x);
#if PY_MAJOR_VERSION < 3
if (likely(v) && !PyLong_Check(v)) {
PyObject *tmp = v;
v = PyNumber_Long(tmp);
Py_DECREF(tmp);
}
#endif
if (likely(v)) {
int one = 1; int is_little = (int)*(unsigned char *)&one;
unsigned char *bytes = (unsigned char *)&val;
int ret = _PyLong_AsByteArray((PyLongObject *)v,
bytes, sizeof(val),
is_little, !is_unsigned);
Py_DECREF(v);
if (likely(!ret))
return val;
}
#endif
return (int) -1;
}
} else {
int val;
PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
if (!tmp) return (int) -1;
val = __Pyx_PyInt_As_int(tmp);
Py_DECREF(tmp);
return val;
}
raise_overflow:
PyErr_SetString(PyExc_OverflowError,
"value too large to convert to int");
return (int) -1;
raise_neg_overflow:
PyErr_SetString(PyExc_OverflowError,
"can't convert negative value to int");
return (int) -1;
}
/* CIntFromPy */
static CYTHON_INLINE uint64_t __Pyx_PyInt_As_uint64_t(PyObject *x) {
const uint64_t neg_one = (uint64_t) ((uint64_t) 0 - (uint64_t) 1), const_zero = (uint64_t) 0;
const int is_unsigned = neg_one > const_zero;
#if PY_MAJOR_VERSION < 3
if (likely(PyInt_Check(x))) {
if (sizeof(uint64_t) < sizeof(long)) {
__PYX_VERIFY_RETURN_INT(uint64_t, long, PyInt_AS_LONG(x))
} else {
long val = PyInt_AS_LONG(x);
if (is_unsigned && unlikely(val < 0)) {
goto raise_neg_overflow;
}
return (uint64_t) val;
}
} else
#endif
if (likely(PyLong_Check(x))) {
if (is_unsigned) {
#if CYTHON_USE_PYLONG_INTERNALS
const digit* digits = ((PyLongObject*)x)->ob_digit;
switch (Py_SIZE(x)) {
case 0: return (uint64_t) 0;
case 1: __PYX_VERIFY_RETURN_INT(uint64_t, digit, digits[0])
case 2:
if (8 * sizeof(uint64_t) > 1 * PyLong_SHIFT) {
if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
__PYX_VERIFY_RETURN_INT(uint64_t, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
} else if (8 * sizeof(uint64_t) >= 2 * PyLong_SHIFT) {
return (uint64_t) (((((uint64_t)digits[1]) << PyLong_SHIFT) | (uint64_t)digits[0]));
}
}
break;
case 3:
if (8 * sizeof(uint64_t) > 2 * PyLong_SHIFT) {
if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
__PYX_VERIFY_RETURN_INT(uint64_t, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
} else if (8 * sizeof(uint64_t) >= 3 * PyLong_SHIFT) {
return (uint64_t) (((((((uint64_t)digits[2]) << PyLong_SHIFT) | (uint64_t)digits[1]) << PyLong_SHIFT) | (uint64_t)digits[0]));
}
}
break;
case 4:
if (8 * sizeof(uint64_t) > 3 * PyLong_SHIFT) {
if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
__PYX_VERIFY_RETURN_INT(uint64_t, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
} else if (8 * sizeof(uint64_t) >= 4 * PyLong_SHIFT) {
return (uint64_t) (((((((((uint64_t)digits[3]) << PyLong_SHIFT) | (uint64_t)digits[2]) << PyLong_SHIFT) | (uint64_t)digits[1]) << PyLong_SHIFT) | (uint64_t)digits[0]));
}
}
break;
}
#endif
#if CYTHON_COMPILING_IN_CPYTHON
if (unlikely(Py_SIZE(x) < 0)) {
goto raise_neg_overflow;
}
#else
{
int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
if (unlikely(result < 0))
return (uint64_t) -1;
if (unlikely(result == 1))
goto raise_neg_overflow;
}
#endif
if (sizeof(uint64_t) <= sizeof(unsigned long)) {
__PYX_VERIFY_RETURN_INT_EXC(uint64_t, unsigned long, PyLong_AsUnsignedLong(x))
#ifdef HAVE_LONG_LONG
} else if (sizeof(uint64_t) <= sizeof(unsigned PY_LONG_LONG)) {
__PYX_VERIFY_RETURN_INT_EXC(uint64_t, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
#endif
}
} else {
#if CYTHON_USE_PYLONG_INTERNALS
const digit* digits = ((PyLongObject*)x)->ob_digit;
switch (Py_SIZE(x)) {
case 0: return (uint64_t) 0;
case -1: __PYX_VERIFY_RETURN_INT(uint64_t, sdigit, (sdigit) (-(sdigit)digits[0]))
case 1: __PYX_VERIFY_RETURN_INT(uint64_t, digit, +digits[0])
case -2:
if (8 * sizeof(uint64_t) - 1 > 1 * PyLong_SHIFT) {
if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
__PYX_VERIFY_RETURN_INT(uint64_t, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
} else if (8 * sizeof(uint64_t) - 1 > 2 * PyLong_SHIFT) {
return (uint64_t) (((uint64_t)-1)*(((((uint64_t)digits[1]) << PyLong_SHIFT) | (uint64_t)digits[0])));
}
}
break;
case 2:
if (8 * sizeof(uint64_t) > 1 * PyLong_SHIFT) {
if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
__PYX_VERIFY_RETURN_INT(uint64_t, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
} else if (8 * sizeof(uint64_t) - 1 > 2 * PyLong_SHIFT) {
return (uint64_t) ((((((uint64_t)digits[1]) << PyLong_SHIFT) | (uint64_t)digits[0])));
}
}
break;
case -3:
if (8 * sizeof(uint64_t) - 1 > 2 * PyLong_SHIFT) {
if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
__PYX_VERIFY_RETURN_INT(uint64_t, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
} else if (8 * sizeof(uint64_t) - 1 > 3 * PyLong_SHIFT) {
return (uint64_t) (((uint64_t)-1)*(((((((uint64_t)digits[2]) << PyLong_SHIFT) | (uint64_t)digits[1]) << PyLong_SHIFT) | (uint64_t)digits[0])));
}
}
break;
case 3:
if (8 * sizeof(uint64_t) > 2 * PyLong_SHIFT) {
if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
__PYX_VERIFY_RETURN_INT(uint64_t, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
} else if (8 * sizeof(uint64_t) - 1 > 3 * PyLong_SHIFT) {
return (uint64_t) ((((((((uint64_t)digits[2]) << PyLong_SHIFT) | (uint64_t)digits[1]) << PyLong_SHIFT) | (uint64_t)digits[0])));
}
}
break;
case -4:
if (8 * sizeof(uint64_t) - 1 > 3 * PyLong_SHIFT) {
if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
__PYX_VERIFY_RETURN_INT(uint64_t, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
} else if (8 * sizeof(uint64_t) - 1 > 4 * PyLong_SHIFT) {
return (uint64_t) (((uint64_t)-1)*(((((((((uint64_t)digits[3]) << PyLong_SHIFT) | (uint64_t)digits[2]) << PyLong_SHIFT) | (uint64_t)digits[1]) << PyLong_SHIFT) | (uint64_t)digits[0])));
}
}
break;
case 4:
if (8 * sizeof(uint64_t) > 3 * PyLong_SHIFT) {
if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
__PYX_VERIFY_RETURN_INT(uint64_t, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
} else if (8 * sizeof(uint64_t) - 1 > 4 * PyLong_SHIFT) {
return (uint64_t) ((((((((((uint64_t)digits[3]) << PyLong_SHIFT) | (uint64_t)digits[2]) << PyLong_SHIFT) | (uint64_t)digits[1]) << PyLong_SHIFT) | (uint64_t)digits[0])));
}
}
break;
}
#endif
if (sizeof(uint64_t) <= sizeof(long)) {
__PYX_VERIFY_RETURN_INT_EXC(uint64_t, long, PyLong_AsLong(x))
#ifdef HAVE_LONG_LONG
} else if (sizeof(uint64_t) <= sizeof(PY_LONG_LONG)) {
__PYX_VERIFY_RETURN_INT_EXC(uint64_t, PY_LONG_LONG, PyLong_AsLongLong(x))
#endif
}
}
{
#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray)
PyErr_SetString(PyExc_RuntimeError,
"_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers");
#else
uint64_t val;
PyObject *v = __Pyx_PyNumber_IntOrLong(x);
#if PY_MAJOR_VERSION < 3
if (likely(v) && !PyLong_Check(v)) {
PyObject *tmp = v;
v = PyNumber_Long(tmp);
Py_DECREF(tmp);
}
#endif
if (likely(v)) {
int one = 1; int is_little = (int)*(unsigned char *)&one;
unsigned char *bytes = (unsigned char *)&val;
int ret = _PyLong_AsByteArray((PyLongObject *)v,
bytes, sizeof(val),
is_little, !is_unsigned);
Py_DECREF(v);
if (likely(!ret))
return val;
}
#endif
return (uint64_t) -1;
}
} else {
uint64_t val;
PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
if (!tmp) return (uint64_t) -1;
val = __Pyx_PyInt_As_uint64_t(tmp);
Py_DECREF(tmp);
return val;
}
raise_overflow:
PyErr_SetString(PyExc_OverflowError,
"value too large to convert to uint64_t");
return (uint64_t) -1;
raise_neg_overflow:
PyErr_SetString(PyExc_OverflowError,
"can't convert negative value to uint64_t");
return (uint64_t) -1;
}
/* CIntFromPy */
static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) {
const long neg_one = (long) ((long) 0 - (long) 1), const_zero = (long) 0;
const int is_unsigned = neg_one > const_zero;
#if PY_MAJOR_VERSION < 3
if (likely(PyInt_Check(x))) {
if (sizeof(long) < sizeof(long)) {
__PYX_VERIFY_RETURN_INT(long, long, PyInt_AS_LONG(x))
} else {
long val = PyInt_AS_LONG(x);
if (is_unsigned && unlikely(val < 0)) {
goto raise_neg_overflow;
}
return (long) val;
}
} else
#endif
if (likely(PyLong_Check(x))) {
if (is_unsigned) {
#if CYTHON_USE_PYLONG_INTERNALS
const digit* digits = ((PyLongObject*)x)->ob_digit;
switch (Py_SIZE(x)) {
case 0: return (long) 0;
case 1: __PYX_VERIFY_RETURN_INT(long, digit, digits[0])
case 2:
if (8 * sizeof(long) > 1 * PyLong_SHIFT) {
if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
__PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
} else if (8 * sizeof(long) >= 2 * PyLong_SHIFT) {
return (long) (((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]));
}
}
break;
case 3:
if (8 * sizeof(long) > 2 * PyLong_SHIFT) {
if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
__PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
} else if (8 * sizeof(long) >= 3 * PyLong_SHIFT) {
return (long) (((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]));
}
}
break;
case 4:
if (8 * sizeof(long) > 3 * PyLong_SHIFT) {
if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
__PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
} else if (8 * sizeof(long) >= 4 * PyLong_SHIFT) {
return (long) (((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]));
}
}
break;
}
#endif
#if CYTHON_COMPILING_IN_CPYTHON
if (unlikely(Py_SIZE(x) < 0)) {
goto raise_neg_overflow;
}
#else
{
int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
if (unlikely(result < 0))
return (long) -1;
if (unlikely(result == 1))
goto raise_neg_overflow;
}
#endif
if (sizeof(long) <= sizeof(unsigned long)) {
__PYX_VERIFY_RETURN_INT_EXC(long, unsigned long, PyLong_AsUnsignedLong(x))
#ifdef HAVE_LONG_LONG
} else if (sizeof(long) <= sizeof(unsigned PY_LONG_LONG)) {
__PYX_VERIFY_RETURN_INT_EXC(long, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
#endif
}
} else {
#if CYTHON_USE_PYLONG_INTERNALS
const digit* digits = ((PyLongObject*)x)->ob_digit;
switch (Py_SIZE(x)) {
case 0: return (long) 0;
case -1: __PYX_VERIFY_RETURN_INT(long, sdigit, (sdigit) (-(sdigit)digits[0]))
case 1: __PYX_VERIFY_RETURN_INT(long, digit, +digits[0])
case -2:
if (8 * sizeof(long) - 1 > 1 * PyLong_SHIFT) {
if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
__PYX_VERIFY_RETURN_INT(long, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
} else if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) {
return (long) (((long)-1)*(((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));
}
}
break;
case 2:
if (8 * sizeof(long) > 1 * PyLong_SHIFT) {
if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
__PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
} else if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) {
return (long) ((((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));
}
}
break;
case -3:
if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) {
if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
__PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
} else if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) {
return (long) (((long)-1)*(((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));
}
}
break;
case 3:
if (8 * sizeof(long) > 2 * PyLong_SHIFT) {
if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
__PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
} else if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) {
return (long) ((((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));
}
}
break;
case -4:
if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) {
if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
__PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
} else if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) {
return (long) (((long)-1)*(((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));
}
}
break;
case 4:
if (8 * sizeof(long) > 3 * PyLong_SHIFT) {
if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
__PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
} else if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) {
return (long) ((((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));
}
}
break;
}
#endif
if (sizeof(long) <= sizeof(long)) {
__PYX_VERIFY_RETURN_INT_EXC(long, long, PyLong_AsLong(x))
#ifdef HAVE_LONG_LONG
} else if (sizeof(long) <= sizeof(PY_LONG_LONG)) {
__PYX_VERIFY_RETURN_INT_EXC(long, PY_LONG_LONG, PyLong_AsLongLong(x))
#endif
}
}
{
#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray)
PyErr_SetString(PyExc_RuntimeError,
"_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers");
#else
long val;
PyObject *v = __Pyx_PyNumber_IntOrLong(x);
#if PY_MAJOR_VERSION < 3
if (likely(v) && !PyLong_Check(v)) {
PyObject *tmp = v;
v = PyNumber_Long(tmp);
Py_DECREF(tmp);
}
#endif
if (likely(v)) {
int one = 1; int is_little = (int)*(unsigned char *)&one;
unsigned char *bytes = (unsigned char *)&val;
int ret = _PyLong_AsByteArray((PyLongObject *)v,
bytes, sizeof(val),
is_little, !is_unsigned);
Py_DECREF(v);
if (likely(!ret))
return val;
}
#endif
return (long) -1;
}
} else {
long val;
PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
if (!tmp) return (long) -1;
val = __Pyx_PyInt_As_long(tmp);
Py_DECREF(tmp);
return val;
}
raise_overflow:
PyErr_SetString(PyExc_OverflowError,
"value too large to convert to long");
return (long) -1;
raise_neg_overflow:
PyErr_SetString(PyExc_OverflowError,
"can't convert negative value to long");
return (long) -1;
}
/* CIntFromPy */
static CYTHON_INLINE int32_t __Pyx_PyInt_As_int32_t(PyObject *x) {
const int32_t neg_one = (int32_t) ((int32_t) 0 - (int32_t) 1), const_zero = (int32_t) 0;
const int is_unsigned = neg_one > const_zero;
#if PY_MAJOR_VERSION < 3
if (likely(PyInt_Check(x))) {
if (sizeof(int32_t) < sizeof(long)) {
__PYX_VERIFY_RETURN_INT(int32_t, long, PyInt_AS_LONG(x))
} else {
long val = PyInt_AS_LONG(x);
if (is_unsigned && unlikely(val < 0)) {
goto raise_neg_overflow;
}
return (int32_t) val;
}
} else
#endif
if (likely(PyLong_Check(x))) {
if (is_unsigned) {
#if CYTHON_USE_PYLONG_INTERNALS
const digit* digits = ((PyLongObject*)x)->ob_digit;
switch (Py_SIZE(x)) {
case 0: return (int32_t) 0;
case 1: __PYX_VERIFY_RETURN_INT(int32_t, digit, digits[0])
case 2:
if (8 * sizeof(int32_t) > 1 * PyLong_SHIFT) {
if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
__PYX_VERIFY_RETURN_INT(int32_t, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
} else if (8 * sizeof(int32_t) >= 2 * PyLong_SHIFT) {
return (int32_t) (((((int32_t)digits[1]) << PyLong_SHIFT) | (int32_t)digits[0]));
}
}
break;
case 3:
if (8 * sizeof(int32_t) > 2 * PyLong_SHIFT) {
if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
__PYX_VERIFY_RETURN_INT(int32_t, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
} else if (8 * sizeof(int32_t) >= 3 * PyLong_SHIFT) {
return (int32_t) (((((((int32_t)digits[2]) << PyLong_SHIFT) | (int32_t)digits[1]) << PyLong_SHIFT) | (int32_t)digits[0]));
}
}
break;
case 4:
if (8 * sizeof(int32_t) > 3 * PyLong_SHIFT) {
if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
__PYX_VERIFY_RETURN_INT(int32_t, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
} else if (8 * sizeof(int32_t) >= 4 * PyLong_SHIFT) {
return (int32_t) (((((((((int32_t)digits[3]) << PyLong_SHIFT) | (int32_t)digits[2]) << PyLong_SHIFT) | (int32_t)digits[1]) << PyLong_SHIFT) | (int32_t)digits[0]));
}
}
break;
}
#endif
#if CYTHON_COMPILING_IN_CPYTHON
if (unlikely(Py_SIZE(x) < 0)) {
goto raise_neg_overflow;
}
#else
{
int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
if (unlikely(result < 0))
return (int32_t) -1;
if (unlikely(result == 1))
goto raise_neg_overflow;
}
#endif
if (sizeof(int32_t) <= sizeof(unsigned long)) {
__PYX_VERIFY_RETURN_INT_EXC(int32_t, unsigned long, PyLong_AsUnsignedLong(x))
#ifdef HAVE_LONG_LONG
} else if (sizeof(int32_t) <= sizeof(unsigned PY_LONG_LONG)) {
__PYX_VERIFY_RETURN_INT_EXC(int32_t, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
#endif
}
} else {
#if CYTHON_USE_PYLONG_INTERNALS
const digit* digits = ((PyLongObject*)x)->ob_digit;
switch (Py_SIZE(x)) {
case 0: return (int32_t) 0;
case -1: __PYX_VERIFY_RETURN_INT(int32_t, sdigit, (sdigit) (-(sdigit)digits[0]))
case 1: __PYX_VERIFY_RETURN_INT(int32_t, digit, +digits[0])
case -2:
if (8 * sizeof(int32_t) - 1 > 1 * PyLong_SHIFT) {
if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
__PYX_VERIFY_RETURN_INT(int32_t, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
} else if (8 * sizeof(int32_t) - 1 > 2 * PyLong_SHIFT) {
return (int32_t) (((int32_t)-1)*(((((int32_t)digits[1]) << PyLong_SHIFT) | (int32_t)digits[0])));
}
}
break;
case 2:
if (8 * sizeof(int32_t) > 1 * PyLong_SHIFT) {
if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
__PYX_VERIFY_RETURN_INT(int32_t, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
} else if (8 * sizeof(int32_t) - 1 > 2 * PyLong_SHIFT) {
return (int32_t) ((((((int32_t)digits[1]) << PyLong_SHIFT) | (int32_t)digits[0])));
}
}
break;
case -3:
if (8 * sizeof(int32_t) - 1 > 2 * PyLong_SHIFT) {
if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
__PYX_VERIFY_RETURN_INT(int32_t, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
} else if (8 * sizeof(int32_t) - 1 > 3 * PyLong_SHIFT) {
return (int32_t) (((int32_t)-1)*(((((((int32_t)digits[2]) << PyLong_SHIFT) | (int32_t)digits[1]) << PyLong_SHIFT) | (int32_t)digits[0])));
}
}
break;
case 3:
if (8 * sizeof(int32_t) > 2 * PyLong_SHIFT) {
if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
__PYX_VERIFY_RETURN_INT(int32_t, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
} else if (8 * sizeof(int32_t) - 1 > 3 * PyLong_SHIFT) {
return (int32_t) ((((((((int32_t)digits[2]) << PyLong_SHIFT) | (int32_t)digits[1]) << PyLong_SHIFT) | (int32_t)digits[0])));
}
}
break;
case -4:
if (8 * sizeof(int32_t) - 1 > 3 * PyLong_SHIFT) {
if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
__PYX_VERIFY_RETURN_INT(int32_t, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
} else if (8 * sizeof(int32_t) - 1 > 4 * PyLong_SHIFT) {
return (int32_t) (((int32_t)-1)*(((((((((int32_t)digits[3]) << PyLong_SHIFT) | (int32_t)digits[2]) << PyLong_SHIFT) | (int32_t)digits[1]) << PyLong_SHIFT) | (int32_t)digits[0])));
}
}
break;
case 4:
if (8 * sizeof(int32_t) > 3 * PyLong_SHIFT) {
if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
__PYX_VERIFY_RETURN_INT(int32_t, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
} else if (8 * sizeof(int32_t) - 1 > 4 * PyLong_SHIFT) {
return (int32_t) ((((((((((int32_t)digits[3]) << PyLong_SHIFT) | (int32_t)digits[2]) << PyLong_SHIFT) | (int32_t)digits[1]) << PyLong_SHIFT) | (int32_t)digits[0])));
}
}
break;
}
#endif
if (sizeof(int32_t) <= sizeof(long)) {
__PYX_VERIFY_RETURN_INT_EXC(int32_t, long, PyLong_AsLong(x))
#ifdef HAVE_LONG_LONG
} else if (sizeof(int32_t) <= sizeof(PY_LONG_LONG)) {
__PYX_VERIFY_RETURN_INT_EXC(int32_t, PY_LONG_LONG, PyLong_AsLongLong(x))
#endif
}
}
{
#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray)
PyErr_SetString(PyExc_RuntimeError,
"_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers");
#else
int32_t val;
PyObject *v = __Pyx_PyNumber_IntOrLong(x);
#if PY_MAJOR_VERSION < 3
if (likely(v) && !PyLong_Check(v)) {
PyObject *tmp = v;
v = PyNumber_Long(tmp);
Py_DECREF(tmp);
}
#endif
if (likely(v)) {
int one = 1; int is_little = (int)*(unsigned char *)&one;
unsigned char *bytes = (unsigned char *)&val;
int ret = _PyLong_AsByteArray((PyLongObject *)v,
bytes, sizeof(val),
is_little, !is_unsigned);
Py_DECREF(v);
if (likely(!ret))
return val;
}
#endif
return (int32_t) -1;
}
} else {
int32_t val;
PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
if (!tmp) return (int32_t) -1;
val = __Pyx_PyInt_As_int32_t(tmp);
Py_DECREF(tmp);
return val;
}
raise_overflow:
PyErr_SetString(PyExc_OverflowError,
"value too large to convert to int32_t");
return (int32_t) -1;
raise_neg_overflow:
PyErr_SetString(PyExc_OverflowError,
"can't convert negative value to int32_t");
return (int32_t) -1;
}
/* MemviewSliceCopyTemplate */
static __Pyx_memviewslice
__pyx_memoryview_copy_new_contig(const __Pyx_memviewslice *from_mvs,
const char *mode, int ndim,
size_t sizeof_dtype, int contig_flag,
int dtype_is_object)
{
__Pyx_RefNannyDeclarations
int i;
__Pyx_memviewslice new_mvs = { 0, 0, { 0 }, { 0 }, { 0 } };
struct __pyx_memoryview_obj *from_memview = from_mvs->memview;
Py_buffer *buf = &from_memview->view;
PyObject *shape_tuple = NULL;
PyObject *temp_int = NULL;
struct __pyx_array_obj *array_obj = NULL;
struct __pyx_memoryview_obj *memview_obj = NULL;
__Pyx_RefNannySetupContext("__pyx_memoryview_copy_new_contig", 0);
for (i = 0; i < ndim; i++) {
if (unlikely(from_mvs->suboffsets[i] >= 0)) {
PyErr_Format(PyExc_ValueError, "Cannot copy memoryview slice with "
"indirect dimensions (axis %d)", i);
goto fail;
}
}
shape_tuple = PyTuple_New(ndim);
if (unlikely(!shape_tuple)) {
goto fail;
}
__Pyx_GOTREF(shape_tuple);
for(i = 0; i < ndim; i++) {
temp_int = PyInt_FromSsize_t(from_mvs->shape[i]);
if(unlikely(!temp_int)) {
goto fail;
} else {
PyTuple_SET_ITEM(shape_tuple, i, temp_int);
temp_int = NULL;
}
}
array_obj = __pyx_array_new(shape_tuple, sizeof_dtype, buf->format, (char *) mode, NULL);
if (unlikely(!array_obj)) {
goto fail;
}
__Pyx_GOTREF(array_obj);
memview_obj = (struct __pyx_memoryview_obj *) __pyx_memoryview_new(
(PyObject *) array_obj, contig_flag,
dtype_is_object,
from_mvs->memview->typeinfo);
if (unlikely(!memview_obj))
goto fail;
if (unlikely(__Pyx_init_memviewslice(memview_obj, ndim, &new_mvs, 1) < 0))
goto fail;
if (unlikely(__pyx_memoryview_copy_contents(*from_mvs, new_mvs, ndim, ndim,
dtype_is_object) < 0))
goto fail;
goto no_fail;
fail:
__Pyx_XDECREF(new_mvs.memview);
new_mvs.memview = NULL;
new_mvs.data = NULL;
no_fail:
__Pyx_XDECREF(shape_tuple);
__Pyx_XDECREF(temp_int);
__Pyx_XDECREF(array_obj);
__Pyx_RefNannyFinishContext();
return new_mvs;
}
/* MemviewSliceInit */
static int
__Pyx_init_memviewslice(struct __pyx_memoryview_obj *memview,
int ndim,
__Pyx_memviewslice *memviewslice,
int memview_is_new_reference)
{
__Pyx_RefNannyDeclarations
int i, retval=-1;
Py_buffer *buf = &memview->view;
__Pyx_RefNannySetupContext("init_memviewslice", 0);
if (unlikely(memviewslice->memview || memviewslice->data)) {
PyErr_SetString(PyExc_ValueError,
"memviewslice is already initialized!");
goto fail;
}
if (buf->strides) {
for (i = 0; i < ndim; i++) {
memviewslice->strides[i] = buf->strides[i];
}
} else {
Py_ssize_t stride = buf->itemsize;
for (i = ndim - 1; i >= 0; i--) {
memviewslice->strides[i] = stride;
stride *= buf->shape[i];
}
}
for (i = 0; i < ndim; i++) {
memviewslice->shape[i] = buf->shape[i];
if (buf->suboffsets) {
memviewslice->suboffsets[i] = buf->suboffsets[i];
} else {
memviewslice->suboffsets[i] = -1;
}
}
memviewslice->memview = memview;
memviewslice->data = (char *)buf->buf;
if (__pyx_add_acquisition_count(memview) == 0 && !memview_is_new_reference) {
Py_INCREF(memview);
}
retval = 0;
goto no_fail;
fail:
memviewslice->memview = 0;
memviewslice->data = 0;
retval = -1;
no_fail:
__Pyx_RefNannyFinishContext();
return retval;
}
#ifndef Py_NO_RETURN
#define Py_NO_RETURN
#endif
static void __pyx_fatalerror(const char *fmt, ...) Py_NO_RETURN {
va_list vargs;
char msg[200];
#ifdef HAVE_STDARG_PROTOTYPES
va_start(vargs, fmt);
#else
va_start(vargs);
#endif
vsnprintf(msg, 200, fmt, vargs);
va_end(vargs);
Py_FatalError(msg);
}
static CYTHON_INLINE int
__pyx_add_acquisition_count_locked(__pyx_atomic_int *acquisition_count,
PyThread_type_lock lock)
{
int result;
PyThread_acquire_lock(lock, 1);
result = (*acquisition_count)++;
PyThread_release_lock(lock);
return result;
}
static CYTHON_INLINE int
__pyx_sub_acquisition_count_locked(__pyx_atomic_int *acquisition_count,
PyThread_type_lock lock)
{
int result;
PyThread_acquire_lock(lock, 1);
result = (*acquisition_count)--;
PyThread_release_lock(lock);
return result;
}
static CYTHON_INLINE void
__Pyx_INC_MEMVIEW(__Pyx_memviewslice *memslice, int have_gil, int lineno)
{
int first_time;
struct __pyx_memoryview_obj *memview = memslice->memview;
if (unlikely(!memview || (PyObject *) memview == Py_None))
return;
if (unlikely(__pyx_get_slice_count(memview) < 0))
__pyx_fatalerror("Acquisition count is %d (line %d)",
__pyx_get_slice_count(memview), lineno);
first_time = __pyx_add_acquisition_count(memview) == 0;
if (unlikely(first_time)) {
if (have_gil) {
Py_INCREF((PyObject *) memview);
} else {
PyGILState_STATE _gilstate = PyGILState_Ensure();
Py_INCREF((PyObject *) memview);
PyGILState_Release(_gilstate);
}
}
}
static CYTHON_INLINE void __Pyx_XDEC_MEMVIEW(__Pyx_memviewslice *memslice,
int have_gil, int lineno) {
int last_time;
struct __pyx_memoryview_obj *memview = memslice->memview;
if (unlikely(!memview || (PyObject *) memview == Py_None)) {
memslice->memview = NULL;
return;
}
if (unlikely(__pyx_get_slice_count(memview) <= 0))
__pyx_fatalerror("Acquisition count is %d (line %d)",
__pyx_get_slice_count(memview), lineno);
last_time = __pyx_sub_acquisition_count(memview) == 1;
memslice->data = NULL;
if (unlikely(last_time)) {
if (have_gil) {
Py_CLEAR(memslice->memview);
} else {
PyGILState_STATE _gilstate = PyGILState_Ensure();
Py_CLEAR(memslice->memview);
PyGILState_Release(_gilstate);
}
} else {
memslice->memview = NULL;
}
}
/* CIntFromPy */
static CYTHON_INLINE char __Pyx_PyInt_As_char(PyObject *x) {
const char neg_one = (char) ((char) 0 - (char) 1), const_zero = (char) 0;
const int is_unsigned = neg_one > const_zero;
#if PY_MAJOR_VERSION < 3
if (likely(PyInt_Check(x))) {
if (sizeof(char) < sizeof(long)) {
__PYX_VERIFY_RETURN_INT(char, long, PyInt_AS_LONG(x))
} else {
long val = PyInt_AS_LONG(x);
if (is_unsigned && unlikely(val < 0)) {
goto raise_neg_overflow;
}
return (char) val;
}
} else
#endif
if (likely(PyLong_Check(x))) {
if (is_unsigned) {
#if CYTHON_USE_PYLONG_INTERNALS
const digit* digits = ((PyLongObject*)x)->ob_digit;
switch (Py_SIZE(x)) {
case 0: return (char) 0;
case 1: __PYX_VERIFY_RETURN_INT(char, digit, digits[0])
case 2:
if (8 * sizeof(char) > 1 * PyLong_SHIFT) {
if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
__PYX_VERIFY_RETURN_INT(char, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
} else if (8 * sizeof(char) >= 2 * PyLong_SHIFT) {
return (char) (((((char)digits[1]) << PyLong_SHIFT) | (char)digits[0]));
}
}
break;
case 3:
if (8 * sizeof(char) > 2 * PyLong_SHIFT) {
if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
__PYX_VERIFY_RETURN_INT(char, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
} else if (8 * sizeof(char) >= 3 * PyLong_SHIFT) {
return (char) (((((((char)digits[2]) << PyLong_SHIFT) | (char)digits[1]) << PyLong_SHIFT) | (char)digits[0]));
}
}
break;
case 4:
if (8 * sizeof(char) > 3 * PyLong_SHIFT) {
if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
__PYX_VERIFY_RETURN_INT(char, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
} else if (8 * sizeof(char) >= 4 * PyLong_SHIFT) {
return (char) (((((((((char)digits[3]) << PyLong_SHIFT) | (char)digits[2]) << PyLong_SHIFT) | (char)digits[1]) << PyLong_SHIFT) | (char)digits[0]));
}
}
break;
}
#endif
#if CYTHON_COMPILING_IN_CPYTHON
if (unlikely(Py_SIZE(x) < 0)) {
goto raise_neg_overflow;
}
#else
{
int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
if (unlikely(result < 0))
return (char) -1;
if (unlikely(result == 1))
goto raise_neg_overflow;
}
#endif
if (sizeof(char) <= sizeof(unsigned long)) {
__PYX_VERIFY_RETURN_INT_EXC(char, unsigned long, PyLong_AsUnsignedLong(x))
#ifdef HAVE_LONG_LONG
} else if (sizeof(char) <= sizeof(unsigned PY_LONG_LONG)) {
__PYX_VERIFY_RETURN_INT_EXC(char, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
#endif
}
} else {
#if CYTHON_USE_PYLONG_INTERNALS
const digit* digits = ((PyLongObject*)x)->ob_digit;
switch (Py_SIZE(x)) {
case 0: return (char) 0;
case -1: __PYX_VERIFY_RETURN_INT(char, sdigit, (sdigit) (-(sdigit)digits[0]))
case 1: __PYX_VERIFY_RETURN_INT(char, digit, +digits[0])
case -2:
if (8 * sizeof(char) - 1 > 1 * PyLong_SHIFT) {
if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
__PYX_VERIFY_RETURN_INT(char, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
} else if (8 * sizeof(char) - 1 > 2 * PyLong_SHIFT) {
return (char) (((char)-1)*(((((char)digits[1]) << PyLong_SHIFT) | (char)digits[0])));
}
}
break;
case 2:
if (8 * sizeof(char) > 1 * PyLong_SHIFT) {
if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
__PYX_VERIFY_RETURN_INT(char, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
} else if (8 * sizeof(char) - 1 > 2 * PyLong_SHIFT) {
return (char) ((((((char)digits[1]) << PyLong_SHIFT) | (char)digits[0])));
}
}
break;
case -3:
if (8 * sizeof(char) - 1 > 2 * PyLong_SHIFT) {
if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
__PYX_VERIFY_RETURN_INT(char, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
} else if (8 * sizeof(char) - 1 > 3 * PyLong_SHIFT) {
return (char) (((char)-1)*(((((((char)digits[2]) << PyLong_SHIFT) | (char)digits[1]) << PyLong_SHIFT) | (char)digits[0])));
}
}
break;
case 3:
if (8 * sizeof(char) > 2 * PyLong_SHIFT) {
if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
__PYX_VERIFY_RETURN_INT(char, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
} else if (8 * sizeof(char) - 1 > 3 * PyLong_SHIFT) {
return (char) ((((((((char)digits[2]) << PyLong_SHIFT) | (char)digits[1]) << PyLong_SHIFT) | (char)digits[0])));
}
}
break;
case -4:
if (8 * sizeof(char) - 1 > 3 * PyLong_SHIFT) {
if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
__PYX_VERIFY_RETURN_INT(char, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
} else if (8 * sizeof(char) - 1 > 4 * PyLong_SHIFT) {
return (char) (((char)-1)*(((((((((char)digits[3]) << PyLong_SHIFT) | (char)digits[2]) << PyLong_SHIFT) | (char)digits[1]) << PyLong_SHIFT) | (char)digits[0])));
}
}
break;
case 4:
if (8 * sizeof(char) > 3 * PyLong_SHIFT) {
if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
__PYX_VERIFY_RETURN_INT(char, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
} else if (8 * sizeof(char) - 1 > 4 * PyLong_SHIFT) {
return (char) ((((((((((char)digits[3]) << PyLong_SHIFT) | (char)digits[2]) << PyLong_SHIFT) | (char)digits[1]) << PyLong_SHIFT) | (char)digits[0])));
}
}
break;
}
#endif
if (sizeof(char) <= sizeof(long)) {
__PYX_VERIFY_RETURN_INT_EXC(char, long, PyLong_AsLong(x))
#ifdef HAVE_LONG_LONG
} else if (sizeof(char) <= sizeof(PY_LONG_LONG)) {
__PYX_VERIFY_RETURN_INT_EXC(char, PY_LONG_LONG, PyLong_AsLongLong(x))
#endif
}
}
{
#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray)
PyErr_SetString(PyExc_RuntimeError,
"_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers");
#else
char val;
PyObject *v = __Pyx_PyNumber_IntOrLong(x);
#if PY_MAJOR_VERSION < 3
if (likely(v) && !PyLong_Check(v)) {
PyObject *tmp = v;
v = PyNumber_Long(tmp);
Py_DECREF(tmp);
}
#endif
if (likely(v)) {
int one = 1; int is_little = (int)*(unsigned char *)&one;
unsigned char *bytes = (unsigned char *)&val;
int ret = _PyLong_AsByteArray((PyLongObject *)v,
bytes, sizeof(val),
is_little, !is_unsigned);
Py_DECREF(v);
if (likely(!ret))
return val;
}
#endif
return (char) -1;
}
} else {
char val;
PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
if (!tmp) return (char) -1;
val = __Pyx_PyInt_As_char(tmp);
Py_DECREF(tmp);
return val;
}
raise_overflow:
PyErr_SetString(PyExc_OverflowError,
"value too large to convert to char");
return (char) -1;
raise_neg_overflow:
PyErr_SetString(PyExc_OverflowError,
"can't convert negative value to char");
return (char) -1;
}
/* CheckBinaryVersion */
static int __Pyx_check_binary_version(void) {
char ctversion[4], rtversion[4];
PyOS_snprintf(ctversion, 4, "%d.%d", PY_MAJOR_VERSION, PY_MINOR_VERSION);
PyOS_snprintf(rtversion, 4, "%s", Py_GetVersion());
if (ctversion[0] != rtversion[0] || ctversion[2] != rtversion[2]) {
char message[200];
PyOS_snprintf(message, sizeof(message),
"compiletime version %s of module '%.100s' "
"does not match runtime version %s",
ctversion, __Pyx_MODULE_NAME, rtversion);
return PyErr_WarnEx(NULL, message, 1);
}
return 0;
}
/* FunctionExport */
static int __Pyx_ExportFunction(const char *name, void (*f)(void), const char *sig) {
PyObject *d = 0;
PyObject *cobj = 0;
union {
void (*fp)(void);
void *p;
} tmp;
d = PyObject_GetAttrString(__pyx_m, (char *)"__pyx_capi__");
if (!d) {
PyErr_Clear();
d = PyDict_New();
if (!d)
goto bad;
Py_INCREF(d);
if (PyModule_AddObject(__pyx_m, (char *)"__pyx_capi__", d) < 0)
goto bad;
}
tmp.fp = f;
#if PY_VERSION_HEX >= 0x02070000
cobj = PyCapsule_New(tmp.p, sig, 0);
#else
cobj = PyCObject_FromVoidPtrAndDesc(tmp.p, (void *)sig, 0);
#endif
if (!cobj)
goto bad;
if (PyDict_SetItemString(d, name, cobj) < 0)
goto bad;
Py_DECREF(cobj);
Py_DECREF(d);
return 0;
bad:
Py_XDECREF(cobj);
Py_XDECREF(d);
return -1;
}
/* VoidPtrImport */
#ifndef __PYX_HAVE_RT_ImportVoidPtr
#define __PYX_HAVE_RT_ImportVoidPtr
static int __Pyx_ImportVoidPtr(PyObject *module, const char *name, void **p, const char *sig) {
PyObject *d = 0;
PyObject *cobj = 0;
d = PyObject_GetAttrString(module, (char *)"__pyx_capi__");
if (!d)
goto bad;
cobj = PyDict_GetItemString(d, name);
if (!cobj) {
PyErr_Format(PyExc_ImportError,
"%.200s does not export expected C variable %.200s",
PyModule_GetName(module), name);
goto bad;
}
#if PY_VERSION_HEX >= 0x02070000
if (!PyCapsule_IsValid(cobj, sig)) {
PyErr_Format(PyExc_TypeError,
"C variable %.200s.%.200s has wrong signature (expected %.500s, got %.500s)",
PyModule_GetName(module), name, sig, PyCapsule_GetName(cobj));
goto bad;
}
*p = PyCapsule_GetPointer(cobj, sig);
#else
{const char *desc, *s1, *s2;
desc = (const char *)PyCObject_GetDesc(cobj);
if (!desc)
goto bad;
s1 = desc; s2 = sig;
while (*s1 != '\0' && *s1 == *s2) { s1++; s2++; }
if (*s1 != *s2) {
PyErr_Format(PyExc_TypeError,
"C variable %.200s.%.200s has wrong signature (expected %.500s, got %.500s)",
PyModule_GetName(module), name, sig, desc);
goto bad;
}
*p = PyCObject_AsVoidPtr(cobj);}
#endif
if (!(*p))
goto bad;
Py_DECREF(d);
return 0;
bad:
Py_XDECREF(d);
return -1;
}
#endif
/* FunctionImport */
#ifndef __PYX_HAVE_RT_ImportFunction
#define __PYX_HAVE_RT_ImportFunction
static int __Pyx_ImportFunction(PyObject *module, const char *funcname, void (**f)(void), const char *sig) {
PyObject *d = 0;
PyObject *cobj = 0;
union {
void (*fp)(void);
void *p;
} tmp;
d = PyObject_GetAttrString(module, (char *)"__pyx_capi__");
if (!d)
goto bad;
cobj = PyDict_GetItemString(d, funcname);
if (!cobj) {
PyErr_Format(PyExc_ImportError,
"%.200s does not export expected C function %.200s",
PyModule_GetName(module), funcname);
goto bad;
}
#if PY_VERSION_HEX >= 0x02070000
if (!PyCapsule_IsValid(cobj, sig)) {
PyErr_Format(PyExc_TypeError,
"C function %.200s.%.200s has wrong signature (expected %.500s, got %.500s)",
PyModule_GetName(module), funcname, sig, PyCapsule_GetName(cobj));
goto bad;
}
tmp.p = PyCapsule_GetPointer(cobj, sig);
#else
{const char *desc, *s1, *s2;
desc = (const char *)PyCObject_GetDesc(cobj);
if (!desc)
goto bad;
s1 = desc; s2 = sig;
while (*s1 != '\0' && *s1 == *s2) { s1++; s2++; }
if (*s1 != *s2) {
PyErr_Format(PyExc_TypeError,
"C function %.200s.%.200s has wrong signature (expected %.500s, got %.500s)",
PyModule_GetName(module), funcname, sig, desc);
goto bad;
}
tmp.p = PyCObject_AsVoidPtr(cobj);}
#endif
*f = tmp.fp;
if (!(*f))
goto bad;
Py_DECREF(d);
return 0;
bad:
Py_XDECREF(d);
return -1;
}
#endif
/* InitStrings */
static int __Pyx_InitStrings(__Pyx_StringTabEntry *t) {
while (t->p) {
#if PY_MAJOR_VERSION < 3
if (t->is_unicode) {
*t->p = PyUnicode_DecodeUTF8(t->s, t->n - 1, NULL);
} else if (t->intern) {
*t->p = PyString_InternFromString(t->s);
} else {
*t->p = PyString_FromStringAndSize(t->s, t->n - 1);
}
#else
if (t->is_unicode | t->is_str) {
if (t->intern) {
*t->p = PyUnicode_InternFromString(t->s);
} else if (t->encoding) {
*t->p = PyUnicode_Decode(t->s, t->n - 1, t->encoding, NULL);
} else {
*t->p = PyUnicode_FromStringAndSize(t->s, t->n - 1);
}
} else {
*t->p = PyBytes_FromStringAndSize(t->s, t->n - 1);
}
#endif
if (!*t->p)
return -1;
if (PyObject_Hash(*t->p) == -1)
return -1;
++t;
}
return 0;
}
static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char* c_str) {
return __Pyx_PyUnicode_FromStringAndSize(c_str, (Py_ssize_t)strlen(c_str));
}
static CYTHON_INLINE const char* __Pyx_PyObject_AsString(PyObject* o) {
Py_ssize_t ignore;
return __Pyx_PyObject_AsStringAndSize(o, &ignore);
}
#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT
#if !CYTHON_PEP393_ENABLED
static const char* __Pyx_PyUnicode_AsStringAndSize(PyObject* o, Py_ssize_t *length) {
char* defenc_c;
PyObject* defenc = _PyUnicode_AsDefaultEncodedString(o, NULL);
if (!defenc) return NULL;
defenc_c = PyBytes_AS_STRING(defenc);
#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII
{
char* end = defenc_c + PyBytes_GET_SIZE(defenc);
char* c;
for (c = defenc_c; c < end; c++) {
if ((unsigned char) (*c) >= 128) {
PyUnicode_AsASCIIString(o);
return NULL;
}
}
}
#endif
*length = PyBytes_GET_SIZE(defenc);
return defenc_c;
}
#else
static CYTHON_INLINE const char* __Pyx_PyUnicode_AsStringAndSize(PyObject* o, Py_ssize_t *length) {
if (unlikely(__Pyx_PyUnicode_READY(o) == -1)) return NULL;
#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII
if (likely(PyUnicode_IS_ASCII(o))) {
*length = PyUnicode_GET_LENGTH(o);
return PyUnicode_AsUTF8(o);
} else {
PyUnicode_AsASCIIString(o);
return NULL;
}
#else
return PyUnicode_AsUTF8AndSize(o, length);
#endif
}
#endif
#endif
static CYTHON_INLINE const char* __Pyx_PyObject_AsStringAndSize(PyObject* o, Py_ssize_t *length) {
#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT
if (
#if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII
__Pyx_sys_getdefaultencoding_not_ascii &&
#endif
PyUnicode_Check(o)) {
return __Pyx_PyUnicode_AsStringAndSize(o, length);
} else
#endif
#if (!CYTHON_COMPILING_IN_PYPY) || (defined(PyByteArray_AS_STRING) && defined(PyByteArray_GET_SIZE))
if (PyByteArray_Check(o)) {
*length = PyByteArray_GET_SIZE(o);
return PyByteArray_AS_STRING(o);
} else
#endif
{
char* result;
int r = PyBytes_AsStringAndSize(o, &result, length);
if (unlikely(r < 0)) {
return NULL;
} else {
return result;
}
}
}
static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject* x) {
int is_true = x == Py_True;
if (is_true | (x == Py_False) | (x == Py_None)) return is_true;
else return PyObject_IsTrue(x);
}
static CYTHON_INLINE int __Pyx_PyObject_IsTrueAndDecref(PyObject* x) {
int retval;
if (unlikely(!x)) return -1;
retval = __Pyx_PyObject_IsTrue(x);
Py_DECREF(x);
return retval;
}
static PyObject* __Pyx_PyNumber_IntOrLongWrongResultType(PyObject* result, const char* type_name) {
#if PY_MAJOR_VERSION >= 3
if (PyLong_Check(result)) {
if (PyErr_WarnFormat(PyExc_DeprecationWarning, 1,
"__int__ returned non-int (type %.200s). "
"The ability to return an instance of a strict subclass of int "
"is deprecated, and may be removed in a future version of Python.",
Py_TYPE(result)->tp_name)) {
Py_DECREF(result);
return NULL;
}
return result;
}
#endif
PyErr_Format(PyExc_TypeError,
"__%.4s__ returned non-%.4s (type %.200s)",
type_name, type_name, Py_TYPE(result)->tp_name);
Py_DECREF(result);
return NULL;
}
static CYTHON_INLINE PyObject* __Pyx_PyNumber_IntOrLong(PyObject* x) {
#if CYTHON_USE_TYPE_SLOTS
PyNumberMethods *m;
#endif
const char *name = NULL;
PyObject *res = NULL;
#if PY_MAJOR_VERSION < 3
if (likely(PyInt_Check(x) || PyLong_Check(x)))
#else
if (likely(PyLong_Check(x)))
#endif
return __Pyx_NewRef(x);
#if CYTHON_USE_TYPE_SLOTS
m = Py_TYPE(x)->tp_as_number;
#if PY_MAJOR_VERSION < 3
if (m && m->nb_int) {
name = "int";
res = m->nb_int(x);
}
else if (m && m->nb_long) {
name = "long";
res = m->nb_long(x);
}
#else
if (likely(m && m->nb_int)) {
name = "int";
res = m->nb_int(x);
}
#endif
#else
if (!PyBytes_CheckExact(x) && !PyUnicode_CheckExact(x)) {
res = PyNumber_Int(x);
}
#endif
if (likely(res)) {
#if PY_MAJOR_VERSION < 3
if (unlikely(!PyInt_Check(res) && !PyLong_Check(res))) {
#else
if (unlikely(!PyLong_CheckExact(res))) {
#endif
return __Pyx_PyNumber_IntOrLongWrongResultType(res, name);
}
}
else if (!PyErr_Occurred()) {
PyErr_SetString(PyExc_TypeError,
"an integer is required");
}
return res;
}
static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject* b) {
Py_ssize_t ival;
PyObject *x;
#if PY_MAJOR_VERSION < 3
if (likely(PyInt_CheckExact(b))) {
if (sizeof(Py_ssize_t) >= sizeof(long))
return PyInt_AS_LONG(b);
else
return PyInt_AsSsize_t(b);
}
#endif
if (likely(PyLong_CheckExact(b))) {
#if CYTHON_USE_PYLONG_INTERNALS
const digit* digits = ((PyLongObject*)b)->ob_digit;
const Py_ssize_t size = Py_SIZE(b);
if (likely(__Pyx_sst_abs(size) <= 1)) {
ival = likely(size) ? digits[0] : 0;
if (size == -1) ival = -ival;
return ival;
} else {
switch (size) {
case 2:
if (8 * sizeof(Py_ssize_t) > 2 * PyLong_SHIFT) {
return (Py_ssize_t) (((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]));
}
break;
case -2:
if (8 * sizeof(Py_ssize_t) > 2 * PyLong_SHIFT) {
return -(Py_ssize_t) (((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]));
}
break;
case 3:
if (8 * sizeof(Py_ssize_t) > 3 * PyLong_SHIFT) {
return (Py_ssize_t) (((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]));
}
break;
case -3:
if (8 * sizeof(Py_ssize_t) > 3 * PyLong_SHIFT) {
return -(Py_ssize_t) (((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]));
}
break;
case 4:
if (8 * sizeof(Py_ssize_t) > 4 * PyLong_SHIFT) {
return (Py_ssize_t) (((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]));
}
break;
case -4:
if (8 * sizeof(Py_ssize_t) > 4 * PyLong_SHIFT) {
return -(Py_ssize_t) (((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]));
}
break;
}
}
#endif
return PyLong_AsSsize_t(b);
}
x = PyNumber_Index(b);
if (!x) return -1;
ival = PyInt_AsSsize_t(x);
Py_DECREF(x);
return ival;
}
static CYTHON_INLINE PyObject * __Pyx_PyBool_FromLong(long b) {
return b ? __Pyx_NewRef(Py_True) : __Pyx_NewRef(Py_False);
}
static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t ival) {
return PyInt_FromSize_t(ival);
}
#endif /* Py_PYTHON_H */
|
[
"rafaelstojoao@gmail.com"
] |
rafaelstojoao@gmail.com
|
566858d6c742187a5500d8506e55ef678f8944fc
|
35e9bc49304132b79757cc85be7900ac245ea925
|
/training_data/src/bvh2cam_origin.cpp
|
796ab3d3ee397c88e0484edb9927aacce8d1b22e
|
[] |
no_license
|
baardkrk/master
|
9596b33f83c4b03516c54cb642b984c9e813a367
|
58af135e745f0633d36acf61a0661f238f94dcda
|
refs/heads/master
| 2021-12-25T06:22:18.177198
| 2021-12-16T10:47:32
| 2021-12-16T10:47:32
| 101,864,398
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 631
|
cpp
|
/***
* Takes a bvh-file, depth-image and timestamp as input, and creates a
* pair of ground truth keypoints and depth maps that will be used when
* training the network.
*/
//コメントは日本語にできるよう!
#include "terminal_colors.h"
#define INCORRECT_USAGE_MSG "Incorrect usage. Please use the format:"
#define HELP_MSG "./prep_data PATH_TO_BerkeleyMHAD"
#define CORRECT_ARG_NUM 2
#define PRINT_ERR() fprintf(stderr, RED "%s\n%s\n" RESET, INCORRECT_USAGE_MSG, HELP_MSG)
#include <stdio.h>
int
main(int argc, char *argv[])
{
if (argc != CORRECT_ARG_NUM) { PRINT_ERR(); return 0; }
return 0;
}
|
[
"baard.krohg@gmail.com"
] |
baard.krohg@gmail.com
|
fabf1b7273651c64c1e724521b4b72b4e48181b3
|
5f4ae1d349ddff57b36b338dd882363452511e78
|
/Lab3/Lab3/island.h
|
b690c266b2b38a58feab8330ba5582f5b255914f
|
[] |
no_license
|
3eqp/OOP_Labs
|
55922ca3ce0d0b89294f4dd6b2ab0fe5080dbd30
|
8bcdd626cebc4d6afb4ae676b94e52c74abe7f84
|
refs/heads/master
| 2021-06-14T00:01:52.075173
| 2017-03-13T09:56:13
| 2017-03-13T09:56:13
| null | 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 195
|
h
|
#pragma once
#include "continent.h"
#include "sea.h"
class Island :
public Sea
{
int island_area;
public:
Island(void);
void setisland_area(int x);
void getisland_area();
~Island(void);
};
|
[
"Ivanzenkovich@mail.ru"
] |
Ivanzenkovich@mail.ru
|
7fa84041ebd0dd38a306166912ab108f1cdd005b
|
6e89098eabc4713a81d6ee8686e6c392760236f0
|
/src/keepass.h
|
0347e173fce4ca1ae308fda4ace54753e401c2ec
|
[
"MIT"
] |
permissive
|
15364097026/russellcoin-1
|
57c5e6a8becfcd17fd98deb3cc07413100edfbc7
|
631a6403af5ea54adf0b276cc537473430019f7d
|
refs/heads/master
| 2020-09-08T09:10:43.327474
| 2019-11-08T06:31:21
| 2019-11-08T06:31:21
| 221,089,041
| 1
| 0
|
MIT
| 2019-11-11T23:30:47
| 2019-11-11T23:30:47
| null |
UTF-8
|
C++
| false
| false
| 3,421
|
h
|
// Copyright (c) 2014 The Dash developers
// Distributed under the MIT/X11 software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
#ifndef _KEEPASS_H_
#define _KEEPASS_H_
#define KEEPASS_CRYPTO_KEY_SIZE 32
#define KEEPASS_CRYPTO_BLOCK_SIZE 16
#define KEEPASS_KEEPASSHTTP_HOST "localhost"
#define KEEPASS_KEEPASSHTTP_PORT 19455
#include <string>
#include <vector>
#include <map>
#include "json/json_spirit_value.h"
#include "allocators.h"
class CKeePassIntegrator {
bool bIsActive;
unsigned int nPort;
SecureString sKeyBase64;
SecureString sKey;
SecureString sUrl;
//SecureString sSubmitUrl;
std::string sKeePassId;
std::string sKeePassEntryName;
class CKeePassRequest {
json_spirit::Object requestObj;
std::string sType;
std::string sIV;
SecureString sKey;
void init();
public:
void addStrParameter(std::string sName, std::string sValue); // Regular
void addStrParameter(std::string sName, SecureString sValue); // Encrypt
std::string getJson();
CKeePassRequest(SecureString sKey, std::string sType)
{
this->sKey = sKey;
this->sType = sType;
init();
};
};
class CKeePassEntry {
SecureString uuid;
SecureString name;
SecureString login;
SecureString password;
public:
CKeePassEntry(SecureString uuid, SecureString name, SecureString login, SecureString password) :
uuid(uuid), name(name), login(login), password(password) {
}
SecureString getUuid() {
return uuid;
}
SecureString getName() {
return name;
}
SecureString getLogin() {
return login;
}
SecureString getPassword() {
return password;
}
};
class CKeePassResponse {
bool bSuccess;
std::string sType;
std::string sIV;
SecureString sKey;
void parseResponse(std::string sResponse);
public:
json_spirit::Object responseObj;
CKeePassResponse(SecureString sKey, std::string sResponse) {
this->sKey = sKey;
parseResponse(sResponse);
}
bool getSuccess() {
return bSuccess;
}
SecureString getSecureStr(std::string sName);
std::string getStr(std::string sName);
std::vector<CKeePassEntry> getEntries();
SecureString decrypt(std::string sValue); // DecodeBase64 and decrypt arbitrary string value
};
static SecureString generateRandomKey(size_t nSize);
static std::string constructHTTPPost(const std::string& strMsg, const std::map<std::string,std::string>& mapRequestHeaders);
void doHTTPPost(const std::string& sRequest, int& nStatus, std::string& sResponse);
void rpcTestAssociation(bool bTriggerUnlock);
std::vector<CKeePassEntry> rpcGetLogins();
void rpcSetLogin(const SecureString& strWalletPass, const SecureString& sEntryId);
public:
CKeePassIntegrator();
void init();
static SecureString generateKeePassKey();
void rpcAssociate(std::string& sId, SecureString& sKeyBase64);
SecureString retrievePassphrase();
void updatePassphrase(const SecureString& sWalletPassphrase);
};
extern CKeePassIntegrator keePassInt;
#endif
|
[
"muqdeshuo@outlook.com"
] |
muqdeshuo@outlook.com
|
dad05efd3a34cffbd45b5117bb4fb887c8ac762c
|
501591e4268ad9a5705012cd93d36bac884847b7
|
/src/server/scripts/Northrend/VaultOfArchavon/instance_vault_of_archavon.cpp
|
5e93744367ad0cd30818af65026fd342f5871143
|
[] |
no_license
|
CryNet/MythCore
|
f550396de5f6e20c79b4aa0eb0a78e5fea9d86ed
|
ffc5fa1c898d25235cec68c76ac94c3279df6827
|
refs/heads/master
| 2020-07-11T10:09:31.244662
| 2013-06-29T19:06:43
| 2013-06-29T19:06:43
| null | 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 3,218
|
cpp
|
/*
* Copyright (C) 2008 - 2011 Trinity <http://www.trinitycore.org/>
*
* Copyright (C) 2010 - 2012 Myth Project <http://mythprojectnetwork.blogspot.com/>
*
* Myth Project's source is based on the Trinity Project source, you can find the
* link to that easily in Trinity Copyrights. Myth Project is a private community.
* To get access, you either have to donate or pass a developer test.
* You may not share Myth Project's sources! For personal use only.
*/
#include "ScriptPCH.h"
#include "vault_of_archavon.h"
#include "OutdoorPvPMgr.h"
#include "OutdoorPvPWG.h"
/* Vault of Archavon encounters:
1 - Archavon the Stone Watcher event
2 - Emalon the Storm Watcher event
3 - Koralon the Flame Watcher event
4 - Toravon the Ice Watcher event
*/
class instance_archavon : public InstanceMapScript
{
public:
instance_archavon() : InstanceMapScript("instance_archavon", 624) { }
struct instance_archavon_InstanceMapScript : public InstanceScript
{
instance_archavon_InstanceMapScript(Map* map) : InstanceScript(map)
{
SetBossNumber(MAX_ENCOUNTER);
}
void Initialize()
{
EmalonGUID = 0;
ToravonGUID = 0;
}
void OnPlayerEnter(Player* m_player)
{
if(sWorld->getBoolConfig(CONFIG_OUTDOORPVP_WINTERGRASP_ENABLED))
{
if(OutdoorPvPWG *pvpWG = (OutdoorPvPWG*)sOutdoorPvPMgr->GetOutdoorPvPToZoneId(4197))
{
if((pvpWG->getDefenderTeam()==TEAM_ALLIANCE) && (m_player->ToPlayer()->GetTeam() == ALLIANCE))
return;
else if((pvpWG->getDefenderTeam()!=TEAM_ALLIANCE) && (m_player->ToPlayer()->GetTeam() == HORDE))
return;
else m_player->CastSpell(m_player, SPELL_TELEPORT_FORTRESS, true);
}
}
}
void OnCreatureCreate(Creature* creature)
{
switch(creature->GetEntry())
{
case CREATURE_EMALON:
EmalonGUID = creature->GetGUID();
break;
case CREATURE_TORAVON:
ToravonGUID = creature->GetGUID();
break;
default:
break;
}
}
uint64 GetData64(uint32 identifier)
{
switch(identifier)
{
case DATA_EMALON:
return EmalonGUID;
case DATA_TORAVON:
return ToravonGUID;
default:
break;
}
return 0;
}
private:
uint64 EmalonGUID;
uint64 ToravonGUID;
};
InstanceScript* GetInstanceScript(InstanceMap* map) const
{
return new instance_archavon_InstanceMapScript(map);
}
};
void AddSC_instance_archavon()
{
new instance_archavon;
}
|
[
"vitasic-pokataev@yandex.ru"
] |
vitasic-pokataev@yandex.ru
|
e0ce15d9569215ad2c97d53c23c2184712935de6
|
dfb3f5c0fa2fb74fe93db3230fe350809f3edd47
|
/uva 299.cpp
|
d4f90ccc3e8b7b2149760cc7738a40f2a4047d1d
|
[] |
no_license
|
MannaEmam/UVA
|
876ef7bd21f024d6a2045ba99f7bfd4066a570a3
|
64d8fef2d41d61b65dc9f6959b31e4fabdaeeb26
|
refs/heads/master
| 2023-01-31T11:08:22.506238
| 2023-01-27T12:09:36
| 2023-01-27T12:09:36
| 149,136,136
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 453
|
cpp
|
#include <bits/stdc++.h>
using namespace std;
int main()
{
int t,c,i,j,n,key_value;
cin>>t;
while(t--)
{
cin>>n;
c = 0;
int A[n];
for(i = 1; i <= n; i++)
cin>>A[i];
for(j = 2;j <= n; j++)
{
key_value = A[j];
i = (j-1);
while(i > 0 && A[i] > key_value)
{
A[i + 1] = A[i];
i--;
c++;
}
A[i + 1] = key_value;
}
cout<<"Optimal train swapping takes "<<c<<" swaps."<<endl;
}
return 0;
}
|
[
"mannaemam@gmail.com"
] |
mannaemam@gmail.com
|
1e7f4ad855f2ade18f9a2ab03598983def1a6b0b
|
877fff5bb313ccd23d1d01bf23b1e1f2b13bb85a
|
/app/src/main/cpp/dir521/dir522/dir572/dir1838/dir1839/dir1840/file1850.cpp
|
a82942bebf816271da9b925d5e81627f1f4eb30f
|
[] |
no_license
|
tgeng/HugeProject
|
829c3bdfb7cbaf57727c41263212d4a67e3eb93d
|
4488d3b765e8827636ce5e878baacdf388710ef2
|
refs/heads/master
| 2022-08-21T16:58:54.161627
| 2020-05-28T01:54:03
| 2020-05-28T01:54:03
| 267,468,475
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 111
|
cpp
|
#ifndef file1850
#error "macro file1850 must be defined"
#endif
static const char* file1850String = "file1850";
|
[
"tgeng@google.com"
] |
tgeng@google.com
|
2eaafdb51da90780abd776c60a6a05f5f44f8888
|
f08ebf4a9a4019239c8eedf1d8e7249828b47dd2
|
/MSVC/Test_FluentStarter/Test_FluentStarter.cpp
|
b2736182b1725c2a63d9a120e7bd72aa907f960a
|
[] |
no_license
|
baniuk/A2F
|
473e30fbc95b3c7f4dbc9439263d78876b321970
|
79298f1348d01e17dc7da45ea3847e768bb69de4
|
refs/heads/master
| 2020-04-28T23:21:58.557787
| 2014-04-11T18:41:59
| 2014-04-11T18:41:59
| 175,651,776
| 0
| 0
| null | null | null | null |
WINDOWS-1250
|
C++
| false
| false
| 3,075
|
cpp
|
/**
* \file Test_FluentStarter.cpp
* \brief Main file that starts all tests
* \details Tests Fluent starter
* \pre Nedd fluent installed
* \author PB
* \date 2014/02/05
* \warning All test should be run on virtual machine A2F.
*/
#include "stdafx.h"
#include "..\Common_utilities\Pantheios_header.h"
#include "..\Common_utilities\PantheiosLogHelper.h"
#include "..\FluentStart\C_Properties.h"
/// Log file name and initialization of Pantheios API
PANTHEIOS_EXTERN_C const PAN_CHAR_T PANTHEIOS_FE_PROCESS_IDENTITY[] = PSTR("Test_FluentStarter");
#ifndef PANTHEIOS_LOG_FILE_NAME
#define PANTHEIOS_LOG_FILE_NAME "c:\\Test_FluentStarter.pantlog"
#else
#error PANTHEIOS_LOG_FILE_NAME already defined!!
#endif
/**
* \brief Struktura określająca minimalny poziom błedu który trafia do danego logu
*
* DEBUG jest poziomem najniższym, co znaczy że do pliku trafi wszystko. Ta struktura działa
* jedynie gdy linkuje się do biblioteki be.N. Kolejność błędów:
* -# DEBUG
* -# INFORMATIONAL
* -# NOTICE
* -# WARNING
* -# ERROR
* -# CRITICAL
* -# ALERT
* -# EMERGENCY
* \n
* Do konsoli trafi wszystko powyżej DEBUG
*/
pan_fe_N_t PAN_FE_N_SEVERITY_CEILINGS[] = {
{ toFile, PANTHEIOS_SEV_DEBUG },
{ toConsole, PANTHEIOS_SEV_ERROR },
PANTHEIOS_FE_N_TERMINATOR_ENTRY(PANTHEIOS_SEV_CRITICAL)
};
/**
* \brief Struktura łącząca poziom błedu z konkretnym wyjściem
*
* LOGI::File i LOGI::Console łączą się z pozycjami w PAN_FE_N_SEVERITY_CEILINGS
*/
pan_be_N_t PAN_BE_N_BACKEND_LIST[] = {
PANTHEIOS_BE_N_STDFORM_ENTRY(toFile, pantheios_be_file, 0),
PANTHEIOS_BE_N_STDFORM_ENTRY(toConsole, pantheios_be_fprintf, 0),
PANTHEIOS_BE_N_TERMINATOR_ENTRY
};
using namespace std;
// set global context for script
string application_scope = "FLUENT";
int _tmain(int argc, _TCHAR* argv[])
{
int ret = 0;
if (pantheios::pantheios_init() < 0)
{
std::cerr << "Failed to initialise the Pantheios logging libraries!\n" << std::endl;
return FALSE;
}
else
{
pantheios_be_file_setFilePath(PSTR(PANTHEIOS_LOG_FILE_NAME), PANTHEIOS_BE_FILE_F_TRUNCATE, PANTHEIOS_BE_FILE_F_TRUNCATE, PANTHEIOS_BEID_ALL);
pantheios::log_INFORMATIONAL("Logger enabled!");
}
::testing::InitGoogleTest(&argc, argv);
ret = RUN_ALL_TESTS();
pantheios::log_INFORMATIONAL("Logger disabled!");
pantheios_be_file_setFilePath(NULL, PANTHEIOS_BEID_ALL);
pantheios::pantheios_uninit();
return ret;
}
/**
* \test FluentStarter:_StartFluent
* Try start Fluent. Most parameters set separately in C_Properties
* \see C_Properties
*/
TEST(FluentStarter,_StartFluent)
{
HRESULT err = E_FAIL;
ASSERT_NO_THROW(err = C_FluentStarter::StartFluent());
ASSERT_HRESULT_SUCCEEDED(err);
}
/**
* \test FluentStarter:_CreateSCM
* Creates journal file and SCM in %TMP% directory
*/
TEST(FluentStarter,_CreateJournal)
{
try
{
C_FluentStarter::CreateJournal();
}
catch(std::exception& ex)
{
std::cerr << "Caught exception: " << ex.what() << endl;
ASSERT_TRUE(false);
}
std::cerr << "Need to check journal file manually" << std::endl;
}
|
[
"baniuk@zut.edu.pl"
] |
baniuk@zut.edu.pl
|
08167b6d68bd56e810536521976e0b282af17249
|
9f7a5e5c6dfce8daa9c6c748c61851a5e8b1464b
|
/027_ImageProcess_pro/ImageProcess09/build/moc_mainwindowimpl.cpp
|
6a1f8a8445993c970f38a8d1687f2e4b763eeb57
|
[] |
no_license
|
jash-git/Jash_QT
|
fdaf4eb2d6575d19ed17f35c57af25940f80554d
|
5e44333512e048649e6b7038428487348fda52aa
|
refs/heads/master
| 2023-05-28T11:24:23.585919
| 2021-06-06T12:43:10
| 2021-06-06T12:43:10
| 372,838,837
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 2,617
|
cpp
|
/****************************************************************************
** Meta object code from reading C++ file 'mainwindowimpl.h'
**
** Created: Tue Aug 17 10:50:11 2010
** by: The Qt Meta Object Compiler version 61 (Qt 4.5.0)
**
** WARNING! All changes made in this file will be lost!
*****************************************************************************/
#include "../src/mainwindowimpl.h"
#if !defined(Q_MOC_OUTPUT_REVISION)
#error "The header file 'mainwindowimpl.h' doesn't include <QObject>."
#elif Q_MOC_OUTPUT_REVISION != 61
#error "This file was generated using the moc from 4.5.0. It"
#error "cannot be used with the include files from this version of Qt."
#error "(The moc has changed too much.)"
#endif
QT_BEGIN_MOC_NAMESPACE
static const uint qt_meta_data_MainWindowImpl[] = {
// content:
2, // revision
0, // classname
0, 0, // classinfo
5, 12, // methods
0, 0, // properties
0, 0, // enums/sets
0, 0, // constructors
// slots: signature, parameters, type, tag, flags
16, 15, 15, 15, 0x08,
31, 15, 15, 15, 0x08,
43, 15, 15, 15, 0x08,
54, 15, 15, 15, 0x08,
69, 15, 15, 15, 0x08,
0 // eod
};
static const char qt_meta_stringdata_MainWindowImpl[] = {
"MainWindowImpl\0\0slotOpenFile()\0"
"slotClose()\0slotGray()\0slotHistgram()\0"
"slotThresh()\0"
};
const QMetaObject MainWindowImpl::staticMetaObject = {
{ &QMainWindow::staticMetaObject, qt_meta_stringdata_MainWindowImpl,
qt_meta_data_MainWindowImpl, 0 }
};
const QMetaObject *MainWindowImpl::metaObject() const
{
return &staticMetaObject;
}
void *MainWindowImpl::qt_metacast(const char *_clname)
{
if (!_clname) return 0;
if (!strcmp(_clname, qt_meta_stringdata_MainWindowImpl))
return static_cast<void*>(const_cast< MainWindowImpl*>(this));
if (!strcmp(_clname, "Ui::MainWindow"))
return static_cast< Ui::MainWindow*>(const_cast< MainWindowImpl*>(this));
return QMainWindow::qt_metacast(_clname);
}
int MainWindowImpl::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
_id = QMainWindow::qt_metacall(_c, _id, _a);
if (_id < 0)
return _id;
if (_c == QMetaObject::InvokeMetaMethod) {
switch (_id) {
case 0: slotOpenFile(); break;
case 1: slotClose(); break;
case 2: slotGray(); break;
case 3: slotHistgram(); break;
case 4: slotThresh(); break;
default: ;
}
_id -= 5;
}
return _id;
}
QT_END_MOC_NAMESPACE
|
[
"jash.liao@gmail.com"
] |
jash.liao@gmail.com
|
9e6f1554afed4289d95a1bdb1c31f69bc02a2201
|
b954f9b1e7dc612474a43fd7a70209cd67508c35
|
/ListLib/List.h
|
7ca97dfb5cbc52f9ee5aa9e20ccf7cee329cb908
|
[] |
no_license
|
sophieparshina/sophieparshina-labs-master-381706-2
|
58f6bc4b0a2fd0640d476e3b66e3822e4ccfee59
|
f4bedb0dff2eaf98566289891ccd51ea0a44ebd6
|
refs/heads/master
| 2020-08-07T10:51:28.673871
| 2019-11-22T09:20:00
| 2019-11-22T09:20:00
| 213,412,606
| 0
| 0
| null | null | null | null |
WINDOWS-1251
|
C++
| false
| false
| 6,788
|
h
|
#pragma once
#include "../ExceptionLib/Exception.h"
#include "Elem.h"
using namespace std;
template <class T>
class TList {
//Класс односвязного списка
protected: //Доступ к этим элементам открыт классам, производным от данного
int count; //Количество элементов односвязного списка
TElem <T>* begin;
public: //Доступ открыт всем, кто видит определение данного класса
TList(); //Конструктор класса по умолчанию
TList(TList<T> &list); //Констуктор копирования
virtual ~TList(); //Деструктор
void Put(int _n, T element); //Метод, реализующий размещение элемента в указаную позицию списка
void PutBegin(T element); //Метод, реализующий размещение элемента в начало списка
void PutEnd(T element); //Метод, реализующий размещение элемента в начало списка
T Get(int _n); // Метод, реализующий забирание элемента по указанной позиции списка
T GetBegin(); // Метод, реализующий забирание элемента из начала списка
T GetEnd(); // Метод, реализующий забирание элемента из конца списка
void Print(); //Печать элементов списка
bool IsFull(); //Проверка списка на полноту
bool IsEmpty(); //Проверка списка на пустоту
};
//Конструктор класса по умолчанию
template <class T>
TList<T>::TList() {
begin = 0;
count = 0;
}
//Констуктор копирования
template <class T>
TList<T>::TList(TList<T> &List) {
count = List.count;
TElem<T>* a = List.begin;
TElem<T>* b;
if (List.begin == 0)
{
begin = 0;
} else {
begin = new TElem<T>(*List.begin);
b = begin;
while (a->TElem<T>::GetNext() != 0)
{
b->TElem<T>::SetNext(new TElem<T>(*(a->TElem<T>::GetNext())));
a = a->TElem<T>::GetNext();
b = b->TElem<T>::GetNext();
}
}
}
//Деструктор
template <class T>
TList<T>::~TList() {
while (begin != 0)
{
TElem<T>* temp = begin; //Назначаем временную переменную для хранения начала списка
begin = begin->GetNext(); //Переобозначаем начало списка как следующий за ним элемент
delete temp; //Удаляем временную переменную с текущим началом списка
}
}
//Проверка списка на пустоту
template <class T>
bool TList<T>::IsEmpty() {
if (begin == 0)
{
return true;
} else {
return false;
}
}
//Проверка списка на полноту
template <class T>
bool TList<T>::IsFull() {
try
{
TElem<T>* element = new TElem<T>();
if (element = NULL)
{
return 1;
} else {
delete element;
return 0;
}
}
catch (...)
{
return 0;
}
return true;
}
//Метод, реализующий размещение элемента в указаную позицию списка
template <class T>
void TList<T>::Put(int _n, T element) {
if (this->IsFull())
{
throw TException("Error! List is full!");
}
if (_n < 1 || _n > count - 1)
{
throw TException("Error! Wrong index!");
} else {
int i = 0;
TElem<T>* elem = begin;
while (i != _n - 1)
{
elem = elem->GetNext();
i++;
}
TElem<T>* temp = new TElem<T>(element, elem->GetNext());
elem->SetNext(temp);
count++;
}
}
//Метод, реализующий размещение элемента в начало списка
template <class T>
void TList<T>::PutBegin(T element) {
if (this->IsFull())
throw TException("Error! List is full!");
if (begin == 0)
{
TElem<T>* temp = new TElem<T>(element, 0);
begin = temp;
} else {
TElem<T>* temp = new TElem <T>(element, begin);
begin = temp;
}
count++;
}
//Метод, реализующий размещение элемента в конец списка
template <class T>
void TList<T>::PutEnd(T element) {
if (this->IsFull())
throw TException("Error! List is full!");
if (begin != 0)
{
TElem<T> *bgn = begin;
while (bgn->GetNext() != 0)
bgn = bgn->GetNext();
bgn->SetNext(new TElem <T>(element, 0));
} else {
begin = new TElem<T>(element, 0);
}
count++;
}
// Метод, реализующий забирание элемента по указанной позиции списка c его удалением из списка
template <class T>
T TList<T>::Get(int _n) {
if (this->IsEmpty())
throw TException("Error! List is empty!");
if (_n < 1 || _n > count - 1)
throw TException("Error! Wrong index!");
else
{
int i = 0;
count--;
TElem<T>* a = begin;
TElem<T>* b = begin->GetNext();
while (i != _n - 1)
{
a = b;
b = b->GetNext();
i++;
}
T temp = b->GetData();
TElem<T>* c = b->GetNext();
a->SetNext(c);
delete b;
return temp;
}
}
// Метод, реализующий забирание элемента из начала списка
template <class T>
T TList <T>::GetBegin() {
if (IsEmpty())
{
throw TException("Error! List is empty");
} else {
TElem<T>* bgn = begin;
T temp = begin->TElem<T>::GetData();
begin = begin->TElem<T>::GetNext();
delete bgn;
count--;
return temp;
}
}
// Метод, реализующий забирание элемента из конца списка
template <class T>
T TList <T>::GetEnd() {
if (IsEmpty())
{
throw TException("Error! List is empty");
} else {
if (begin->TElem<T>::GetNext() == 0)
{
T result = begin->TElem<T>::GetData();
begin = begin->TElem<T>::GetNext();
count--;
return result;
}
else
{
TElem<T> *a = begin;
while (a->GetNext()->GetNext() != 0)
a = a->GetNext();
TElem<T> *a1 = a->GetNext();
T res = a1->GetData();
delete a1;
a->SetNext(0);
count--;
return res;
}
}
}
//Печать элементов списка
template <class T>
void TList <T>::Print() {
if (IsEmpty())
{
cout << "List is empty" << '\n';
} else {
TElem<T>* a = begin;
do
{
cout << a->TElem<T>::GetData() << " ";
a = a->GetNext();
} while (a != 0);
cout << '\n' << '\n';
}
}
|
[
"55620466+sophieparshina@users.noreply.github.com"
] |
55620466+sophieparshina@users.noreply.github.com
|
70abef73df230ded924dac8428add4f5ecd91f74
|
39d139bb6a167f37f95f9cdffddcbc1a8dfb3651
|
/DAY3/0_임시객체4.cpp
|
3d08eef99b5fce2e22cc703a7091bec1c8dd3b7e
|
[] |
no_license
|
bk1472/advenced_cpp_edu
|
88f3d81fcd1020ba02d6531576adf35477114f34
|
e2b388d5be91642682deb820f72adcb430863333
|
refs/heads/master
| 2023-01-08T03:21:25.418017
| 2020-11-09T01:10:37
| 2020-11-09T01:10:37
| 311,188,981
| 0
| 0
| null | null | null | null |
UHC
|
C++
| false
| false
| 1,344
|
cpp
|
#include <iostream>
class Point
{
public:
int x, y;
Point(int a, int b) { std::cout << "Point()" << std::endl; }
~Point() { std::cout << "~Point()" << std::endl; }
};
// 4. 임시객체와 함수 반환값.
void f1(Point pt) {} // call by value : 복사본 생성
void f2(Point& pt) {} // call by reference : 복사본 생성 안됨.
Point pt(1, 2);
// 1. 값 리턴과 참조 리턴의 차이점..
// 지역변수는 참조리턴 하면 안된다.
Point foo() // return by value : 임시객체 반환
{
return pt;
}
Point& goo() // return by reference : 리턴용 임시객체를 만들지 말라는 표기법
{
return pt;
}
Point& hoo()
{
Point p(1, 2);
return p; // 버그.. 절대, 지역변수를 참조 리턴하지는 마세요..!!!
// 지역변수는 반드시 값리턴만 해야 합니다
}
Point& koo(Point& p)
{
return p; // 이런 코드는 아무 문제 없습니다. 그리고 널리 사용됩니다.
} // 오늘 아주 자주 등장합니다.
int main()
{
// int a;
// std::cout << a << std::endl; // 0
Point& p = hoo();
std::cout << p.x << std::endl;
goo().x = 10; // ok.. pt.x = 10
foo().x = 10; // error. (리턴용) 임시객체이므로 등호의 왼쪽에 올수 없다.
Point p(0, 0);
f1(p);
f2(p);
}
|
[
"baekwon.choi@GS-HQ10-NA106OE.LGE.NET"
] |
baekwon.choi@GS-HQ10-NA106OE.LGE.NET
|
e399dc36216316f17cb663dd69c69888516e4756
|
4d97a686009ece5d768f0c99c430b6174fb9ec7e
|
/arduino/libraries/RadioHead/RH_ASK.cpp
|
e7ca2dec26378296fb46a9428a1da04becf1efb3
|
[
"MIT",
"GPL-1.0-or-later",
"GPL-2.0-only"
] |
permissive
|
shschaefer/pwrs
|
bee0b93424e9d82a081bb3a1ad47a10b2a9eb98e
|
6525daca72a5ea79f13d306808ac340a4224608b
|
refs/heads/master
| 2020-08-29T08:32:20.811769
| 2019-12-18T08:55:18
| 2019-12-18T08:55:18
| 217,982,466
| 0
| 1
|
MIT
| 2019-12-17T23:03:03
| 2019-10-28T06:44:07
|
C++
|
UTF-8
|
C++
| false
| false
| 26,538
|
cpp
|
// RH_ASK.cpp
//
// Copyright (C) 2014 Mike McCauley
// $Id: RH_ASK.cpp,v 1.20 2017/01/12 23:58:00 mikem Exp $
#include <RH_ASK.h>
#include <RHCRC.h>
#if (RH_PLATFORM == RH_PLATFORM_STM32) // Maple etc
HardwareTimer timer(MAPLE_TIMER);
#endif
#if (RH_PLATFORM == RH_PLATFORM_ESP8266)
// interrupt handler and related code must be in RAM on ESP8266,
// according to issue #46.
#define INTERRUPT_ATTR ICACHE_RAM_ATTR
#else
#define INTERRUPT_ATTR
#endif
// RH_ASK on Arduino uses Timer 1 to generate interrupts 8 times per bit interval
// Define RH_ASK_ARDUINO_USE_TIMER2 if you want to use Timer 2 instead of Timer 1 on Arduino
// You may need this to work around other librraies that insist on using timer 1
// Should be moved to header file
//#define RH_ASK_ARDUINO_USE_TIMER2
// Interrupt handler uses this to find the most recently initialised instance of this driver
static RH_ASK* thisASKDriver;
// 4 bit to 6 bit symbol converter table
// Used to convert the high and low nybbles of the transmitted data
// into 6 bit symbols for transmission. Each 6-bit symbol has 3 1s and 3 0s
// with at most 3 consecutive identical bits
static uint8_t symbols[] =
{
0xd, 0xe, 0x13, 0x15, 0x16, 0x19, 0x1a, 0x1c,
0x23, 0x25, 0x26, 0x29, 0x2a, 0x2c, 0x32, 0x34
};
// This is the value of the start symbol after 6-bit conversion and nybble swapping
#define RH_ASK_START_SYMBOL 0xb38
RH_ASK::RH_ASK(uint16_t speed, uint8_t rxPin, uint8_t txPin, uint8_t pttPin, bool pttInverted)
:
_speed(speed),
_rxPin(rxPin),
_txPin(txPin),
_pttPin(pttPin),
_pttInverted(pttInverted),
_rxInverted(false)
{
// Initialise the first 8 nibbles of the tx buffer to be the standard
// preamble. We will append messages after that. 0x38, 0x2c is the start symbol before
// 6-bit conversion to RH_ASK_START_SYMBOL
uint8_t preamble[RH_ASK_PREAMBLE_LEN] = {0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x38, 0x2c};
memcpy(_txBuf, preamble, sizeof(preamble));
}
bool RH_ASK::init()
{
if (!RHGenericDriver::init())
return false;
thisASKDriver = this;
#if (RH_PLATFORM == RH_PLATFORM_GENERIC_AVR8)
#ifdef RH_ASK_PTT_PIN
RH_ASK_PTT_DDR |= (1<<RH_ASK_PTT_PIN);
RH_ASK_TX_DDR |= (1<<RH_ASK_TX_PIN);
RH_ASK_RX_DDR &= ~(1<<RH_ASK_RX_PIN);
#else
RH_ASK_TX_DDR |= (1<<RH_ASK_TX_PIN);
RH_ASK_RX_DDR &= ~(1<<RH_ASK_RX_PIN);
#endif
#else
// Set up digital IO pins for arduino
pinMode(_txPin, OUTPUT);
pinMode(_rxPin, INPUT);
pinMode(_pttPin, OUTPUT);
#endif
// Ready to go
setModeIdle();
timerSetup();
return true;
}
// Put these prescaler structs in PROGMEM, not on the stack
#if (RH_PLATFORM == RH_PLATFORM_ARDUINO) || (RH_PLATFORM == RH_PLATFORM_GENERIC_AVR8)
#if defined(RH_ASK_ARDUINO_USE_TIMER2)
// Timer 2 has different prescalers
PROGMEM static const uint16_t prescalers[] = {0, 1, 8, 32, 64, 128, 256, 3333};
#else
PROGMEM static const uint16_t prescalers[] = {0, 1, 8, 64, 256, 1024, 3333};
#endif
#define NUM_PRESCALERS (sizeof(prescalers) / sizeof( uint16_t))
#endif
// Common function for setting timer ticks @ prescaler values for speed
// Returns prescaler index into {0, 1, 8, 64, 256, 1024} array
// and sets nticks to compare-match value if lower than max_ticks
// returns 0 & nticks = 0 on fault
uint8_t RH_ASK::timerCalc(uint16_t speed, uint16_t max_ticks, uint16_t *nticks)
{
#if (RH_PLATFORM == RH_PLATFORM_ARDUINO) || (RH_PLATFORM == RH_PLATFORM_GENERIC_AVR8)
// Clock divider (prescaler) values - 0/3333: error flag
uint8_t prescaler; // index into array & return bit value
unsigned long ulticks; // calculate by ntick overflow
// Div-by-zero protection
if (speed == 0)
{
// signal fault
*nticks = 0;
return 0;
}
// test increasing prescaler (divisor), decreasing ulticks until no overflow
// 1/Fraction of second needed to xmit one bit
unsigned long inv_bit_time = ((unsigned long)speed) * 8;
for (prescaler=1; prescaler < NUM_PRESCALERS; prescaler += 1)
{
// Integer arithmetic courtesy Jim Remington
// 1/Amount of time per CPU clock tick (in seconds)
uint16_t prescalerValue;
memcpy_P(&prescalerValue, &prescalers[prescaler], sizeof(uint16_t));
unsigned long inv_clock_time = F_CPU / ((unsigned long)prescalerValue);
// number of prescaled ticks needed to handle bit time @ speed
ulticks = inv_clock_time / inv_bit_time;
// Test if ulticks fits in nticks bitwidth (with 1-tick safety margin)
if ((ulticks > 1) && (ulticks < max_ticks))
break; // found prescaler
// Won't fit, check with next prescaler value
}
// Check for error
if ((prescaler == 6) || (ulticks < 2) || (ulticks > max_ticks))
{
// signal fault
*nticks = 0;
return 0;
}
*nticks = ulticks;
return prescaler;
#else
return 0; // not implemented or needed on other platforms
#endif
}
// The idea here is to get 8 timer interrupts per bit period
void RH_ASK::timerSetup()
{
#if (RH_PLATFORM == RH_PLATFORM_GENERIC_AVR8)
uint16_t nticks;
uint8_t prescaler = timerCalc(_speed, (uint16_t)-1, &nticks);
if (!prescaler) return;
_COMB(TCCR,RH_ASK_TIMER_INDEX,A)= 0;
_COMB(TCCR,RH_ASK_TIMER_INDEX,B)= _BV(WGM12);
_COMB(TCCR,RH_ASK_TIMER_INDEX,B)|= prescaler;
_COMB(OCR,RH_ASK_TIMER_INDEX,A)= nticks;
_COMB(TI,MSK,RH_ASK_TIMER_INDEX)|= _BV(_COMB(OCIE,RH_ASK_TIMER_INDEX,A));
#elif (RH_PLATFORM == RH_PLATFORM_MSP430) // LaunchPad specific
// Calculate the counter overflow count based on the required bit speed
// and CPU clock rate
uint16_t ocr1a = (F_CPU / 8UL) / _speed;
// This code is for Energia/MSP430
TA0CCR0 = ocr1a; // Ticks for 62,5 us
TA0CTL = TASSEL_2 + MC_1; // SMCLK, up mode
TA0CCTL0 |= CCIE; // CCR0 interrupt enabled
#elif (RH_PLATFORM == RH_PLATFORM_ARDUINO) // Arduino specific
uint16_t nticks; // number of prescaled ticks needed
uint8_t prescaler; // Bit values for CS0[2:0]
#ifdef RH_PLATFORM_ATTINY
// figure out prescaler value and counter match value
// REVISIT: does not correctly handle 1MHz clock speeds, only works with 8MHz clocks
// At 1MHz clock, get 1/8 of the expected baud rate
prescaler = timerCalc(_speed, (uint8_t)-1, &nticks);
if (!prescaler)
return; // fault
TCCR0A = 0;
TCCR0A = _BV(WGM01); // Turn on CTC mode / Output Compare pins disconnected
// convert prescaler index to TCCRnB prescaler bits CS00, CS01, CS02
TCCR0B = 0;
TCCR0B = prescaler; // set CS00, CS01, CS02 (other bits not needed)
// Number of ticks to count before firing interrupt
OCR0A = uint8_t(nticks);
// Set mask to fire interrupt when OCF0A bit is set in TIFR0
#ifdef TIMSK0
// ATtiny84
TIMSK0 |= _BV(OCIE0A);
#else
// ATtiny85
TIMSK |= _BV(OCIE0A);
#endif
#elif defined(__arm__) && defined(CORE_TEENSY)
// on Teensy 3.0 (32 bit ARM), use an interval timer
IntervalTimer *t = new IntervalTimer();
void TIMER1_COMPA_vect(void);
t->begin(TIMER1_COMPA_vect, 125000 / _speed);
#elif defined (__arm__) && defined(ARDUINO_ARCH_SAMD)
// Arduino Zero
#define RH_ASK_ZERO_TIMER TC3
// Clock speed is 48MHz, prescaler of 64 gives a good range of available speeds vs precision
#define RH_ASK_ZERO_PRESCALER 64
#define RH_ASK_ZERO_TIMER_IRQ TC3_IRQn
// Enable clock for TC
REG_GCLK_CLKCTRL = (uint16_t) (GCLK_CLKCTRL_CLKEN | GCLK_CLKCTRL_GEN_GCLK0 | GCLK_CLKCTRL_ID(GCM_TCC2_TC3)) ;
while ( GCLK->STATUS.bit.SYNCBUSY == 1 ); // wait for sync
// The type cast must fit with the selected timer mode
TcCount16* TC = (TcCount16*)RH_ASK_ZERO_TIMER; // get timer struct
TC->CTRLA.reg &= ~TC_CTRLA_ENABLE; // Disable TC
while (TC->STATUS.bit.SYNCBUSY == 1); // wait for sync
TC->CTRLA.reg |= TC_CTRLA_MODE_COUNT16; // Set Timer counter Mode to 16 bits
while (TC->STATUS.bit.SYNCBUSY == 1); // wait for sync
TC->CTRLA.reg |= TC_CTRLA_WAVEGEN_MFRQ; // Set TC as Match Frequency
while (TC->STATUS.bit.SYNCBUSY == 1); // wait for sync
// Compute the count required to achieve the requested baud (with 8 interrupts per bit)
uint32_t rc = (VARIANT_MCK / _speed) / RH_ASK_ZERO_PRESCALER / 8;
TC->CTRLA.reg |= TC_CTRLA_PRESCALER_DIV64; // Set prescaler to agree with RH_ASK_ZERO_PRESCALER
while (TC->STATUS.bit.SYNCBUSY == 1); // wait for sync
TC->CC[0].reg = rc; // FIXME
while (TC->STATUS.bit.SYNCBUSY == 1); // wait for sync
// Interrupts
TC->INTENSET.reg = 0; // disable all interrupts
TC->INTENSET.bit.MC0 = 1; // enable compare match to CC0
// Enable InterruptVector
NVIC_ClearPendingIRQ(RH_ASK_ZERO_TIMER_IRQ);
NVIC_EnableIRQ(RH_ASK_ZERO_TIMER_IRQ);
// Enable TC
TC->CTRLA.reg |= TC_CTRLA_ENABLE;
while (TC->STATUS.bit.SYNCBUSY == 1); // wait for sync
#elif defined(__arm__) && defined(ARDUINO_SAM_DUE)
// Arduino Due
// Clock speed is 84MHz
// Due has 9 timers in 3 blocks of 3.
// We use timer 1 TC1_IRQn on TC0 channel 1, since timers 0, 2, 3, 4, 5 are used by the Servo library
#define RH_ASK_DUE_TIMER TC0
#define RH_ASK_DUE_TIMER_CHANNEL 1
#define RH_ASK_DUE_TIMER_IRQ TC1_IRQn
pmc_set_writeprotect(false);
pmc_enable_periph_clk(RH_ASK_DUE_TIMER_IRQ);
// Clock speed 4 can handle all reasonable _speeds we might ask for. Its divisor is 128
// and we want 8 interrupts per bit
uint32_t rc = (VARIANT_MCK / _speed) / 128 / 8;
TC_Configure(RH_ASK_DUE_TIMER, RH_ASK_DUE_TIMER_CHANNEL,
TC_CMR_WAVE | TC_CMR_WAVSEL_UP_RC | TC_CMR_TCCLKS_TIMER_CLOCK4);
TC_SetRC(RH_ASK_DUE_TIMER, RH_ASK_DUE_TIMER_CHANNEL, rc);
// Enable the RC Compare Interrupt
RH_ASK_DUE_TIMER->TC_CHANNEL[RH_ASK_DUE_TIMER_CHANNEL].TC_IER = TC_IER_CPCS;
NVIC_ClearPendingIRQ(RH_ASK_DUE_TIMER_IRQ);
NVIC_EnableIRQ(RH_ASK_DUE_TIMER_IRQ);
TC_Start(RH_ASK_DUE_TIMER, RH_ASK_DUE_TIMER_CHANNEL);
#else
// This is the path for most Arduinos
// figure out prescaler value and counter match value
#if defined(RH_ASK_ARDUINO_USE_TIMER2)
prescaler = timerCalc(_speed, (uint8_t)-1, &nticks);
if (!prescaler)
return; // fault
// Use timer 2
TCCR2A = _BV(WGM21); // Turn on CTC mode)
// convert prescaler index to TCCRnB prescaler bits CS10, CS11, CS12
TCCR2B = prescaler;
// Caution: special procedures for setting 16 bit regs
// is handled by the compiler
OCR2A = nticks;
// Enable interrupt
#ifdef TIMSK2
// atmega168
TIMSK2 |= _BV(OCIE2A);
#else
// others
TIMSK |= _BV(OCIE2A);
#endif // TIMSK2
#else
// Use timer 1
prescaler = timerCalc(_speed, (uint16_t)-1, &nticks);
if (!prescaler)
return; // fault
TCCR1A = 0; // Output Compare pins disconnected
TCCR1B = _BV(WGM12); // Turn on CTC mode
// convert prescaler index to TCCRnB prescaler bits CS10, CS11, CS12
TCCR1B |= prescaler;
// Caution: special procedures for setting 16 bit regs
// is handled by the compiler
OCR1A = nticks;
// Enable interrupt
#ifdef TIMSK1
// atmega168
TIMSK1 |= _BV(OCIE1A);
#else
// others
TIMSK |= _BV(OCIE1A);
#endif // TIMSK1
#endif
#endif
#elif (RH_PLATFORM == RH_PLATFORM_STM32) // Maple etc
// Pause the timer while we're configuring it
timer.pause();
timer.setPeriod((1000000/8)/_speed);
// Set up an interrupt on channel 1
timer.setChannel1Mode(TIMER_OUTPUT_COMPARE);
timer.setCompare(TIMER_CH1, 1); // Interrupt 1 count after each update
void interrupt(); // defined below
timer.attachCompare1Interrupt(interrupt);
// Refresh the timer's count, prescale, and overflow
timer.refresh();
// Start the timer counting
timer.resume();
#elif (RH_PLATFORM == RH_PLATFORM_STM32F2) // Photon
// Inspired by SparkIntervalTimer
// We use Timer 6
void TimerInterruptHandler(); // Forward declaration for interrupt handler
#define SYSCORECLOCK 60000000UL // Timer clock tree uses core clock / 2
TIM_TimeBaseInitTypeDef timerInitStructure;
NVIC_InitTypeDef nvicStructure;
TIM_TypeDef* TIMx;
uint32_t period = (1000000 / 8) / _speed; // In microseconds
uint16_t prescaler = (uint16_t)(SYSCORECLOCK / 1000000UL) - 1; //To get TIM counter clock = 1MHz
attachSystemInterrupt(SysInterrupt_TIM6_Update, TimerInterruptHandler);
RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM6, ENABLE);
nvicStructure.NVIC_IRQChannel = TIM6_DAC_IRQn;
TIMx = TIM6;
nvicStructure.NVIC_IRQChannelPreemptionPriority = 10;
nvicStructure.NVIC_IRQChannelSubPriority = 1;
nvicStructure.NVIC_IRQChannelCmd = ENABLE;
NVIC_Init(&nvicStructure);
timerInitStructure.TIM_Prescaler = prescaler;
timerInitStructure.TIM_CounterMode = TIM_CounterMode_Up;
timerInitStructure.TIM_Period = period;
timerInitStructure.TIM_ClockDivision = TIM_CKD_DIV1;
timerInitStructure.TIM_RepetitionCounter = 0;
TIM_TimeBaseInit(TIMx, &timerInitStructure);
TIM_ITConfig(TIMx, TIM_IT_Update, ENABLE);
TIM_Cmd(TIMx, ENABLE);
#elif (RH_PLATFORM == RH_PLATFORM_CHIPKIT_CORE)
// UsingChipKIT Core on Arduino IDE
uint32_t chipkit_timer_interrupt_handler(uint32_t currentTime); // Forward declaration
attachCoreTimerService(chipkit_timer_interrupt_handler);
#elif (RH_PLATFORM == RH_PLATFORM_UNO32)
// Under old MPIDE, which has been discontinued:
// ON Uno32 we use timer1
OpenTimer1(T1_ON | T1_PS_1_1 | T1_SOURCE_INT, (F_CPU / 8) / _speed);
ConfigIntTimer1(T1_INT_ON | T1_INT_PRIOR_1);
#elif (RH_PLATFORM == RH_PLATFORM_ESP8266)
void INTERRUPT_ATTR esp8266_timer_interrupt_handler(); // Forward declarat
// The - 120 is a heuristic to correct for interrupt handling overheads
_timerIncrement = (clockCyclesPerMicrosecond() * 1000000 / 8 / _speed) - 120;
timer0_isr_init();
timer0_attachInterrupt(esp8266_timer_interrupt_handler);
timer0_write(ESP.getCycleCount() + _timerIncrement);
// timer0_write(ESP.getCycleCount() + 41660000);
#endif
}
void INTERRUPT_ATTR RH_ASK::setModeIdle()
{
if (_mode != RHModeIdle)
{
// Disable the transmitter hardware
writePtt(LOW);
writeTx(LOW);
_mode = RHModeIdle;
}
}
void RH_ASK::setModeRx()
{
if (_mode != RHModeRx)
{
// Disable the transmitter hardware
writePtt(LOW);
writeTx(LOW);
_mode = RHModeRx;
}
}
void RH_ASK::setModeTx()
{
if (_mode != RHModeTx)
{
// PRepare state varibles for a new transmission
_txIndex = 0;
_txBit = 0;
_txSample = 0;
// Enable the transmitter hardware
writePtt(HIGH);
_mode = RHModeTx;
}
}
// Call this often
bool RH_ASK::available()
{
if (_mode == RHModeTx)
return false;
setModeRx();
if (_rxBufFull)
{
validateRxBuf();
_rxBufFull= false;
}
return _rxBufValid;
}
bool RH_ASK::recv(uint8_t* buf, uint8_t* len)
{
if (!available())
return false;
if (buf && len)
{
// Skip the length and 4 headers that are at the beginning of the rxBuf
// and drop the trailing 2 bytes of FCS
uint8_t message_len = _rxBufLen-RH_ASK_HEADER_LEN - 3;
if (*len > message_len)
*len = message_len;
memcpy(buf, _rxBuf+RH_ASK_HEADER_LEN+1, *len);
}
_rxBufValid = false; // Got the most recent message, delete it
// printBuffer("recv:", buf, *len);
return true;
}
// Caution: this may block
bool RH_ASK::send(const uint8_t* data, uint8_t len)
{
uint8_t i;
uint16_t index = 0;
uint16_t crc = 0xffff;
uint8_t *p = _txBuf + RH_ASK_PREAMBLE_LEN; // start of the message area
uint8_t count = len + 3 + RH_ASK_HEADER_LEN; // Added byte count and FCS and headers to get total number of bytes
if (len > RH_ASK_MAX_MESSAGE_LEN)
return false;
// Wait for transmitter to become available
waitPacketSent();
if (!waitCAD())
return false; // Check channel activity
// Encode the message length
crc = RHcrc_ccitt_update(crc, count);
p[index++] = symbols[count >> 4];
p[index++] = symbols[count & 0xf];
// Encode the headers
crc = RHcrc_ccitt_update(crc, _txHeaderTo);
p[index++] = symbols[_txHeaderTo >> 4];
p[index++] = symbols[_txHeaderTo & 0xf];
crc = RHcrc_ccitt_update(crc, _txHeaderFrom);
p[index++] = symbols[_txHeaderFrom >> 4];
p[index++] = symbols[_txHeaderFrom & 0xf];
crc = RHcrc_ccitt_update(crc, _txHeaderId);
p[index++] = symbols[_txHeaderId >> 4];
p[index++] = symbols[_txHeaderId & 0xf];
crc = RHcrc_ccitt_update(crc, _txHeaderFlags);
p[index++] = symbols[_txHeaderFlags >> 4];
p[index++] = symbols[_txHeaderFlags & 0xf];
// Encode the message into 6 bit symbols. Each byte is converted into
// 2 6-bit symbols, high nybble first, low nybble second
for (i = 0; i < len; i++)
{
crc = RHcrc_ccitt_update(crc, data[i]);
p[index++] = symbols[data[i] >> 4];
p[index++] = symbols[data[i] & 0xf];
}
// Append the fcs, 16 bits before encoding (4 6-bit symbols after encoding)
// Caution: VW expects the _ones_complement_ of the CCITT CRC-16 as the FCS
// VW sends FCS as low byte then hi byte
crc = ~crc;
p[index++] = symbols[(crc >> 4) & 0xf];
p[index++] = symbols[crc & 0xf];
p[index++] = symbols[(crc >> 12) & 0xf];
p[index++] = symbols[(crc >> 8) & 0xf];
// Total number of 6-bit symbols to send
_txBufLen = index + RH_ASK_PREAMBLE_LEN;
// Start the low level interrupt handler sending symbols
setModeTx();
return true;
}
// Read the RX data input pin, taking into account platform type and inversion.
bool INTERRUPT_ATTR RH_ASK::readRx()
{
bool value;
#if (RH_PLATFORM == RH_PLATFORM_GENERIC_AVR8)
value = ((RH_ASK_RX_PORT & (1<<RH_ASK_RX_PIN)) ? 1 : 0);
#else
value = digitalRead(_rxPin);
#endif
return value ^ _rxInverted;
}
// Write the TX output pin, taking into account platform type.
void INTERRUPT_ATTR RH_ASK::writeTx(bool value)
{
#if (RH_PLATFORM == RH_PLATFORM_GENERIC_AVR8)
((value) ? (RH_ASK_TX_PORT |= (1<<RH_ASK_TX_PIN)) : (RH_ASK_TX_PORT &= ~(1<<RH_ASK_TX_PIN)));
#else
digitalWrite(_txPin, value);
#endif
}
// Write the PTT output pin, taking into account platform type and inversion.
void INTERRUPT_ATTR RH_ASK::writePtt(bool value)
{
#if (RH_PLATFORM == RH_PLATFORM_GENERIC_AVR8)
#if RH_ASK_PTT_PIN
((value) ? (RH_ASK_PTT_PORT |= (1<<RH_ASK_PTT_PIN)) : (RH_ASK_PTT_PORT &= ~(1<<RH_ASK_PTT_PIN)));
#else
((value) ? (RH_ASK_TX_PORT |= (1<<RH_ASK_TX_PIN)) : (RH_ASK_TX_PORT &= ~(1<<RH_ASK_TX_PIN)));
#endif
#else
digitalWrite(_pttPin, value ^ _pttInverted);
#endif
}
uint8_t RH_ASK::maxMessageLength()
{
return RH_ASK_MAX_MESSAGE_LEN;
}
#if (RH_PLATFORM == RH_PLATFORM_ARDUINO)
#if defined(RH_PLATFORM_ATTINY)
#define RH_ASK_TIMER_VECTOR TIM0_COMPA_vect
#else // Assume Arduino Uno (328p or similar)
#if defined(RH_ASK_ARDUINO_USE_TIMER2)
#define RH_ASK_TIMER_VECTOR TIMER2_COMPA_vect
#else
#define RH_ASK_TIMER_VECTOR TIMER1_COMPA_vect
#endif
#endif
#elif (RH_ASK_PLATFORM == RH_ASK_PLATFORM_GENERIC_AVR8)
#define __COMB(a,b,c) (a##b##c)
#define _COMB(a,b,c) __COMB(a,b,c)
#define RH_ASK_TIMER_VECTOR _COMB(TIMER,RH_ASK_TIMER_INDEX,_COMPA_vect)
#endif
#if (RH_PLATFORM == RH_PLATFORM_ARDUINO) && defined(__arm__) && defined(CORE_TEENSY)
void TIMER1_COMPA_vect(void)
{
thisASKDriver->handleTimerInterrupt();
}
#elif (RH_PLATFORM == RH_PLATFORM_ARDUINO) && defined (__arm__) && defined(ARDUINO_ARCH_SAMD)
// Arduino Zero
void TC3_Handler()
{
// The type cast must fit with the selected timer mode
TcCount16* TC = (TcCount16*)RH_ASK_ZERO_TIMER; // get timer struct
TC->INTFLAG.bit.MC0 = 1;
thisASKDriver->handleTimerInterrupt();
}
#elif (RH_PLATFORM == RH_PLATFORM_ARDUINO) && defined(__arm__) && defined(ARDUINO_SAM_DUE)
// Arduino Due
void TC1_Handler()
{
TC_GetStatus(RH_ASK_DUE_TIMER, 1);
thisASKDriver->handleTimerInterrupt();
}
#elif (RH_PLATFORM == RH_PLATFORM_ARDUINO) || (RH_PLATFORM == RH_PLATFORM_GENERIC_AVR8)
// This is the interrupt service routine called when timer1 overflows
// Its job is to output the next bit from the transmitter (every 8 calls)
// and to call the PLL code if the receiver is enabled
//ISR(SIG_OUTPUT_COMPARE1A)
ISR(RH_ASK_TIMER_VECTOR)
{
thisASKDriver->handleTimerInterrupt();
}
#elif (RH_PLATFORM == RH_PLATFORM_MSP430) || (RH_PLATFORM == RH_PLATFORM_STM32)
// LaunchPad, Maple
void interrupt()
{
thisASKDriver->handleTimerInterrupt();
}
#elif (RH_PLATFORM == RH_PLATFORM_STM32F2) // Photon
void TimerInterruptHandler()
{
thisASKDriver->handleTimerInterrupt();
}
#elif (RH_PLATFORM == RH_PLATFORM_MSP430)
interrupt(TIMER0_A0_VECTOR) Timer_A_int(void)
{
thisASKDriver->handleTimerInterrupt();
};
#elif (RH_PLATFORM == RH_PLATFORM_CHIPKIT_CORE)
// Using ChipKIT Core on Arduino IDE
uint32_t chipkit_timer_interrupt_handler(uint32_t currentTime)
{
thisASKDriver->handleTimerInterrupt();
return (currentTime + ((CORE_TICK_RATE * 1000)/8)/thisASKDriver->speed());
}
#elif (RH_PLATFORM == RH_PLATFORM_UNO32)
// Under old MPIDE, which has been discontinued:
extern "C"
{
void __ISR(_TIMER_1_VECTOR, ipl1) timerInterrupt(void)
{
thisASKDriver->handleTimerInterrupt();
mT1ClearIntFlag(); // Clear timer 1 interrupt flag
}
}
#elif (RH_PLATFORM == RH_PLATFORM_ESP8266)
void INTERRUPT_ATTR esp8266_timer_interrupt_handler()
{
// timer0_write(ESP.getCycleCount() + 41660000);
// timer0_write(ESP.getCycleCount() + (clockCyclesPerMicrosecond() * 100) - 120 );
timer0_write(ESP.getCycleCount() + thisASKDriver->_timerIncrement);
// static int toggle = 0;
// toggle = (toggle == 1) ? 0 : 1;
// digitalWrite(4, toggle);
thisASKDriver->handleTimerInterrupt();
}
#endif
// Convert a 6 bit encoded symbol into its 4 bit decoded equivalent
uint8_t INTERRUPT_ATTR RH_ASK::symbol_6to4(uint8_t symbol)
{
uint8_t i;
uint8_t count;
// Linear search :-( Could have a 64 byte reverse lookup table?
// There is a little speedup here courtesy Ralph Doncaster:
// The shortcut works because bit 5 of the symbol is 1 for the last 8
// symbols, and it is 0 for the first 8.
// So we only have to search half the table
for (i = (symbol>>2) & 8, count=8; count-- ; i++)
if (symbol == symbols[i]) return i;
return 0; // Not found
}
// Check whether the latest received message is complete and uncorrupted
// We should always check the FCS at user level, not interrupt level
// since it is slow
void RH_ASK::validateRxBuf()
{
uint16_t crc = 0xffff;
// The CRC covers the byte count, headers and user data
for (uint8_t i = 0; i < _rxBufLen; i++)
crc = RHcrc_ccitt_update(crc, _rxBuf[i]);
if (crc != 0xf0b8) // CRC when buffer and expected CRC are CRC'd
{
// Reject and drop the message
_rxBad++;
_rxBufValid = false;
return;
}
// Extract the 4 headers that follow the message length
_rxHeaderTo = _rxBuf[1];
_rxHeaderFrom = _rxBuf[2];
_rxHeaderId = _rxBuf[3];
_rxHeaderFlags = _rxBuf[4];
if (_promiscuous ||
_rxHeaderTo == _thisAddress ||
_rxHeaderTo == RH_BROADCAST_ADDRESS)
{
_rxGood++;
_rxBufValid = true;
}
}
void INTERRUPT_ATTR RH_ASK::receiveTimer()
{
bool rxSample = readRx();
// Integrate each sample
if (rxSample)
_rxIntegrator++;
if (rxSample != _rxLastSample)
{
// Transition, advance if ramp > 80, retard if < 80
_rxPllRamp += ((_rxPllRamp < RH_ASK_RAMP_TRANSITION)
? RH_ASK_RAMP_INC_RETARD
: RH_ASK_RAMP_INC_ADVANCE);
_rxLastSample = rxSample;
}
else
{
// No transition
// Advance ramp by standard 20 (== 160/8 samples)
_rxPllRamp += RH_ASK_RAMP_INC;
}
if (_rxPllRamp >= RH_ASK_RX_RAMP_LEN)
{
// Add this to the 12th bit of _rxBits, LSB first
// The last 12 bits are kept
_rxBits >>= 1;
// Check the integrator to see how many samples in this cycle were high.
// If < 5 out of 8, then its declared a 0 bit, else a 1;
if (_rxIntegrator >= 5)
_rxBits |= 0x800;
_rxPllRamp -= RH_ASK_RX_RAMP_LEN;
_rxIntegrator = 0; // Clear the integral for the next cycle
if (_rxActive)
{
// We have the start symbol and now we are collecting message bits,
// 6 per symbol, each which has to be decoded to 4 bits
if (++_rxBitCount >= 12)
{
// Have 12 bits of encoded message == 1 byte encoded
// Decode as 2 lots of 6 bits into 2 lots of 4 bits
// The 6 lsbits are the high nybble
uint8_t this_byte =
(symbol_6to4(_rxBits & 0x3f)) << 4
| symbol_6to4(_rxBits >> 6);
// The first decoded byte is the byte count of the following message
// the count includes the byte count and the 2 trailing FCS bytes
// REVISIT: may also include the ACK flag at 0x40
if (_rxBufLen == 0)
{
// The first byte is the byte count
// Check it for sensibility. It cant be less than 7, since it
// includes the byte count itself, the 4 byte header and the 2 byte FCS
_rxCount = this_byte;
if (_rxCount < 7 || _rxCount > RH_ASK_MAX_PAYLOAD_LEN)
{
// Stupid message length, drop the whole thing
_rxActive = false;
_rxBad++;
return;
}
}
_rxBuf[_rxBufLen++] = this_byte;
if (_rxBufLen >= _rxCount)
{
// Got all the bytes now
_rxActive = false;
_rxBufFull = true;
setModeIdle();
}
_rxBitCount = 0;
}
}
// Not in a message, see if we have a start symbol
else if (_rxBits == RH_ASK_START_SYMBOL)
{
// Have start symbol, start collecting message
_rxActive = true;
_rxBitCount = 0;
_rxBufLen = 0;
}
}
}
void INTERRUPT_ATTR RH_ASK::transmitTimer()
{
if (_txSample++ == 0)
{
// Send next bit
// Symbols are sent LSB first
// Finished sending the whole message? (after waiting one bit period
// since the last bit)
if (_txIndex >= _txBufLen)
{
setModeIdle();
_txGood++;
}
else
{
writeTx(_txBuf[_txIndex] & (1 << _txBit++));
if (_txBit >= 6)
{
_txBit = 0;
_txIndex++;
}
}
}
if (_txSample > 7)
_txSample = 0;
}
void INTERRUPT_ATTR RH_ASK::handleTimerInterrupt()
{
if (_mode == RHModeRx)
receiveTimer(); // Receiving
else if (_mode == RHModeTx)
transmitTimer(); // Transmitting
}
|
[
"stuart@theschaefers.com"
] |
stuart@theschaefers.com
|
87d4b312deafbf00cd73db33e58194b8a72eb4a5
|
3c1265597bf2832df5f929bb24a26d43ac486256
|
/Dynamic Programming - 1/minSquareNumbers.cpp
|
cf7e6030562000e4f11b1366e12448c969d88b5e
|
[] |
no_license
|
JoKeR-VIKING/Competitive-Programming
|
7da21894e38f15cb436d3885ce367e535e10e2e3
|
7ea66d92e195058bddcfbc75c5f25ccd6343315f
|
refs/heads/main
| 2023-08-27T14:57:51.335670
| 2021-11-05T13:57:54
| 2021-11-05T13:57:54
| 401,932,829
| 1
| 1
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 510
|
cpp
|
#include<bits/stdc++.h>
using namespace std;
int main()
{
int t;
cin>>t;
while (t--)
{
int n;
cin>>n;
int* dp = new int[n+1];
dp[0] = 0;
dp[1] = 1;
for (int i=2;i<=n;i++)
{
dp[i] = i;
for (int j=2;j<=sqrt(i);j++)
{
dp[i] = min(dp[i], dp[i - j*j] + 1);
}
}
cout<<dp[n]<<"\n";
}
return 0;
}
|
[
"noreply@github.com"
] |
JoKeR-VIKING.noreply@github.com
|
a853417947889428477561fac0bb51c54a75555b
|
a50d5160992cd7245904805d11c12de244529d88
|
/OpenGLCanvasWindow.cpp
|
1bb7e0c05fc04a41747f5d061bdd5533ecc1bc18
|
[] |
no_license
|
rgsouza/triangleMesh
|
aa7a1b4502a0d08b4a68d0ba1823d001365e985f
|
7765d57629a1f25311aa41219c4043a269f78889
|
refs/heads/master
| 2021-01-21T09:59:56.324438
| 2017-02-28T00:12:36
| 2017-02-28T00:12:36
| 83,370,121
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 9,546
|
cpp
|
#include "OpenGLCanvasWindow.h"
#include<GL/gl.h>
#include<GL/glu.h>
#include"Vector.h"
#include<cmath>
#include<stdio.h>
#include"Vector.h"
using namespace std;
OpenGLCanvasWindow::OpenGLCanvasWindow( )
{
_object = 0;
_state=10;
createWindow( );
initCanvas( );
}
OpenGLCanvasWindow::~OpenGLCanvasWindow( )
{
IupDestroy( _dialog );
}
void OpenGLCanvasWindow::hide( )
{
IupHide( _dialog );
}
void OpenGLCanvasWindow::show( )
{
IupShow( _dialog );
}
void OpenGLCanvasWindow::initCanvas( )
{
GLfloat matSpecular[] = { 1.0 , 1.0 , 1.0 , 1.0 };
GLfloat matShininess[] = { 36.0 };
GLfloat lightPosition[] = { 1.0, 1.0, 1.0, 1.0 };
GLfloat whiteLight[] = { 1.0, 1.0, 1.0, 1.0 };
GLfloat lmodelAmbient[] = { 0.1, 0.1, 0.1, 1.0 };
GLfloat material[] = { 1.0, 0.0, 0.0, 1.0 };
glClearColor( 1.0, 1.0, 1.0, 1.0 );
glShadeModel( GL_SMOOTH );
glMaterialfv( GL_FRONT_AND_BACK, GL_SPECULAR, matSpecular );
glMaterialfv( GL_FRONT_AND_BACK, GL_SHININESS, matShininess );
glLightfv( GL_LIGHT0, GL_POSITION, lightPosition );
glLightfv( GL_LIGHT0, GL_DIFFUSE, whiteLight );
glLightfv( GL_LIGHT0, GL_SPECULAR, whiteLight );
glLightModelfv( GL_LIGHT_MODEL_AMBIENT, lmodelAmbient );
glLightModeli( GL_LIGHT_MODEL_TWO_SIDE, GL_TRUE );
glEnable( GL_COLOR_MATERIAL );
glMaterialfv( GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, material );
glEnable( GL_LIGHTING );
glEnable( GL_LIGHT0 );
glEnable( GL_DEPTH_TEST );
}
void OpenGLCanvasWindow::createWindow( )
{
Ihandle *button = IupButton( "Exit ", NULL );
Ihandle *button2 = IupButton( "Open", NULL );
Ihandle *canvas = IupGLCanvas( NULL );
Ihandle *porFace = IupToggle( "Por face", NULL );
Ihandle *ponderadaArea = IupToggle( "Por vertice ponderada por area.", NULL );
Ihandle *ponderadaAngulo = IupToggle( "Por vertice ponderada por angulo", NULL );
Ihandle *hboxButton = IupHbox( IupFill( ), button2, button, NULL );
Ihandle *togglesHbox = IupHbox( porFace, ponderadaArea, ponderadaAngulo, IupFill( ), NULL );
Ihandle *radioOptions = IupRadio( togglesHbox );
Ihandle *frameNormal = IupFrame( radioOptions );
Ihandle *hboxCanvas = IupHbox( canvas, NULL );
Ihandle *vbox = IupVbox( frameNormal, hboxCanvas, hboxButton, NULL );
_dialog = IupDialog( vbox );
IupSetAttribute( _dialog, "THIS", (char*) this );
IupSetAttribute( _dialog, "CANVAS", (char*) canvas );
IupSetAttribute( _dialog, IUP_TITLE, "TriangleMesh" );
IupSetAttribute( vbox, "MARGIN", "10X10" );
IupSetAttribute( vbox, "GAP", "10" );
IupSetAttribute( frameNormal, IUP_TITLE, "Zoom" );
IupSetAttribute( canvas, "RASTERSIZE", "600x600" );
IupSetAttribute( canvas, "BUFFER", "DOUBLE" );
IupSetCallback( button, IUP_ACTION, (Icallback) exitButton );
IupSetCallback( button2, IUP_ACTION, (Icallback) openCallback );
IupSetCallback( canvas, IUP_ACTION, (Icallback) actionCallback );
IupSetCallback( canvas, IUP_RESIZE_CB, (Icallback) resizeCanvasCallback );
IupSetCallback( porFace, IUP_ACTION, (Icallback) toogleCallbackI );
IupSetCallback( ponderadaArea, IUP_ACTION, (Icallback) toogleCallbackII );
IupSetCallback( ponderadaAngulo, IUP_ACTION, (Icallback) toogleCallbackIII );
IupMap( _dialog );
IupGLMakeCurrent( canvas );
}
int OpenGLCanvasWindow::exitButton( Ihandle* exi )
{
return IUP_CLOSE;
}
int OpenGLCanvasWindow::toogleCallbackI( Ihandle* ih, int state )
{
OpenGLCanvasWindow *window = (OpenGLCanvasWindow*) IupGetAttribute( ih, "THIS" );
if (state)
{
window->_state=10;
}
// Ihandle *canvas = (Ihandle*) IupGetAttribute( ih, "CANVAS" );
//IupUpdate( canvas );
return IUP_DEFAULT;
}
int OpenGLCanvasWindow::toogleCallbackII( Ihandle* ih, int state )
{
OpenGLCanvasWindow *window = (OpenGLCanvasWindow*) IupGetAttribute( ih, "THIS" );
if (state)
{
window->_state=20;
}
Ihandle *canvas = (Ihandle*) IupGetAttribute( ih, "CANVAS" );
IupUpdate( canvas );
return IUP_DEFAULT;
}
int OpenGLCanvasWindow::toogleCallbackIII( Ihandle* ih, int state )
{
OpenGLCanvasWindow *window = (OpenGLCanvasWindow*) IupGetAttribute( ih, "THIS" );
if (state )
{
window->_state=30;
}
Ihandle *canvas = (Ihandle*) IupGetAttribute( ih, "CANVAS" );
IupUpdate( canvas );
return IUP_DEFAULT;
}
int OpenGLCanvasWindow::openCallback( Ihandle* ih, int state )
{
IupGLMakeCurrent( ih );
OpenGLCanvasWindow *window = (OpenGLCanvasWindow*) IupGetAttribute( ih, "THIS" );
Ihandle *dlg = IupFileDlg( );
IupSetAttribute( dlg, "DIALOGTYPE", "OPEN" );
IupSetAttribute( dlg, "TITLE", "IupFileDlg OPEN " );
IupSetAttribute( dlg, "FILTER", "*.off" );
IupSetAttribute( dlg, "FILTERINFO", " OFF Files" );
IupPopup( dlg, IUP_CURRENT, IUP_CURRENT );
if( IupGetInt( dlg, "STATUS" ) != -1)
{
delete window->_object;
printf("%p\n", window->_object);
window->_object = new TriangleMesh( IupGetAttribute( dlg, "VALUE" ) );
window->_xMin = window->_object->getXmin( );
window->_xMax = window->_object->getXmax( );
window->_yMin = window->_object->getYmin( );
window->_yMax = window->_object->getYmax( );
window->_zMin = window->_object->getZmin( );
window->_zMax = window->_object->getZmax( );
printf(" %s ",IupGetAttribute( dlg, "VALUE" ));
}
Ihandle *canvas = (Ihandle*) IupGetAttribute( ih, "CANVAS" );
IupUpdate( canvas );
IupDestroy(dlg);
return IUP_DEFAULT;
}
void OpenGLCanvasWindow::drawFace( )
{
const Vector *vertice = _object->getVertice();
const Vector *normal = _object->getNormalFace();
glBegin( GL_TRIANGLES );
for (int i = 0; i < _object->getNumTriangle( ); i++)
{
const int *triangle = _object->getTriangles( i );
glNormal3f( -normal[i].getX( ), -normal[i].getY( ),-normal[i].getZ( ) );
for (int j = 0; j < 3; j++)
{
glVertex3f( vertice[triangle[j]].getX( ), vertice[triangle[j]].getY( ),
vertice[triangle[j]].getZ( ) );
}
}
glEnd( );
}
void OpenGLCanvasWindow::drawArea( )
{
const Vector *vertice = _object->getVertice();
const Vector *normal = _object->getNormalArea();
glBegin( GL_TRIANGLES );
for (int i = 0; i < _object->getNumTriangle(); i++)
{
const int *triangle = _object->getTriangles( i );
for (int j = 0; j < 3; j++)
{
glNormal3f( -normal[triangle[j]].getX( ), -normal[triangle[j]].getY( ),-normal[triangle[j]].getZ( ) );
glVertex3f( vertice[triangle[j]].getX( ), vertice[triangle[j]].getY( ),
vertice[triangle[j]].getZ( ) );
}
}
glEnd( );
}
void OpenGLCanvasWindow::drawAngle( )
{
const Vector *vertice = _object->getVertice();
const Vector *normal = _object->getNormalAngle();
glBegin( GL_TRIANGLES );
for (int i = 0; i < _object->getNumTriangle(); i++)
{
const int *triangle = _object->getTriangles( i );
for (int j = 0; j < 3; j++)
{
glNormal3f( -normal[triangle[j]].getX( ), -normal[triangle[j]].getY( ),-normal[triangle[j]].getZ( ) );
glVertex3f( vertice[triangle[j]].getX( ), vertice[triangle[j]].getY( ),
vertice[triangle[j]].getZ( ) );
}
}
glEnd( );
}
int OpenGLCanvasWindow::actionCallback( Ihandle* ih )
{
IupGLMakeCurrent( ih );
OpenGLCanvasWindow *window = (OpenGLCanvasWindow*) IupGetAttribute( ih, "THIS" );
GLfloat lightPosition[] = { 0.0, 0.0, 0.0, 1.0 };
glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
glEnable( GL_LIGHTING );
glColor3f( 1.0f, 0.0f, 0.0f );
glMatrixMode( GL_MODELVIEW );
glLoadIdentity( );
if (window->_object != 0)
{
double norma = 0.5*sqrt( pow( window->_xMin - window->_xMax, 2 ) + pow( window->_yMin - window->_yMax, 2 )
+ pow( window->_zMin - window->_zMax, 2 ) );
double x = window->_xMin + window->_xMax;
double y = window->_yMin + window->_yMax;
double z = window->_zMin + window->_zMax;
gluLookAt( x / 2 + norma, y / 2 , z / 2 + norma, x / 2, y / 2, z / 2, 0.0, 1.0, 0.0 );
if (window->_state == 10 )
window->drawFace();
else if (window->_state == 20 )
window->drawArea();
else if ( window->_state == 30 )
window->drawAngle();
glDisable( GL_LIGHTING );
}
IupGLSwapBuffers( ih );
return IUP_DEFAULT;
}
int OpenGLCanvasWindow::resizeCanvasCallback( Ihandle* ih, int w, int h )
{
IupGLMakeCurrent( ih );
OpenGLCanvasWindow *window = (OpenGLCanvasWindow*) IupGetAttribute( ih, "THIS" );
GLfloat light_position[] = { 0.0, 0.0, 0.0, 0.0 };
glViewport( 0, 0, (GLsizei) w, (GLsizei) h );
glMatrixMode( GL_PROJECTION );
glLoadIdentity( );
gluPerspective( 60.0, (GLfloat) w / (GLfloat) h, 0.1, 20000.0 );
glMatrixMode( GL_MODELVIEW );
glLoadIdentity( );
IupUpdate( ih );
return IUP_DEFAULT;
}
|
[
"gsouzarayanne@gmail.com"
] |
gsouzarayanne@gmail.com
|
e951d220c0ba67bda0d89d39841efbd41a53d7a9
|
a6b26bf776d81ef54b92a110bb09605b0aad0a40
|
/Hacker Rank Programs/HK-Strings.cpp
|
3f0c55c6f5912b3ac01c98da96f9e2c0a119478f
|
[] |
no_license
|
cameronww7/CPP_Mini_Programs
|
5eaca7b6fecb078aa1f8271890f2198c714dbccd
|
286df5f5d9379306c8dfed1cf5b3d2a8f885ab78
|
refs/heads/master
| 2021-01-23T08:44:06.483437
| 2017-10-17T20:45:56
| 2017-10-17T20:45:56
| 102,540,321
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 1,578
|
cpp
|
/**************************************************************************
* AUTHOR : Cameron W
* PROJECT : C++ Practice
* -----------------------------------------------------------------------
* Goal :
* You are given two strings, a and b, separated by a new line.
* Each string will consist of lower case Latin characters ('a'-'z').
*
* Output Format
*
* In the first line print two space-separated integers,
* representing the length of a and b respectively.
*
* In the second line print the string produced by concatenating
* a and b(a+b).
*
* In the third line print two strings separated by a space, a'
* and b'. a' and b' are the same as a' and b', respectively,
* except that their first characters are swapped.
*
* Sample Input
* abcd
* ef
*
* Sample Output
* 4 2
* abcdef
* ebcd af
*
*************************************************************************/
#include "../src/header.h"
std::string HK_Strings(std::string string1,
std::string string2) {
std::string returnString = "";
// std::cout << std::endl << string1.length() << " " << string2.length();
// std::cout << std::endl << string1 << string2;
// std::cout << std::endl << string2[0] << string1.substr(1,3) << " "
// << string1[0] << string2.substr(1,1);
returnString = std::to_string(string1.length()) + " " +
std::to_string(string2.length()) + "\n" +
string1 + string2 + "\n" +
string2[0] + string1.substr(1,3) + " " +
string1[0] + string2.substr(1,1);
return returnString;
}
|
[
"cameronww7@users.noreply.github.com"
] |
cameronww7@users.noreply.github.com
|
031b403d8880109340ba06524c11cc7236d5d383
|
8a4a0742a8d8fc96d4a13c24ec98293b83d55368
|
/leetcode.051-100/058.length-of-last-word/main.cpp
|
e50ac4b62843dbcb9b2c6deda77cb12b8cf76285
|
[
"MIT"
] |
permissive
|
cloudy064/leetcode
|
5cee7968a30706450772d2593de4adb0a36db259
|
b85ec4aed57542247ac4762883bd7fe80b3cfbab
|
refs/heads/master
| 2020-03-20T19:10:51.147123
| 2019-04-12T09:22:32
| 2019-04-12T09:22:32
| 137,625,270
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 992
|
cpp
|
//
// Created by cloudy064 on 2019/2/22.
//
#include "common.h"
using namespace std;
/// Solution for https://leetcode-cn.com/problems/length-of-last-word/
class Solution {
public:
int lengthOfLastWord(string s) {
int length = s.length();
if (length == 0) return 0;
int result = 0;
int i = length - 1;
while (i >= 0 && s[i--] == ' ');
++i;
while (i >= 0 && s[i--] != ' ') ++result;
return result;
}
};
class Test058Solution : public ::testing::Test {
public:
Solution sln;
};
TEST_F(Test058Solution, t1) {
EXPECT_EQ(sln.lengthOfLastWord(""), 0);
EXPECT_EQ(sln.lengthOfLastWord(" "), 0);
}
TEST_F(Test058Solution, t2) {
EXPECT_EQ(sln.lengthOfLastWord("abc"), 3);
EXPECT_EQ(sln.lengthOfLastWord(" abc"), 3);
EXPECT_EQ(sln.lengthOfLastWord("abc "), 3);
}
TEST_F(Test058Solution, t3) {
EXPECT_EQ(sln.lengthOfLastWord("hello world"), 5);
EXPECT_EQ(sln.lengthOfLastWord(" hello world"), 5);
EXPECT_EQ(sln.lengthOfLastWord("hello world "), 5);
}
GTEST_MAIN
|
[
"cloudy064@gmail.com"
] |
cloudy064@gmail.com
|
f314adec131e92d123cf9d6f53c906b692794901
|
00c60dbcc3737bb5b3b7387bcee5fc5fab18db29
|
/base.cpp
|
c2be7fcc07cff0990599cc0f5d50348458c68ac9
|
[] |
no_license
|
dinahas/HSE
|
f496834eb3954bfb558070f68368d0a5897215f0
|
6ca5fd7d4e1b5900d203132d68dc2fff215e7ee9
|
refs/heads/master
| 2021-09-01T10:39:11.276965
| 2017-12-26T14:40:33
| 2017-12-26T14:40:33
| 105,639,038
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 985
|
cpp
|
#include "base.h"
//Base::Base()
//{
//}
void Base::setName(const QString &name){
QRegExp regName("^\\S+$");
if (regName.exactMatch(name)){
this->name = name;
}
else{
//qDebug() << "Incorrect name";
this->name = "Unknown name";
}
//qDebug() << "Debug: setName is called";
}
void Base::setDescr(const QString &descr){
this->descr = descr;
//qDebug() << "Debug: setDescr is called";
}
void Base::setYear(const int &year){
if (year >= 1 && year <= 2017){
this->year = year;
}
else{
qDebug() << "Incorrect year";
this->year = 0;
}
//qDebug() << "Debug: setYear is called";
}
QString Base::getName() const{
//qDebug() << "Debug: getName is called";
return this->name;
}
QString Base::getDescr() const{
//qDebug() << "Debug: getDescr is called";
return this->descr;
}
int Base::getYear() const{
//qDebug() << "Debug: getYear is called";
return this->year;
}
|
[
"dinka020498@mail.ru"
] |
dinka020498@mail.ru
|
84b4e68555ac9f0e14b97b01516a28d12fbd26a3
|
8eac19f630410c368edfc7bc1caa6df1667459cc
|
/Client/QScintilla/qscintilla/Qsci/qscilexercss.h
|
350b1f99b92eae1980fe5c25effa8896ce65f6f8
|
[] |
no_license
|
Jonpoulet/CLL-Synergie
|
174fccda170b7865d581f40a469901537d424477
|
b55c87ebff6d2be09da737239d8248c54a75e6cf
|
refs/heads/master
| 2022-02-17T23:44:37.254437
| 2011-05-21T18:08:42
| 2011-05-21T18:08:42
| null | 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 7,186
|
h
|
// This defines the interface to the QsciLexerCSS class.
//
// Copyright (c) 2011 Riverbank Computing Limited <info@riverbankcomputing.com>
//
// This file is part of QScintilla.
//
// This file may be used under the terms of the GNU General Public
// License versions 2.0 or 3.0 as published by the Free Software
// Foundation and appearing in the files LICENSE.GPL2 and LICENSE.GPL3
// included in the packaging of this file. Alternatively you may (at
// your option) use any later version of the GNU General Public
// License if such license has been publicly approved by Riverbank
// Computing Limited (or its successors, if any) and the KDE Free Qt
// Foundation. In addition, as a special exception, Riverbank gives you
// certain additional rights. These rights are described in the Riverbank
// GPL Exception version 1.1, which can be found in the file
// GPL_EXCEPTION.txt in this package.
//
// Please review the following information to ensure GNU General
// Public Licensing requirements will be met:
// http://trolltech.com/products/qt/licenses/licensing/opensource/. If
// you are unsure which license is appropriate for your use, please
// review the following information:
// http://trolltech.com/products/qt/licenses/licensing/licensingoverview
// or contact the sales department at sales@riverbankcomputing.com.
//
// This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
// WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
#ifndef QSCILEXERCSS_H
#define QSCILEXERCSS_H
#ifdef __APPLE__
extern "C++" {
#endif
#include <qobject.h>
#include "qsciglobal.h"
#include "qscilexer.h"
//! \brief The QsciLexerCSS class encapsulates the Scintilla CSS lexer.
class QSCINTILLA_EXPORT QsciLexerCSS : public QsciLexer
{
Q_OBJECT
public:
//! This enum defines the meanings of the different styles used by the
//! CSS lexer.
enum {
//! The default.
Default = 0,
//! A tag.
Tag = 1,
//! A class selector.
ClassSelector = 2,
//! A pseudo class. The list of pseudo classes is defined by keyword
//! set 2.
PseudoClass = 3,
//! An unknown pseudo class.
UnknownPseudoClass = 4,
//! An operator.
Operator = 5,
//! A CSS1 property. The list of CSS1 properties is defined by keyword
//! set 1.
CSS1Property = 6,
//! An unknown property.
UnknownProperty = 7,
//! A value.
Value = 8,
//! A comment.
Comment = 9,
//! An ID selector.
IDSelector = 10,
//! An important value.
Important = 11,
//! An @-rule.
AtRule = 12,
//! A double-quoted string.
DoubleQuotedString = 13,
//! A single-quoted string.
SingleQuotedString = 14,
//! A CSS2 property. The list of CSS2 properties is defined by keyword
//! set 3.
CSS2Property = 15,
//! An attribute.
Attribute = 16,
//! A CSS3 property. The list of CSS3 properties is defined by keyword
//! set 4.
CSS3Property = 17,
//! A pseudo element. The list of pseudo elements is defined by
//! keyword set 5.
PseudoElement = 18,
//! An extended (browser specific) CSS property. The list of extended
//! CSS properties is defined by keyword set 6.
ExtendedCSSProperty = 19,
//! An extended (browser specific) pseudo class. The list of extended
//! pseudo classes is defined by keyword set 7.
ExtendedPseudoClass = 20,
//! An extended (browser specific) pseudo element. The list of
//! extended pseudo elements is defined by keyword set 8.
ExtendedPseudoElement = 21,
//! A media rule.
MediaRule = 22
};
//! Construct a QsciLexerCSS with parent \a parent. \a parent is typically
//! the QsciScintilla instance.
QsciLexerCSS(QObject *parent = 0);
//! Destroys the QsciLexerCSS instance.
virtual ~QsciLexerCSS();
//! Returns the name of the language.
const char *language() const;
//! Returns the name of the lexer. Some lexers support a number of
//! languages.
const char *lexer() const;
//! \internal Returns a space separated list of words or characters in
//! a particular style that define the end of a block for
//! auto-indentation. The styles is returned via \a style.
const char *blockEnd(int *style = 0) const;
//! \internal Returns a space separated list of words or characters in
//! a particular style that define the start of a block for
//! auto-indentation. The styles is returned via \a style.
const char *blockStart(int *style = 0) const;
//! \internal Returns the string of characters that comprise a word.
const char *wordCharacters() const;
//! Returns the foreground colour of the text for style number \a style.
QColor defaultColor(int style) const;
//! Returns the font for style number \a style.
QFont defaultFont(int style) const;
//! Returns the set of keywords for the keyword set \a set recognised
//! by the lexer as a space separated string.
const char *keywords(int set) const;
//! Returns the descriptive name for style number \a style. If the
//! style is invalid for this language then an empty QString is returned.
//! This is intended to be used in user preference dialogs.
QString description(int style) const;
//! Causes all properties to be refreshed by emitting the
//! propertyChanged() signal as required.
void refreshProperties();
//! Returns true if multi-line comment blocks can be folded.
//!
//! \sa setFoldComments()
bool foldComments() const;
//! Returns true if trailing blank lines are included in a fold block.
//!
//! \sa setFoldCompact()
bool foldCompact() const;
public slots:
//! If \a fold is true then multi-line comment blocks can be folded.
//! The default is false.
//!
//! \sa foldComments()
virtual void setFoldComments(bool fold);
//! If \a fold is true then trailing blank lines are included in a fold
//! block. The default is true.
//!
//! \sa foldCompact()
virtual void setFoldCompact(bool fold);
protected:
//! The lexer's properties are read from the settings \a qs. \a prefix
//! (which has a trailing '/') should be used as a prefix to the key of
//! each setting. true is returned if there is no error.
//!
bool readProperties(QSettings &qs,const QString &prefix);
//! The lexer's properties are written to the settings \a qs.
//! \a prefix (which has a trailing '/') should be used as a prefix to
//! the key of each setting. true is returned if there is no error.
//!
bool writeProperties(QSettings &qs,const QString &prefix) const;
private:
void setCommentProp();
void setCompactProp();
bool fold_comments;
bool fold_compact;
QsciLexerCSS(const QsciLexerCSS &);
QsciLexerCSS &operator=(const QsciLexerCSS &);
};
#ifdef __APPLE__
}
#endif
#endif
|
[
"pouliot.jonathan@gmail.com"
] |
pouliot.jonathan@gmail.com
|
4ce6e01bb74e504f3d1ee9884bb169d238bda82a
|
f3da935503141d081bc52253cbbc409cd8b59fd1
|
/Source/DDSTextureLoader.h
|
9ef3f2530756f1677bee655f75ab8eac688972a8
|
[] |
no_license
|
makasone/RayMarchingStudy
|
a11c4822081d547b448eb72af6c79b3c18f3dbbe
|
c8cbce1a0f150d268cc7c2f223d9348c9c23ab85
|
refs/heads/master
| 2020-04-27T21:12:49.457546
| 2019-09-01T09:24:25
| 2019-09-01T09:24:25
| 174,688,059
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 1,873
|
h
|
#pragma once
//--------------------------------------------------------------------------------------
// File: DDSTextureLoader.h
//
// Functions for loading a DDS texture and creating a Direct3D 11 runtime resource for it
//
// Note these functions are useful as a light-weight runtime loader for DDS files. For
// a full-featured DDS file reader, writer, and texture processing pipeline see
// the 'Texconv' sample and the 'DirectXTex' library.
//
// THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF
// ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO
// THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A
// PARTICULAR PURPOSE.
//
// Copyright (c) Microsoft Corporation. All rights reserved.
//
// http://go.microsoft.com/fwlink/?LinkId=248926
// http://go.microsoft.com/fwlink/?LinkId=248929
//--------------------------------------------------------------------------------------
#pragma once
#include <wrl.h>
#include <DXUtils/d3dx12.h>
#include <cstdint>
#if defined(_MSC_VER) && (_MSC_VER<1610) && !defined(_In_reads_)
#define _In_reads_(exp)
#define _Out_writes_(exp)
#define _In_reads_bytes_(exp)
#define _In_reads_opt_(exp)
#define _Outptr_opt_
#endif
#ifndef _Use_decl_annotations_
#define _Use_decl_annotations_
#endif
namespace DirectX {
enum class DDS_ALPHA_MODE : std::uint8_t {
DDS_ALPHA_MODE_UNKNOWN = 0,
DDS_ALPHA_MODE_STRAIGHT = 1,
DDS_ALPHA_MODE_PREMULTIPLIED = 2,
DDS_ALPHA_MODE_OPAQUE = 3,
DDS_ALPHA_MODE_CUSTOM = 4,
};
HRESULT CreateDDSTextureFromFile12(_In_ ID3D12Device* device,
_In_ ID3D12GraphicsCommandList* commandList,
_In_z_ const wchar_t* szFileName,
_Out_ Microsoft::WRL::ComPtr<ID3D12Resource>& texture,
_Out_ Microsoft::WRL::ComPtr<ID3D12Resource>& textureUploadHeap,
_In_ std::size_t maxsize = 0,
_Out_opt_ DDS_ALPHA_MODE* alphaMode = nullptr
) noexcept;
}
|
[
"makasone@gmail.com"
] |
makasone@gmail.com
|
a6eec78194c978291e8b235db06d78259525f348
|
352b4ded0fc31eb363165ab3ad15143a61f152ef
|
/KFPlugin/KFRecordClient/KFRecordClientPlugin.cpp
|
4e29c8ee8b6d8cede32bb1c06906809aff536254
|
[] |
no_license
|
lori227/Dark
|
c9c2409d0888916f4a52fb8d0e5081ecb56ff4ba
|
86ec8fff527f488f1be058e1e40350d5a0b11b41
|
refs/heads/master
| 2022-10-12T06:31:06.129090
| 2020-06-12T05:52:45
| 2020-06-12T05:52:45
| 181,450,024
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 1,010
|
cpp
|
#include "KFRecordClientPlugin.hpp"
#include "KFRecordClientModule.hpp"
#include "KFConfig/KFConfigInterface.h"
namespace KFrame
{
void KFRecordClientPlugin::Install()
{
__REGISTER_MODULE__( KFRecordClient );
}
void KFRecordClientPlugin::UnInstall()
{
__UN_MODULE__( KFRecordClient );
}
void KFRecordClientPlugin::LoadModule()
{
__FIND_MODULE__( _kf_reset, KFResetInterface );
__FIND_MODULE__( _kf_config, KFConfigInterface );
__FIND_MODULE__( _kf_notice, KFNoticeInterface );
__FIND_MODULE__( _kf_player, KFPlayerInterface );
__FIND_MODULE__( _kf_kernel, KFKernelInterface );
__FIND_MODULE__( _kf_display, KFDisplayInterface );
__FIND_MODULE__( _kf_message, KFMessageInterface );
__FIND_MODULE__( _kf_route, KFRouteClientInterface );
}
void KFRecordClientPlugin::AddConfig()
{
__KF_ADD_CONFIG__( KFRecordConfig );
__KF_ADD_CONFIG__( KFProfessionConfig );
}
}
|
[
"lori227@qq.com"
] |
lori227@qq.com
|
a8f32a428f322cf97866214931345e8bdbe241f4
|
ded628ad8ce28b1d01f497e1735637405b01fef0
|
/Code/Servo_motor_code/Servo_motor_code.ino
|
80b6879ccc1d509cd925f6a76eff5867fe8afba7
|
[] |
no_license
|
allen-michael-tan/Cardboard-bear
|
ac5c435d92aa7ab507630d1218f6c987eb4f9b6e
|
74b2797a5e25b71261318283be0e4119f6044303
|
refs/heads/main
| 2023-06-21T11:58:57.602049
| 2021-08-05T02:38:16
| 2021-08-05T02:38:16
| 390,197,753
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 614
|
ino
|
#include <Servo.h>
Servo left;
Servo right;
int leftAngle = 20;
int rightAngle = 25;
void setup() {
left.attach(5);
right.attach(4);
left.write(20);
right.write(25);
}
void loop() {
for (rightAngle == 25; leftAngle < 90; leftAngle ++) {
left.write(leftAngle);
delay(7);
}
for (leftAngle == 90; rightAngle < 90; rightAngle ++){
right.write(rightAngle);
delay(7);
}
for (rightAngle == 90; leftAngle > 20; leftAngle --) {
left.write(leftAngle);
delay(7);
}
for (leftAngle == 20; rightAngle > 25; rightAngle --) {
right.write(rightAngle);
delay(7);
}
}
|
[
"56618748+allen-michael-tan@users.noreply.github.com"
] |
56618748+allen-michael-tan@users.noreply.github.com
|
17f088dc4861bcb5852181792754653c584a72e9
|
8bacf0a54468ad90cbc695c0dee51eaa4afb5ee3
|
/MoistSensor.h
|
e573081107536622a8f83a41aa3a36ec4d66e1fd
|
[
"Apache-2.0"
] |
permissive
|
irudym/iotivity-weeder
|
d94011e52b19366056002807aa6fc65ab02dd883
|
9b4ac29e78629b0f3ace88ee1f777eb93bd63bf1
|
refs/heads/master
| 2021-01-01T04:29:37.760451
| 2016-05-23T16:05:01
| 2016-05-23T16:05:01
| 58,034,207
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 606
|
h
|
//
// Created by ubuntu on 19.05.16.
//
#ifndef IOTIVITY_WEEDER_MOISTSENSOR_H
#define IOTIVITY_WEEDER_MOISTSENSOR_H
#include "CSensor.h"
#include "sensors.h"
#include "namedefs.h"
class MoistSensor : public CSensor {
public:
MoistSensor(const string &name, int pin) : CSensor(name, pin) {
this->m_Representation.setValue(MOIST_RESOURCE_KEY, 0);
}
virtual ~MoistSensor() { }
virtual OCRepresentation getRepresentation();
virtual void observerLoop();
virtual OCEntityHandlerResult entityHandler(shared_ptr<OCResourceRequest>);
};
#endif //IOTIVITY_WEEDER_MOISTSENSOR_H
|
[
"irudym@gmail.com"
] |
irudym@gmail.com
|
8899b19294eee99b3eb1cd8cf80a0cce7764d6e8
|
21d930922e338a7f4251d2bd8790eb87a53c1ac9
|
/include/BareCpper/Chrono.hpp
|
368c09fdd952dc1673cf487a3f4d6ac4b9f3211e
|
[] |
no_license
|
BareCpper/BareCpper
|
961339d4e4d246ee6bd9de0a670a5a83534cfd50
|
878b2fb48a74cfa56068381f4503c9577ed26b3f
|
refs/heads/master
| 2022-10-18T06:04:26.539599
| 2022-10-07T09:44:41
| 2022-10-07T09:44:41
| 226,130,360
| 1
| 2
| null | 2022-10-07T09:44:42
| 2019-12-05T15:16:45
|
C++
|
UTF-8
|
C++
| false
| false
| 560
|
hpp
|
#ifndef BARECPPER_CHRONO_HPP
#define BARECPPER_CHRONO_HPP
#include "MonotonicClock.hpp"
#include "RealtimeClock.hpp"
namespace BareCpper {
/** Clocks for std::chrono providing a flexible collection of types that track time with varying degrees of precision
* @see https://en.cppreference.com/w/cpp/chrono
*/
namespace Chrono
{
/** @see MonotonicClock
*/
using SteadyClock = MonotonicClock;
/** @see RealtimeClock
*/
using SystemClock = RealtimeClock;
}
} //END: BareCpper
#endif
|
[
"54269136+CraigHutchinson@users.noreply.github.com"
] |
54269136+CraigHutchinson@users.noreply.github.com
|
3e00cbcea1d2390dad47d017e302bb26cbf6d2ab
|
459fabe8dcc30a168034a9166f8931ceb986b21a
|
/atcoder/ABC-123/c.cpp
|
411aa6ca879f86b47838f537bffeb99abd21e5c6
|
[
"MIT"
] |
permissive
|
YusukeKato/ProgrammingContest
|
a04727472e4b3684d2928e7114f5bde0f517aa58
|
d8ae46b936eaa4f8794ad333f5367c177c18d92f
|
refs/heads/master
| 2022-12-02T15:53:47.032118
| 2019-08-28T14:04:59
| 2019-08-28T14:04:59
| 170,851,658
| 1
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 511
|
cpp
|
#include <iostream>
#include <vector>
#include <cmath>
#include <string>
using namespace std;
int main()
{
long long A[6] = {0};
cin >> A[0];
cin >> A[1];
cin >> A[2];
cin >> A[3];
cin >> A[4];
cin >> A[5];
long long minval = A[1];
for(int i = 2; i < 6; i++)
{
if(minval > A[i]) minval = A[i];
}
long long time;
if(A[0] % minval == 0) time = A[0] / minval + 4;
else time = A[0] / minval + 1 + 4;
cout << time << endl;
return 0;
}
|
[
"s1526035cn@s.chibakoudai.jp"
] |
s1526035cn@s.chibakoudai.jp
|
67ba53dc7e2b95e0816717e82c39c7b3f2fb3385
|
bac7267590c6267b489178c8717e42a1865bb46b
|
/WildMagic5/LibMathematics/Containment/Wm5ContPointInPolygon2.cpp
|
c92f84845ef43ce48dcc632636212e06ce9ec517
|
[] |
no_license
|
VB6Hobbyst7/GeometricTools-Apple
|
1e53f260e84f8942e12adf7591b83ba2dd46a7f1
|
07b9764871a9dbe1240b6181039dd703e118a628
|
refs/heads/master
| 2021-02-11T11:17:56.813941
| 2013-11-26T15:25:10
| 2013-11-26T15:25:10
| null | 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 5,859
|
cpp
|
// Geometric Tools, LLC
// Copyright (c) 1998-2013
// Distributed under the Boost Software License, Version 1.0.
// http://www.boost.org/LICENSE_1_0.txt
// http://www.geometrictools.com/License/Boost/LICENSE_1_0.txt
//
// File Version: 5.0.1 (2010/10/01)
#include "Wm5MathematicsPCH.h"
#include "Wm5ContPointInPolygon2.h"
namespace Wm5
{
//----------------------------------------------------------------------------
template <typename Real>
PointInPolygon2<Real>::PointInPolygon2 (int numPoints,
const Vector2<Real>* points)
:
mNumPoints(numPoints),
mPoints(points)
{
}
//----------------------------------------------------------------------------
template <typename Real>
bool PointInPolygon2<Real>::Contains (const Vector2<Real>& p) const
{
bool inside = false;
for (int i = 0, j = mNumPoints-1; i < mNumPoints; j = i++)
{
const Vector2<Real>& U0 = mPoints[i];
const Vector2<Real>& U1 = mPoints[j];
Real rhs, lhs;
if (p.Y() < U1.Y()) // U1 above ray
{
if (U0.Y() <= p.Y()) // U0 on or below ray
{
lhs = (p.Y() - U0.Y())*(U1.X() - U0.X());
rhs = (p.X() - U0.X())*(U1.Y() - U0.Y());
if (lhs > rhs)
{
inside = !inside;
}
}
}
else if (p.Y() < U0.Y()) // U1 on or below ray, U0 above ray
{
lhs = (p.Y() - U0.Y())*(U1.X() - U0.X());
rhs = (p.X() - U0.X())*(U1.Y() - U0.Y());
if (lhs < rhs)
{
inside = !inside;
}
}
}
return inside;
}
//----------------------------------------------------------------------------
template <typename Real>
bool PointInPolygon2<Real>::ContainsConvexOrderN (const Vector2<Real>& p)
const
{
for (int i1 = 0, i0 = mNumPoints-1; i1 < mNumPoints; i0 = i1++)
{
Real nx = mPoints[i1].Y() - mPoints[i0].Y();
Real ny = mPoints[i0].X() - mPoints[i1].X();
Real dx = p.X() - mPoints[i0].X();
Real dy = p.Y() - mPoints[i0].Y();
if (nx*dx + ny*dy > (Real)0)
{
return false;
}
}
return true;
}
//----------------------------------------------------------------------------
template <typename Real>
bool PointInPolygon2<Real>::ContainsConvexOrderLogN (const Vector2<Real>& p)
const
{
return SubContainsPoint(p, 0, 0);
}
//----------------------------------------------------------------------------
template <typename Real>
bool PointInPolygon2<Real>::ContainsQuadrilateral (const Vector2<Real>& p)
const
{
if (mNumPoints != 4)
{
return false;
}
Real nx = mPoints[2].Y() - mPoints[0].Y();
Real ny = mPoints[0].X() - mPoints[2].X();
Real dx = p.X() - mPoints[0].X();
Real dy = p.Y() - mPoints[0].Y();
if (nx*dx + ny*dy > (Real)0)
{
// P potentially in <V0,V1,V2>
nx = mPoints[1].Y() - mPoints[0].Y();
ny = mPoints[0].X() - mPoints[1].X();
if (nx*dx + ny*dy > (Real)0.0)
{
return false;
}
nx = mPoints[2].Y() - mPoints[1].Y();
ny = mPoints[1].X() - mPoints[2].X();
dx = p.X() - mPoints[1].X();
dy = p.Y() - mPoints[1].Y();
if (nx*dx + ny*dy > (Real)0)
{
return false;
}
}
else
{
// P potentially in <V0,V2,V3>
nx = mPoints[0].Y() - mPoints[3].Y();
ny = mPoints[3].X() - mPoints[0].X();
if (nx*dx + ny*dy > (Real)0)
{
return false;
}
nx = mPoints[3].Y() - mPoints[2].Y();
ny = mPoints[2].X() - mPoints[3].X();
dx = p.X() - mPoints[3].X();
dy = p.Y() - mPoints[3].Y();
if (nx*dx + ny*dy > (Real)0)
{
return false;
}
}
return true;
}
//----------------------------------------------------------------------------
template <typename Real>
bool PointInPolygon2<Real>::SubContainsPoint (const Vector2<Real>& p, int i0,
int i1) const
{
Real nx, ny, dx, dy;
int diff = i1 - i0;
if (diff == 1 || (diff < 0 && diff + mNumPoints == 1))
{
nx = mPoints[i1].Y() - mPoints[i0].Y();
ny = mPoints[i0].X() - mPoints[i1].X();
dx = p.X() - mPoints[i0].X();
dy = p.Y() - mPoints[i0].Y();
return nx*dx + ny*dy <= (Real)0;
}
// Bisect the index range.
int mid;
if (i0 < i1)
{
mid = (i0 + i1) >> 1;
}
else
{
mid = ((i0 + i1 + mNumPoints) >> 1);
if (mid >= mNumPoints)
{
mid -= mNumPoints;
}
}
// Determine which side of the splitting line contains the point.
nx = mPoints[mid].Y() - mPoints[i0].Y();
ny = mPoints[i0].X() - mPoints[mid].X();
dx = p.X() - mPoints[i0].X();
dy = p.Y() - mPoints[i0].Y();
if (nx*dx + ny*dy > (Real)0)
{
// P potentially in <V(i0),V(i0+1),...,V(mid-1),V(mid)>
return SubContainsPoint(p, i0, mid);
}
else
{
// P potentially in <V(mid),V(mid+1),...,V(i1-1),V(i1)>
return SubContainsPoint(p, mid, i1);
}
}
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
// Explicit instantiation.
//----------------------------------------------------------------------------
template WM5_MATHEMATICS_ITEM
class PointInPolygon2<float>;
template WM5_MATHEMATICS_ITEM
class PointInPolygon2<double>;
//----------------------------------------------------------------------------
}
|
[
"tprepscius"
] |
tprepscius
|
d650be69ebc8f8e79fc6ec7a2577294635dbac71
|
553e8a8c36d52580b85e572bf1ba071e304932e9
|
/casablanca/Release/libs/websocketpp/test/processors/hybi08.cpp
|
a6c97b3c712d553d7cf9c748c09dc904923198ea
|
[
"Apache-2.0",
"BSD-3-Clause",
"MIT",
"Zlib"
] |
permissive
|
mentionllc/traintracks-cpp-sdk
|
ba0d62bc5289d4d82d0c17b282788d65e1863cec
|
c294a463ef2d55bc7b27e35fe7f903d51104c6bd
|
refs/heads/master
| 2020-04-19T06:40:23.949106
| 2015-02-05T04:45:24
| 2015-02-05T04:45:24
| 28,652,489
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 8,521
|
cpp
|
/*
* Copyright (c) 2013, Peter Thorson. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* * Neither the name of the WebSocket++ Project nor the
* names of its contributors may be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
//#define BOOST_TEST_DYN_LINK
#define BOOST_TEST_MODULE hybi_08_processor
#include <boost/test/unit_test.hpp>
#include <iostream>
#include <string>
#include <websocketpp/processors/hybi08.hpp>
#include <websocketpp/http/request.hpp>
#include <websocketpp/http/response.hpp>
#include <websocketpp/message_buffer/message.hpp>
#include <websocketpp/message_buffer/alloc.hpp>
#include <websocketpp/extensions/permessage_deflate/disabled.hpp>
#include <websocketpp/random/none.hpp>
struct stub_config {
typedef websocketpp::http::parser::request request_type;
typedef websocketpp::http::parser::response response_type;
typedef websocketpp::message_buffer::message
<websocketpp::message_buffer::alloc::con_msg_manager> message_type;
typedef websocketpp::message_buffer::alloc::con_msg_manager<message_type>
con_msg_manager_type;
typedef websocketpp::random::none::int_generator<uint32_t> rng_type;
static const size_t max_message_size = 16000000;
/// Extension related config
static const bool enable_extensions = false;
/// Extension specific config
/// permessage_deflate_config
struct permessage_deflate_config {
typedef stub_config::request_type request_type;
};
typedef websocketpp::extensions::permessage_deflate::disabled
<permessage_deflate_config> permessage_deflate_type;
};
BOOST_AUTO_TEST_CASE( exact_match ) {
stub_config::request_type r;
stub_config::response_type response;
stub_config::con_msg_manager_type::ptr msg_manager;
stub_config::rng_type rng;
websocketpp::processor::hybi08<stub_config> p(false,true,msg_manager,rng);
websocketpp::lib::error_code ec;
std::string handshake = "GET / HTTP/1.1\r\nHost: www.example.com\r\nConnection: upgrade\r\nUpgrade: websocket\r\nSec-WebSocket-Version: 8\r\nSec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==\r\n\r\n";
r.consume(handshake.c_str(),handshake.size());
BOOST_CHECK(websocketpp::processor::is_websocket_handshake(r));
BOOST_CHECK(websocketpp::processor::get_websocket_version(r) == p.get_version());
ec = p.validate_handshake(r);
BOOST_CHECK(!ec);
websocketpp::uri_ptr u;
u = p.get_uri(r);
BOOST_CHECK(u->get_valid() == true);
BOOST_CHECK(u->get_secure() == false);
BOOST_CHECK(u->get_host() == "www.example.com");
BOOST_CHECK(u->get_resource() == "/");
BOOST_CHECK(u->get_port() == websocketpp::uri_default_port);
p.process_handshake(r,"",response);
BOOST_CHECK(response.get_header("Connection") == "upgrade");
BOOST_CHECK(response.get_header("Upgrade") == "websocket");
BOOST_CHECK(response.get_header("Sec-WebSocket-Accept") == "s3pPLMBiTxaQ9kYGzzhZRbK+xOo=");
}
BOOST_AUTO_TEST_CASE( non_get_method ) {
stub_config::request_type r;
stub_config::response_type response;
stub_config::rng_type rng;
stub_config::con_msg_manager_type::ptr msg_manager;
websocketpp::processor::hybi08<stub_config> p(false,true,msg_manager,rng);
websocketpp::lib::error_code ec;
std::string handshake = "POST / HTTP/1.1\r\nHost: www.example.com\r\nConnection: upgrade\r\nUpgrade: websocket\r\nSec-WebSocket-Version: 8\r\nSec-WebSocket-Key: foo\r\n\r\n";
r.consume(handshake.c_str(),handshake.size());
BOOST_CHECK(websocketpp::processor::is_websocket_handshake(r));
BOOST_CHECK(websocketpp::processor::get_websocket_version(r) == p.get_version());
ec = p.validate_handshake(r);
BOOST_CHECK( ec == websocketpp::processor::error::invalid_http_method );
}
BOOST_AUTO_TEST_CASE( old_http_version ) {
stub_config::request_type r;
stub_config::response_type response;
stub_config::con_msg_manager_type::ptr msg_manager;
stub_config::rng_type rng;
websocketpp::processor::hybi08<stub_config> p(false,true,msg_manager,rng);
websocketpp::lib::error_code ec;
std::string handshake = "GET / HTTP/1.0\r\nHost: www.example.com\r\nConnection: upgrade\r\nUpgrade: websocket\r\nSec-WebSocket-Version: 8\r\nSec-WebSocket-Key: foo\r\n\r\n";
r.consume(handshake.c_str(),handshake.size());
BOOST_CHECK(websocketpp::processor::is_websocket_handshake(r));
BOOST_CHECK(websocketpp::processor::get_websocket_version(r) == p.get_version());
ec = p.validate_handshake(r);
BOOST_CHECK( ec == websocketpp::processor::error::invalid_http_version );
}
BOOST_AUTO_TEST_CASE( missing_handshake_key1 ) {
stub_config::request_type r;
stub_config::response_type response;
stub_config::con_msg_manager_type::ptr msg_manager;
stub_config::rng_type rng;
websocketpp::processor::hybi08<stub_config> p(false,true,msg_manager,rng);
websocketpp::lib::error_code ec;
std::string handshake = "GET / HTTP/1.1\r\nHost: www.example.com\r\nConnection: upgrade\r\nUpgrade: websocket\r\nSec-WebSocket-Version: 8\r\n\r\n";
r.consume(handshake.c_str(),handshake.size());
BOOST_CHECK(websocketpp::processor::is_websocket_handshake(r));
BOOST_CHECK(websocketpp::processor::get_websocket_version(r) == p.get_version());
ec = p.validate_handshake(r);
BOOST_CHECK( ec == websocketpp::processor::error::missing_required_header );
}
BOOST_AUTO_TEST_CASE( missing_handshake_key2 ) {
stub_config::request_type r;
stub_config::response_type response;
stub_config::con_msg_manager_type::ptr msg_manager;
stub_config::rng_type rng;
websocketpp::processor::hybi08<stub_config> p(false,true,msg_manager,rng);
websocketpp::lib::error_code ec;
std::string handshake = "GET / HTTP/1.1\r\nHost: www.example.com\r\nConnection: upgrade\r\nUpgrade: websocket\r\nSec-WebSocket-Version: 8\r\n\r\n";
r.consume(handshake.c_str(),handshake.size());
BOOST_CHECK(websocketpp::processor::is_websocket_handshake(r));
BOOST_CHECK(websocketpp::processor::get_websocket_version(r) == p.get_version());
ec = p.validate_handshake(r);
BOOST_CHECK( ec == websocketpp::processor::error::missing_required_header );
}
BOOST_AUTO_TEST_CASE( bad_host ) {
stub_config::request_type r;
stub_config::response_type response;
stub_config::con_msg_manager_type::ptr msg_manager;
stub_config::rng_type rng;
websocketpp::processor::hybi08<stub_config> p(false,true,msg_manager,rng);
websocketpp::uri_ptr u;
websocketpp::lib::error_code ec;
std::string handshake = "GET / HTTP/1.1\r\nHost: www.example.com:70000\r\nConnection: upgrade\r\nUpgrade: websocket\r\nSec-WebSocket-Version: 8\r\nSec-WebSocket-Key: foo\r\n\r\n";
r.consume(handshake.c_str(),handshake.size());
BOOST_CHECK(websocketpp::processor::is_websocket_handshake(r));
BOOST_CHECK(websocketpp::processor::get_websocket_version(r) == p.get_version());
ec = p.validate_handshake(r);
BOOST_CHECK( !ec );
u = p.get_uri(r);
BOOST_CHECK( !u->get_valid() );
}
|
[
"heisenberg@traintracks.io"
] |
heisenberg@traintracks.io
|
d6774b0c60b3b02134677070950416c7c8c60e81
|
ecec137010f2cb4631f96b8c183983a62c9b2ca0
|
/C++/learning_plus_book/common/firstcpp.cpp
|
69331ef55fc440f6bf299ffd1b5198673236dded
|
[] |
no_license
|
lijiayan2020/Code
|
d6296658bdec1adb6353faa3ca1ae583542ce926
|
ba9f015c51a60fc8aeb1f5efbd33e96126c34265
|
refs/heads/master
| 2023-04-12T19:23:21.860951
| 2021-04-21T16:21:11
| 2021-04-21T16:21:11
| 330,329,460
| 1
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 158
|
cpp
|
#include<iostream>
int main()
{
using namespace std;
cout<<"Come up and C++ me some time.";
cout<<endl;
cout<<"You won't regret it!"<<endl;
return 0;
}
|
[
"1131106863@qq.com"
] |
1131106863@qq.com
|
a94713fadc8ebcf32d4d15f932bb6fdcfee95cff
|
3efc50ba20499cc9948473ee9ed2ccfce257d79a
|
/data/code-jam/files/1150486_jinlin_1163489_0_extracted_main.cpp
|
0e262e95f183a94628d6b460c037832e00d331bb
|
[] |
no_license
|
arthurherbout/crypto_code_detection
|
7e10ed03238278690d2d9acaa90fab73e52bab86
|
3c9ff8a4b2e4d341a069956a6259bf9f731adfc0
|
refs/heads/master
| 2020-07-29T15:34:31.380731
| 2019-12-20T13:52:39
| 2019-12-20T13:52:39
| 209,857,592
| 9
| 4
| null | 2019-12-20T13:52:42
| 2019-09-20T18:35:35
|
C
|
UTF-8
|
C++
| false
| false
| 1,131
|
cpp
|
#include <algorithm>
#include <iostream>
#include <cstring>
#include <cstdio>
using namespace std;
double vs[2000];
double ls[2000];
int ind[2000];
bool cmp(int a, int b) {
return vs[a]<vs[b];
}
int main() {
int T;
scanf("%d", &T);
for(int cas=1; cas<=T; ++cas) {
double X, S, R, t;
int N;
scanf("%lf%lf%lf%lf%d", &X, &S, &R, &t, &N);
if(R<S) R = S;
double len = X;
for(int b, e, w, i=0; i<N; ++i) {
scanf("%d%d%d", &b, &e, &w);
ls[i] = e-b;
len -= ls[i];
vs[i] = w;
}
printf("Case #%d: ", cas);
if(t*R<=len) {
double ans = t;
ans += (len-t*R)/S;
for(int i=0; i<N; ++i) {
ans += ls[i]/(vs[i]+S);
}
printf("%.7lf\n", ans);
} else {
double ans = len/R;
t -= ans;
for(int i=0; i<N; ++i)
ind[i] = i;
sort(ind, ind+N, cmp);
for(int index=0; index<N; ++index) {
int i = ind[index];
if(t*(vs[i]+R)>ls[i]) {
t -= ls[i]/(vs[i]+R);
ans += ls[i]/(vs[i]+R);
} else {
ans += t;
ans += (ls[i]-t*(vs[i]+R))/(vs[i]+S);
t = 0;
}
}
printf("%.7lf\n", ans);
}
}
}
|
[
"arthurherbout@gmail.com"
] |
arthurherbout@gmail.com
|
74a570942793688071c13a5cf6f3805ae288b730
|
5b8b423fc0c2e15ed4e690e07b32d01cfe0a04d8
|
/MD_MIDIFile-master/examples/MD_MIDIFile_Loop/MD_MIDIFile_Loop.ino
|
54c2c75292f4d37e725c84788c0a06cbafccfc88
|
[] |
no_license
|
theawsomeavr/arduino-midi-player-mkll
|
94aaa9ff69af8767b1b012ac120bc55202e86766
|
c27ced76ac0bccb4020da79a621f76cee05e40df
|
refs/heads/master
| 2020-03-20T08:10:36.218950
| 2019-09-23T06:49:59
| 2019-09-23T06:49:59
| 137,301,115
| 6
| 2
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 2,400
|
ino
|
// Play a file from the SD card in looping mode, from the SD card.
// Example program to demonstrate the use of the MIDFile library
//
// Hardware required:
// SD card interface - change SD_SELECT for SPI comms
#include <SdFat.h>
#include <MD_MIDIFile.h>
#define USE_MIDI 1
#if USE_MIDI // set up for direct MIDI serial output
#define DEBUGS(s)
#define DEBUG(s, x)
#define DEBUGX(s, x)
#define SERIAL_RATE 31250
#else // don't use MIDI to allow printing debug statements
#define DEBUGS(s) Serial.print(s)
#define DEBUG(s, x) { Serial.print(F(s)); Serial.print(x); }
#define DEBUGX(s, x) { Serial.print(F(s)); Serial.print(x, HEX); }
#define SERIAL_RATE 57600
#endif // USE_MIDI
// SD chip select pin for SPI comms.
// Arduino Ethernet shield, pin 4.
// Default SD chip select is the SPI SS pin (10).
// Other hardware will be different as documented for that hardware.
#define SD_SELECT 10
#define ARRAY_SIZE(a) (sizeof(a)/sizeof(a[0]))
// The files in the tune list should be located on the SD card
// or an error will occur opening the file and the next in the
// list will be opened (skips errors).
char *loopfile = "AFROCUBA.MID"; // simple and short file
SdFat SD;
MD_MIDIFile SMF;
void midiCallback(midi_event *pev)
// Called by the MIDIFile library when a file event needs to be processed
// thru the midi communications interface.
// This callback is set up in the setup() function.
{
#if USE_MIDI
if ((pev->data[0] >= 0x80) && (pev->data[0] <= 0xe0))
{
Serial.write(pev->data[0] | pev->channel);
Serial.write(&pev->data[1], pev->size-1);
}
else
Serial.write(pev->data, pev->size);
#endif
DEBUG("\nM T", pev->track);
DEBUG(": Ch ", pev->channel+1);
DEBUGS(" Data");
for (uint8_t i=0; i<pev->size; i++)
{
DEBUGX(" ", pev->data[i]);
}
}
void setup(void)
{
int err;
Serial.begin(SERIAL_RATE);
DEBUGS("\n[MidiFile Looper]");
// Initialize SD
if (!SD.begin(SD_SELECT, SPI_FULL_SPEED))
{
DEBUGS("\nSD init fail!");
while (true) ;
}
// Initialize MIDIFile
SMF.begin(&SD);
SMF.setMidiHandler(midiCallback);
SMF.looping(true);
// use the next file name and play it
DEBUG("\nFile: ", loopfile);
SMF.setFilename(loopfile);
err = SMF.load();
if (err != -1)
{
DEBUG("\nSMF load Error ", err);
while (true);
}
}
void loop(void)
{
// play the file
if (!SMF.isEOF())
{
SMF.getNextEvent();
}
}
|
[
"noreply@github.com"
] |
theawsomeavr.noreply@github.com
|
efb736c3afda962843ec6e9642a7794664e92a22
|
511a2241ca69ad4a05a9322969c40672811c90e7
|
/Easy/ReverseLinkedList/main.cpp
|
73427d2f7b65b7e5586c1c2b4fadd9b0d67416d5
|
[] |
no_license
|
Suhailkhn/Leetcode
|
31f5c942aec1d618b69c4997defb14430d9522e0
|
57f939fdbacd6d320c8e5f55ad93625b012cb229
|
refs/heads/master
| 2021-04-09T19:51:55.064226
| 2020-03-20T23:58:16
| 2020-03-20T23:58:16
| 248,873,733
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 576
|
cpp
|
#include <stdio.h>
class Solution {
public:
ListNode* reverseList(ListNode* head) {
ListNode* previous = nullptr;
ListNode* current = head;
ListNode* next_node = head ? head->next : nullptr;
while(current) {
current->next = previous;
previous = current;
current = next_node;
if(next_node)
next_node = next_node->next;
}
head = previous;
return head;
}
};
int main(int argc, char **argv)
{
printf("hello world\n");
return 0;
}
|
[
"ksuhail32@gmail.com"
] |
ksuhail32@gmail.com
|
9214b30348830f0058482dfb69429e77953486bf
|
64140e2d9f7ec9dda817bb65db159cb1b5b62d7f
|
/tetattds/network/include/messagebuffer.h
|
c3e1c49a74acf3c775a86a9d71f97b14c0d13033
|
[] |
no_license
|
Flare183/tetattds
|
fa168809c01a25777d7da8e2efee58abea64daf7
|
024480f2c72c72f385c321d0d0f3add0fe46cc7f
|
refs/heads/master
| 2021-12-04T11:15:55.406897
| 2015-03-16T09:03:17
| 2015-03-16T09:03:17
| null | 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 482
|
h
|
#pragma once
#define BUFFER_SIZE 2048
class MessageBuffer
{
public:
MessageBuffer();
~MessageBuffer();
bool Put(void* data, unsigned int length, void* from);
bool Get(void* data, unsigned int* length, void** from);
private:
unsigned int Write(unsigned int pos, void* data, unsigned int length);
unsigned int Read(unsigned int pos, void* data, unsigned int length);
char buffer[BUFFER_SIZE];
unsigned int readCursor;
unsigned int writeCursor;
};
|
[
"sten.larsson@gmail.com"
] |
sten.larsson@gmail.com
|
da434052cd755fd3b32ba3b1fbe6020a7c8f23fc
|
24f26275ffcd9324998d7570ea9fda82578eeb9e
|
/ash/system/unified/unified_notifier_settings_controller.cc
|
6e8a6ac4a62ff59816d53108e4c339b930c45fb4
|
[
"BSD-3-Clause"
] |
permissive
|
Vizionnation/chromenohistory
|
70a51193c8538d7b995000a1b2a654e70603040f
|
146feeb85985a6835f4b8826ad67be9195455402
|
refs/heads/master
| 2022-12-15T07:02:54.461083
| 2019-10-25T15:07:06
| 2019-10-25T15:07:06
| 217,557,501
| 2
| 1
|
BSD-3-Clause
| 2022-11-19T06:53:07
| 2019-10-25T14:58:54
| null |
UTF-8
|
C++
| false
| false
| 2,132
|
cc
|
// Copyright 2018 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "ash/system/unified/unified_notifier_settings_controller.h"
#include "ash/strings/grit/ash_strings.h"
#include "ash/system/message_center/notifier_settings_view.h"
#include "ash/system/tray/detailed_view_delegate.h"
#include "ash/system/tray/tray_detailed_view.h"
#include "ui/message_center/message_center.h"
#include "ui/message_center/message_center_observer.h"
#include "ui/views/layout/box_layout.h"
namespace ash {
namespace {
class UnifiedNotifierSettingsView
: public TrayDetailedView,
public message_center::MessageCenterObserver {
public:
explicit UnifiedNotifierSettingsView(DetailedViewDelegate* delegate)
: TrayDetailedView(delegate), settings_view_(new NotifierSettingsView()) {
CreateTitleRow(IDS_ASH_MESSAGE_CENTER_FOOTER_TITLE);
AddChildView(settings_view_);
box_layout()->SetFlexForView(settings_view_, 1);
OnQuietModeChanged(message_center::MessageCenter::Get()->IsQuietMode());
message_center::MessageCenter::Get()->AddObserver(this);
}
~UnifiedNotifierSettingsView() override {
message_center::MessageCenter::Get()->RemoveObserver(this);
}
// MessageCenterObserver:
void OnQuietModeChanged(bool in_quiet_mode) override {
settings_view_->SetQuietModeState(in_quiet_mode);
}
const char* GetClassName() const override {
return "UnifiedNotifierSettingsView";
}
private:
NotifierSettingsView* const settings_view_;
DISALLOW_COPY_AND_ASSIGN(UnifiedNotifierSettingsView);
};
} // namespace
UnifiedNotifierSettingsController::UnifiedNotifierSettingsController(
UnifiedSystemTrayController* tray_controller)
: detailed_view_delegate_(
std::make_unique<DetailedViewDelegate>(tray_controller)) {}
UnifiedNotifierSettingsController::~UnifiedNotifierSettingsController() =
default;
views::View* UnifiedNotifierSettingsController::CreateView() {
return new UnifiedNotifierSettingsView(detailed_view_delegate_.get());
}
} // namespace ash
|
[
"rjkroege@chromium.org"
] |
rjkroege@chromium.org
|
9c9d076b05f331350d2160d2f2cbbfa8d1202229
|
1f1538d6aba2ec840673f8d35c234a4f04d549e0
|
/BuildTools/vssdk80/Common_Inc/sh.h
|
4b52debc07c9580067163adc6aa02024b3fa692f
|
[] |
no_license
|
otherdeniz/EconNetvert
|
fd8e1b74e47b91c629eb97a6b780f4f2b20955d1
|
39f778d4c668f7bf430620b370b50d4326452bb9
|
refs/heads/master
| 2020-04-25T06:55:39.861738
| 2019-02-25T23:29:15
| 2019-02-25T23:29:15
| 172,597,683
| 1
| 1
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 273,548
|
h
|
/* this ALWAYS GENERATED file contains the definitions for the interfaces */
/* File created by MIDL compiler version 6.00.0366 */
/* Compiler settings for sh.idl:
Oicf, W1, Zp8, env=Win32 (32b run)
protocol : dce , ms_ext, c_ext, robust
error checks: allocation ref bounds_check enum stub_data
VC __declspec() decoration level:
__declspec(uuid()), __declspec(selectany), __declspec(novtable)
DECLSPEC_UUID(), MIDL_INTERFACE()
*/
//@@MIDL_FILE_HEADING( )
#pragma warning( disable: 4049 ) /* more than 64k source lines */
/* verify that the <rpcndr.h> version is high enough to compile this file*/
#ifndef __REQUIRED_RPCNDR_H_VERSION__
#define __REQUIRED_RPCNDR_H_VERSION__ 475
#endif
#include "rpc.h"
#include "rpcndr.h"
#ifndef __RPCNDR_H_VERSION__
#error this stub requires an updated version of <rpcndr.h>
#endif // __RPCNDR_H_VERSION__
#ifndef COM_NO_WINDOWS_H
#include "windows.h"
#include "ole2.h"
#endif /*COM_NO_WINDOWS_H*/
#ifndef __sh_h__
#define __sh_h__
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
#pragma once
#endif
/* Forward Declarations */
#ifndef __IDebugSymbolProvider_FWD_DEFINED__
#define __IDebugSymbolProvider_FWD_DEFINED__
typedef interface IDebugSymbolProvider IDebugSymbolProvider;
#endif /* __IDebugSymbolProvider_FWD_DEFINED__ */
#ifndef __IDebugSymbolProviderDirect_FWD_DEFINED__
#define __IDebugSymbolProviderDirect_FWD_DEFINED__
typedef interface IDebugSymbolProviderDirect IDebugSymbolProviderDirect;
#endif /* __IDebugSymbolProviderDirect_FWD_DEFINED__ */
#ifndef __IDebugComPlusSymbolProvider_FWD_DEFINED__
#define __IDebugComPlusSymbolProvider_FWD_DEFINED__
typedef interface IDebugComPlusSymbolProvider IDebugComPlusSymbolProvider;
#endif /* __IDebugComPlusSymbolProvider_FWD_DEFINED__ */
#ifndef __IDebugComPlusSymbolProvider2_FWD_DEFINED__
#define __IDebugComPlusSymbolProvider2_FWD_DEFINED__
typedef interface IDebugComPlusSymbolProvider2 IDebugComPlusSymbolProvider2;
#endif /* __IDebugComPlusSymbolProvider2_FWD_DEFINED__ */
#ifndef __IDebugSymbolProviderGroup_FWD_DEFINED__
#define __IDebugSymbolProviderGroup_FWD_DEFINED__
typedef interface IDebugSymbolProviderGroup IDebugSymbolProviderGroup;
#endif /* __IDebugSymbolProviderGroup_FWD_DEFINED__ */
#ifndef __IDebugGenericFieldDefinition_FWD_DEFINED__
#define __IDebugGenericFieldDefinition_FWD_DEFINED__
typedef interface IDebugGenericFieldDefinition IDebugGenericFieldDefinition;
#endif /* __IDebugGenericFieldDefinition_FWD_DEFINED__ */
#ifndef __IDebugGenericFieldInstance_FWD_DEFINED__
#define __IDebugGenericFieldInstance_FWD_DEFINED__
typedef interface IDebugGenericFieldInstance IDebugGenericFieldInstance;
#endif /* __IDebugGenericFieldInstance_FWD_DEFINED__ */
#ifndef __IDebugField_FWD_DEFINED__
#define __IDebugField_FWD_DEFINED__
typedef interface IDebugField IDebugField;
#endif /* __IDebugField_FWD_DEFINED__ */
#ifndef __IDebugGenericParamField_FWD_DEFINED__
#define __IDebugGenericParamField_FWD_DEFINED__
typedef interface IDebugGenericParamField IDebugGenericParamField;
#endif /* __IDebugGenericParamField_FWD_DEFINED__ */
#ifndef __IDebugComPlusSymbolSearchInfo_FWD_DEFINED__
#define __IDebugComPlusSymbolSearchInfo_FWD_DEFINED__
typedef interface IDebugComPlusSymbolSearchInfo IDebugComPlusSymbolSearchInfo;
#endif /* __IDebugComPlusSymbolSearchInfo_FWD_DEFINED__ */
#ifndef __IDebugTypeFieldBuilder_FWD_DEFINED__
#define __IDebugTypeFieldBuilder_FWD_DEFINED__
typedef interface IDebugTypeFieldBuilder IDebugTypeFieldBuilder;
#endif /* __IDebugTypeFieldBuilder_FWD_DEFINED__ */
#ifndef __IDebugTypeFieldBuilder2_FWD_DEFINED__
#define __IDebugTypeFieldBuilder2_FWD_DEFINED__
typedef interface IDebugTypeFieldBuilder2 IDebugTypeFieldBuilder2;
#endif /* __IDebugTypeFieldBuilder2_FWD_DEFINED__ */
#ifndef __IDebugNativeSymbolProvider_FWD_DEFINED__
#define __IDebugNativeSymbolProvider_FWD_DEFINED__
typedef interface IDebugNativeSymbolProvider IDebugNativeSymbolProvider;
#endif /* __IDebugNativeSymbolProvider_FWD_DEFINED__ */
#ifndef __IDebugExtendedField_FWD_DEFINED__
#define __IDebugExtendedField_FWD_DEFINED__
typedef interface IDebugExtendedField IDebugExtendedField;
#endif /* __IDebugExtendedField_FWD_DEFINED__ */
#ifndef __IDebugPrimitiveTypeField_FWD_DEFINED__
#define __IDebugPrimitiveTypeField_FWD_DEFINED__
typedef interface IDebugPrimitiveTypeField IDebugPrimitiveTypeField;
#endif /* __IDebugPrimitiveTypeField_FWD_DEFINED__ */
#ifndef __IDebugContainerField_FWD_DEFINED__
#define __IDebugContainerField_FWD_DEFINED__
typedef interface IDebugContainerField IDebugContainerField;
#endif /* __IDebugContainerField_FWD_DEFINED__ */
#ifndef __IDebugMethodField_FWD_DEFINED__
#define __IDebugMethodField_FWD_DEFINED__
typedef interface IDebugMethodField IDebugMethodField;
#endif /* __IDebugMethodField_FWD_DEFINED__ */
#ifndef __IDebugThisAdjust_FWD_DEFINED__
#define __IDebugThisAdjust_FWD_DEFINED__
typedef interface IDebugThisAdjust IDebugThisAdjust;
#endif /* __IDebugThisAdjust_FWD_DEFINED__ */
#ifndef __IDebugClassField_FWD_DEFINED__
#define __IDebugClassField_FWD_DEFINED__
typedef interface IDebugClassField IDebugClassField;
#endif /* __IDebugClassField_FWD_DEFINED__ */
#ifndef __IDebugModOpt_FWD_DEFINED__
#define __IDebugModOpt_FWD_DEFINED__
typedef interface IDebugModOpt IDebugModOpt;
#endif /* __IDebugModOpt_FWD_DEFINED__ */
#ifndef __IDebugPropertyField_FWD_DEFINED__
#define __IDebugPropertyField_FWD_DEFINED__
typedef interface IDebugPropertyField IDebugPropertyField;
#endif /* __IDebugPropertyField_FWD_DEFINED__ */
#ifndef __IDebugArrayField_FWD_DEFINED__
#define __IDebugArrayField_FWD_DEFINED__
typedef interface IDebugArrayField IDebugArrayField;
#endif /* __IDebugArrayField_FWD_DEFINED__ */
#ifndef __IDebugPointerField_FWD_DEFINED__
#define __IDebugPointerField_FWD_DEFINED__
typedef interface IDebugPointerField IDebugPointerField;
#endif /* __IDebugPointerField_FWD_DEFINED__ */
#ifndef __IDebugEnumField_FWD_DEFINED__
#define __IDebugEnumField_FWD_DEFINED__
typedef interface IDebugEnumField IDebugEnumField;
#endif /* __IDebugEnumField_FWD_DEFINED__ */
#ifndef __IDebugBitField_FWD_DEFINED__
#define __IDebugBitField_FWD_DEFINED__
typedef interface IDebugBitField IDebugBitField;
#endif /* __IDebugBitField_FWD_DEFINED__ */
#ifndef __IDebugDynamicField_FWD_DEFINED__
#define __IDebugDynamicField_FWD_DEFINED__
typedef interface IDebugDynamicField IDebugDynamicField;
#endif /* __IDebugDynamicField_FWD_DEFINED__ */
#ifndef __IDebugDynamicFieldCOMPlus_FWD_DEFINED__
#define __IDebugDynamicFieldCOMPlus_FWD_DEFINED__
typedef interface IDebugDynamicFieldCOMPlus IDebugDynamicFieldCOMPlus;
#endif /* __IDebugDynamicFieldCOMPlus_FWD_DEFINED__ */
#ifndef __IDebugEngineSymbolProviderServices_FWD_DEFINED__
#define __IDebugEngineSymbolProviderServices_FWD_DEFINED__
typedef interface IDebugEngineSymbolProviderServices IDebugEngineSymbolProviderServices;
#endif /* __IDebugEngineSymbolProviderServices_FWD_DEFINED__ */
#ifndef __IDebugEngineSymbolProviderServices2_FWD_DEFINED__
#define __IDebugEngineSymbolProviderServices2_FWD_DEFINED__
typedef interface IDebugEngineSymbolProviderServices2 IDebugEngineSymbolProviderServices2;
#endif /* __IDebugEngineSymbolProviderServices2_FWD_DEFINED__ */
#ifndef __IDebugAddress_FWD_DEFINED__
#define __IDebugAddress_FWD_DEFINED__
typedef interface IDebugAddress IDebugAddress;
#endif /* __IDebugAddress_FWD_DEFINED__ */
#ifndef __IDebugAddress2_FWD_DEFINED__
#define __IDebugAddress2_FWD_DEFINED__
typedef interface IDebugAddress2 IDebugAddress2;
#endif /* __IDebugAddress2_FWD_DEFINED__ */
#ifndef __IEnumDebugFields_FWD_DEFINED__
#define __IEnumDebugFields_FWD_DEFINED__
typedef interface IEnumDebugFields IEnumDebugFields;
#endif /* __IEnumDebugFields_FWD_DEFINED__ */
#ifndef __IEnumDebugAddresses_FWD_DEFINED__
#define __IEnumDebugAddresses_FWD_DEFINED__
typedef interface IEnumDebugAddresses IEnumDebugAddresses;
#endif /* __IEnumDebugAddresses_FWD_DEFINED__ */
#ifndef __IDebugCustomAttributeQuery_FWD_DEFINED__
#define __IDebugCustomAttributeQuery_FWD_DEFINED__
typedef interface IDebugCustomAttributeQuery IDebugCustomAttributeQuery;
#endif /* __IDebugCustomAttributeQuery_FWD_DEFINED__ */
#ifndef __IDebugCustomAttribute_FWD_DEFINED__
#define __IDebugCustomAttribute_FWD_DEFINED__
typedef interface IDebugCustomAttribute IDebugCustomAttribute;
#endif /* __IDebugCustomAttribute_FWD_DEFINED__ */
#ifndef __IDebugCustomAttributeQuery2_FWD_DEFINED__
#define __IDebugCustomAttributeQuery2_FWD_DEFINED__
typedef interface IDebugCustomAttributeQuery2 IDebugCustomAttributeQuery2;
#endif /* __IDebugCustomAttributeQuery2_FWD_DEFINED__ */
#ifndef __IEnumDebugCustomAttributes_FWD_DEFINED__
#define __IEnumDebugCustomAttributes_FWD_DEFINED__
typedef interface IEnumDebugCustomAttributes IEnumDebugCustomAttributes;
#endif /* __IEnumDebugCustomAttributes_FWD_DEFINED__ */
#ifndef __SHManaged_FWD_DEFINED__
#define __SHManaged_FWD_DEFINED__
#ifdef __cplusplus
typedef class SHManaged SHManaged;
#else
typedef struct SHManaged SHManaged;
#endif /* __cplusplus */
#endif /* __SHManaged_FWD_DEFINED__ */
/* header files for imported files */
#include "wtypes.h"
#include "msdbg.h"
#ifdef __cplusplus
extern "C"{
#endif
void * __RPC_USER MIDL_user_allocate(size_t);
void __RPC_USER MIDL_user_free( void * );
/* interface __MIDL_itf_sh_0000 */
/* [local] */
// Symbol provider HRESULTs
//
// HRESULTs: General
static const int E_SH_SYMBOL_STORE_NOT_INITIALIZED = MAKE_HRESULT(1, FACILITY_ITF, 0x0001);
static const int E_SH_SYMBOL_STORE_ALREADY_INITIALIZED = MAKE_HRESULT(1, FACILITY_ITF, 0x0002);
// HRESULTs: GetContainerField and GetTypeFromAddress
static const int E_SH_INVALID_ADDRESS = MAKE_HRESULT(1, FACILITY_ITF, 0x0003);
// HRESULTs: GetAddressesFromPosition
static const int E_SH_NO_SYMBOLS_FOR_POSITION = MAKE_HRESULT(1, FACILITY_ITF, 0x0004);
static const int E_SH_INVALID_POSITION = MAKE_HRESULT(1, FACILITY_ITF, 0x0005);
// HRESULTs: GetContextFromAddress
static const int E_SH_NO_SYMBOLS_FOR_ADDRESS = MAKE_HRESULT(1, FACILITY_ITF, 0x0006);
static const int S_SH_ENC_OLD_CONTEXT = MAKE_HRESULT(0, FACILITY_ITF, 0x0040);
// HRESULTs: GetAddress
static const int E_SH_NO_ADDRESS = MAKE_HRESULT(1, FACILITY_ITF, 0x0007);
// HRESULTs: GetType
static const int E_SH_NO_TYPE = MAKE_HRESULT(1, FACILITY_ITF, 0x0008);
static const int E_SH_DYNAMIC_TYPE = MAKE_HRESULT(1, FACILITY_ITF, 0x0009);
// HRESULTs: GetContainer
static const int S_SH_NO_CONTAINER = MAKE_HRESULT(0, FACILITY_ITF, 0x000a);
// HRESULTs: GetSize
static const int S_SH_NO_SIZE = MAKE_HRESULT(0, FACILITY_ITF, 0x000b);
static const int E_SH_DYNAMIC_SIZE = MAKE_HRESULT(1, FACILITY_ITF, 0x000c);
// HRESULTs: EnumFields
static const int S_SH_NO_FIELDS = MAKE_HRESULT(0, FACILITY_ITF, 0x000d);
// HRESULTs: GetThis
static const int S_SH_METHOD_NO_THIS = MAKE_HRESULT(0, FACILITY_ITF, 0x000e);
// HRESULTs: EnumBaseClasses
static const int S_SH_NO_BASE_CLASSES = MAKE_HRESULT(0, FACILITY_ITF, 0x000f);
static const int E_SH_FILE_NOT_FOUND = MAKE_HRESULT(1, FACILITY_ITF, 0x0010);
static const int E_SH_SYMBOLS_NOT_FOUND = MAKE_HRESULT(1, FACILITY_ITF, 0x0020);
extern GUID guidSymStoreMetaPDB;
extern GUID guidConstantValue;
extern GUID guidConstantType;
extern GUID guidIntPtr;
extern GUID guidValueType;
// HRESULTS: GetContextInfo
static const int E_SH_NO_DOC_CONTEXT = MAKE_HRESULT(1, FACILITY_ITF, 0x0011);
// HRESULTS: ClassRefToClassDef
static const int E_SH_CLASSDEFINITION_NOT_LOADED = MAKE_HRESULT(1, FACILITY_ITF, 0x0012);
static const int E_SH_MODULE_NOT_LOADED = MAKE_HRESULT(1, FACILITY_ITF, 0x0013);
// HRESULTS: ConvertDiaHR
static const int E_SH_OK = MAKE_HRESULT(1, FACILITY_ITF, 0x0021);
static const int E_SH_USAGE = MAKE_HRESULT(1, FACILITY_ITF, 0x0022);
static const int E_SH_OUT_OF_MEMORY = MAKE_HRESULT(1, FACILITY_ITF, 0x0023);
static const int E_SH_FILE_SYSTEM = MAKE_HRESULT(1, FACILITY_ITF, 0x0024);
static const int E_SH_NOT_FOUND = MAKE_HRESULT(1, FACILITY_ITF, 0x0025);
static const int E_SH_INVALID_SIG = MAKE_HRESULT(1, FACILITY_ITF, 0x0026);
static const int E_SH_INVALID_AGE = MAKE_HRESULT(1, FACILITY_ITF, 0x0027);
static const int E_SH_V1_PDB = MAKE_HRESULT(1, FACILITY_ITF, 0x0028);
static const int E_SH_FORMAT = MAKE_HRESULT(1, FACILITY_ITF, 0x0029);
static const int E_SH_CORRUPT = MAKE_HRESULT(1, FACILITY_ITF, 0x002a);
static const int E_SH_ACCESS_DENIED = MAKE_HRESULT(1, FACILITY_ITF, 0x002b);
static const int E_SH_INVALID_EXECUTABLE = MAKE_HRESULT(1, FACILITY_ITF, 0x002c);
static const int E_SH_NO_DEBUG_INFO = MAKE_HRESULT(1, FACILITY_ITF, 0x002d);
static const int E_SH_INVALID_EXE_TIMESTAMP = MAKE_HRESULT(1, FACILITY_ITF, 0x002e);
static const int E_SH_DEBUG_INFO_NOT_IN_PDB = MAKE_HRESULT(1, FACILITY_ITF, 0x0030);
// HRESULTS: ConstructInstantiation
static const int E_SH_TYPE_ARG_NOT_CLOSED = MAKE_HRESULT(1, FACILITY_ITF, 0x0050);
typedef INT32 _mdToken;
typedef
enum NameMatchOptions
{ nmNone = 0,
nmCaseSensitive = nmNone + 1,
nmCaseInsensitive = nmCaseSensitive + 1
} NAME_MATCH;
extern RPC_IF_HANDLE __MIDL_itf_sh_0000_v0_0_c_ifspec;
extern RPC_IF_HANDLE __MIDL_itf_sh_0000_v0_0_s_ifspec;
#ifndef __IDebugSymbolProvider_INTERFACE_DEFINED__
#define __IDebugSymbolProvider_INTERFACE_DEFINED__
/* interface IDebugSymbolProvider */
/* [unique][uuid][object] */
EXTERN_C const IID IID_IDebugSymbolProvider;
#if defined(__cplusplus) && !defined(CINTERFACE)
MIDL_INTERFACE("c2e34eae-8b9d-11d2-9014-00c04fa38338")
IDebugSymbolProvider : public IUnknown
{
public:
virtual HRESULT STDMETHODCALLTYPE Initialize(
/* [in] */ IDebugEngineSymbolProviderServices *pServices) = 0;
virtual HRESULT STDMETHODCALLTYPE Uninitialize( void) = 0;
virtual HRESULT STDMETHODCALLTYPE GetContainerField(
/* [in] */ IDebugAddress *pAddress,
/* [out] */ IDebugContainerField **ppContainerField) = 0;
virtual HRESULT STDMETHODCALLTYPE GetField(
/* [in] */ IDebugAddress *pAddress,
/* [in] */ IDebugAddress *pAddressCur,
/* [out] */ IDebugField **ppField) = 0;
virtual HRESULT STDMETHODCALLTYPE GetAddressesFromPosition(
/* [in] */ IDebugDocumentPosition2 *pDocPos,
/* [in] */ BOOL fStatmentOnly,
/* [out] */ IEnumDebugAddresses **ppEnumBegAddresses,
/* [out] */ IEnumDebugAddresses **ppEnumEndAddresses) = 0;
virtual HRESULT STDMETHODCALLTYPE GetAddressesFromContext(
/* [in] */ IDebugDocumentContext2 *pDocContext,
/* [in] */ BOOL fStatmentOnly,
/* [out] */ IEnumDebugAddresses **ppEnumBegAddresses,
/* [out] */ IEnumDebugAddresses **ppEnumEndAddresses) = 0;
virtual HRESULT STDMETHODCALLTYPE GetContextFromAddress(
/* [in] */ IDebugAddress *pAddress,
/* [out] */ IDebugDocumentContext2 **ppDocContext) = 0;
virtual HRESULT STDMETHODCALLTYPE GetLanguage(
/* [in] */ IDebugAddress *pAddress,
/* [out] */ GUID *pguidLanguage,
/* [out] */ GUID *pguidLanguageVendor) = 0;
virtual HRESULT STDMETHODCALLTYPE GetGlobalContainer(
/* [out] */ IDebugContainerField **pField) = 0;
virtual HRESULT STDMETHODCALLTYPE GetMethodFieldsByName(
/* [full][in] */ LPCOLESTR pszFullName,
/* [in] */ NAME_MATCH nameMatch,
/* [out] */ IEnumDebugFields **ppEnum) = 0;
virtual HRESULT STDMETHODCALLTYPE GetClassTypeByName(
/* [full][in] */ LPCOLESTR pszClassName,
/* [in] */ NAME_MATCH nameMatch,
/* [out] */ IDebugClassField **ppField) = 0;
virtual HRESULT STDMETHODCALLTYPE GetNamespacesUsedAtAddress(
/* [in] */ IDebugAddress *pAddress,
/* [out] */ IEnumDebugFields **ppEnum) = 0;
virtual HRESULT STDMETHODCALLTYPE GetTypeByName(
/* [full][in] */ LPCOLESTR pszClassName,
/* [in] */ NAME_MATCH nameMatch,
/* [out] */ IDebugField **ppField) = 0;
virtual HRESULT STDMETHODCALLTYPE GetNextAddress(
/* [in] */ IDebugAddress *pAddress,
/* [in] */ BOOL fStatmentOnly,
/* [out] */ IDebugAddress **ppAddress) = 0;
};
#else /* C style interface */
typedef struct IDebugSymbolProviderVtbl
{
BEGIN_INTERFACE
HRESULT ( STDMETHODCALLTYPE *QueryInterface )(
IDebugSymbolProvider * This,
/* [in] */ REFIID riid,
/* [iid_is][out] */ void **ppvObject);
ULONG ( STDMETHODCALLTYPE *AddRef )(
IDebugSymbolProvider * This);
ULONG ( STDMETHODCALLTYPE *Release )(
IDebugSymbolProvider * This);
HRESULT ( STDMETHODCALLTYPE *Initialize )(
IDebugSymbolProvider * This,
/* [in] */ IDebugEngineSymbolProviderServices *pServices);
HRESULT ( STDMETHODCALLTYPE *Uninitialize )(
IDebugSymbolProvider * This);
HRESULT ( STDMETHODCALLTYPE *GetContainerField )(
IDebugSymbolProvider * This,
/* [in] */ IDebugAddress *pAddress,
/* [out] */ IDebugContainerField **ppContainerField);
HRESULT ( STDMETHODCALLTYPE *GetField )(
IDebugSymbolProvider * This,
/* [in] */ IDebugAddress *pAddress,
/* [in] */ IDebugAddress *pAddressCur,
/* [out] */ IDebugField **ppField);
HRESULT ( STDMETHODCALLTYPE *GetAddressesFromPosition )(
IDebugSymbolProvider * This,
/* [in] */ IDebugDocumentPosition2 *pDocPos,
/* [in] */ BOOL fStatmentOnly,
/* [out] */ IEnumDebugAddresses **ppEnumBegAddresses,
/* [out] */ IEnumDebugAddresses **ppEnumEndAddresses);
HRESULT ( STDMETHODCALLTYPE *GetAddressesFromContext )(
IDebugSymbolProvider * This,
/* [in] */ IDebugDocumentContext2 *pDocContext,
/* [in] */ BOOL fStatmentOnly,
/* [out] */ IEnumDebugAddresses **ppEnumBegAddresses,
/* [out] */ IEnumDebugAddresses **ppEnumEndAddresses);
HRESULT ( STDMETHODCALLTYPE *GetContextFromAddress )(
IDebugSymbolProvider * This,
/* [in] */ IDebugAddress *pAddress,
/* [out] */ IDebugDocumentContext2 **ppDocContext);
HRESULT ( STDMETHODCALLTYPE *GetLanguage )(
IDebugSymbolProvider * This,
/* [in] */ IDebugAddress *pAddress,
/* [out] */ GUID *pguidLanguage,
/* [out] */ GUID *pguidLanguageVendor);
HRESULT ( STDMETHODCALLTYPE *GetGlobalContainer )(
IDebugSymbolProvider * This,
/* [out] */ IDebugContainerField **pField);
HRESULT ( STDMETHODCALLTYPE *GetMethodFieldsByName )(
IDebugSymbolProvider * This,
/* [full][in] */ LPCOLESTR pszFullName,
/* [in] */ NAME_MATCH nameMatch,
/* [out] */ IEnumDebugFields **ppEnum);
HRESULT ( STDMETHODCALLTYPE *GetClassTypeByName )(
IDebugSymbolProvider * This,
/* [full][in] */ LPCOLESTR pszClassName,
/* [in] */ NAME_MATCH nameMatch,
/* [out] */ IDebugClassField **ppField);
HRESULT ( STDMETHODCALLTYPE *GetNamespacesUsedAtAddress )(
IDebugSymbolProvider * This,
/* [in] */ IDebugAddress *pAddress,
/* [out] */ IEnumDebugFields **ppEnum);
HRESULT ( STDMETHODCALLTYPE *GetTypeByName )(
IDebugSymbolProvider * This,
/* [full][in] */ LPCOLESTR pszClassName,
/* [in] */ NAME_MATCH nameMatch,
/* [out] */ IDebugField **ppField);
HRESULT ( STDMETHODCALLTYPE *GetNextAddress )(
IDebugSymbolProvider * This,
/* [in] */ IDebugAddress *pAddress,
/* [in] */ BOOL fStatmentOnly,
/* [out] */ IDebugAddress **ppAddress);
END_INTERFACE
} IDebugSymbolProviderVtbl;
interface IDebugSymbolProvider
{
CONST_VTBL struct IDebugSymbolProviderVtbl *lpVtbl;
};
#ifdef COBJMACROS
#define IDebugSymbolProvider_QueryInterface(This,riid,ppvObject) \
(This)->lpVtbl -> QueryInterface(This,riid,ppvObject)
#define IDebugSymbolProvider_AddRef(This) \
(This)->lpVtbl -> AddRef(This)
#define IDebugSymbolProvider_Release(This) \
(This)->lpVtbl -> Release(This)
#define IDebugSymbolProvider_Initialize(This,pServices) \
(This)->lpVtbl -> Initialize(This,pServices)
#define IDebugSymbolProvider_Uninitialize(This) \
(This)->lpVtbl -> Uninitialize(This)
#define IDebugSymbolProvider_GetContainerField(This,pAddress,ppContainerField) \
(This)->lpVtbl -> GetContainerField(This,pAddress,ppContainerField)
#define IDebugSymbolProvider_GetField(This,pAddress,pAddressCur,ppField) \
(This)->lpVtbl -> GetField(This,pAddress,pAddressCur,ppField)
#define IDebugSymbolProvider_GetAddressesFromPosition(This,pDocPos,fStatmentOnly,ppEnumBegAddresses,ppEnumEndAddresses) \
(This)->lpVtbl -> GetAddressesFromPosition(This,pDocPos,fStatmentOnly,ppEnumBegAddresses,ppEnumEndAddresses)
#define IDebugSymbolProvider_GetAddressesFromContext(This,pDocContext,fStatmentOnly,ppEnumBegAddresses,ppEnumEndAddresses) \
(This)->lpVtbl -> GetAddressesFromContext(This,pDocContext,fStatmentOnly,ppEnumBegAddresses,ppEnumEndAddresses)
#define IDebugSymbolProvider_GetContextFromAddress(This,pAddress,ppDocContext) \
(This)->lpVtbl -> GetContextFromAddress(This,pAddress,ppDocContext)
#define IDebugSymbolProvider_GetLanguage(This,pAddress,pguidLanguage,pguidLanguageVendor) \
(This)->lpVtbl -> GetLanguage(This,pAddress,pguidLanguage,pguidLanguageVendor)
#define IDebugSymbolProvider_GetGlobalContainer(This,pField) \
(This)->lpVtbl -> GetGlobalContainer(This,pField)
#define IDebugSymbolProvider_GetMethodFieldsByName(This,pszFullName,nameMatch,ppEnum) \
(This)->lpVtbl -> GetMethodFieldsByName(This,pszFullName,nameMatch,ppEnum)
#define IDebugSymbolProvider_GetClassTypeByName(This,pszClassName,nameMatch,ppField) \
(This)->lpVtbl -> GetClassTypeByName(This,pszClassName,nameMatch,ppField)
#define IDebugSymbolProvider_GetNamespacesUsedAtAddress(This,pAddress,ppEnum) \
(This)->lpVtbl -> GetNamespacesUsedAtAddress(This,pAddress,ppEnum)
#define IDebugSymbolProvider_GetTypeByName(This,pszClassName,nameMatch,ppField) \
(This)->lpVtbl -> GetTypeByName(This,pszClassName,nameMatch,ppField)
#define IDebugSymbolProvider_GetNextAddress(This,pAddress,fStatmentOnly,ppAddress) \
(This)->lpVtbl -> GetNextAddress(This,pAddress,fStatmentOnly,ppAddress)
#endif /* COBJMACROS */
#endif /* C style interface */
HRESULT STDMETHODCALLTYPE IDebugSymbolProvider_Initialize_Proxy(
IDebugSymbolProvider * This,
/* [in] */ IDebugEngineSymbolProviderServices *pServices);
void __RPC_STUB IDebugSymbolProvider_Initialize_Stub(
IRpcStubBuffer *This,
IRpcChannelBuffer *_pRpcChannelBuffer,
PRPC_MESSAGE _pRpcMessage,
DWORD *_pdwStubPhase);
HRESULT STDMETHODCALLTYPE IDebugSymbolProvider_Uninitialize_Proxy(
IDebugSymbolProvider * This);
void __RPC_STUB IDebugSymbolProvider_Uninitialize_Stub(
IRpcStubBuffer *This,
IRpcChannelBuffer *_pRpcChannelBuffer,
PRPC_MESSAGE _pRpcMessage,
DWORD *_pdwStubPhase);
HRESULT STDMETHODCALLTYPE IDebugSymbolProvider_GetContainerField_Proxy(
IDebugSymbolProvider * This,
/* [in] */ IDebugAddress *pAddress,
/* [out] */ IDebugContainerField **ppContainerField);
void __RPC_STUB IDebugSymbolProvider_GetContainerField_Stub(
IRpcStubBuffer *This,
IRpcChannelBuffer *_pRpcChannelBuffer,
PRPC_MESSAGE _pRpcMessage,
DWORD *_pdwStubPhase);
HRESULT STDMETHODCALLTYPE IDebugSymbolProvider_GetField_Proxy(
IDebugSymbolProvider * This,
/* [in] */ IDebugAddress *pAddress,
/* [in] */ IDebugAddress *pAddressCur,
/* [out] */ IDebugField **ppField);
void __RPC_STUB IDebugSymbolProvider_GetField_Stub(
IRpcStubBuffer *This,
IRpcChannelBuffer *_pRpcChannelBuffer,
PRPC_MESSAGE _pRpcMessage,
DWORD *_pdwStubPhase);
HRESULT STDMETHODCALLTYPE IDebugSymbolProvider_GetAddressesFromPosition_Proxy(
IDebugSymbolProvider * This,
/* [in] */ IDebugDocumentPosition2 *pDocPos,
/* [in] */ BOOL fStatmentOnly,
/* [out] */ IEnumDebugAddresses **ppEnumBegAddresses,
/* [out] */ IEnumDebugAddresses **ppEnumEndAddresses);
void __RPC_STUB IDebugSymbolProvider_GetAddressesFromPosition_Stub(
IRpcStubBuffer *This,
IRpcChannelBuffer *_pRpcChannelBuffer,
PRPC_MESSAGE _pRpcMessage,
DWORD *_pdwStubPhase);
HRESULT STDMETHODCALLTYPE IDebugSymbolProvider_GetAddressesFromContext_Proxy(
IDebugSymbolProvider * This,
/* [in] */ IDebugDocumentContext2 *pDocContext,
/* [in] */ BOOL fStatmentOnly,
/* [out] */ IEnumDebugAddresses **ppEnumBegAddresses,
/* [out] */ IEnumDebugAddresses **ppEnumEndAddresses);
void __RPC_STUB IDebugSymbolProvider_GetAddressesFromContext_Stub(
IRpcStubBuffer *This,
IRpcChannelBuffer *_pRpcChannelBuffer,
PRPC_MESSAGE _pRpcMessage,
DWORD *_pdwStubPhase);
HRESULT STDMETHODCALLTYPE IDebugSymbolProvider_GetContextFromAddress_Proxy(
IDebugSymbolProvider * This,
/* [in] */ IDebugAddress *pAddress,
/* [out] */ IDebugDocumentContext2 **ppDocContext);
void __RPC_STUB IDebugSymbolProvider_GetContextFromAddress_Stub(
IRpcStubBuffer *This,
IRpcChannelBuffer *_pRpcChannelBuffer,
PRPC_MESSAGE _pRpcMessage,
DWORD *_pdwStubPhase);
HRESULT STDMETHODCALLTYPE IDebugSymbolProvider_GetLanguage_Proxy(
IDebugSymbolProvider * This,
/* [in] */ IDebugAddress *pAddress,
/* [out] */ GUID *pguidLanguage,
/* [out] */ GUID *pguidLanguageVendor);
void __RPC_STUB IDebugSymbolProvider_GetLanguage_Stub(
IRpcStubBuffer *This,
IRpcChannelBuffer *_pRpcChannelBuffer,
PRPC_MESSAGE _pRpcMessage,
DWORD *_pdwStubPhase);
HRESULT STDMETHODCALLTYPE IDebugSymbolProvider_GetGlobalContainer_Proxy(
IDebugSymbolProvider * This,
/* [out] */ IDebugContainerField **pField);
void __RPC_STUB IDebugSymbolProvider_GetGlobalContainer_Stub(
IRpcStubBuffer *This,
IRpcChannelBuffer *_pRpcChannelBuffer,
PRPC_MESSAGE _pRpcMessage,
DWORD *_pdwStubPhase);
HRESULT STDMETHODCALLTYPE IDebugSymbolProvider_GetMethodFieldsByName_Proxy(
IDebugSymbolProvider * This,
/* [full][in] */ LPCOLESTR pszFullName,
/* [in] */ NAME_MATCH nameMatch,
/* [out] */ IEnumDebugFields **ppEnum);
void __RPC_STUB IDebugSymbolProvider_GetMethodFieldsByName_Stub(
IRpcStubBuffer *This,
IRpcChannelBuffer *_pRpcChannelBuffer,
PRPC_MESSAGE _pRpcMessage,
DWORD *_pdwStubPhase);
HRESULT STDMETHODCALLTYPE IDebugSymbolProvider_GetClassTypeByName_Proxy(
IDebugSymbolProvider * This,
/* [full][in] */ LPCOLESTR pszClassName,
/* [in] */ NAME_MATCH nameMatch,
/* [out] */ IDebugClassField **ppField);
void __RPC_STUB IDebugSymbolProvider_GetClassTypeByName_Stub(
IRpcStubBuffer *This,
IRpcChannelBuffer *_pRpcChannelBuffer,
PRPC_MESSAGE _pRpcMessage,
DWORD *_pdwStubPhase);
HRESULT STDMETHODCALLTYPE IDebugSymbolProvider_GetNamespacesUsedAtAddress_Proxy(
IDebugSymbolProvider * This,
/* [in] */ IDebugAddress *pAddress,
/* [out] */ IEnumDebugFields **ppEnum);
void __RPC_STUB IDebugSymbolProvider_GetNamespacesUsedAtAddress_Stub(
IRpcStubBuffer *This,
IRpcChannelBuffer *_pRpcChannelBuffer,
PRPC_MESSAGE _pRpcMessage,
DWORD *_pdwStubPhase);
HRESULT STDMETHODCALLTYPE IDebugSymbolProvider_GetTypeByName_Proxy(
IDebugSymbolProvider * This,
/* [full][in] */ LPCOLESTR pszClassName,
/* [in] */ NAME_MATCH nameMatch,
/* [out] */ IDebugField **ppField);
void __RPC_STUB IDebugSymbolProvider_GetTypeByName_Stub(
IRpcStubBuffer *This,
IRpcChannelBuffer *_pRpcChannelBuffer,
PRPC_MESSAGE _pRpcMessage,
DWORD *_pdwStubPhase);
HRESULT STDMETHODCALLTYPE IDebugSymbolProvider_GetNextAddress_Proxy(
IDebugSymbolProvider * This,
/* [in] */ IDebugAddress *pAddress,
/* [in] */ BOOL fStatmentOnly,
/* [out] */ IDebugAddress **ppAddress);
void __RPC_STUB IDebugSymbolProvider_GetNextAddress_Stub(
IRpcStubBuffer *This,
IRpcChannelBuffer *_pRpcChannelBuffer,
PRPC_MESSAGE _pRpcMessage,
DWORD *_pdwStubPhase);
#endif /* __IDebugSymbolProvider_INTERFACE_DEFINED__ */
#ifndef __IDebugSymbolProviderDirect_INTERFACE_DEFINED__
#define __IDebugSymbolProviderDirect_INTERFACE_DEFINED__
/* interface IDebugSymbolProviderDirect */
/* [unique][uuid][object] */
EXTERN_C const IID IID_IDebugSymbolProviderDirect;
#if defined(__cplusplus) && !defined(CINTERFACE)
MIDL_INTERFACE("533A62E9-FDDD-4fef-B7C3-BE4117773087")
IDebugSymbolProviderDirect : public IUnknown
{
public:
virtual HRESULT STDMETHODCALLTYPE GetCurrentModulesState(
DWORD *pState,
unsigned long *count) = 0;
virtual HRESULT STDMETHODCALLTYPE GetMethodFromAddress(
IDebugAddress *pAddress,
GUID *pGuid,
DWORD *pAppID,
_mdToken *pTokenClass,
_mdToken *pTokenMethod,
DWORD *pdwOffset,
DWORD *pdwVersion) = 0;
virtual HRESULT STDMETHODCALLTYPE GetAppIDFromAddress(
IDebugAddress *pAddress,
DWORD *pAppID) = 0;
virtual HRESULT STDMETHODCALLTYPE GetMetaDataImport(
GUID *guid,
DWORD appID,
IUnknown **ppImport) = 0;
virtual HRESULT STDMETHODCALLTYPE GetSymUnmanagedReader(
/* [in] */ ULONG32 ulAppDomainID,
/* [in] */ GUID guidModule,
/* [out] */ IUnknown **ppSymUnmanagedReader) = 0;
virtual HRESULT STDMETHODCALLTYPE GetCurrentModulesInfo(
unsigned long *pCount,
GUID *ppGuids,
DWORD *pADIds,
DWORD *pCurrentState,
IUnknown **ppCDModItfs) = 0;
};
#else /* C style interface */
typedef struct IDebugSymbolProviderDirectVtbl
{
BEGIN_INTERFACE
HRESULT ( STDMETHODCALLTYPE *QueryInterface )(
IDebugSymbolProviderDirect * This,
/* [in] */ REFIID riid,
/* [iid_is][out] */ void **ppvObject);
ULONG ( STDMETHODCALLTYPE *AddRef )(
IDebugSymbolProviderDirect * This);
ULONG ( STDMETHODCALLTYPE *Release )(
IDebugSymbolProviderDirect * This);
HRESULT ( STDMETHODCALLTYPE *GetCurrentModulesState )(
IDebugSymbolProviderDirect * This,
DWORD *pState,
unsigned long *count);
HRESULT ( STDMETHODCALLTYPE *GetMethodFromAddress )(
IDebugSymbolProviderDirect * This,
IDebugAddress *pAddress,
GUID *pGuid,
DWORD *pAppID,
_mdToken *pTokenClass,
_mdToken *pTokenMethod,
DWORD *pdwOffset,
DWORD *pdwVersion);
HRESULT ( STDMETHODCALLTYPE *GetAppIDFromAddress )(
IDebugSymbolProviderDirect * This,
IDebugAddress *pAddress,
DWORD *pAppID);
HRESULT ( STDMETHODCALLTYPE *GetMetaDataImport )(
IDebugSymbolProviderDirect * This,
GUID *guid,
DWORD appID,
IUnknown **ppImport);
HRESULT ( STDMETHODCALLTYPE *GetSymUnmanagedReader )(
IDebugSymbolProviderDirect * This,
/* [in] */ ULONG32 ulAppDomainID,
/* [in] */ GUID guidModule,
/* [out] */ IUnknown **ppSymUnmanagedReader);
HRESULT ( STDMETHODCALLTYPE *GetCurrentModulesInfo )(
IDebugSymbolProviderDirect * This,
unsigned long *pCount,
GUID *ppGuids,
DWORD *pADIds,
DWORD *pCurrentState,
IUnknown **ppCDModItfs);
END_INTERFACE
} IDebugSymbolProviderDirectVtbl;
interface IDebugSymbolProviderDirect
{
CONST_VTBL struct IDebugSymbolProviderDirectVtbl *lpVtbl;
};
#ifdef COBJMACROS
#define IDebugSymbolProviderDirect_QueryInterface(This,riid,ppvObject) \
(This)->lpVtbl -> QueryInterface(This,riid,ppvObject)
#define IDebugSymbolProviderDirect_AddRef(This) \
(This)->lpVtbl -> AddRef(This)
#define IDebugSymbolProviderDirect_Release(This) \
(This)->lpVtbl -> Release(This)
#define IDebugSymbolProviderDirect_GetCurrentModulesState(This,pState,count) \
(This)->lpVtbl -> GetCurrentModulesState(This,pState,count)
#define IDebugSymbolProviderDirect_GetMethodFromAddress(This,pAddress,pGuid,pAppID,pTokenClass,pTokenMethod,pdwOffset,pdwVersion) \
(This)->lpVtbl -> GetMethodFromAddress(This,pAddress,pGuid,pAppID,pTokenClass,pTokenMethod,pdwOffset,pdwVersion)
#define IDebugSymbolProviderDirect_GetAppIDFromAddress(This,pAddress,pAppID) \
(This)->lpVtbl -> GetAppIDFromAddress(This,pAddress,pAppID)
#define IDebugSymbolProviderDirect_GetMetaDataImport(This,guid,appID,ppImport) \
(This)->lpVtbl -> GetMetaDataImport(This,guid,appID,ppImport)
#define IDebugSymbolProviderDirect_GetSymUnmanagedReader(This,ulAppDomainID,guidModule,ppSymUnmanagedReader) \
(This)->lpVtbl -> GetSymUnmanagedReader(This,ulAppDomainID,guidModule,ppSymUnmanagedReader)
#define IDebugSymbolProviderDirect_GetCurrentModulesInfo(This,pCount,ppGuids,pADIds,pCurrentState,ppCDModItfs) \
(This)->lpVtbl -> GetCurrentModulesInfo(This,pCount,ppGuids,pADIds,pCurrentState,ppCDModItfs)
#endif /* COBJMACROS */
#endif /* C style interface */
HRESULT STDMETHODCALLTYPE IDebugSymbolProviderDirect_GetCurrentModulesState_Proxy(
IDebugSymbolProviderDirect * This,
DWORD *pState,
unsigned long *count);
void __RPC_STUB IDebugSymbolProviderDirect_GetCurrentModulesState_Stub(
IRpcStubBuffer *This,
IRpcChannelBuffer *_pRpcChannelBuffer,
PRPC_MESSAGE _pRpcMessage,
DWORD *_pdwStubPhase);
HRESULT STDMETHODCALLTYPE IDebugSymbolProviderDirect_GetMethodFromAddress_Proxy(
IDebugSymbolProviderDirect * This,
IDebugAddress *pAddress,
GUID *pGuid,
DWORD *pAppID,
_mdToken *pTokenClass,
_mdToken *pTokenMethod,
DWORD *pdwOffset,
DWORD *pdwVersion);
void __RPC_STUB IDebugSymbolProviderDirect_GetMethodFromAddress_Stub(
IRpcStubBuffer *This,
IRpcChannelBuffer *_pRpcChannelBuffer,
PRPC_MESSAGE _pRpcMessage,
DWORD *_pdwStubPhase);
HRESULT STDMETHODCALLTYPE IDebugSymbolProviderDirect_GetAppIDFromAddress_Proxy(
IDebugSymbolProviderDirect * This,
IDebugAddress *pAddress,
DWORD *pAppID);
void __RPC_STUB IDebugSymbolProviderDirect_GetAppIDFromAddress_Stub(
IRpcStubBuffer *This,
IRpcChannelBuffer *_pRpcChannelBuffer,
PRPC_MESSAGE _pRpcMessage,
DWORD *_pdwStubPhase);
HRESULT STDMETHODCALLTYPE IDebugSymbolProviderDirect_GetMetaDataImport_Proxy(
IDebugSymbolProviderDirect * This,
GUID *guid,
DWORD appID,
IUnknown **ppImport);
void __RPC_STUB IDebugSymbolProviderDirect_GetMetaDataImport_Stub(
IRpcStubBuffer *This,
IRpcChannelBuffer *_pRpcChannelBuffer,
PRPC_MESSAGE _pRpcMessage,
DWORD *_pdwStubPhase);
HRESULT STDMETHODCALLTYPE IDebugSymbolProviderDirect_GetSymUnmanagedReader_Proxy(
IDebugSymbolProviderDirect * This,
/* [in] */ ULONG32 ulAppDomainID,
/* [in] */ GUID guidModule,
/* [out] */ IUnknown **ppSymUnmanagedReader);
void __RPC_STUB IDebugSymbolProviderDirect_GetSymUnmanagedReader_Stub(
IRpcStubBuffer *This,
IRpcChannelBuffer *_pRpcChannelBuffer,
PRPC_MESSAGE _pRpcMessage,
DWORD *_pdwStubPhase);
HRESULT STDMETHODCALLTYPE IDebugSymbolProviderDirect_GetCurrentModulesInfo_Proxy(
IDebugSymbolProviderDirect * This,
unsigned long *pCount,
GUID *ppGuids,
DWORD *pADIds,
DWORD *pCurrentState,
IUnknown **ppCDModItfs);
void __RPC_STUB IDebugSymbolProviderDirect_GetCurrentModulesInfo_Stub(
IRpcStubBuffer *This,
IRpcChannelBuffer *_pRpcChannelBuffer,
PRPC_MESSAGE _pRpcMessage,
DWORD *_pdwStubPhase);
#endif /* __IDebugSymbolProviderDirect_INTERFACE_DEFINED__ */
#ifndef __IDebugComPlusSymbolProvider_INTERFACE_DEFINED__
#define __IDebugComPlusSymbolProvider_INTERFACE_DEFINED__
/* interface IDebugComPlusSymbolProvider */
/* [unique][uuid][object] */
EXTERN_C const IID IID_IDebugComPlusSymbolProvider;
#if defined(__cplusplus) && !defined(CINTERFACE)
MIDL_INTERFACE("c2e34eaf-8b9d-11d2-9014-00c04fa38338")
IDebugComPlusSymbolProvider : public IDebugSymbolProvider
{
public:
virtual HRESULT STDMETHODCALLTYPE LoadSymbols(
/* [in] */ ULONG32 ulAppDomainID,
/* [in] */ GUID guidModule,
/* [in] */ ULONGLONG baseAddress,
/* [in] */ IUnknown *pUnkMetadataImport,
/* [in] */ BSTR bstrModuleName,
/* [in] */ BSTR bstrSymSearchPath) = 0;
virtual HRESULT STDMETHODCALLTYPE UnloadSymbols(
/* [in] */ ULONG32 ulAppDomainID,
/* [in] */ GUID guidModule) = 0;
virtual HRESULT STDMETHODCALLTYPE GetEntryPoint(
/* [in] */ ULONG32 ulAppDomainID,
/* [in] */ GUID guidModule,
/* [out] */ IDebugAddress **ppAddress) = 0;
virtual HRESULT STDMETHODCALLTYPE GetTypeFromAddress(
/* [in] */ IDebugAddress *pAddress,
/* [out] */ IDebugField **ppField) = 0;
virtual HRESULT STDMETHODCALLTYPE UpdateSymbols(
/* [in] */ ULONG32 ulAppDomainID,
/* [in] */ GUID guidModule,
/* [in] */ IStream *pUpdateStream) = 0;
virtual HRESULT STDMETHODCALLTYPE CreateTypeFromPrimitive(
/* [in] */ DWORD dwPrimType,
/* [in] */ IDebugAddress *pAddress,
/* [in] */ IDebugField **ppType) = 0;
virtual HRESULT STDMETHODCALLTYPE GetFunctionLineOffset(
/* [in] */ IDebugAddress *pAddress,
/* [in] */ DWORD dwLine,
/* [out] */ IDebugAddress **ppNewAddress) = 0;
virtual HRESULT STDMETHODCALLTYPE GetAddressesInModuleFromPosition(
/* [in] */ ULONG32 ulAppDomainID,
/* [in] */ GUID guidModule,
/* [in] */ IDebugDocumentPosition2 *pDocPos,
/* [in] */ BOOL fStatmentOnly,
/* [out] */ IEnumDebugAddresses **ppEnumBegAddresses,
/* [out] */ IEnumDebugAddresses **ppEnumEndAddresses) = 0;
virtual HRESULT STDMETHODCALLTYPE GetArrayTypeFromAddress(
/* [in] */ IDebugAddress *pAddress,
/* [length_is][size_is][in] */ BYTE *pSig,
/* [in] */ DWORD dwSigLength,
/* [out] */ IDebugField **ppField) = 0;
virtual HRESULT STDMETHODCALLTYPE GetSymAttribute(
/* [in] */ ULONG32 ulAppDomainID,
/* [in] */ GUID guidModule,
/* [in] */ _mdToken tokParent,
/* [in] */ LPOLESTR pstrName,
/* [in] */ ULONG32 cBuffer,
/* [out] */ ULONG32 *pcBuffer,
/* [length_is][size_is][out] */ BYTE *buffer) = 0;
virtual HRESULT STDMETHODCALLTYPE ReplaceSymbols(
/* [in] */ ULONG32 ulAppDomainID,
/* [in] */ GUID guidModule,
/* [in] */ IStream *pStream) = 0;
virtual HRESULT STDMETHODCALLTYPE AreSymbolsLoaded(
/* [in] */ ULONG32 ulAppDomainID,
/* [in] */ GUID guidModule) = 0;
virtual HRESULT STDMETHODCALLTYPE LoadSymbolsFromStream(
/* [in] */ ULONG32 ulAppDomainID,
/* [in] */ GUID guidModule,
/* [in] */ ULONGLONG baseAddress,
/* [in] */ IUnknown *pUnkMetadataImport,
/* [in] */ IStream *pStream) = 0;
virtual HRESULT STDMETHODCALLTYPE GetSymUnmanagedReader(
/* [in] */ ULONG32 ulAppDomainID,
/* [in] */ GUID guidModule,
/* [out] */ IUnknown **ppSymUnmanagedReader) = 0;
virtual HRESULT STDMETHODCALLTYPE GetAttributedClassesinModule(
/* [in] */ ULONG32 ulAppDomainID,
/* [in] */ GUID guidModule,
/* [in] */ LPOLESTR pstrAttribute,
/* [out] */ IEnumDebugFields **ppEnum) = 0;
virtual HRESULT STDMETHODCALLTYPE GetAttributedClassesForLanguage(
/* [in] */ GUID guidLanguage,
/* [in] */ LPOLESTR pstrAttribute,
/* [out] */ IEnumDebugFields **ppEnum) = 0;
virtual HRESULT STDMETHODCALLTYPE IsHiddenCode(
/* [in] */ IDebugAddress *pAddress) = 0;
virtual HRESULT STDMETHODCALLTYPE IsFunctionDeleted(
/* [in] */ IDebugAddress *pAddress) = 0;
virtual HRESULT STDMETHODCALLTYPE GetNameFromToken(
/* [in] */ IUnknown *pMetadataImport,
/* [in] */ DWORD dwToken,
/* [out] */ BSTR *pbstrName) = 0;
virtual HRESULT STDMETHODCALLTYPE IsFunctionStale(
/* [in] */ IDebugAddress *pAddress) = 0;
virtual HRESULT STDMETHODCALLTYPE GetLocalVariablelayout(
/* [in] */ ULONG32 ulAppDomainID,
/* [in] */ GUID guidModule,
/* [in] */ ULONG32 cMethods,
/* [size_is][in] */ _mdToken rgMethodTokens[ ],
/* [out] */ IStream **pStreamLayout) = 0;
virtual HRESULT STDMETHODCALLTYPE GetAssemblyName(
/* [in] */ ULONG32 ulAppDomainID,
/* [in] */ GUID guidModule,
/* [out] */ BSTR *pbstrName) = 0;
};
#else /* C style interface */
typedef struct IDebugComPlusSymbolProviderVtbl
{
BEGIN_INTERFACE
HRESULT ( STDMETHODCALLTYPE *QueryInterface )(
IDebugComPlusSymbolProvider * This,
/* [in] */ REFIID riid,
/* [iid_is][out] */ void **ppvObject);
ULONG ( STDMETHODCALLTYPE *AddRef )(
IDebugComPlusSymbolProvider * This);
ULONG ( STDMETHODCALLTYPE *Release )(
IDebugComPlusSymbolProvider * This);
HRESULT ( STDMETHODCALLTYPE *Initialize )(
IDebugComPlusSymbolProvider * This,
/* [in] */ IDebugEngineSymbolProviderServices *pServices);
HRESULT ( STDMETHODCALLTYPE *Uninitialize )(
IDebugComPlusSymbolProvider * This);
HRESULT ( STDMETHODCALLTYPE *GetContainerField )(
IDebugComPlusSymbolProvider * This,
/* [in] */ IDebugAddress *pAddress,
/* [out] */ IDebugContainerField **ppContainerField);
HRESULT ( STDMETHODCALLTYPE *GetField )(
IDebugComPlusSymbolProvider * This,
/* [in] */ IDebugAddress *pAddress,
/* [in] */ IDebugAddress *pAddressCur,
/* [out] */ IDebugField **ppField);
HRESULT ( STDMETHODCALLTYPE *GetAddressesFromPosition )(
IDebugComPlusSymbolProvider * This,
/* [in] */ IDebugDocumentPosition2 *pDocPos,
/* [in] */ BOOL fStatmentOnly,
/* [out] */ IEnumDebugAddresses **ppEnumBegAddresses,
/* [out] */ IEnumDebugAddresses **ppEnumEndAddresses);
HRESULT ( STDMETHODCALLTYPE *GetAddressesFromContext )(
IDebugComPlusSymbolProvider * This,
/* [in] */ IDebugDocumentContext2 *pDocContext,
/* [in] */ BOOL fStatmentOnly,
/* [out] */ IEnumDebugAddresses **ppEnumBegAddresses,
/* [out] */ IEnumDebugAddresses **ppEnumEndAddresses);
HRESULT ( STDMETHODCALLTYPE *GetContextFromAddress )(
IDebugComPlusSymbolProvider * This,
/* [in] */ IDebugAddress *pAddress,
/* [out] */ IDebugDocumentContext2 **ppDocContext);
HRESULT ( STDMETHODCALLTYPE *GetLanguage )(
IDebugComPlusSymbolProvider * This,
/* [in] */ IDebugAddress *pAddress,
/* [out] */ GUID *pguidLanguage,
/* [out] */ GUID *pguidLanguageVendor);
HRESULT ( STDMETHODCALLTYPE *GetGlobalContainer )(
IDebugComPlusSymbolProvider * This,
/* [out] */ IDebugContainerField **pField);
HRESULT ( STDMETHODCALLTYPE *GetMethodFieldsByName )(
IDebugComPlusSymbolProvider * This,
/* [full][in] */ LPCOLESTR pszFullName,
/* [in] */ NAME_MATCH nameMatch,
/* [out] */ IEnumDebugFields **ppEnum);
HRESULT ( STDMETHODCALLTYPE *GetClassTypeByName )(
IDebugComPlusSymbolProvider * This,
/* [full][in] */ LPCOLESTR pszClassName,
/* [in] */ NAME_MATCH nameMatch,
/* [out] */ IDebugClassField **ppField);
HRESULT ( STDMETHODCALLTYPE *GetNamespacesUsedAtAddress )(
IDebugComPlusSymbolProvider * This,
/* [in] */ IDebugAddress *pAddress,
/* [out] */ IEnumDebugFields **ppEnum);
HRESULT ( STDMETHODCALLTYPE *GetTypeByName )(
IDebugComPlusSymbolProvider * This,
/* [full][in] */ LPCOLESTR pszClassName,
/* [in] */ NAME_MATCH nameMatch,
/* [out] */ IDebugField **ppField);
HRESULT ( STDMETHODCALLTYPE *GetNextAddress )(
IDebugComPlusSymbolProvider * This,
/* [in] */ IDebugAddress *pAddress,
/* [in] */ BOOL fStatmentOnly,
/* [out] */ IDebugAddress **ppAddress);
HRESULT ( STDMETHODCALLTYPE *LoadSymbols )(
IDebugComPlusSymbolProvider * This,
/* [in] */ ULONG32 ulAppDomainID,
/* [in] */ GUID guidModule,
/* [in] */ ULONGLONG baseAddress,
/* [in] */ IUnknown *pUnkMetadataImport,
/* [in] */ BSTR bstrModuleName,
/* [in] */ BSTR bstrSymSearchPath);
HRESULT ( STDMETHODCALLTYPE *UnloadSymbols )(
IDebugComPlusSymbolProvider * This,
/* [in] */ ULONG32 ulAppDomainID,
/* [in] */ GUID guidModule);
HRESULT ( STDMETHODCALLTYPE *GetEntryPoint )(
IDebugComPlusSymbolProvider * This,
/* [in] */ ULONG32 ulAppDomainID,
/* [in] */ GUID guidModule,
/* [out] */ IDebugAddress **ppAddress);
HRESULT ( STDMETHODCALLTYPE *GetTypeFromAddress )(
IDebugComPlusSymbolProvider * This,
/* [in] */ IDebugAddress *pAddress,
/* [out] */ IDebugField **ppField);
HRESULT ( STDMETHODCALLTYPE *UpdateSymbols )(
IDebugComPlusSymbolProvider * This,
/* [in] */ ULONG32 ulAppDomainID,
/* [in] */ GUID guidModule,
/* [in] */ IStream *pUpdateStream);
HRESULT ( STDMETHODCALLTYPE *CreateTypeFromPrimitive )(
IDebugComPlusSymbolProvider * This,
/* [in] */ DWORD dwPrimType,
/* [in] */ IDebugAddress *pAddress,
/* [in] */ IDebugField **ppType);
HRESULT ( STDMETHODCALLTYPE *GetFunctionLineOffset )(
IDebugComPlusSymbolProvider * This,
/* [in] */ IDebugAddress *pAddress,
/* [in] */ DWORD dwLine,
/* [out] */ IDebugAddress **ppNewAddress);
HRESULT ( STDMETHODCALLTYPE *GetAddressesInModuleFromPosition )(
IDebugComPlusSymbolProvider * This,
/* [in] */ ULONG32 ulAppDomainID,
/* [in] */ GUID guidModule,
/* [in] */ IDebugDocumentPosition2 *pDocPos,
/* [in] */ BOOL fStatmentOnly,
/* [out] */ IEnumDebugAddresses **ppEnumBegAddresses,
/* [out] */ IEnumDebugAddresses **ppEnumEndAddresses);
HRESULT ( STDMETHODCALLTYPE *GetArrayTypeFromAddress )(
IDebugComPlusSymbolProvider * This,
/* [in] */ IDebugAddress *pAddress,
/* [length_is][size_is][in] */ BYTE *pSig,
/* [in] */ DWORD dwSigLength,
/* [out] */ IDebugField **ppField);
HRESULT ( STDMETHODCALLTYPE *GetSymAttribute )(
IDebugComPlusSymbolProvider * This,
/* [in] */ ULONG32 ulAppDomainID,
/* [in] */ GUID guidModule,
/* [in] */ _mdToken tokParent,
/* [in] */ LPOLESTR pstrName,
/* [in] */ ULONG32 cBuffer,
/* [out] */ ULONG32 *pcBuffer,
/* [length_is][size_is][out] */ BYTE *buffer);
HRESULT ( STDMETHODCALLTYPE *ReplaceSymbols )(
IDebugComPlusSymbolProvider * This,
/* [in] */ ULONG32 ulAppDomainID,
/* [in] */ GUID guidModule,
/* [in] */ IStream *pStream);
HRESULT ( STDMETHODCALLTYPE *AreSymbolsLoaded )(
IDebugComPlusSymbolProvider * This,
/* [in] */ ULONG32 ulAppDomainID,
/* [in] */ GUID guidModule);
HRESULT ( STDMETHODCALLTYPE *LoadSymbolsFromStream )(
IDebugComPlusSymbolProvider * This,
/* [in] */ ULONG32 ulAppDomainID,
/* [in] */ GUID guidModule,
/* [in] */ ULONGLONG baseAddress,
/* [in] */ IUnknown *pUnkMetadataImport,
/* [in] */ IStream *pStream);
HRESULT ( STDMETHODCALLTYPE *GetSymUnmanagedReader )(
IDebugComPlusSymbolProvider * This,
/* [in] */ ULONG32 ulAppDomainID,
/* [in] */ GUID guidModule,
/* [out] */ IUnknown **ppSymUnmanagedReader);
HRESULT ( STDMETHODCALLTYPE *GetAttributedClassesinModule )(
IDebugComPlusSymbolProvider * This,
/* [in] */ ULONG32 ulAppDomainID,
/* [in] */ GUID guidModule,
/* [in] */ LPOLESTR pstrAttribute,
/* [out] */ IEnumDebugFields **ppEnum);
HRESULT ( STDMETHODCALLTYPE *GetAttributedClassesForLanguage )(
IDebugComPlusSymbolProvider * This,
/* [in] */ GUID guidLanguage,
/* [in] */ LPOLESTR pstrAttribute,
/* [out] */ IEnumDebugFields **ppEnum);
HRESULT ( STDMETHODCALLTYPE *IsHiddenCode )(
IDebugComPlusSymbolProvider * This,
/* [in] */ IDebugAddress *pAddress);
HRESULT ( STDMETHODCALLTYPE *IsFunctionDeleted )(
IDebugComPlusSymbolProvider * This,
/* [in] */ IDebugAddress *pAddress);
HRESULT ( STDMETHODCALLTYPE *GetNameFromToken )(
IDebugComPlusSymbolProvider * This,
/* [in] */ IUnknown *pMetadataImport,
/* [in] */ DWORD dwToken,
/* [out] */ BSTR *pbstrName);
HRESULT ( STDMETHODCALLTYPE *IsFunctionStale )(
IDebugComPlusSymbolProvider * This,
/* [in] */ IDebugAddress *pAddress);
HRESULT ( STDMETHODCALLTYPE *GetLocalVariablelayout )(
IDebugComPlusSymbolProvider * This,
/* [in] */ ULONG32 ulAppDomainID,
/* [in] */ GUID guidModule,
/* [in] */ ULONG32 cMethods,
/* [size_is][in] */ _mdToken rgMethodTokens[ ],
/* [out] */ IStream **pStreamLayout);
HRESULT ( STDMETHODCALLTYPE *GetAssemblyName )(
IDebugComPlusSymbolProvider * This,
/* [in] */ ULONG32 ulAppDomainID,
/* [in] */ GUID guidModule,
/* [out] */ BSTR *pbstrName);
END_INTERFACE
} IDebugComPlusSymbolProviderVtbl;
interface IDebugComPlusSymbolProvider
{
CONST_VTBL struct IDebugComPlusSymbolProviderVtbl *lpVtbl;
};
#ifdef COBJMACROS
#define IDebugComPlusSymbolProvider_QueryInterface(This,riid,ppvObject) \
(This)->lpVtbl -> QueryInterface(This,riid,ppvObject)
#define IDebugComPlusSymbolProvider_AddRef(This) \
(This)->lpVtbl -> AddRef(This)
#define IDebugComPlusSymbolProvider_Release(This) \
(This)->lpVtbl -> Release(This)
#define IDebugComPlusSymbolProvider_Initialize(This,pServices) \
(This)->lpVtbl -> Initialize(This,pServices)
#define IDebugComPlusSymbolProvider_Uninitialize(This) \
(This)->lpVtbl -> Uninitialize(This)
#define IDebugComPlusSymbolProvider_GetContainerField(This,pAddress,ppContainerField) \
(This)->lpVtbl -> GetContainerField(This,pAddress,ppContainerField)
#define IDebugComPlusSymbolProvider_GetField(This,pAddress,pAddressCur,ppField) \
(This)->lpVtbl -> GetField(This,pAddress,pAddressCur,ppField)
#define IDebugComPlusSymbolProvider_GetAddressesFromPosition(This,pDocPos,fStatmentOnly,ppEnumBegAddresses,ppEnumEndAddresses) \
(This)->lpVtbl -> GetAddressesFromPosition(This,pDocPos,fStatmentOnly,ppEnumBegAddresses,ppEnumEndAddresses)
#define IDebugComPlusSymbolProvider_GetAddressesFromContext(This,pDocContext,fStatmentOnly,ppEnumBegAddresses,ppEnumEndAddresses) \
(This)->lpVtbl -> GetAddressesFromContext(This,pDocContext,fStatmentOnly,ppEnumBegAddresses,ppEnumEndAddresses)
#define IDebugComPlusSymbolProvider_GetContextFromAddress(This,pAddress,ppDocContext) \
(This)->lpVtbl -> GetContextFromAddress(This,pAddress,ppDocContext)
#define IDebugComPlusSymbolProvider_GetLanguage(This,pAddress,pguidLanguage,pguidLanguageVendor) \
(This)->lpVtbl -> GetLanguage(This,pAddress,pguidLanguage,pguidLanguageVendor)
#define IDebugComPlusSymbolProvider_GetGlobalContainer(This,pField) \
(This)->lpVtbl -> GetGlobalContainer(This,pField)
#define IDebugComPlusSymbolProvider_GetMethodFieldsByName(This,pszFullName,nameMatch,ppEnum) \
(This)->lpVtbl -> GetMethodFieldsByName(This,pszFullName,nameMatch,ppEnum)
#define IDebugComPlusSymbolProvider_GetClassTypeByName(This,pszClassName,nameMatch,ppField) \
(This)->lpVtbl -> GetClassTypeByName(This,pszClassName,nameMatch,ppField)
#define IDebugComPlusSymbolProvider_GetNamespacesUsedAtAddress(This,pAddress,ppEnum) \
(This)->lpVtbl -> GetNamespacesUsedAtAddress(This,pAddress,ppEnum)
#define IDebugComPlusSymbolProvider_GetTypeByName(This,pszClassName,nameMatch,ppField) \
(This)->lpVtbl -> GetTypeByName(This,pszClassName,nameMatch,ppField)
#define IDebugComPlusSymbolProvider_GetNextAddress(This,pAddress,fStatmentOnly,ppAddress) \
(This)->lpVtbl -> GetNextAddress(This,pAddress,fStatmentOnly,ppAddress)
#define IDebugComPlusSymbolProvider_LoadSymbols(This,ulAppDomainID,guidModule,baseAddress,pUnkMetadataImport,bstrModuleName,bstrSymSearchPath) \
(This)->lpVtbl -> LoadSymbols(This,ulAppDomainID,guidModule,baseAddress,pUnkMetadataImport,bstrModuleName,bstrSymSearchPath)
#define IDebugComPlusSymbolProvider_UnloadSymbols(This,ulAppDomainID,guidModule) \
(This)->lpVtbl -> UnloadSymbols(This,ulAppDomainID,guidModule)
#define IDebugComPlusSymbolProvider_GetEntryPoint(This,ulAppDomainID,guidModule,ppAddress) \
(This)->lpVtbl -> GetEntryPoint(This,ulAppDomainID,guidModule,ppAddress)
#define IDebugComPlusSymbolProvider_GetTypeFromAddress(This,pAddress,ppField) \
(This)->lpVtbl -> GetTypeFromAddress(This,pAddress,ppField)
#define IDebugComPlusSymbolProvider_UpdateSymbols(This,ulAppDomainID,guidModule,pUpdateStream) \
(This)->lpVtbl -> UpdateSymbols(This,ulAppDomainID,guidModule,pUpdateStream)
#define IDebugComPlusSymbolProvider_CreateTypeFromPrimitive(This,dwPrimType,pAddress,ppType) \
(This)->lpVtbl -> CreateTypeFromPrimitive(This,dwPrimType,pAddress,ppType)
#define IDebugComPlusSymbolProvider_GetFunctionLineOffset(This,pAddress,dwLine,ppNewAddress) \
(This)->lpVtbl -> GetFunctionLineOffset(This,pAddress,dwLine,ppNewAddress)
#define IDebugComPlusSymbolProvider_GetAddressesInModuleFromPosition(This,ulAppDomainID,guidModule,pDocPos,fStatmentOnly,ppEnumBegAddresses,ppEnumEndAddresses) \
(This)->lpVtbl -> GetAddressesInModuleFromPosition(This,ulAppDomainID,guidModule,pDocPos,fStatmentOnly,ppEnumBegAddresses,ppEnumEndAddresses)
#define IDebugComPlusSymbolProvider_GetArrayTypeFromAddress(This,pAddress,pSig,dwSigLength,ppField) \
(This)->lpVtbl -> GetArrayTypeFromAddress(This,pAddress,pSig,dwSigLength,ppField)
#define IDebugComPlusSymbolProvider_GetSymAttribute(This,ulAppDomainID,guidModule,tokParent,pstrName,cBuffer,pcBuffer,buffer) \
(This)->lpVtbl -> GetSymAttribute(This,ulAppDomainID,guidModule,tokParent,pstrName,cBuffer,pcBuffer,buffer)
#define IDebugComPlusSymbolProvider_ReplaceSymbols(This,ulAppDomainID,guidModule,pStream) \
(This)->lpVtbl -> ReplaceSymbols(This,ulAppDomainID,guidModule,pStream)
#define IDebugComPlusSymbolProvider_AreSymbolsLoaded(This,ulAppDomainID,guidModule) \
(This)->lpVtbl -> AreSymbolsLoaded(This,ulAppDomainID,guidModule)
#define IDebugComPlusSymbolProvider_LoadSymbolsFromStream(This,ulAppDomainID,guidModule,baseAddress,pUnkMetadataImport,pStream) \
(This)->lpVtbl -> LoadSymbolsFromStream(This,ulAppDomainID,guidModule,baseAddress,pUnkMetadataImport,pStream)
#define IDebugComPlusSymbolProvider_GetSymUnmanagedReader(This,ulAppDomainID,guidModule,ppSymUnmanagedReader) \
(This)->lpVtbl -> GetSymUnmanagedReader(This,ulAppDomainID,guidModule,ppSymUnmanagedReader)
#define IDebugComPlusSymbolProvider_GetAttributedClassesinModule(This,ulAppDomainID,guidModule,pstrAttribute,ppEnum) \
(This)->lpVtbl -> GetAttributedClassesinModule(This,ulAppDomainID,guidModule,pstrAttribute,ppEnum)
#define IDebugComPlusSymbolProvider_GetAttributedClassesForLanguage(This,guidLanguage,pstrAttribute,ppEnum) \
(This)->lpVtbl -> GetAttributedClassesForLanguage(This,guidLanguage,pstrAttribute,ppEnum)
#define IDebugComPlusSymbolProvider_IsHiddenCode(This,pAddress) \
(This)->lpVtbl -> IsHiddenCode(This,pAddress)
#define IDebugComPlusSymbolProvider_IsFunctionDeleted(This,pAddress) \
(This)->lpVtbl -> IsFunctionDeleted(This,pAddress)
#define IDebugComPlusSymbolProvider_GetNameFromToken(This,pMetadataImport,dwToken,pbstrName) \
(This)->lpVtbl -> GetNameFromToken(This,pMetadataImport,dwToken,pbstrName)
#define IDebugComPlusSymbolProvider_IsFunctionStale(This,pAddress) \
(This)->lpVtbl -> IsFunctionStale(This,pAddress)
#define IDebugComPlusSymbolProvider_GetLocalVariablelayout(This,ulAppDomainID,guidModule,cMethods,rgMethodTokens,pStreamLayout) \
(This)->lpVtbl -> GetLocalVariablelayout(This,ulAppDomainID,guidModule,cMethods,rgMethodTokens,pStreamLayout)
#define IDebugComPlusSymbolProvider_GetAssemblyName(This,ulAppDomainID,guidModule,pbstrName) \
(This)->lpVtbl -> GetAssemblyName(This,ulAppDomainID,guidModule,pbstrName)
#endif /* COBJMACROS */
#endif /* C style interface */
HRESULT STDMETHODCALLTYPE IDebugComPlusSymbolProvider_LoadSymbols_Proxy(
IDebugComPlusSymbolProvider * This,
/* [in] */ ULONG32 ulAppDomainID,
/* [in] */ GUID guidModule,
/* [in] */ ULONGLONG baseAddress,
/* [in] */ IUnknown *pUnkMetadataImport,
/* [in] */ BSTR bstrModuleName,
/* [in] */ BSTR bstrSymSearchPath);
void __RPC_STUB IDebugComPlusSymbolProvider_LoadSymbols_Stub(
IRpcStubBuffer *This,
IRpcChannelBuffer *_pRpcChannelBuffer,
PRPC_MESSAGE _pRpcMessage,
DWORD *_pdwStubPhase);
HRESULT STDMETHODCALLTYPE IDebugComPlusSymbolProvider_UnloadSymbols_Proxy(
IDebugComPlusSymbolProvider * This,
/* [in] */ ULONG32 ulAppDomainID,
/* [in] */ GUID guidModule);
void __RPC_STUB IDebugComPlusSymbolProvider_UnloadSymbols_Stub(
IRpcStubBuffer *This,
IRpcChannelBuffer *_pRpcChannelBuffer,
PRPC_MESSAGE _pRpcMessage,
DWORD *_pdwStubPhase);
HRESULT STDMETHODCALLTYPE IDebugComPlusSymbolProvider_GetEntryPoint_Proxy(
IDebugComPlusSymbolProvider * This,
/* [in] */ ULONG32 ulAppDomainID,
/* [in] */ GUID guidModule,
/* [out] */ IDebugAddress **ppAddress);
void __RPC_STUB IDebugComPlusSymbolProvider_GetEntryPoint_Stub(
IRpcStubBuffer *This,
IRpcChannelBuffer *_pRpcChannelBuffer,
PRPC_MESSAGE _pRpcMessage,
DWORD *_pdwStubPhase);
HRESULT STDMETHODCALLTYPE IDebugComPlusSymbolProvider_GetTypeFromAddress_Proxy(
IDebugComPlusSymbolProvider * This,
/* [in] */ IDebugAddress *pAddress,
/* [out] */ IDebugField **ppField);
void __RPC_STUB IDebugComPlusSymbolProvider_GetTypeFromAddress_Stub(
IRpcStubBuffer *This,
IRpcChannelBuffer *_pRpcChannelBuffer,
PRPC_MESSAGE _pRpcMessage,
DWORD *_pdwStubPhase);
HRESULT STDMETHODCALLTYPE IDebugComPlusSymbolProvider_UpdateSymbols_Proxy(
IDebugComPlusSymbolProvider * This,
/* [in] */ ULONG32 ulAppDomainID,
/* [in] */ GUID guidModule,
/* [in] */ IStream *pUpdateStream);
void __RPC_STUB IDebugComPlusSymbolProvider_UpdateSymbols_Stub(
IRpcStubBuffer *This,
IRpcChannelBuffer *_pRpcChannelBuffer,
PRPC_MESSAGE _pRpcMessage,
DWORD *_pdwStubPhase);
HRESULT STDMETHODCALLTYPE IDebugComPlusSymbolProvider_CreateTypeFromPrimitive_Proxy(
IDebugComPlusSymbolProvider * This,
/* [in] */ DWORD dwPrimType,
/* [in] */ IDebugAddress *pAddress,
/* [in] */ IDebugField **ppType);
void __RPC_STUB IDebugComPlusSymbolProvider_CreateTypeFromPrimitive_Stub(
IRpcStubBuffer *This,
IRpcChannelBuffer *_pRpcChannelBuffer,
PRPC_MESSAGE _pRpcMessage,
DWORD *_pdwStubPhase);
HRESULT STDMETHODCALLTYPE IDebugComPlusSymbolProvider_GetFunctionLineOffset_Proxy(
IDebugComPlusSymbolProvider * This,
/* [in] */ IDebugAddress *pAddress,
/* [in] */ DWORD dwLine,
/* [out] */ IDebugAddress **ppNewAddress);
void __RPC_STUB IDebugComPlusSymbolProvider_GetFunctionLineOffset_Stub(
IRpcStubBuffer *This,
IRpcChannelBuffer *_pRpcChannelBuffer,
PRPC_MESSAGE _pRpcMessage,
DWORD *_pdwStubPhase);
HRESULT STDMETHODCALLTYPE IDebugComPlusSymbolProvider_GetAddressesInModuleFromPosition_Proxy(
IDebugComPlusSymbolProvider * This,
/* [in] */ ULONG32 ulAppDomainID,
/* [in] */ GUID guidModule,
/* [in] */ IDebugDocumentPosition2 *pDocPos,
/* [in] */ BOOL fStatmentOnly,
/* [out] */ IEnumDebugAddresses **ppEnumBegAddresses,
/* [out] */ IEnumDebugAddresses **ppEnumEndAddresses);
void __RPC_STUB IDebugComPlusSymbolProvider_GetAddressesInModuleFromPosition_Stub(
IRpcStubBuffer *This,
IRpcChannelBuffer *_pRpcChannelBuffer,
PRPC_MESSAGE _pRpcMessage,
DWORD *_pdwStubPhase);
HRESULT STDMETHODCALLTYPE IDebugComPlusSymbolProvider_GetArrayTypeFromAddress_Proxy(
IDebugComPlusSymbolProvider * This,
/* [in] */ IDebugAddress *pAddress,
/* [length_is][size_is][in] */ BYTE *pSig,
/* [in] */ DWORD dwSigLength,
/* [out] */ IDebugField **ppField);
void __RPC_STUB IDebugComPlusSymbolProvider_GetArrayTypeFromAddress_Stub(
IRpcStubBuffer *This,
IRpcChannelBuffer *_pRpcChannelBuffer,
PRPC_MESSAGE _pRpcMessage,
DWORD *_pdwStubPhase);
HRESULT STDMETHODCALLTYPE IDebugComPlusSymbolProvider_GetSymAttribute_Proxy(
IDebugComPlusSymbolProvider * This,
/* [in] */ ULONG32 ulAppDomainID,
/* [in] */ GUID guidModule,
/* [in] */ _mdToken tokParent,
/* [in] */ LPOLESTR pstrName,
/* [in] */ ULONG32 cBuffer,
/* [out] */ ULONG32 *pcBuffer,
/* [length_is][size_is][out] */ BYTE *buffer);
void __RPC_STUB IDebugComPlusSymbolProvider_GetSymAttribute_Stub(
IRpcStubBuffer *This,
IRpcChannelBuffer *_pRpcChannelBuffer,
PRPC_MESSAGE _pRpcMessage,
DWORD *_pdwStubPhase);
HRESULT STDMETHODCALLTYPE IDebugComPlusSymbolProvider_ReplaceSymbols_Proxy(
IDebugComPlusSymbolProvider * This,
/* [in] */ ULONG32 ulAppDomainID,
/* [in] */ GUID guidModule,
/* [in] */ IStream *pStream);
void __RPC_STUB IDebugComPlusSymbolProvider_ReplaceSymbols_Stub(
IRpcStubBuffer *This,
IRpcChannelBuffer *_pRpcChannelBuffer,
PRPC_MESSAGE _pRpcMessage,
DWORD *_pdwStubPhase);
HRESULT STDMETHODCALLTYPE IDebugComPlusSymbolProvider_AreSymbolsLoaded_Proxy(
IDebugComPlusSymbolProvider * This,
/* [in] */ ULONG32 ulAppDomainID,
/* [in] */ GUID guidModule);
void __RPC_STUB IDebugComPlusSymbolProvider_AreSymbolsLoaded_Stub(
IRpcStubBuffer *This,
IRpcChannelBuffer *_pRpcChannelBuffer,
PRPC_MESSAGE _pRpcMessage,
DWORD *_pdwStubPhase);
HRESULT STDMETHODCALLTYPE IDebugComPlusSymbolProvider_LoadSymbolsFromStream_Proxy(
IDebugComPlusSymbolProvider * This,
/* [in] */ ULONG32 ulAppDomainID,
/* [in] */ GUID guidModule,
/* [in] */ ULONGLONG baseAddress,
/* [in] */ IUnknown *pUnkMetadataImport,
/* [in] */ IStream *pStream);
void __RPC_STUB IDebugComPlusSymbolProvider_LoadSymbolsFromStream_Stub(
IRpcStubBuffer *This,
IRpcChannelBuffer *_pRpcChannelBuffer,
PRPC_MESSAGE _pRpcMessage,
DWORD *_pdwStubPhase);
HRESULT STDMETHODCALLTYPE IDebugComPlusSymbolProvider_GetSymUnmanagedReader_Proxy(
IDebugComPlusSymbolProvider * This,
/* [in] */ ULONG32 ulAppDomainID,
/* [in] */ GUID guidModule,
/* [out] */ IUnknown **ppSymUnmanagedReader);
void __RPC_STUB IDebugComPlusSymbolProvider_GetSymUnmanagedReader_Stub(
IRpcStubBuffer *This,
IRpcChannelBuffer *_pRpcChannelBuffer,
PRPC_MESSAGE _pRpcMessage,
DWORD *_pdwStubPhase);
HRESULT STDMETHODCALLTYPE IDebugComPlusSymbolProvider_GetAttributedClassesinModule_Proxy(
IDebugComPlusSymbolProvider * This,
/* [in] */ ULONG32 ulAppDomainID,
/* [in] */ GUID guidModule,
/* [in] */ LPOLESTR pstrAttribute,
/* [out] */ IEnumDebugFields **ppEnum);
void __RPC_STUB IDebugComPlusSymbolProvider_GetAttributedClassesinModule_Stub(
IRpcStubBuffer *This,
IRpcChannelBuffer *_pRpcChannelBuffer,
PRPC_MESSAGE _pRpcMessage,
DWORD *_pdwStubPhase);
HRESULT STDMETHODCALLTYPE IDebugComPlusSymbolProvider_GetAttributedClassesForLanguage_Proxy(
IDebugComPlusSymbolProvider * This,
/* [in] */ GUID guidLanguage,
/* [in] */ LPOLESTR pstrAttribute,
/* [out] */ IEnumDebugFields **ppEnum);
void __RPC_STUB IDebugComPlusSymbolProvider_GetAttributedClassesForLanguage_Stub(
IRpcStubBuffer *This,
IRpcChannelBuffer *_pRpcChannelBuffer,
PRPC_MESSAGE _pRpcMessage,
DWORD *_pdwStubPhase);
HRESULT STDMETHODCALLTYPE IDebugComPlusSymbolProvider_IsHiddenCode_Proxy(
IDebugComPlusSymbolProvider * This,
/* [in] */ IDebugAddress *pAddress);
void __RPC_STUB IDebugComPlusSymbolProvider_IsHiddenCode_Stub(
IRpcStubBuffer *This,
IRpcChannelBuffer *_pRpcChannelBuffer,
PRPC_MESSAGE _pRpcMessage,
DWORD *_pdwStubPhase);
HRESULT STDMETHODCALLTYPE IDebugComPlusSymbolProvider_IsFunctionDeleted_Proxy(
IDebugComPlusSymbolProvider * This,
/* [in] */ IDebugAddress *pAddress);
void __RPC_STUB IDebugComPlusSymbolProvider_IsFunctionDeleted_Stub(
IRpcStubBuffer *This,
IRpcChannelBuffer *_pRpcChannelBuffer,
PRPC_MESSAGE _pRpcMessage,
DWORD *_pdwStubPhase);
HRESULT STDMETHODCALLTYPE IDebugComPlusSymbolProvider_GetNameFromToken_Proxy(
IDebugComPlusSymbolProvider * This,
/* [in] */ IUnknown *pMetadataImport,
/* [in] */ DWORD dwToken,
/* [out] */ BSTR *pbstrName);
void __RPC_STUB IDebugComPlusSymbolProvider_GetNameFromToken_Stub(
IRpcStubBuffer *This,
IRpcChannelBuffer *_pRpcChannelBuffer,
PRPC_MESSAGE _pRpcMessage,
DWORD *_pdwStubPhase);
HRESULT STDMETHODCALLTYPE IDebugComPlusSymbolProvider_IsFunctionStale_Proxy(
IDebugComPlusSymbolProvider * This,
/* [in] */ IDebugAddress *pAddress);
void __RPC_STUB IDebugComPlusSymbolProvider_IsFunctionStale_Stub(
IRpcStubBuffer *This,
IRpcChannelBuffer *_pRpcChannelBuffer,
PRPC_MESSAGE _pRpcMessage,
DWORD *_pdwStubPhase);
HRESULT STDMETHODCALLTYPE IDebugComPlusSymbolProvider_GetLocalVariablelayout_Proxy(
IDebugComPlusSymbolProvider * This,
/* [in] */ ULONG32 ulAppDomainID,
/* [in] */ GUID guidModule,
/* [in] */ ULONG32 cMethods,
/* [size_is][in] */ _mdToken rgMethodTokens[ ],
/* [out] */ IStream **pStreamLayout);
void __RPC_STUB IDebugComPlusSymbolProvider_GetLocalVariablelayout_Stub(
IRpcStubBuffer *This,
IRpcChannelBuffer *_pRpcChannelBuffer,
PRPC_MESSAGE _pRpcMessage,
DWORD *_pdwStubPhase);
HRESULT STDMETHODCALLTYPE IDebugComPlusSymbolProvider_GetAssemblyName_Proxy(
IDebugComPlusSymbolProvider * This,
/* [in] */ ULONG32 ulAppDomainID,
/* [in] */ GUID guidModule,
/* [out] */ BSTR *pbstrName);
void __RPC_STUB IDebugComPlusSymbolProvider_GetAssemblyName_Stub(
IRpcStubBuffer *This,
IRpcChannelBuffer *_pRpcChannelBuffer,
PRPC_MESSAGE _pRpcMessage,
DWORD *_pdwStubPhase);
#endif /* __IDebugComPlusSymbolProvider_INTERFACE_DEFINED__ */
#ifndef __IDebugComPlusSymbolProvider2_INTERFACE_DEFINED__
#define __IDebugComPlusSymbolProvider2_INTERFACE_DEFINED__
/* interface IDebugComPlusSymbolProvider2 */
/* [unique][uuid][object] */
EXTERN_C const IID IID_IDebugComPlusSymbolProvider2;
#if defined(__cplusplus) && !defined(CINTERFACE)
MIDL_INTERFACE("29D97D99-2C50-4855-BC74-B3E372DDD602")
IDebugComPlusSymbolProvider2 : public IDebugComPlusSymbolProvider
{
public:
virtual HRESULT STDMETHODCALLTYPE LoadSymbolsFromCallback(
/* [in] */ ULONG32 ulAppDomainID,
/* [in] */ GUID guidModule,
/* [in] */ IUnknown *pUnkMetadataImport,
/* [in] */ IUnknown *pUnkCorDebugModule,
/* [in] */ BSTR bstrModuleName,
/* [in] */ BSTR bstrSymSearchPath,
/* [in] */ IUnknown *pCallback) = 0;
virtual HRESULT STDMETHODCALLTYPE IsAddressSequencePoint(
/* [in] */ IDebugAddress *pAddress) = 0;
virtual HRESULT STDMETHODCALLTYPE FunctionHasLineInfo(
/* [in] */ IDebugAddress *pAddress) = 0;
virtual HRESULT STDMETHODCALLTYPE GetTypesByName(
/* [full][in] */ LPCOLESTR pszClassName,
/* [in] */ NAME_MATCH nameMatch,
/* [out] */ IEnumDebugFields **ppEnum) = 0;
virtual HRESULT STDMETHODCALLTYPE LoadSymbolsWithCorModule(
/* [in] */ ULONG32 ulAppDomainID,
/* [in] */ GUID guidModule,
/* [in] */ ULONGLONG baseAddress,
/* [in] */ IUnknown *pUnkMetadataImport,
/* [in] */ IUnknown *pUnkCorDebugModule,
/* [in] */ BSTR bstrModuleName,
/* [in] */ BSTR bstrSymSearchPath) = 0;
virtual HRESULT STDMETHODCALLTYPE LoadSymbolsFromStreamWithCorModule(
/* [in] */ ULONG32 ulAppDomainID,
/* [in] */ GUID guidModule,
/* [in] */ ULONGLONG baseAddress,
/* [in] */ IUnknown *pUnkMetadataImport,
/* [in] */ IUnknown *pUnkCorDebugModule,
/* [in] */ IStream *pStream) = 0;
virtual HRESULT STDMETHODCALLTYPE GetTypeFromToken(
/* [in] */ ULONG32 appDomain,
/* [in] */ GUID guidModule,
/* [in] */ DWORD tdToken,
/* [out] */ IDebugField **ppField) = 0;
};
#else /* C style interface */
typedef struct IDebugComPlusSymbolProvider2Vtbl
{
BEGIN_INTERFACE
HRESULT ( STDMETHODCALLTYPE *QueryInterface )(
IDebugComPlusSymbolProvider2 * This,
/* [in] */ REFIID riid,
/* [iid_is][out] */ void **ppvObject);
ULONG ( STDMETHODCALLTYPE *AddRef )(
IDebugComPlusSymbolProvider2 * This);
ULONG ( STDMETHODCALLTYPE *Release )(
IDebugComPlusSymbolProvider2 * This);
HRESULT ( STDMETHODCALLTYPE *Initialize )(
IDebugComPlusSymbolProvider2 * This,
/* [in] */ IDebugEngineSymbolProviderServices *pServices);
HRESULT ( STDMETHODCALLTYPE *Uninitialize )(
IDebugComPlusSymbolProvider2 * This);
HRESULT ( STDMETHODCALLTYPE *GetContainerField )(
IDebugComPlusSymbolProvider2 * This,
/* [in] */ IDebugAddress *pAddress,
/* [out] */ IDebugContainerField **ppContainerField);
HRESULT ( STDMETHODCALLTYPE *GetField )(
IDebugComPlusSymbolProvider2 * This,
/* [in] */ IDebugAddress *pAddress,
/* [in] */ IDebugAddress *pAddressCur,
/* [out] */ IDebugField **ppField);
HRESULT ( STDMETHODCALLTYPE *GetAddressesFromPosition )(
IDebugComPlusSymbolProvider2 * This,
/* [in] */ IDebugDocumentPosition2 *pDocPos,
/* [in] */ BOOL fStatmentOnly,
/* [out] */ IEnumDebugAddresses **ppEnumBegAddresses,
/* [out] */ IEnumDebugAddresses **ppEnumEndAddresses);
HRESULT ( STDMETHODCALLTYPE *GetAddressesFromContext )(
IDebugComPlusSymbolProvider2 * This,
/* [in] */ IDebugDocumentContext2 *pDocContext,
/* [in] */ BOOL fStatmentOnly,
/* [out] */ IEnumDebugAddresses **ppEnumBegAddresses,
/* [out] */ IEnumDebugAddresses **ppEnumEndAddresses);
HRESULT ( STDMETHODCALLTYPE *GetContextFromAddress )(
IDebugComPlusSymbolProvider2 * This,
/* [in] */ IDebugAddress *pAddress,
/* [out] */ IDebugDocumentContext2 **ppDocContext);
HRESULT ( STDMETHODCALLTYPE *GetLanguage )(
IDebugComPlusSymbolProvider2 * This,
/* [in] */ IDebugAddress *pAddress,
/* [out] */ GUID *pguidLanguage,
/* [out] */ GUID *pguidLanguageVendor);
HRESULT ( STDMETHODCALLTYPE *GetGlobalContainer )(
IDebugComPlusSymbolProvider2 * This,
/* [out] */ IDebugContainerField **pField);
HRESULT ( STDMETHODCALLTYPE *GetMethodFieldsByName )(
IDebugComPlusSymbolProvider2 * This,
/* [full][in] */ LPCOLESTR pszFullName,
/* [in] */ NAME_MATCH nameMatch,
/* [out] */ IEnumDebugFields **ppEnum);
HRESULT ( STDMETHODCALLTYPE *GetClassTypeByName )(
IDebugComPlusSymbolProvider2 * This,
/* [full][in] */ LPCOLESTR pszClassName,
/* [in] */ NAME_MATCH nameMatch,
/* [out] */ IDebugClassField **ppField);
HRESULT ( STDMETHODCALLTYPE *GetNamespacesUsedAtAddress )(
IDebugComPlusSymbolProvider2 * This,
/* [in] */ IDebugAddress *pAddress,
/* [out] */ IEnumDebugFields **ppEnum);
HRESULT ( STDMETHODCALLTYPE *GetTypeByName )(
IDebugComPlusSymbolProvider2 * This,
/* [full][in] */ LPCOLESTR pszClassName,
/* [in] */ NAME_MATCH nameMatch,
/* [out] */ IDebugField **ppField);
HRESULT ( STDMETHODCALLTYPE *GetNextAddress )(
IDebugComPlusSymbolProvider2 * This,
/* [in] */ IDebugAddress *pAddress,
/* [in] */ BOOL fStatmentOnly,
/* [out] */ IDebugAddress **ppAddress);
HRESULT ( STDMETHODCALLTYPE *LoadSymbols )(
IDebugComPlusSymbolProvider2 * This,
/* [in] */ ULONG32 ulAppDomainID,
/* [in] */ GUID guidModule,
/* [in] */ ULONGLONG baseAddress,
/* [in] */ IUnknown *pUnkMetadataImport,
/* [in] */ BSTR bstrModuleName,
/* [in] */ BSTR bstrSymSearchPath);
HRESULT ( STDMETHODCALLTYPE *UnloadSymbols )(
IDebugComPlusSymbolProvider2 * This,
/* [in] */ ULONG32 ulAppDomainID,
/* [in] */ GUID guidModule);
HRESULT ( STDMETHODCALLTYPE *GetEntryPoint )(
IDebugComPlusSymbolProvider2 * This,
/* [in] */ ULONG32 ulAppDomainID,
/* [in] */ GUID guidModule,
/* [out] */ IDebugAddress **ppAddress);
HRESULT ( STDMETHODCALLTYPE *GetTypeFromAddress )(
IDebugComPlusSymbolProvider2 * This,
/* [in] */ IDebugAddress *pAddress,
/* [out] */ IDebugField **ppField);
HRESULT ( STDMETHODCALLTYPE *UpdateSymbols )(
IDebugComPlusSymbolProvider2 * This,
/* [in] */ ULONG32 ulAppDomainID,
/* [in] */ GUID guidModule,
/* [in] */ IStream *pUpdateStream);
HRESULT ( STDMETHODCALLTYPE *CreateTypeFromPrimitive )(
IDebugComPlusSymbolProvider2 * This,
/* [in] */ DWORD dwPrimType,
/* [in] */ IDebugAddress *pAddress,
/* [in] */ IDebugField **ppType);
HRESULT ( STDMETHODCALLTYPE *GetFunctionLineOffset )(
IDebugComPlusSymbolProvider2 * This,
/* [in] */ IDebugAddress *pAddress,
/* [in] */ DWORD dwLine,
/* [out] */ IDebugAddress **ppNewAddress);
HRESULT ( STDMETHODCALLTYPE *GetAddressesInModuleFromPosition )(
IDebugComPlusSymbolProvider2 * This,
/* [in] */ ULONG32 ulAppDomainID,
/* [in] */ GUID guidModule,
/* [in] */ IDebugDocumentPosition2 *pDocPos,
/* [in] */ BOOL fStatmentOnly,
/* [out] */ IEnumDebugAddresses **ppEnumBegAddresses,
/* [out] */ IEnumDebugAddresses **ppEnumEndAddresses);
HRESULT ( STDMETHODCALLTYPE *GetArrayTypeFromAddress )(
IDebugComPlusSymbolProvider2 * This,
/* [in] */ IDebugAddress *pAddress,
/* [length_is][size_is][in] */ BYTE *pSig,
/* [in] */ DWORD dwSigLength,
/* [out] */ IDebugField **ppField);
HRESULT ( STDMETHODCALLTYPE *GetSymAttribute )(
IDebugComPlusSymbolProvider2 * This,
/* [in] */ ULONG32 ulAppDomainID,
/* [in] */ GUID guidModule,
/* [in] */ _mdToken tokParent,
/* [in] */ LPOLESTR pstrName,
/* [in] */ ULONG32 cBuffer,
/* [out] */ ULONG32 *pcBuffer,
/* [length_is][size_is][out] */ BYTE *buffer);
HRESULT ( STDMETHODCALLTYPE *ReplaceSymbols )(
IDebugComPlusSymbolProvider2 * This,
/* [in] */ ULONG32 ulAppDomainID,
/* [in] */ GUID guidModule,
/* [in] */ IStream *pStream);
HRESULT ( STDMETHODCALLTYPE *AreSymbolsLoaded )(
IDebugComPlusSymbolProvider2 * This,
/* [in] */ ULONG32 ulAppDomainID,
/* [in] */ GUID guidModule);
HRESULT ( STDMETHODCALLTYPE *LoadSymbolsFromStream )(
IDebugComPlusSymbolProvider2 * This,
/* [in] */ ULONG32 ulAppDomainID,
/* [in] */ GUID guidModule,
/* [in] */ ULONGLONG baseAddress,
/* [in] */ IUnknown *pUnkMetadataImport,
/* [in] */ IStream *pStream);
HRESULT ( STDMETHODCALLTYPE *GetSymUnmanagedReader )(
IDebugComPlusSymbolProvider2 * This,
/* [in] */ ULONG32 ulAppDomainID,
/* [in] */ GUID guidModule,
/* [out] */ IUnknown **ppSymUnmanagedReader);
HRESULT ( STDMETHODCALLTYPE *GetAttributedClassesinModule )(
IDebugComPlusSymbolProvider2 * This,
/* [in] */ ULONG32 ulAppDomainID,
/* [in] */ GUID guidModule,
/* [in] */ LPOLESTR pstrAttribute,
/* [out] */ IEnumDebugFields **ppEnum);
HRESULT ( STDMETHODCALLTYPE *GetAttributedClassesForLanguage )(
IDebugComPlusSymbolProvider2 * This,
/* [in] */ GUID guidLanguage,
/* [in] */ LPOLESTR pstrAttribute,
/* [out] */ IEnumDebugFields **ppEnum);
HRESULT ( STDMETHODCALLTYPE *IsHiddenCode )(
IDebugComPlusSymbolProvider2 * This,
/* [in] */ IDebugAddress *pAddress);
HRESULT ( STDMETHODCALLTYPE *IsFunctionDeleted )(
IDebugComPlusSymbolProvider2 * This,
/* [in] */ IDebugAddress *pAddress);
HRESULT ( STDMETHODCALLTYPE *GetNameFromToken )(
IDebugComPlusSymbolProvider2 * This,
/* [in] */ IUnknown *pMetadataImport,
/* [in] */ DWORD dwToken,
/* [out] */ BSTR *pbstrName);
HRESULT ( STDMETHODCALLTYPE *IsFunctionStale )(
IDebugComPlusSymbolProvider2 * This,
/* [in] */ IDebugAddress *pAddress);
HRESULT ( STDMETHODCALLTYPE *GetLocalVariablelayout )(
IDebugComPlusSymbolProvider2 * This,
/* [in] */ ULONG32 ulAppDomainID,
/* [in] */ GUID guidModule,
/* [in] */ ULONG32 cMethods,
/* [size_is][in] */ _mdToken rgMethodTokens[ ],
/* [out] */ IStream **pStreamLayout);
HRESULT ( STDMETHODCALLTYPE *GetAssemblyName )(
IDebugComPlusSymbolProvider2 * This,
/* [in] */ ULONG32 ulAppDomainID,
/* [in] */ GUID guidModule,
/* [out] */ BSTR *pbstrName);
HRESULT ( STDMETHODCALLTYPE *LoadSymbolsFromCallback )(
IDebugComPlusSymbolProvider2 * This,
/* [in] */ ULONG32 ulAppDomainID,
/* [in] */ GUID guidModule,
/* [in] */ IUnknown *pUnkMetadataImport,
/* [in] */ IUnknown *pUnkCorDebugModule,
/* [in] */ BSTR bstrModuleName,
/* [in] */ BSTR bstrSymSearchPath,
/* [in] */ IUnknown *pCallback);
HRESULT ( STDMETHODCALLTYPE *IsAddressSequencePoint )(
IDebugComPlusSymbolProvider2 * This,
/* [in] */ IDebugAddress *pAddress);
HRESULT ( STDMETHODCALLTYPE *FunctionHasLineInfo )(
IDebugComPlusSymbolProvider2 * This,
/* [in] */ IDebugAddress *pAddress);
HRESULT ( STDMETHODCALLTYPE *GetTypesByName )(
IDebugComPlusSymbolProvider2 * This,
/* [full][in] */ LPCOLESTR pszClassName,
/* [in] */ NAME_MATCH nameMatch,
/* [out] */ IEnumDebugFields **ppEnum);
HRESULT ( STDMETHODCALLTYPE *LoadSymbolsWithCorModule )(
IDebugComPlusSymbolProvider2 * This,
/* [in] */ ULONG32 ulAppDomainID,
/* [in] */ GUID guidModule,
/* [in] */ ULONGLONG baseAddress,
/* [in] */ IUnknown *pUnkMetadataImport,
/* [in] */ IUnknown *pUnkCorDebugModule,
/* [in] */ BSTR bstrModuleName,
/* [in] */ BSTR bstrSymSearchPath);
HRESULT ( STDMETHODCALLTYPE *LoadSymbolsFromStreamWithCorModule )(
IDebugComPlusSymbolProvider2 * This,
/* [in] */ ULONG32 ulAppDomainID,
/* [in] */ GUID guidModule,
/* [in] */ ULONGLONG baseAddress,
/* [in] */ IUnknown *pUnkMetadataImport,
/* [in] */ IUnknown *pUnkCorDebugModule,
/* [in] */ IStream *pStream);
HRESULT ( STDMETHODCALLTYPE *GetTypeFromToken )(
IDebugComPlusSymbolProvider2 * This,
/* [in] */ ULONG32 appDomain,
/* [in] */ GUID guidModule,
/* [in] */ DWORD tdToken,
/* [out] */ IDebugField **ppField);
END_INTERFACE
} IDebugComPlusSymbolProvider2Vtbl;
interface IDebugComPlusSymbolProvider2
{
CONST_VTBL struct IDebugComPlusSymbolProvider2Vtbl *lpVtbl;
};
#ifdef COBJMACROS
#define IDebugComPlusSymbolProvider2_QueryInterface(This,riid,ppvObject) \
(This)->lpVtbl -> QueryInterface(This,riid,ppvObject)
#define IDebugComPlusSymbolProvider2_AddRef(This) \
(This)->lpVtbl -> AddRef(This)
#define IDebugComPlusSymbolProvider2_Release(This) \
(This)->lpVtbl -> Release(This)
#define IDebugComPlusSymbolProvider2_Initialize(This,pServices) \
(This)->lpVtbl -> Initialize(This,pServices)
#define IDebugComPlusSymbolProvider2_Uninitialize(This) \
(This)->lpVtbl -> Uninitialize(This)
#define IDebugComPlusSymbolProvider2_GetContainerField(This,pAddress,ppContainerField) \
(This)->lpVtbl -> GetContainerField(This,pAddress,ppContainerField)
#define IDebugComPlusSymbolProvider2_GetField(This,pAddress,pAddressCur,ppField) \
(This)->lpVtbl -> GetField(This,pAddress,pAddressCur,ppField)
#define IDebugComPlusSymbolProvider2_GetAddressesFromPosition(This,pDocPos,fStatmentOnly,ppEnumBegAddresses,ppEnumEndAddresses) \
(This)->lpVtbl -> GetAddressesFromPosition(This,pDocPos,fStatmentOnly,ppEnumBegAddresses,ppEnumEndAddresses)
#define IDebugComPlusSymbolProvider2_GetAddressesFromContext(This,pDocContext,fStatmentOnly,ppEnumBegAddresses,ppEnumEndAddresses) \
(This)->lpVtbl -> GetAddressesFromContext(This,pDocContext,fStatmentOnly,ppEnumBegAddresses,ppEnumEndAddresses)
#define IDebugComPlusSymbolProvider2_GetContextFromAddress(This,pAddress,ppDocContext) \
(This)->lpVtbl -> GetContextFromAddress(This,pAddress,ppDocContext)
#define IDebugComPlusSymbolProvider2_GetLanguage(This,pAddress,pguidLanguage,pguidLanguageVendor) \
(This)->lpVtbl -> GetLanguage(This,pAddress,pguidLanguage,pguidLanguageVendor)
#define IDebugComPlusSymbolProvider2_GetGlobalContainer(This,pField) \
(This)->lpVtbl -> GetGlobalContainer(This,pField)
#define IDebugComPlusSymbolProvider2_GetMethodFieldsByName(This,pszFullName,nameMatch,ppEnum) \
(This)->lpVtbl -> GetMethodFieldsByName(This,pszFullName,nameMatch,ppEnum)
#define IDebugComPlusSymbolProvider2_GetClassTypeByName(This,pszClassName,nameMatch,ppField) \
(This)->lpVtbl -> GetClassTypeByName(This,pszClassName,nameMatch,ppField)
#define IDebugComPlusSymbolProvider2_GetNamespacesUsedAtAddress(This,pAddress,ppEnum) \
(This)->lpVtbl -> GetNamespacesUsedAtAddress(This,pAddress,ppEnum)
#define IDebugComPlusSymbolProvider2_GetTypeByName(This,pszClassName,nameMatch,ppField) \
(This)->lpVtbl -> GetTypeByName(This,pszClassName,nameMatch,ppField)
#define IDebugComPlusSymbolProvider2_GetNextAddress(This,pAddress,fStatmentOnly,ppAddress) \
(This)->lpVtbl -> GetNextAddress(This,pAddress,fStatmentOnly,ppAddress)
#define IDebugComPlusSymbolProvider2_LoadSymbols(This,ulAppDomainID,guidModule,baseAddress,pUnkMetadataImport,bstrModuleName,bstrSymSearchPath) \
(This)->lpVtbl -> LoadSymbols(This,ulAppDomainID,guidModule,baseAddress,pUnkMetadataImport,bstrModuleName,bstrSymSearchPath)
#define IDebugComPlusSymbolProvider2_UnloadSymbols(This,ulAppDomainID,guidModule) \
(This)->lpVtbl -> UnloadSymbols(This,ulAppDomainID,guidModule)
#define IDebugComPlusSymbolProvider2_GetEntryPoint(This,ulAppDomainID,guidModule,ppAddress) \
(This)->lpVtbl -> GetEntryPoint(This,ulAppDomainID,guidModule,ppAddress)
#define IDebugComPlusSymbolProvider2_GetTypeFromAddress(This,pAddress,ppField) \
(This)->lpVtbl -> GetTypeFromAddress(This,pAddress,ppField)
#define IDebugComPlusSymbolProvider2_UpdateSymbols(This,ulAppDomainID,guidModule,pUpdateStream) \
(This)->lpVtbl -> UpdateSymbols(This,ulAppDomainID,guidModule,pUpdateStream)
#define IDebugComPlusSymbolProvider2_CreateTypeFromPrimitive(This,dwPrimType,pAddress,ppType) \
(This)->lpVtbl -> CreateTypeFromPrimitive(This,dwPrimType,pAddress,ppType)
#define IDebugComPlusSymbolProvider2_GetFunctionLineOffset(This,pAddress,dwLine,ppNewAddress) \
(This)->lpVtbl -> GetFunctionLineOffset(This,pAddress,dwLine,ppNewAddress)
#define IDebugComPlusSymbolProvider2_GetAddressesInModuleFromPosition(This,ulAppDomainID,guidModule,pDocPos,fStatmentOnly,ppEnumBegAddresses,ppEnumEndAddresses) \
(This)->lpVtbl -> GetAddressesInModuleFromPosition(This,ulAppDomainID,guidModule,pDocPos,fStatmentOnly,ppEnumBegAddresses,ppEnumEndAddresses)
#define IDebugComPlusSymbolProvider2_GetArrayTypeFromAddress(This,pAddress,pSig,dwSigLength,ppField) \
(This)->lpVtbl -> GetArrayTypeFromAddress(This,pAddress,pSig,dwSigLength,ppField)
#define IDebugComPlusSymbolProvider2_GetSymAttribute(This,ulAppDomainID,guidModule,tokParent,pstrName,cBuffer,pcBuffer,buffer) \
(This)->lpVtbl -> GetSymAttribute(This,ulAppDomainID,guidModule,tokParent,pstrName,cBuffer,pcBuffer,buffer)
#define IDebugComPlusSymbolProvider2_ReplaceSymbols(This,ulAppDomainID,guidModule,pStream) \
(This)->lpVtbl -> ReplaceSymbols(This,ulAppDomainID,guidModule,pStream)
#define IDebugComPlusSymbolProvider2_AreSymbolsLoaded(This,ulAppDomainID,guidModule) \
(This)->lpVtbl -> AreSymbolsLoaded(This,ulAppDomainID,guidModule)
#define IDebugComPlusSymbolProvider2_LoadSymbolsFromStream(This,ulAppDomainID,guidModule,baseAddress,pUnkMetadataImport,pStream) \
(This)->lpVtbl -> LoadSymbolsFromStream(This,ulAppDomainID,guidModule,baseAddress,pUnkMetadataImport,pStream)
#define IDebugComPlusSymbolProvider2_GetSymUnmanagedReader(This,ulAppDomainID,guidModule,ppSymUnmanagedReader) \
(This)->lpVtbl -> GetSymUnmanagedReader(This,ulAppDomainID,guidModule,ppSymUnmanagedReader)
#define IDebugComPlusSymbolProvider2_GetAttributedClassesinModule(This,ulAppDomainID,guidModule,pstrAttribute,ppEnum) \
(This)->lpVtbl -> GetAttributedClassesinModule(This,ulAppDomainID,guidModule,pstrAttribute,ppEnum)
#define IDebugComPlusSymbolProvider2_GetAttributedClassesForLanguage(This,guidLanguage,pstrAttribute,ppEnum) \
(This)->lpVtbl -> GetAttributedClassesForLanguage(This,guidLanguage,pstrAttribute,ppEnum)
#define IDebugComPlusSymbolProvider2_IsHiddenCode(This,pAddress) \
(This)->lpVtbl -> IsHiddenCode(This,pAddress)
#define IDebugComPlusSymbolProvider2_IsFunctionDeleted(This,pAddress) \
(This)->lpVtbl -> IsFunctionDeleted(This,pAddress)
#define IDebugComPlusSymbolProvider2_GetNameFromToken(This,pMetadataImport,dwToken,pbstrName) \
(This)->lpVtbl -> GetNameFromToken(This,pMetadataImport,dwToken,pbstrName)
#define IDebugComPlusSymbolProvider2_IsFunctionStale(This,pAddress) \
(This)->lpVtbl -> IsFunctionStale(This,pAddress)
#define IDebugComPlusSymbolProvider2_GetLocalVariablelayout(This,ulAppDomainID,guidModule,cMethods,rgMethodTokens,pStreamLayout) \
(This)->lpVtbl -> GetLocalVariablelayout(This,ulAppDomainID,guidModule,cMethods,rgMethodTokens,pStreamLayout)
#define IDebugComPlusSymbolProvider2_GetAssemblyName(This,ulAppDomainID,guidModule,pbstrName) \
(This)->lpVtbl -> GetAssemblyName(This,ulAppDomainID,guidModule,pbstrName)
#define IDebugComPlusSymbolProvider2_LoadSymbolsFromCallback(This,ulAppDomainID,guidModule,pUnkMetadataImport,pUnkCorDebugModule,bstrModuleName,bstrSymSearchPath,pCallback) \
(This)->lpVtbl -> LoadSymbolsFromCallback(This,ulAppDomainID,guidModule,pUnkMetadataImport,pUnkCorDebugModule,bstrModuleName,bstrSymSearchPath,pCallback)
#define IDebugComPlusSymbolProvider2_IsAddressSequencePoint(This,pAddress) \
(This)->lpVtbl -> IsAddressSequencePoint(This,pAddress)
#define IDebugComPlusSymbolProvider2_FunctionHasLineInfo(This,pAddress) \
(This)->lpVtbl -> FunctionHasLineInfo(This,pAddress)
#define IDebugComPlusSymbolProvider2_GetTypesByName(This,pszClassName,nameMatch,ppEnum) \
(This)->lpVtbl -> GetTypesByName(This,pszClassName,nameMatch,ppEnum)
#define IDebugComPlusSymbolProvider2_LoadSymbolsWithCorModule(This,ulAppDomainID,guidModule,baseAddress,pUnkMetadataImport,pUnkCorDebugModule,bstrModuleName,bstrSymSearchPath) \
(This)->lpVtbl -> LoadSymbolsWithCorModule(This,ulAppDomainID,guidModule,baseAddress,pUnkMetadataImport,pUnkCorDebugModule,bstrModuleName,bstrSymSearchPath)
#define IDebugComPlusSymbolProvider2_LoadSymbolsFromStreamWithCorModule(This,ulAppDomainID,guidModule,baseAddress,pUnkMetadataImport,pUnkCorDebugModule,pStream) \
(This)->lpVtbl -> LoadSymbolsFromStreamWithCorModule(This,ulAppDomainID,guidModule,baseAddress,pUnkMetadataImport,pUnkCorDebugModule,pStream)
#define IDebugComPlusSymbolProvider2_GetTypeFromToken(This,appDomain,guidModule,tdToken,ppField) \
(This)->lpVtbl -> GetTypeFromToken(This,appDomain,guidModule,tdToken,ppField)
#endif /* COBJMACROS */
#endif /* C style interface */
HRESULT STDMETHODCALLTYPE IDebugComPlusSymbolProvider2_LoadSymbolsFromCallback_Proxy(
IDebugComPlusSymbolProvider2 * This,
/* [in] */ ULONG32 ulAppDomainID,
/* [in] */ GUID guidModule,
/* [in] */ IUnknown *pUnkMetadataImport,
/* [in] */ IUnknown *pUnkCorDebugModule,
/* [in] */ BSTR bstrModuleName,
/* [in] */ BSTR bstrSymSearchPath,
/* [in] */ IUnknown *pCallback);
void __RPC_STUB IDebugComPlusSymbolProvider2_LoadSymbolsFromCallback_Stub(
IRpcStubBuffer *This,
IRpcChannelBuffer *_pRpcChannelBuffer,
PRPC_MESSAGE _pRpcMessage,
DWORD *_pdwStubPhase);
HRESULT STDMETHODCALLTYPE IDebugComPlusSymbolProvider2_IsAddressSequencePoint_Proxy(
IDebugComPlusSymbolProvider2 * This,
/* [in] */ IDebugAddress *pAddress);
void __RPC_STUB IDebugComPlusSymbolProvider2_IsAddressSequencePoint_Stub(
IRpcStubBuffer *This,
IRpcChannelBuffer *_pRpcChannelBuffer,
PRPC_MESSAGE _pRpcMessage,
DWORD *_pdwStubPhase);
HRESULT STDMETHODCALLTYPE IDebugComPlusSymbolProvider2_FunctionHasLineInfo_Proxy(
IDebugComPlusSymbolProvider2 * This,
/* [in] */ IDebugAddress *pAddress);
void __RPC_STUB IDebugComPlusSymbolProvider2_FunctionHasLineInfo_Stub(
IRpcStubBuffer *This,
IRpcChannelBuffer *_pRpcChannelBuffer,
PRPC_MESSAGE _pRpcMessage,
DWORD *_pdwStubPhase);
HRESULT STDMETHODCALLTYPE IDebugComPlusSymbolProvider2_GetTypesByName_Proxy(
IDebugComPlusSymbolProvider2 * This,
/* [full][in] */ LPCOLESTR pszClassName,
/* [in] */ NAME_MATCH nameMatch,
/* [out] */ IEnumDebugFields **ppEnum);
void __RPC_STUB IDebugComPlusSymbolProvider2_GetTypesByName_Stub(
IRpcStubBuffer *This,
IRpcChannelBuffer *_pRpcChannelBuffer,
PRPC_MESSAGE _pRpcMessage,
DWORD *_pdwStubPhase);
HRESULT STDMETHODCALLTYPE IDebugComPlusSymbolProvider2_LoadSymbolsWithCorModule_Proxy(
IDebugComPlusSymbolProvider2 * This,
/* [in] */ ULONG32 ulAppDomainID,
/* [in] */ GUID guidModule,
/* [in] */ ULONGLONG baseAddress,
/* [in] */ IUnknown *pUnkMetadataImport,
/* [in] */ IUnknown *pUnkCorDebugModule,
/* [in] */ BSTR bstrModuleName,
/* [in] */ BSTR bstrSymSearchPath);
void __RPC_STUB IDebugComPlusSymbolProvider2_LoadSymbolsWithCorModule_Stub(
IRpcStubBuffer *This,
IRpcChannelBuffer *_pRpcChannelBuffer,
PRPC_MESSAGE _pRpcMessage,
DWORD *_pdwStubPhase);
HRESULT STDMETHODCALLTYPE IDebugComPlusSymbolProvider2_LoadSymbolsFromStreamWithCorModule_Proxy(
IDebugComPlusSymbolProvider2 * This,
/* [in] */ ULONG32 ulAppDomainID,
/* [in] */ GUID guidModule,
/* [in] */ ULONGLONG baseAddress,
/* [in] */ IUnknown *pUnkMetadataImport,
/* [in] */ IUnknown *pUnkCorDebugModule,
/* [in] */ IStream *pStream);
void __RPC_STUB IDebugComPlusSymbolProvider2_LoadSymbolsFromStreamWithCorModule_Stub(
IRpcStubBuffer *This,
IRpcChannelBuffer *_pRpcChannelBuffer,
PRPC_MESSAGE _pRpcMessage,
DWORD *_pdwStubPhase);
HRESULT STDMETHODCALLTYPE IDebugComPlusSymbolProvider2_GetTypeFromToken_Proxy(
IDebugComPlusSymbolProvider2 * This,
/* [in] */ ULONG32 appDomain,
/* [in] */ GUID guidModule,
/* [in] */ DWORD tdToken,
/* [out] */ IDebugField **ppField);
void __RPC_STUB IDebugComPlusSymbolProvider2_GetTypeFromToken_Stub(
IRpcStubBuffer *This,
IRpcChannelBuffer *_pRpcChannelBuffer,
PRPC_MESSAGE _pRpcMessage,
DWORD *_pdwStubPhase);
#endif /* __IDebugComPlusSymbolProvider2_INTERFACE_DEFINED__ */
#ifndef __IDebugSymbolProviderGroup_INTERFACE_DEFINED__
#define __IDebugSymbolProviderGroup_INTERFACE_DEFINED__
/* interface IDebugSymbolProviderGroup */
/* [unique][uuid][object] */
EXTERN_C const IID IID_IDebugSymbolProviderGroup;
#if defined(__cplusplus) && !defined(CINTERFACE)
MIDL_INTERFACE("2B226A06-FF61-44f3-9ADD-B34BD9F72FCB")
IDebugSymbolProviderGroup : public IUnknown
{
public:
virtual HRESULT STDMETHODCALLTYPE CreateGroup(
IUnknown **ppGroup) = 0;
virtual HRESULT STDMETHODCALLTYPE SetGroup(
IUnknown *pGroup) = 0;
};
#else /* C style interface */
typedef struct IDebugSymbolProviderGroupVtbl
{
BEGIN_INTERFACE
HRESULT ( STDMETHODCALLTYPE *QueryInterface )(
IDebugSymbolProviderGroup * This,
/* [in] */ REFIID riid,
/* [iid_is][out] */ void **ppvObject);
ULONG ( STDMETHODCALLTYPE *AddRef )(
IDebugSymbolProviderGroup * This);
ULONG ( STDMETHODCALLTYPE *Release )(
IDebugSymbolProviderGroup * This);
HRESULT ( STDMETHODCALLTYPE *CreateGroup )(
IDebugSymbolProviderGroup * This,
IUnknown **ppGroup);
HRESULT ( STDMETHODCALLTYPE *SetGroup )(
IDebugSymbolProviderGroup * This,
IUnknown *pGroup);
END_INTERFACE
} IDebugSymbolProviderGroupVtbl;
interface IDebugSymbolProviderGroup
{
CONST_VTBL struct IDebugSymbolProviderGroupVtbl *lpVtbl;
};
#ifdef COBJMACROS
#define IDebugSymbolProviderGroup_QueryInterface(This,riid,ppvObject) \
(This)->lpVtbl -> QueryInterface(This,riid,ppvObject)
#define IDebugSymbolProviderGroup_AddRef(This) \
(This)->lpVtbl -> AddRef(This)
#define IDebugSymbolProviderGroup_Release(This) \
(This)->lpVtbl -> Release(This)
#define IDebugSymbolProviderGroup_CreateGroup(This,ppGroup) \
(This)->lpVtbl -> CreateGroup(This,ppGroup)
#define IDebugSymbolProviderGroup_SetGroup(This,pGroup) \
(This)->lpVtbl -> SetGroup(This,pGroup)
#endif /* COBJMACROS */
#endif /* C style interface */
HRESULT STDMETHODCALLTYPE IDebugSymbolProviderGroup_CreateGroup_Proxy(
IDebugSymbolProviderGroup * This,
IUnknown **ppGroup);
void __RPC_STUB IDebugSymbolProviderGroup_CreateGroup_Stub(
IRpcStubBuffer *This,
IRpcChannelBuffer *_pRpcChannelBuffer,
PRPC_MESSAGE _pRpcMessage,
DWORD *_pdwStubPhase);
HRESULT STDMETHODCALLTYPE IDebugSymbolProviderGroup_SetGroup_Proxy(
IDebugSymbolProviderGroup * This,
IUnknown *pGroup);
void __RPC_STUB IDebugSymbolProviderGroup_SetGroup_Stub(
IRpcStubBuffer *This,
IRpcChannelBuffer *_pRpcChannelBuffer,
PRPC_MESSAGE _pRpcMessage,
DWORD *_pdwStubPhase);
#endif /* __IDebugSymbolProviderGroup_INTERFACE_DEFINED__ */
#ifndef __IDebugGenericFieldDefinition_INTERFACE_DEFINED__
#define __IDebugGenericFieldDefinition_INTERFACE_DEFINED__
/* interface IDebugGenericFieldDefinition */
/* [unique][uuid][object] */
EXTERN_C const IID IID_IDebugGenericFieldDefinition;
#if defined(__cplusplus) && !defined(CINTERFACE)
MIDL_INTERFACE("C5717D6C-8DBF-4852-B7D8-C003EE09541F")
IDebugGenericFieldDefinition : public IUnknown
{
public:
virtual HRESULT STDMETHODCALLTYPE TypeParamCount(
/* [out][in] */ ULONG32 *pcParams) = 0;
virtual HRESULT STDMETHODCALLTYPE GetFormalTypeParams(
/* [in] */ ULONG32 cParams,
/* [length_is][size_is][out] */ IDebugGenericParamField **ppParams,
/* [out][in] */ ULONG32 *pcParams) = 0;
virtual HRESULT STDMETHODCALLTYPE ConstructInstantiation(
/* [in] */ ULONG32 cArgs,
/* [size_is][in] */ IDebugField **ppArgs,
/* [out] */ IDebugField **ppConstructedField) = 0;
};
#else /* C style interface */
typedef struct IDebugGenericFieldDefinitionVtbl
{
BEGIN_INTERFACE
HRESULT ( STDMETHODCALLTYPE *QueryInterface )(
IDebugGenericFieldDefinition * This,
/* [in] */ REFIID riid,
/* [iid_is][out] */ void **ppvObject);
ULONG ( STDMETHODCALLTYPE *AddRef )(
IDebugGenericFieldDefinition * This);
ULONG ( STDMETHODCALLTYPE *Release )(
IDebugGenericFieldDefinition * This);
HRESULT ( STDMETHODCALLTYPE *TypeParamCount )(
IDebugGenericFieldDefinition * This,
/* [out][in] */ ULONG32 *pcParams);
HRESULT ( STDMETHODCALLTYPE *GetFormalTypeParams )(
IDebugGenericFieldDefinition * This,
/* [in] */ ULONG32 cParams,
/* [length_is][size_is][out] */ IDebugGenericParamField **ppParams,
/* [out][in] */ ULONG32 *pcParams);
HRESULT ( STDMETHODCALLTYPE *ConstructInstantiation )(
IDebugGenericFieldDefinition * This,
/* [in] */ ULONG32 cArgs,
/* [size_is][in] */ IDebugField **ppArgs,
/* [out] */ IDebugField **ppConstructedField);
END_INTERFACE
} IDebugGenericFieldDefinitionVtbl;
interface IDebugGenericFieldDefinition
{
CONST_VTBL struct IDebugGenericFieldDefinitionVtbl *lpVtbl;
};
#ifdef COBJMACROS
#define IDebugGenericFieldDefinition_QueryInterface(This,riid,ppvObject) \
(This)->lpVtbl -> QueryInterface(This,riid,ppvObject)
#define IDebugGenericFieldDefinition_AddRef(This) \
(This)->lpVtbl -> AddRef(This)
#define IDebugGenericFieldDefinition_Release(This) \
(This)->lpVtbl -> Release(This)
#define IDebugGenericFieldDefinition_TypeParamCount(This,pcParams) \
(This)->lpVtbl -> TypeParamCount(This,pcParams)
#define IDebugGenericFieldDefinition_GetFormalTypeParams(This,cParams,ppParams,pcParams) \
(This)->lpVtbl -> GetFormalTypeParams(This,cParams,ppParams,pcParams)
#define IDebugGenericFieldDefinition_ConstructInstantiation(This,cArgs,ppArgs,ppConstructedField) \
(This)->lpVtbl -> ConstructInstantiation(This,cArgs,ppArgs,ppConstructedField)
#endif /* COBJMACROS */
#endif /* C style interface */
HRESULT STDMETHODCALLTYPE IDebugGenericFieldDefinition_TypeParamCount_Proxy(
IDebugGenericFieldDefinition * This,
/* [out][in] */ ULONG32 *pcParams);
void __RPC_STUB IDebugGenericFieldDefinition_TypeParamCount_Stub(
IRpcStubBuffer *This,
IRpcChannelBuffer *_pRpcChannelBuffer,
PRPC_MESSAGE _pRpcMessage,
DWORD *_pdwStubPhase);
HRESULT STDMETHODCALLTYPE IDebugGenericFieldDefinition_GetFormalTypeParams_Proxy(
IDebugGenericFieldDefinition * This,
/* [in] */ ULONG32 cParams,
/* [length_is][size_is][out] */ IDebugGenericParamField **ppParams,
/* [out][in] */ ULONG32 *pcParams);
void __RPC_STUB IDebugGenericFieldDefinition_GetFormalTypeParams_Stub(
IRpcStubBuffer *This,
IRpcChannelBuffer *_pRpcChannelBuffer,
PRPC_MESSAGE _pRpcMessage,
DWORD *_pdwStubPhase);
HRESULT STDMETHODCALLTYPE IDebugGenericFieldDefinition_ConstructInstantiation_Proxy(
IDebugGenericFieldDefinition * This,
/* [in] */ ULONG32 cArgs,
/* [size_is][in] */ IDebugField **ppArgs,
/* [out] */ IDebugField **ppConstructedField);
void __RPC_STUB IDebugGenericFieldDefinition_ConstructInstantiation_Stub(
IRpcStubBuffer *This,
IRpcChannelBuffer *_pRpcChannelBuffer,
PRPC_MESSAGE _pRpcMessage,
DWORD *_pdwStubPhase);
#endif /* __IDebugGenericFieldDefinition_INTERFACE_DEFINED__ */
#ifndef __IDebugGenericFieldInstance_INTERFACE_DEFINED__
#define __IDebugGenericFieldInstance_INTERFACE_DEFINED__
/* interface IDebugGenericFieldInstance */
/* [unique][uuid][object] */
EXTERN_C const IID IID_IDebugGenericFieldInstance;
#if defined(__cplusplus) && !defined(CINTERFACE)
MIDL_INTERFACE("C93C9DD0-0A65-4966-BCEB-633EEEE2E096")
IDebugGenericFieldInstance : public IUnknown
{
public:
virtual HRESULT STDMETHODCALLTYPE TypeArgumentCount(
/* [out][in] */ ULONG32 *pcArgs) = 0;
virtual HRESULT STDMETHODCALLTYPE GetTypeArguments(
/* [in] */ ULONG32 cArgs,
/* [length_is][size_is][out] */ IDebugField **ppArgs,
/* [out][in] */ ULONG32 *pcArgs) = 0;
};
#else /* C style interface */
typedef struct IDebugGenericFieldInstanceVtbl
{
BEGIN_INTERFACE
HRESULT ( STDMETHODCALLTYPE *QueryInterface )(
IDebugGenericFieldInstance * This,
/* [in] */ REFIID riid,
/* [iid_is][out] */ void **ppvObject);
ULONG ( STDMETHODCALLTYPE *AddRef )(
IDebugGenericFieldInstance * This);
ULONG ( STDMETHODCALLTYPE *Release )(
IDebugGenericFieldInstance * This);
HRESULT ( STDMETHODCALLTYPE *TypeArgumentCount )(
IDebugGenericFieldInstance * This,
/* [out][in] */ ULONG32 *pcArgs);
HRESULT ( STDMETHODCALLTYPE *GetTypeArguments )(
IDebugGenericFieldInstance * This,
/* [in] */ ULONG32 cArgs,
/* [length_is][size_is][out] */ IDebugField **ppArgs,
/* [out][in] */ ULONG32 *pcArgs);
END_INTERFACE
} IDebugGenericFieldInstanceVtbl;
interface IDebugGenericFieldInstance
{
CONST_VTBL struct IDebugGenericFieldInstanceVtbl *lpVtbl;
};
#ifdef COBJMACROS
#define IDebugGenericFieldInstance_QueryInterface(This,riid,ppvObject) \
(This)->lpVtbl -> QueryInterface(This,riid,ppvObject)
#define IDebugGenericFieldInstance_AddRef(This) \
(This)->lpVtbl -> AddRef(This)
#define IDebugGenericFieldInstance_Release(This) \
(This)->lpVtbl -> Release(This)
#define IDebugGenericFieldInstance_TypeArgumentCount(This,pcArgs) \
(This)->lpVtbl -> TypeArgumentCount(This,pcArgs)
#define IDebugGenericFieldInstance_GetTypeArguments(This,cArgs,ppArgs,pcArgs) \
(This)->lpVtbl -> GetTypeArguments(This,cArgs,ppArgs,pcArgs)
#endif /* COBJMACROS */
#endif /* C style interface */
HRESULT STDMETHODCALLTYPE IDebugGenericFieldInstance_TypeArgumentCount_Proxy(
IDebugGenericFieldInstance * This,
/* [out][in] */ ULONG32 *pcArgs);
void __RPC_STUB IDebugGenericFieldInstance_TypeArgumentCount_Stub(
IRpcStubBuffer *This,
IRpcChannelBuffer *_pRpcChannelBuffer,
PRPC_MESSAGE _pRpcMessage,
DWORD *_pdwStubPhase);
HRESULT STDMETHODCALLTYPE IDebugGenericFieldInstance_GetTypeArguments_Proxy(
IDebugGenericFieldInstance * This,
/* [in] */ ULONG32 cArgs,
/* [length_is][size_is][out] */ IDebugField **ppArgs,
/* [out][in] */ ULONG32 *pcArgs);
void __RPC_STUB IDebugGenericFieldInstance_GetTypeArguments_Stub(
IRpcStubBuffer *This,
IRpcChannelBuffer *_pRpcChannelBuffer,
PRPC_MESSAGE _pRpcMessage,
DWORD *_pdwStubPhase);
#endif /* __IDebugGenericFieldInstance_INTERFACE_DEFINED__ */
#ifndef __IDebugField_INTERFACE_DEFINED__
#define __IDebugField_INTERFACE_DEFINED__
/* interface IDebugField */
/* [unique][uuid][object] */
enum enum_FIELD_MODIFIERS
{ FIELD_MOD_NONE = 0,
FIELD_MOD_ACCESS_NONE = 0x1,
FIELD_MOD_ACCESS_PUBLIC = 0x2,
FIELD_MOD_ACCESS_PROTECTED = 0x4,
FIELD_MOD_ACCESS_PRIVATE = 0x8,
FIELD_MOD_ACCESS_FRIEND = 0x1000000,
FIELD_MOD_NOMODIFIERS = 0x10,
FIELD_MOD_STATIC = 0x20,
FIELD_MOD_CONSTANT = 0x40,
FIELD_MOD_TRANSIENT = 0x80,
FIELD_MOD_VOLATILE = 0x100,
FIELD_MOD_ABSTRACT = 0x200,
FIELD_MOD_NATIVE = 0x400,
FIELD_MOD_SYNCHRONIZED = 0x800,
FIELD_MOD_VIRTUAL = 0x1000,
FIELD_MOD_INTERFACE = 0x2000,
FIELD_MOD_FINAL = 0x4000,
FIELD_MOD_SENTINEL = 0x8000,
FIELD_MOD_INNERCLASS = 0x10000,
FIELD_MOD_OPTIONAL = 0x20000,
FIELD_MOD_BYREF = 0x40000,
FIELD_MOD_HIDDEN = 0x80000,
FIELD_MOD_MARSHALASOBJECT = 0x100000,
FIELD_MOD_SPECIAL_NAME = 0x200000,
FIELD_MOD_HIDEBYSIG = 0x400000,
FIELD_MOD_NEWSLOT = 0x800000,
FIELD_MOD_WRITEONLY = 0x80000000,
FIELD_MOD_ACCESS_MASK = 0xf00000f,
FIELD_MOD_MASK = 0xf0fffff0,
FIELD_MOD_ALL = 0x7fffffff
} ;
typedef DWORD FIELD_MODIFIERS;
enum enum_FIELD_KIND
{ FIELD_KIND_NONE = 0,
FIELD_KIND_TYPE = 0x1,
FIELD_KIND_SYMBOL = 0x2,
FIELD_TYPE_PRIMITIVE = 0x10,
FIELD_TYPE_STRUCT = 0x20,
FIELD_TYPE_CLASS = 0x40,
FIELD_TYPE_INTERFACE = 0x80,
FIELD_TYPE_UNION = 0x100,
FIELD_TYPE_ARRAY = 0x200,
FIELD_TYPE_METHOD = 0x400,
FIELD_TYPE_BLOCK = 0x800,
FIELD_TYPE_POINTER = 0x1000,
FIELD_TYPE_ENUM = 0x2000,
FIELD_TYPE_LABEL = 0x4000,
FIELD_TYPE_TYPEDEF = 0x8000,
FIELD_TYPE_BITFIELD = 0x10000,
FIELD_TYPE_NAMESPACE = 0x20000,
FIELD_TYPE_MODULE = 0x40000,
FIELD_TYPE_DYNAMIC = 0x80000,
FIELD_TYPE_PROP = 0x100000,
FIELD_TYPE_INNERCLASS = 0x200000,
FIELD_TYPE_REFERENCE = 0x400000,
FIELD_TYPE_EXTENDED = 0x800000,
FIELD_SYM_MEMBER = 0x1000000,
FIELD_SYM_LOCAL = 0x2000000,
FIELD_SYM_PARAM = 0x4000000,
FIELD_SYM_THIS = 0x8000000,
FIELD_SYM_GLOBAL = 0x10000000,
FIELD_SYM_PROP_GETTER = 0x20000000,
FIELD_SYM_PROP_SETTER = 0x40000000,
FIELD_SYM_EXTENED = 0x80000000,
FIELD_KIND_MASK = 0xf,
FIELD_TYPE_MASK = 0xfffff0,
FIELD_SYM_MASK = 0xff000000,
FIELD_KIND_ALL = 0xffffffff
} ;
typedef DWORD FIELD_KIND;
enum enum_FIELD_INFO_FIELDS
{ FIF_FULLNAME = 0x1,
FIF_NAME = 0x2,
FIF_TYPE = 0x4,
FIF_MODIFIERS = 0x8,
FIF_ALL = 0xffffffff
} ;
typedef DWORD FIELD_INFO_FIELDS;
typedef struct _tagFieldInfo
{
FIELD_INFO_FIELDS dwFields;
BSTR bstrFullName;
BSTR bstrName;
BSTR bstrType;
FIELD_MODIFIERS dwModifiers;
} FIELD_INFO;
enum enum_dwTYPE_KIND
{ TYPE_KIND_METADATA = 0x1,
TYPE_KIND_PDB = 0x2,
TYPE_KIND_BUILT = 0x3
} ;
typedef DWORD dwTYPE_KIND;
typedef struct _tagTYPE_METADATA
{
ULONG32 ulAppDomainID;
GUID guidModule;
_mdToken tokClass;
} METADATA_TYPE;
typedef struct _tagTYPE_PDB
{
ULONG32 ulAppDomainID;
GUID guidModule;
DWORD symid;
} PDB_TYPE;
typedef struct _tagTYPE_BUILT
{
ULONG32 ulAppDomainID;
GUID guidModule;
IDebugField *pUnderlyingField;
} BUILT_TYPE;
typedef struct _tagTYPE_INFO_UNION
{
dwTYPE_KIND dwKind;
/* [switch_is] */ /* [switch_type] */ union __MIDL_IDebugField_0001
{
/* [case()] */ METADATA_TYPE typeMeta;
/* [case()] */ PDB_TYPE typePdb;
/* [case()] */ BUILT_TYPE typeBuilt;
/* [default] */ DWORD unused;
} type;
} TYPE_INFO;
EXTERN_C const IID IID_IDebugField;
#if defined(__cplusplus) && !defined(CINTERFACE)
MIDL_INTERFACE("c2e34eb1-8b9d-11d2-9014-00c04fa38338")
IDebugField : public IUnknown
{
public:
virtual HRESULT STDMETHODCALLTYPE GetInfo(
/* [in] */ FIELD_INFO_FIELDS dwFields,
/* [out] */ FIELD_INFO *pFieldInfo) = 0;
virtual HRESULT STDMETHODCALLTYPE GetKind(
/* [out] */ FIELD_KIND *pdwKind) = 0;
virtual HRESULT STDMETHODCALLTYPE GetType(
/* [out] */ IDebugField **ppType) = 0;
virtual HRESULT STDMETHODCALLTYPE GetContainer(
/* [out] */ IDebugContainerField **ppContainerField) = 0;
virtual HRESULT STDMETHODCALLTYPE GetAddress(
/* [out] */ IDebugAddress **ppAddress) = 0;
virtual HRESULT STDMETHODCALLTYPE GetSize(
/* [out] */ DWORD *pdwSize) = 0;
virtual HRESULT STDMETHODCALLTYPE GetExtendedInfo(
/* [in] */ REFGUID guidExtendedInfo,
/* [length_is][size_is][out] */ BYTE **prgBuffer,
/* [out][in] */ DWORD *pdwLen) = 0;
virtual HRESULT STDMETHODCALLTYPE Equal(
/* [in] */ IDebugField *pField) = 0;
virtual HRESULT STDMETHODCALLTYPE GetTypeInfo(
/* [out] */ TYPE_INFO *pTypeInfo) = 0;
};
#else /* C style interface */
typedef struct IDebugFieldVtbl
{
BEGIN_INTERFACE
HRESULT ( STDMETHODCALLTYPE *QueryInterface )(
IDebugField * This,
/* [in] */ REFIID riid,
/* [iid_is][out] */ void **ppvObject);
ULONG ( STDMETHODCALLTYPE *AddRef )(
IDebugField * This);
ULONG ( STDMETHODCALLTYPE *Release )(
IDebugField * This);
HRESULT ( STDMETHODCALLTYPE *GetInfo )(
IDebugField * This,
/* [in] */ FIELD_INFO_FIELDS dwFields,
/* [out] */ FIELD_INFO *pFieldInfo);
HRESULT ( STDMETHODCALLTYPE *GetKind )(
IDebugField * This,
/* [out] */ FIELD_KIND *pdwKind);
HRESULT ( STDMETHODCALLTYPE *GetType )(
IDebugField * This,
/* [out] */ IDebugField **ppType);
HRESULT ( STDMETHODCALLTYPE *GetContainer )(
IDebugField * This,
/* [out] */ IDebugContainerField **ppContainerField);
HRESULT ( STDMETHODCALLTYPE *GetAddress )(
IDebugField * This,
/* [out] */ IDebugAddress **ppAddress);
HRESULT ( STDMETHODCALLTYPE *GetSize )(
IDebugField * This,
/* [out] */ DWORD *pdwSize);
HRESULT ( STDMETHODCALLTYPE *GetExtendedInfo )(
IDebugField * This,
/* [in] */ REFGUID guidExtendedInfo,
/* [length_is][size_is][out] */ BYTE **prgBuffer,
/* [out][in] */ DWORD *pdwLen);
HRESULT ( STDMETHODCALLTYPE *Equal )(
IDebugField * This,
/* [in] */ IDebugField *pField);
HRESULT ( STDMETHODCALLTYPE *GetTypeInfo )(
IDebugField * This,
/* [out] */ TYPE_INFO *pTypeInfo);
END_INTERFACE
} IDebugFieldVtbl;
interface IDebugField
{
CONST_VTBL struct IDebugFieldVtbl *lpVtbl;
};
#ifdef COBJMACROS
#define IDebugField_QueryInterface(This,riid,ppvObject) \
(This)->lpVtbl -> QueryInterface(This,riid,ppvObject)
#define IDebugField_AddRef(This) \
(This)->lpVtbl -> AddRef(This)
#define IDebugField_Release(This) \
(This)->lpVtbl -> Release(This)
#define IDebugField_GetInfo(This,dwFields,pFieldInfo) \
(This)->lpVtbl -> GetInfo(This,dwFields,pFieldInfo)
#define IDebugField_GetKind(This,pdwKind) \
(This)->lpVtbl -> GetKind(This,pdwKind)
#define IDebugField_GetType(This,ppType) \
(This)->lpVtbl -> GetType(This,ppType)
#define IDebugField_GetContainer(This,ppContainerField) \
(This)->lpVtbl -> GetContainer(This,ppContainerField)
#define IDebugField_GetAddress(This,ppAddress) \
(This)->lpVtbl -> GetAddress(This,ppAddress)
#define IDebugField_GetSize(This,pdwSize) \
(This)->lpVtbl -> GetSize(This,pdwSize)
#define IDebugField_GetExtendedInfo(This,guidExtendedInfo,prgBuffer,pdwLen) \
(This)->lpVtbl -> GetExtendedInfo(This,guidExtendedInfo,prgBuffer,pdwLen)
#define IDebugField_Equal(This,pField) \
(This)->lpVtbl -> Equal(This,pField)
#define IDebugField_GetTypeInfo(This,pTypeInfo) \
(This)->lpVtbl -> GetTypeInfo(This,pTypeInfo)
#endif /* COBJMACROS */
#endif /* C style interface */
HRESULT STDMETHODCALLTYPE IDebugField_GetInfo_Proxy(
IDebugField * This,
/* [in] */ FIELD_INFO_FIELDS dwFields,
/* [out] */ FIELD_INFO *pFieldInfo);
void __RPC_STUB IDebugField_GetInfo_Stub(
IRpcStubBuffer *This,
IRpcChannelBuffer *_pRpcChannelBuffer,
PRPC_MESSAGE _pRpcMessage,
DWORD *_pdwStubPhase);
HRESULT STDMETHODCALLTYPE IDebugField_GetKind_Proxy(
IDebugField * This,
/* [out] */ FIELD_KIND *pdwKind);
void __RPC_STUB IDebugField_GetKind_Stub(
IRpcStubBuffer *This,
IRpcChannelBuffer *_pRpcChannelBuffer,
PRPC_MESSAGE _pRpcMessage,
DWORD *_pdwStubPhase);
HRESULT STDMETHODCALLTYPE IDebugField_GetType_Proxy(
IDebugField * This,
/* [out] */ IDebugField **ppType);
void __RPC_STUB IDebugField_GetType_Stub(
IRpcStubBuffer *This,
IRpcChannelBuffer *_pRpcChannelBuffer,
PRPC_MESSAGE _pRpcMessage,
DWORD *_pdwStubPhase);
HRESULT STDMETHODCALLTYPE IDebugField_GetContainer_Proxy(
IDebugField * This,
/* [out] */ IDebugContainerField **ppContainerField);
void __RPC_STUB IDebugField_GetContainer_Stub(
IRpcStubBuffer *This,
IRpcChannelBuffer *_pRpcChannelBuffer,
PRPC_MESSAGE _pRpcMessage,
DWORD *_pdwStubPhase);
HRESULT STDMETHODCALLTYPE IDebugField_GetAddress_Proxy(
IDebugField * This,
/* [out] */ IDebugAddress **ppAddress);
void __RPC_STUB IDebugField_GetAddress_Stub(
IRpcStubBuffer *This,
IRpcChannelBuffer *_pRpcChannelBuffer,
PRPC_MESSAGE _pRpcMessage,
DWORD *_pdwStubPhase);
HRESULT STDMETHODCALLTYPE IDebugField_GetSize_Proxy(
IDebugField * This,
/* [out] */ DWORD *pdwSize);
void __RPC_STUB IDebugField_GetSize_Stub(
IRpcStubBuffer *This,
IRpcChannelBuffer *_pRpcChannelBuffer,
PRPC_MESSAGE _pRpcMessage,
DWORD *_pdwStubPhase);
HRESULT STDMETHODCALLTYPE IDebugField_GetExtendedInfo_Proxy(
IDebugField * This,
/* [in] */ REFGUID guidExtendedInfo,
/* [length_is][size_is][out] */ BYTE **prgBuffer,
/* [out][in] */ DWORD *pdwLen);
void __RPC_STUB IDebugField_GetExtendedInfo_Stub(
IRpcStubBuffer *This,
IRpcChannelBuffer *_pRpcChannelBuffer,
PRPC_MESSAGE _pRpcMessage,
DWORD *_pdwStubPhase);
HRESULT STDMETHODCALLTYPE IDebugField_Equal_Proxy(
IDebugField * This,
/* [in] */ IDebugField *pField);
void __RPC_STUB IDebugField_Equal_Stub(
IRpcStubBuffer *This,
IRpcChannelBuffer *_pRpcChannelBuffer,
PRPC_MESSAGE _pRpcMessage,
DWORD *_pdwStubPhase);
HRESULT STDMETHODCALLTYPE IDebugField_GetTypeInfo_Proxy(
IDebugField * This,
/* [out] */ TYPE_INFO *pTypeInfo);
void __RPC_STUB IDebugField_GetTypeInfo_Stub(
IRpcStubBuffer *This,
IRpcChannelBuffer *_pRpcChannelBuffer,
PRPC_MESSAGE _pRpcMessage,
DWORD *_pdwStubPhase);
#endif /* __IDebugField_INTERFACE_DEFINED__ */
#ifndef __IDebugGenericParamField_INTERFACE_DEFINED__
#define __IDebugGenericParamField_INTERFACE_DEFINED__
/* interface IDebugGenericParamField */
/* [unique][uuid][object] */
EXTERN_C const IID IID_IDebugGenericParamField;
#if defined(__cplusplus) && !defined(CINTERFACE)
MIDL_INTERFACE("941105E9-760A-49ec-995F-7668CB60216C")
IDebugGenericParamField : public IDebugField
{
public:
virtual HRESULT STDMETHODCALLTYPE GetNameOfFormalParam(
/* [out] */ BSTR *pbstrName) = 0;
virtual HRESULT STDMETHODCALLTYPE ConstraintCount(
/* [out][in] */ ULONG32 *pcConst) = 0;
virtual HRESULT STDMETHODCALLTYPE GetConstraints(
/* [in] */ ULONG32 cConstraints,
/* [length_is][size_is][out] */ IDebugField **ppConstraints,
/* [out][in] */ ULONG32 *pcConstraints) = 0;
virtual HRESULT STDMETHODCALLTYPE GetOwner(
/* [out] */ IDebugField **ppOwner) = 0;
virtual HRESULT STDMETHODCALLTYPE GetIndex(
/* [out] */ DWORD *pIndex) = 0;
virtual HRESULT STDMETHODCALLTYPE GetFlags(
/* [out] */ DWORD *pdwFlags) = 0;
};
#else /* C style interface */
typedef struct IDebugGenericParamFieldVtbl
{
BEGIN_INTERFACE
HRESULT ( STDMETHODCALLTYPE *QueryInterface )(
IDebugGenericParamField * This,
/* [in] */ REFIID riid,
/* [iid_is][out] */ void **ppvObject);
ULONG ( STDMETHODCALLTYPE *AddRef )(
IDebugGenericParamField * This);
ULONG ( STDMETHODCALLTYPE *Release )(
IDebugGenericParamField * This);
HRESULT ( STDMETHODCALLTYPE *GetInfo )(
IDebugGenericParamField * This,
/* [in] */ FIELD_INFO_FIELDS dwFields,
/* [out] */ FIELD_INFO *pFieldInfo);
HRESULT ( STDMETHODCALLTYPE *GetKind )(
IDebugGenericParamField * This,
/* [out] */ FIELD_KIND *pdwKind);
HRESULT ( STDMETHODCALLTYPE *GetType )(
IDebugGenericParamField * This,
/* [out] */ IDebugField **ppType);
HRESULT ( STDMETHODCALLTYPE *GetContainer )(
IDebugGenericParamField * This,
/* [out] */ IDebugContainerField **ppContainerField);
HRESULT ( STDMETHODCALLTYPE *GetAddress )(
IDebugGenericParamField * This,
/* [out] */ IDebugAddress **ppAddress);
HRESULT ( STDMETHODCALLTYPE *GetSize )(
IDebugGenericParamField * This,
/* [out] */ DWORD *pdwSize);
HRESULT ( STDMETHODCALLTYPE *GetExtendedInfo )(
IDebugGenericParamField * This,
/* [in] */ REFGUID guidExtendedInfo,
/* [length_is][size_is][out] */ BYTE **prgBuffer,
/* [out][in] */ DWORD *pdwLen);
HRESULT ( STDMETHODCALLTYPE *Equal )(
IDebugGenericParamField * This,
/* [in] */ IDebugField *pField);
HRESULT ( STDMETHODCALLTYPE *GetTypeInfo )(
IDebugGenericParamField * This,
/* [out] */ TYPE_INFO *pTypeInfo);
HRESULT ( STDMETHODCALLTYPE *GetNameOfFormalParam )(
IDebugGenericParamField * This,
/* [out] */ BSTR *pbstrName);
HRESULT ( STDMETHODCALLTYPE *ConstraintCount )(
IDebugGenericParamField * This,
/* [out][in] */ ULONG32 *pcConst);
HRESULT ( STDMETHODCALLTYPE *GetConstraints )(
IDebugGenericParamField * This,
/* [in] */ ULONG32 cConstraints,
/* [length_is][size_is][out] */ IDebugField **ppConstraints,
/* [out][in] */ ULONG32 *pcConstraints);
HRESULT ( STDMETHODCALLTYPE *GetOwner )(
IDebugGenericParamField * This,
/* [out] */ IDebugField **ppOwner);
HRESULT ( STDMETHODCALLTYPE *GetIndex )(
IDebugGenericParamField * This,
/* [out] */ DWORD *pIndex);
HRESULT ( STDMETHODCALLTYPE *GetFlags )(
IDebugGenericParamField * This,
/* [out] */ DWORD *pdwFlags);
END_INTERFACE
} IDebugGenericParamFieldVtbl;
interface IDebugGenericParamField
{
CONST_VTBL struct IDebugGenericParamFieldVtbl *lpVtbl;
};
#ifdef COBJMACROS
#define IDebugGenericParamField_QueryInterface(This,riid,ppvObject) \
(This)->lpVtbl -> QueryInterface(This,riid,ppvObject)
#define IDebugGenericParamField_AddRef(This) \
(This)->lpVtbl -> AddRef(This)
#define IDebugGenericParamField_Release(This) \
(This)->lpVtbl -> Release(This)
#define IDebugGenericParamField_GetInfo(This,dwFields,pFieldInfo) \
(This)->lpVtbl -> GetInfo(This,dwFields,pFieldInfo)
#define IDebugGenericParamField_GetKind(This,pdwKind) \
(This)->lpVtbl -> GetKind(This,pdwKind)
#define IDebugGenericParamField_GetType(This,ppType) \
(This)->lpVtbl -> GetType(This,ppType)
#define IDebugGenericParamField_GetContainer(This,ppContainerField) \
(This)->lpVtbl -> GetContainer(This,ppContainerField)
#define IDebugGenericParamField_GetAddress(This,ppAddress) \
(This)->lpVtbl -> GetAddress(This,ppAddress)
#define IDebugGenericParamField_GetSize(This,pdwSize) \
(This)->lpVtbl -> GetSize(This,pdwSize)
#define IDebugGenericParamField_GetExtendedInfo(This,guidExtendedInfo,prgBuffer,pdwLen) \
(This)->lpVtbl -> GetExtendedInfo(This,guidExtendedInfo,prgBuffer,pdwLen)
#define IDebugGenericParamField_Equal(This,pField) \
(This)->lpVtbl -> Equal(This,pField)
#define IDebugGenericParamField_GetTypeInfo(This,pTypeInfo) \
(This)->lpVtbl -> GetTypeInfo(This,pTypeInfo)
#define IDebugGenericParamField_GetNameOfFormalParam(This,pbstrName) \
(This)->lpVtbl -> GetNameOfFormalParam(This,pbstrName)
#define IDebugGenericParamField_ConstraintCount(This,pcConst) \
(This)->lpVtbl -> ConstraintCount(This,pcConst)
#define IDebugGenericParamField_GetConstraints(This,cConstraints,ppConstraints,pcConstraints) \
(This)->lpVtbl -> GetConstraints(This,cConstraints,ppConstraints,pcConstraints)
#define IDebugGenericParamField_GetOwner(This,ppOwner) \
(This)->lpVtbl -> GetOwner(This,ppOwner)
#define IDebugGenericParamField_GetIndex(This,pIndex) \
(This)->lpVtbl -> GetIndex(This,pIndex)
#define IDebugGenericParamField_GetFlags(This,pdwFlags) \
(This)->lpVtbl -> GetFlags(This,pdwFlags)
#endif /* COBJMACROS */
#endif /* C style interface */
HRESULT STDMETHODCALLTYPE IDebugGenericParamField_GetNameOfFormalParam_Proxy(
IDebugGenericParamField * This,
/* [out] */ BSTR *pbstrName);
void __RPC_STUB IDebugGenericParamField_GetNameOfFormalParam_Stub(
IRpcStubBuffer *This,
IRpcChannelBuffer *_pRpcChannelBuffer,
PRPC_MESSAGE _pRpcMessage,
DWORD *_pdwStubPhase);
HRESULT STDMETHODCALLTYPE IDebugGenericParamField_ConstraintCount_Proxy(
IDebugGenericParamField * This,
/* [out][in] */ ULONG32 *pcConst);
void __RPC_STUB IDebugGenericParamField_ConstraintCount_Stub(
IRpcStubBuffer *This,
IRpcChannelBuffer *_pRpcChannelBuffer,
PRPC_MESSAGE _pRpcMessage,
DWORD *_pdwStubPhase);
HRESULT STDMETHODCALLTYPE IDebugGenericParamField_GetConstraints_Proxy(
IDebugGenericParamField * This,
/* [in] */ ULONG32 cConstraints,
/* [length_is][size_is][out] */ IDebugField **ppConstraints,
/* [out][in] */ ULONG32 *pcConstraints);
void __RPC_STUB IDebugGenericParamField_GetConstraints_Stub(
IRpcStubBuffer *This,
IRpcChannelBuffer *_pRpcChannelBuffer,
PRPC_MESSAGE _pRpcMessage,
DWORD *_pdwStubPhase);
HRESULT STDMETHODCALLTYPE IDebugGenericParamField_GetOwner_Proxy(
IDebugGenericParamField * This,
/* [out] */ IDebugField **ppOwner);
void __RPC_STUB IDebugGenericParamField_GetOwner_Stub(
IRpcStubBuffer *This,
IRpcChannelBuffer *_pRpcChannelBuffer,
PRPC_MESSAGE _pRpcMessage,
DWORD *_pdwStubPhase);
HRESULT STDMETHODCALLTYPE IDebugGenericParamField_GetIndex_Proxy(
IDebugGenericParamField * This,
/* [out] */ DWORD *pIndex);
void __RPC_STUB IDebugGenericParamField_GetIndex_Stub(
IRpcStubBuffer *This,
IRpcChannelBuffer *_pRpcChannelBuffer,
PRPC_MESSAGE _pRpcMessage,
DWORD *_pdwStubPhase);
HRESULT STDMETHODCALLTYPE IDebugGenericParamField_GetFlags_Proxy(
IDebugGenericParamField * This,
/* [out] */ DWORD *pdwFlags);
void __RPC_STUB IDebugGenericParamField_GetFlags_Stub(
IRpcStubBuffer *This,
IRpcChannelBuffer *_pRpcChannelBuffer,
PRPC_MESSAGE _pRpcMessage,
DWORD *_pdwStubPhase);
#endif /* __IDebugGenericParamField_INTERFACE_DEFINED__ */
#ifndef __IDebugComPlusSymbolSearchInfo_INTERFACE_DEFINED__
#define __IDebugComPlusSymbolSearchInfo_INTERFACE_DEFINED__
/* interface IDebugComPlusSymbolSearchInfo */
/* [unique][uuid][object] */
typedef struct _tagSymbolSearchInfo
{
BSTR bstrPath;
HRESULT hrHRESULT;
} SYMBOL_SEARCH_INFO;
EXTERN_C const IID IID_IDebugComPlusSymbolSearchInfo;
#if defined(__cplusplus) && !defined(CINTERFACE)
MIDL_INTERFACE("F96F4D16-E799-492d-B33D-2325E63D4135")
IDebugComPlusSymbolSearchInfo : public IUnknown
{
public:
virtual HRESULT STDMETHODCALLTYPE GetLastSymbolSearchInfo(
/* [in] */ ULONG32 ulAppDomainID,
/* [in] */ GUID guidModule,
/* [out] */ BSTR *pbstrPath,
/* [out] */ HRESULT *phrHRESULT) = 0;
virtual HRESULT STDMETHODCALLTYPE GetSymbolSearchInfoCount(
/* [in] */ ULONG32 ulAppDomainID,
/* [in] */ GUID guidModule,
/* [out] */ ULONG32 *pCount) = 0;
virtual HRESULT STDMETHODCALLTYPE GetSymbolSearchInfo(
/* [in] */ ULONG32 ulAppDomainID,
/* [in] */ GUID guidModule,
/* [in] */ ULONG32 ulSearchInfo,
/* [out] */ ULONG32 *pulSearchInfo,
/* [length_is][size_is][out] */ SYMBOL_SEARCH_INFO **prgSearchInfo) = 0;
virtual HRESULT STDMETHODCALLTYPE LoadSymbolsWithoutPDB(
/* [in] */ ULONG32 ulAppDomainID,
/* [in] */ GUID guidModule,
/* [in] */ ULONGLONG baseAddress,
/* [in] */ IUnknown *pUnkMetadataImport,
/* [in] */ IUnknown *pUnkCorDebugModule,
/* [in] */ BSTR bstrModule) = 0;
};
#else /* C style interface */
typedef struct IDebugComPlusSymbolSearchInfoVtbl
{
BEGIN_INTERFACE
HRESULT ( STDMETHODCALLTYPE *QueryInterface )(
IDebugComPlusSymbolSearchInfo * This,
/* [in] */ REFIID riid,
/* [iid_is][out] */ void **ppvObject);
ULONG ( STDMETHODCALLTYPE *AddRef )(
IDebugComPlusSymbolSearchInfo * This);
ULONG ( STDMETHODCALLTYPE *Release )(
IDebugComPlusSymbolSearchInfo * This);
HRESULT ( STDMETHODCALLTYPE *GetLastSymbolSearchInfo )(
IDebugComPlusSymbolSearchInfo * This,
/* [in] */ ULONG32 ulAppDomainID,
/* [in] */ GUID guidModule,
/* [out] */ BSTR *pbstrPath,
/* [out] */ HRESULT *phrHRESULT);
HRESULT ( STDMETHODCALLTYPE *GetSymbolSearchInfoCount )(
IDebugComPlusSymbolSearchInfo * This,
/* [in] */ ULONG32 ulAppDomainID,
/* [in] */ GUID guidModule,
/* [out] */ ULONG32 *pCount);
HRESULT ( STDMETHODCALLTYPE *GetSymbolSearchInfo )(
IDebugComPlusSymbolSearchInfo * This,
/* [in] */ ULONG32 ulAppDomainID,
/* [in] */ GUID guidModule,
/* [in] */ ULONG32 ulSearchInfo,
/* [out] */ ULONG32 *pulSearchInfo,
/* [length_is][size_is][out] */ SYMBOL_SEARCH_INFO **prgSearchInfo);
HRESULT ( STDMETHODCALLTYPE *LoadSymbolsWithoutPDB )(
IDebugComPlusSymbolSearchInfo * This,
/* [in] */ ULONG32 ulAppDomainID,
/* [in] */ GUID guidModule,
/* [in] */ ULONGLONG baseAddress,
/* [in] */ IUnknown *pUnkMetadataImport,
/* [in] */ IUnknown *pUnkCorDebugModule,
/* [in] */ BSTR bstrModule);
END_INTERFACE
} IDebugComPlusSymbolSearchInfoVtbl;
interface IDebugComPlusSymbolSearchInfo
{
CONST_VTBL struct IDebugComPlusSymbolSearchInfoVtbl *lpVtbl;
};
#ifdef COBJMACROS
#define IDebugComPlusSymbolSearchInfo_QueryInterface(This,riid,ppvObject) \
(This)->lpVtbl -> QueryInterface(This,riid,ppvObject)
#define IDebugComPlusSymbolSearchInfo_AddRef(This) \
(This)->lpVtbl -> AddRef(This)
#define IDebugComPlusSymbolSearchInfo_Release(This) \
(This)->lpVtbl -> Release(This)
#define IDebugComPlusSymbolSearchInfo_GetLastSymbolSearchInfo(This,ulAppDomainID,guidModule,pbstrPath,phrHRESULT) \
(This)->lpVtbl -> GetLastSymbolSearchInfo(This,ulAppDomainID,guidModule,pbstrPath,phrHRESULT)
#define IDebugComPlusSymbolSearchInfo_GetSymbolSearchInfoCount(This,ulAppDomainID,guidModule,pCount) \
(This)->lpVtbl -> GetSymbolSearchInfoCount(This,ulAppDomainID,guidModule,pCount)
#define IDebugComPlusSymbolSearchInfo_GetSymbolSearchInfo(This,ulAppDomainID,guidModule,ulSearchInfo,pulSearchInfo,prgSearchInfo) \
(This)->lpVtbl -> GetSymbolSearchInfo(This,ulAppDomainID,guidModule,ulSearchInfo,pulSearchInfo,prgSearchInfo)
#define IDebugComPlusSymbolSearchInfo_LoadSymbolsWithoutPDB(This,ulAppDomainID,guidModule,baseAddress,pUnkMetadataImport,pUnkCorDebugModule,bstrModule) \
(This)->lpVtbl -> LoadSymbolsWithoutPDB(This,ulAppDomainID,guidModule,baseAddress,pUnkMetadataImport,pUnkCorDebugModule,bstrModule)
#endif /* COBJMACROS */
#endif /* C style interface */
HRESULT STDMETHODCALLTYPE IDebugComPlusSymbolSearchInfo_GetLastSymbolSearchInfo_Proxy(
IDebugComPlusSymbolSearchInfo * This,
/* [in] */ ULONG32 ulAppDomainID,
/* [in] */ GUID guidModule,
/* [out] */ BSTR *pbstrPath,
/* [out] */ HRESULT *phrHRESULT);
void __RPC_STUB IDebugComPlusSymbolSearchInfo_GetLastSymbolSearchInfo_Stub(
IRpcStubBuffer *This,
IRpcChannelBuffer *_pRpcChannelBuffer,
PRPC_MESSAGE _pRpcMessage,
DWORD *_pdwStubPhase);
HRESULT STDMETHODCALLTYPE IDebugComPlusSymbolSearchInfo_GetSymbolSearchInfoCount_Proxy(
IDebugComPlusSymbolSearchInfo * This,
/* [in] */ ULONG32 ulAppDomainID,
/* [in] */ GUID guidModule,
/* [out] */ ULONG32 *pCount);
void __RPC_STUB IDebugComPlusSymbolSearchInfo_GetSymbolSearchInfoCount_Stub(
IRpcStubBuffer *This,
IRpcChannelBuffer *_pRpcChannelBuffer,
PRPC_MESSAGE _pRpcMessage,
DWORD *_pdwStubPhase);
HRESULT STDMETHODCALLTYPE IDebugComPlusSymbolSearchInfo_GetSymbolSearchInfo_Proxy(
IDebugComPlusSymbolSearchInfo * This,
/* [in] */ ULONG32 ulAppDomainID,
/* [in] */ GUID guidModule,
/* [in] */ ULONG32 ulSearchInfo,
/* [out] */ ULONG32 *pulSearchInfo,
/* [length_is][size_is][out] */ SYMBOL_SEARCH_INFO **prgSearchInfo);
void __RPC_STUB IDebugComPlusSymbolSearchInfo_GetSymbolSearchInfo_Stub(
IRpcStubBuffer *This,
IRpcChannelBuffer *_pRpcChannelBuffer,
PRPC_MESSAGE _pRpcMessage,
DWORD *_pdwStubPhase);
HRESULT STDMETHODCALLTYPE IDebugComPlusSymbolSearchInfo_LoadSymbolsWithoutPDB_Proxy(
IDebugComPlusSymbolSearchInfo * This,
/* [in] */ ULONG32 ulAppDomainID,
/* [in] */ GUID guidModule,
/* [in] */ ULONGLONG baseAddress,
/* [in] */ IUnknown *pUnkMetadataImport,
/* [in] */ IUnknown *pUnkCorDebugModule,
/* [in] */ BSTR bstrModule);
void __RPC_STUB IDebugComPlusSymbolSearchInfo_LoadSymbolsWithoutPDB_Stub(
IRpcStubBuffer *This,
IRpcChannelBuffer *_pRpcChannelBuffer,
PRPC_MESSAGE _pRpcMessage,
DWORD *_pdwStubPhase);
#endif /* __IDebugComPlusSymbolSearchInfo_INTERFACE_DEFINED__ */
#ifndef __IDebugTypeFieldBuilder_INTERFACE_DEFINED__
#define __IDebugTypeFieldBuilder_INTERFACE_DEFINED__
/* interface IDebugTypeFieldBuilder */
/* [unique][uuid][object] */
EXTERN_C const IID IID_IDebugTypeFieldBuilder;
#if defined(__cplusplus) && !defined(CINTERFACE)
MIDL_INTERFACE("796AE40B-6CDA-4f05-A663-D282A93AC7D4")
IDebugTypeFieldBuilder : public IUnknown
{
public:
virtual HRESULT STDMETHODCALLTYPE CreatePrimitive(
/* [in] */ DWORD dwElementType,
/* [out] */ IDebugField **pTypeField) = 0;
virtual HRESULT STDMETHODCALLTYPE CreatePointerToType(
/* [in] */ IDebugField *pTypeField,
/* [out] */ IDebugField **pPtrToTypeField) = 0;
};
#else /* C style interface */
typedef struct IDebugTypeFieldBuilderVtbl
{
BEGIN_INTERFACE
HRESULT ( STDMETHODCALLTYPE *QueryInterface )(
IDebugTypeFieldBuilder * This,
/* [in] */ REFIID riid,
/* [iid_is][out] */ void **ppvObject);
ULONG ( STDMETHODCALLTYPE *AddRef )(
IDebugTypeFieldBuilder * This);
ULONG ( STDMETHODCALLTYPE *Release )(
IDebugTypeFieldBuilder * This);
HRESULT ( STDMETHODCALLTYPE *CreatePrimitive )(
IDebugTypeFieldBuilder * This,
/* [in] */ DWORD dwElementType,
/* [out] */ IDebugField **pTypeField);
HRESULT ( STDMETHODCALLTYPE *CreatePointerToType )(
IDebugTypeFieldBuilder * This,
/* [in] */ IDebugField *pTypeField,
/* [out] */ IDebugField **pPtrToTypeField);
END_INTERFACE
} IDebugTypeFieldBuilderVtbl;
interface IDebugTypeFieldBuilder
{
CONST_VTBL struct IDebugTypeFieldBuilderVtbl *lpVtbl;
};
#ifdef COBJMACROS
#define IDebugTypeFieldBuilder_QueryInterface(This,riid,ppvObject) \
(This)->lpVtbl -> QueryInterface(This,riid,ppvObject)
#define IDebugTypeFieldBuilder_AddRef(This) \
(This)->lpVtbl -> AddRef(This)
#define IDebugTypeFieldBuilder_Release(This) \
(This)->lpVtbl -> Release(This)
#define IDebugTypeFieldBuilder_CreatePrimitive(This,dwElementType,pTypeField) \
(This)->lpVtbl -> CreatePrimitive(This,dwElementType,pTypeField)
#define IDebugTypeFieldBuilder_CreatePointerToType(This,pTypeField,pPtrToTypeField) \
(This)->lpVtbl -> CreatePointerToType(This,pTypeField,pPtrToTypeField)
#endif /* COBJMACROS */
#endif /* C style interface */
HRESULT STDMETHODCALLTYPE IDebugTypeFieldBuilder_CreatePrimitive_Proxy(
IDebugTypeFieldBuilder * This,
/* [in] */ DWORD dwElementType,
/* [out] */ IDebugField **pTypeField);
void __RPC_STUB IDebugTypeFieldBuilder_CreatePrimitive_Stub(
IRpcStubBuffer *This,
IRpcChannelBuffer *_pRpcChannelBuffer,
PRPC_MESSAGE _pRpcMessage,
DWORD *_pdwStubPhase);
HRESULT STDMETHODCALLTYPE IDebugTypeFieldBuilder_CreatePointerToType_Proxy(
IDebugTypeFieldBuilder * This,
/* [in] */ IDebugField *pTypeField,
/* [out] */ IDebugField **pPtrToTypeField);
void __RPC_STUB IDebugTypeFieldBuilder_CreatePointerToType_Stub(
IRpcStubBuffer *This,
IRpcChannelBuffer *_pRpcChannelBuffer,
PRPC_MESSAGE _pRpcMessage,
DWORD *_pdwStubPhase);
#endif /* __IDebugTypeFieldBuilder_INTERFACE_DEFINED__ */
#ifndef __IDebugTypeFieldBuilder2_INTERFACE_DEFINED__
#define __IDebugTypeFieldBuilder2_INTERFACE_DEFINED__
/* interface IDebugTypeFieldBuilder2 */
/* [unique][uuid][object] */
EXTERN_C const IID IID_IDebugTypeFieldBuilder2;
#if defined(__cplusplus) && !defined(CINTERFACE)
MIDL_INTERFACE("EED3392E-C13A-42a9-932F-145C12B4FB5C")
IDebugTypeFieldBuilder2 : public IDebugTypeFieldBuilder
{
public:
virtual HRESULT STDMETHODCALLTYPE CreateArrayOfType(
/* [in] */ IDebugField *pTypeField,
/* [in] */ DWORD rank,
/* [out] */ IDebugField **pArrayOfTypeField) = 0;
};
#else /* C style interface */
typedef struct IDebugTypeFieldBuilder2Vtbl
{
BEGIN_INTERFACE
HRESULT ( STDMETHODCALLTYPE *QueryInterface )(
IDebugTypeFieldBuilder2 * This,
/* [in] */ REFIID riid,
/* [iid_is][out] */ void **ppvObject);
ULONG ( STDMETHODCALLTYPE *AddRef )(
IDebugTypeFieldBuilder2 * This);
ULONG ( STDMETHODCALLTYPE *Release )(
IDebugTypeFieldBuilder2 * This);
HRESULT ( STDMETHODCALLTYPE *CreatePrimitive )(
IDebugTypeFieldBuilder2 * This,
/* [in] */ DWORD dwElementType,
/* [out] */ IDebugField **pTypeField);
HRESULT ( STDMETHODCALLTYPE *CreatePointerToType )(
IDebugTypeFieldBuilder2 * This,
/* [in] */ IDebugField *pTypeField,
/* [out] */ IDebugField **pPtrToTypeField);
HRESULT ( STDMETHODCALLTYPE *CreateArrayOfType )(
IDebugTypeFieldBuilder2 * This,
/* [in] */ IDebugField *pTypeField,
/* [in] */ DWORD rank,
/* [out] */ IDebugField **pArrayOfTypeField);
END_INTERFACE
} IDebugTypeFieldBuilder2Vtbl;
interface IDebugTypeFieldBuilder2
{
CONST_VTBL struct IDebugTypeFieldBuilder2Vtbl *lpVtbl;
};
#ifdef COBJMACROS
#define IDebugTypeFieldBuilder2_QueryInterface(This,riid,ppvObject) \
(This)->lpVtbl -> QueryInterface(This,riid,ppvObject)
#define IDebugTypeFieldBuilder2_AddRef(This) \
(This)->lpVtbl -> AddRef(This)
#define IDebugTypeFieldBuilder2_Release(This) \
(This)->lpVtbl -> Release(This)
#define IDebugTypeFieldBuilder2_CreatePrimitive(This,dwElementType,pTypeField) \
(This)->lpVtbl -> CreatePrimitive(This,dwElementType,pTypeField)
#define IDebugTypeFieldBuilder2_CreatePointerToType(This,pTypeField,pPtrToTypeField) \
(This)->lpVtbl -> CreatePointerToType(This,pTypeField,pPtrToTypeField)
#define IDebugTypeFieldBuilder2_CreateArrayOfType(This,pTypeField,rank,pArrayOfTypeField) \
(This)->lpVtbl -> CreateArrayOfType(This,pTypeField,rank,pArrayOfTypeField)
#endif /* COBJMACROS */
#endif /* C style interface */
HRESULT STDMETHODCALLTYPE IDebugTypeFieldBuilder2_CreateArrayOfType_Proxy(
IDebugTypeFieldBuilder2 * This,
/* [in] */ IDebugField *pTypeField,
/* [in] */ DWORD rank,
/* [out] */ IDebugField **pArrayOfTypeField);
void __RPC_STUB IDebugTypeFieldBuilder2_CreateArrayOfType_Stub(
IRpcStubBuffer *This,
IRpcChannelBuffer *_pRpcChannelBuffer,
PRPC_MESSAGE _pRpcMessage,
DWORD *_pdwStubPhase);
#endif /* __IDebugTypeFieldBuilder2_INTERFACE_DEFINED__ */
#ifndef __IDebugNativeSymbolProvider_INTERFACE_DEFINED__
#define __IDebugNativeSymbolProvider_INTERFACE_DEFINED__
/* interface IDebugNativeSymbolProvider */
/* [unique][uuid][object] */
EXTERN_C const IID IID_IDebugNativeSymbolProvider;
#if defined(__cplusplus) && !defined(CINTERFACE)
MIDL_INTERFACE("c2e34eb0-8b9d-11d2-9014-00c04fa38338")
IDebugNativeSymbolProvider : public IDebugSymbolProvider
{
public:
virtual HRESULT STDMETHODCALLTYPE LoadSymbols(
/* [in] */ LPCOLESTR pszFileName) = 0;
};
#else /* C style interface */
typedef struct IDebugNativeSymbolProviderVtbl
{
BEGIN_INTERFACE
HRESULT ( STDMETHODCALLTYPE *QueryInterface )(
IDebugNativeSymbolProvider * This,
/* [in] */ REFIID riid,
/* [iid_is][out] */ void **ppvObject);
ULONG ( STDMETHODCALLTYPE *AddRef )(
IDebugNativeSymbolProvider * This);
ULONG ( STDMETHODCALLTYPE *Release )(
IDebugNativeSymbolProvider * This);
HRESULT ( STDMETHODCALLTYPE *Initialize )(
IDebugNativeSymbolProvider * This,
/* [in] */ IDebugEngineSymbolProviderServices *pServices);
HRESULT ( STDMETHODCALLTYPE *Uninitialize )(
IDebugNativeSymbolProvider * This);
HRESULT ( STDMETHODCALLTYPE *GetContainerField )(
IDebugNativeSymbolProvider * This,
/* [in] */ IDebugAddress *pAddress,
/* [out] */ IDebugContainerField **ppContainerField);
HRESULT ( STDMETHODCALLTYPE *GetField )(
IDebugNativeSymbolProvider * This,
/* [in] */ IDebugAddress *pAddress,
/* [in] */ IDebugAddress *pAddressCur,
/* [out] */ IDebugField **ppField);
HRESULT ( STDMETHODCALLTYPE *GetAddressesFromPosition )(
IDebugNativeSymbolProvider * This,
/* [in] */ IDebugDocumentPosition2 *pDocPos,
/* [in] */ BOOL fStatmentOnly,
/* [out] */ IEnumDebugAddresses **ppEnumBegAddresses,
/* [out] */ IEnumDebugAddresses **ppEnumEndAddresses);
HRESULT ( STDMETHODCALLTYPE *GetAddressesFromContext )(
IDebugNativeSymbolProvider * This,
/* [in] */ IDebugDocumentContext2 *pDocContext,
/* [in] */ BOOL fStatmentOnly,
/* [out] */ IEnumDebugAddresses **ppEnumBegAddresses,
/* [out] */ IEnumDebugAddresses **ppEnumEndAddresses);
HRESULT ( STDMETHODCALLTYPE *GetContextFromAddress )(
IDebugNativeSymbolProvider * This,
/* [in] */ IDebugAddress *pAddress,
/* [out] */ IDebugDocumentContext2 **ppDocContext);
HRESULT ( STDMETHODCALLTYPE *GetLanguage )(
IDebugNativeSymbolProvider * This,
/* [in] */ IDebugAddress *pAddress,
/* [out] */ GUID *pguidLanguage,
/* [out] */ GUID *pguidLanguageVendor);
HRESULT ( STDMETHODCALLTYPE *GetGlobalContainer )(
IDebugNativeSymbolProvider * This,
/* [out] */ IDebugContainerField **pField);
HRESULT ( STDMETHODCALLTYPE *GetMethodFieldsByName )(
IDebugNativeSymbolProvider * This,
/* [full][in] */ LPCOLESTR pszFullName,
/* [in] */ NAME_MATCH nameMatch,
/* [out] */ IEnumDebugFields **ppEnum);
HRESULT ( STDMETHODCALLTYPE *GetClassTypeByName )(
IDebugNativeSymbolProvider * This,
/* [full][in] */ LPCOLESTR pszClassName,
/* [in] */ NAME_MATCH nameMatch,
/* [out] */ IDebugClassField **ppField);
HRESULT ( STDMETHODCALLTYPE *GetNamespacesUsedAtAddress )(
IDebugNativeSymbolProvider * This,
/* [in] */ IDebugAddress *pAddress,
/* [out] */ IEnumDebugFields **ppEnum);
HRESULT ( STDMETHODCALLTYPE *GetTypeByName )(
IDebugNativeSymbolProvider * This,
/* [full][in] */ LPCOLESTR pszClassName,
/* [in] */ NAME_MATCH nameMatch,
/* [out] */ IDebugField **ppField);
HRESULT ( STDMETHODCALLTYPE *GetNextAddress )(
IDebugNativeSymbolProvider * This,
/* [in] */ IDebugAddress *pAddress,
/* [in] */ BOOL fStatmentOnly,
/* [out] */ IDebugAddress **ppAddress);
HRESULT ( STDMETHODCALLTYPE *LoadSymbols )(
IDebugNativeSymbolProvider * This,
/* [in] */ LPCOLESTR pszFileName);
END_INTERFACE
} IDebugNativeSymbolProviderVtbl;
interface IDebugNativeSymbolProvider
{
CONST_VTBL struct IDebugNativeSymbolProviderVtbl *lpVtbl;
};
#ifdef COBJMACROS
#define IDebugNativeSymbolProvider_QueryInterface(This,riid,ppvObject) \
(This)->lpVtbl -> QueryInterface(This,riid,ppvObject)
#define IDebugNativeSymbolProvider_AddRef(This) \
(This)->lpVtbl -> AddRef(This)
#define IDebugNativeSymbolProvider_Release(This) \
(This)->lpVtbl -> Release(This)
#define IDebugNativeSymbolProvider_Initialize(This,pServices) \
(This)->lpVtbl -> Initialize(This,pServices)
#define IDebugNativeSymbolProvider_Uninitialize(This) \
(This)->lpVtbl -> Uninitialize(This)
#define IDebugNativeSymbolProvider_GetContainerField(This,pAddress,ppContainerField) \
(This)->lpVtbl -> GetContainerField(This,pAddress,ppContainerField)
#define IDebugNativeSymbolProvider_GetField(This,pAddress,pAddressCur,ppField) \
(This)->lpVtbl -> GetField(This,pAddress,pAddressCur,ppField)
#define IDebugNativeSymbolProvider_GetAddressesFromPosition(This,pDocPos,fStatmentOnly,ppEnumBegAddresses,ppEnumEndAddresses) \
(This)->lpVtbl -> GetAddressesFromPosition(This,pDocPos,fStatmentOnly,ppEnumBegAddresses,ppEnumEndAddresses)
#define IDebugNativeSymbolProvider_GetAddressesFromContext(This,pDocContext,fStatmentOnly,ppEnumBegAddresses,ppEnumEndAddresses) \
(This)->lpVtbl -> GetAddressesFromContext(This,pDocContext,fStatmentOnly,ppEnumBegAddresses,ppEnumEndAddresses)
#define IDebugNativeSymbolProvider_GetContextFromAddress(This,pAddress,ppDocContext) \
(This)->lpVtbl -> GetContextFromAddress(This,pAddress,ppDocContext)
#define IDebugNativeSymbolProvider_GetLanguage(This,pAddress,pguidLanguage,pguidLanguageVendor) \
(This)->lpVtbl -> GetLanguage(This,pAddress,pguidLanguage,pguidLanguageVendor)
#define IDebugNativeSymbolProvider_GetGlobalContainer(This,pField) \
(This)->lpVtbl -> GetGlobalContainer(This,pField)
#define IDebugNativeSymbolProvider_GetMethodFieldsByName(This,pszFullName,nameMatch,ppEnum) \
(This)->lpVtbl -> GetMethodFieldsByName(This,pszFullName,nameMatch,ppEnum)
#define IDebugNativeSymbolProvider_GetClassTypeByName(This,pszClassName,nameMatch,ppField) \
(This)->lpVtbl -> GetClassTypeByName(This,pszClassName,nameMatch,ppField)
#define IDebugNativeSymbolProvider_GetNamespacesUsedAtAddress(This,pAddress,ppEnum) \
(This)->lpVtbl -> GetNamespacesUsedAtAddress(This,pAddress,ppEnum)
#define IDebugNativeSymbolProvider_GetTypeByName(This,pszClassName,nameMatch,ppField) \
(This)->lpVtbl -> GetTypeByName(This,pszClassName,nameMatch,ppField)
#define IDebugNativeSymbolProvider_GetNextAddress(This,pAddress,fStatmentOnly,ppAddress) \
(This)->lpVtbl -> GetNextAddress(This,pAddress,fStatmentOnly,ppAddress)
#define IDebugNativeSymbolProvider_LoadSymbols(This,pszFileName) \
(This)->lpVtbl -> LoadSymbols(This,pszFileName)
#endif /* COBJMACROS */
#endif /* C style interface */
HRESULT STDMETHODCALLTYPE IDebugNativeSymbolProvider_LoadSymbols_Proxy(
IDebugNativeSymbolProvider * This,
/* [in] */ LPCOLESTR pszFileName);
void __RPC_STUB IDebugNativeSymbolProvider_LoadSymbols_Stub(
IRpcStubBuffer *This,
IRpcChannelBuffer *_pRpcChannelBuffer,
PRPC_MESSAGE _pRpcMessage,
DWORD *_pdwStubPhase);
#endif /* __IDebugNativeSymbolProvider_INTERFACE_DEFINED__ */
#ifndef __IDebugExtendedField_INTERFACE_DEFINED__
#define __IDebugExtendedField_INTERFACE_DEFINED__
/* interface IDebugExtendedField */
/* [unique][uuid][object] */
enum enum_FIELD_KIND_EX
{ FIELD_KIND_EX_NONE = 0,
FIELD_TYPE_EX_METHODVAR = 0x1,
FIELD_TYPE_EX_CLASSVAR = 0x2
} ;
typedef DWORD FIELD_KIND_EX;
EXTERN_C const IID IID_IDebugExtendedField;
#if defined(__cplusplus) && !defined(CINTERFACE)
MIDL_INTERFACE("20F22571-AA1C-4724-AD0A-BDE2D19D6163")
IDebugExtendedField : public IDebugField
{
public:
virtual HRESULT STDMETHODCALLTYPE GetExtendedKind(
/* [out] */ FIELD_KIND_EX *pdwKind) = 0;
virtual HRESULT STDMETHODCALLTYPE IsClosedType( void) = 0;
};
#else /* C style interface */
typedef struct IDebugExtendedFieldVtbl
{
BEGIN_INTERFACE
HRESULT ( STDMETHODCALLTYPE *QueryInterface )(
IDebugExtendedField * This,
/* [in] */ REFIID riid,
/* [iid_is][out] */ void **ppvObject);
ULONG ( STDMETHODCALLTYPE *AddRef )(
IDebugExtendedField * This);
ULONG ( STDMETHODCALLTYPE *Release )(
IDebugExtendedField * This);
HRESULT ( STDMETHODCALLTYPE *GetInfo )(
IDebugExtendedField * This,
/* [in] */ FIELD_INFO_FIELDS dwFields,
/* [out] */ FIELD_INFO *pFieldInfo);
HRESULT ( STDMETHODCALLTYPE *GetKind )(
IDebugExtendedField * This,
/* [out] */ FIELD_KIND *pdwKind);
HRESULT ( STDMETHODCALLTYPE *GetType )(
IDebugExtendedField * This,
/* [out] */ IDebugField **ppType);
HRESULT ( STDMETHODCALLTYPE *GetContainer )(
IDebugExtendedField * This,
/* [out] */ IDebugContainerField **ppContainerField);
HRESULT ( STDMETHODCALLTYPE *GetAddress )(
IDebugExtendedField * This,
/* [out] */ IDebugAddress **ppAddress);
HRESULT ( STDMETHODCALLTYPE *GetSize )(
IDebugExtendedField * This,
/* [out] */ DWORD *pdwSize);
HRESULT ( STDMETHODCALLTYPE *GetExtendedInfo )(
IDebugExtendedField * This,
/* [in] */ REFGUID guidExtendedInfo,
/* [length_is][size_is][out] */ BYTE **prgBuffer,
/* [out][in] */ DWORD *pdwLen);
HRESULT ( STDMETHODCALLTYPE *Equal )(
IDebugExtendedField * This,
/* [in] */ IDebugField *pField);
HRESULT ( STDMETHODCALLTYPE *GetTypeInfo )(
IDebugExtendedField * This,
/* [out] */ TYPE_INFO *pTypeInfo);
HRESULT ( STDMETHODCALLTYPE *GetExtendedKind )(
IDebugExtendedField * This,
/* [out] */ FIELD_KIND_EX *pdwKind);
HRESULT ( STDMETHODCALLTYPE *IsClosedType )(
IDebugExtendedField * This);
END_INTERFACE
} IDebugExtendedFieldVtbl;
interface IDebugExtendedField
{
CONST_VTBL struct IDebugExtendedFieldVtbl *lpVtbl;
};
#ifdef COBJMACROS
#define IDebugExtendedField_QueryInterface(This,riid,ppvObject) \
(This)->lpVtbl -> QueryInterface(This,riid,ppvObject)
#define IDebugExtendedField_AddRef(This) \
(This)->lpVtbl -> AddRef(This)
#define IDebugExtendedField_Release(This) \
(This)->lpVtbl -> Release(This)
#define IDebugExtendedField_GetInfo(This,dwFields,pFieldInfo) \
(This)->lpVtbl -> GetInfo(This,dwFields,pFieldInfo)
#define IDebugExtendedField_GetKind(This,pdwKind) \
(This)->lpVtbl -> GetKind(This,pdwKind)
#define IDebugExtendedField_GetType(This,ppType) \
(This)->lpVtbl -> GetType(This,ppType)
#define IDebugExtendedField_GetContainer(This,ppContainerField) \
(This)->lpVtbl -> GetContainer(This,ppContainerField)
#define IDebugExtendedField_GetAddress(This,ppAddress) \
(This)->lpVtbl -> GetAddress(This,ppAddress)
#define IDebugExtendedField_GetSize(This,pdwSize) \
(This)->lpVtbl -> GetSize(This,pdwSize)
#define IDebugExtendedField_GetExtendedInfo(This,guidExtendedInfo,prgBuffer,pdwLen) \
(This)->lpVtbl -> GetExtendedInfo(This,guidExtendedInfo,prgBuffer,pdwLen)
#define IDebugExtendedField_Equal(This,pField) \
(This)->lpVtbl -> Equal(This,pField)
#define IDebugExtendedField_GetTypeInfo(This,pTypeInfo) \
(This)->lpVtbl -> GetTypeInfo(This,pTypeInfo)
#define IDebugExtendedField_GetExtendedKind(This,pdwKind) \
(This)->lpVtbl -> GetExtendedKind(This,pdwKind)
#define IDebugExtendedField_IsClosedType(This) \
(This)->lpVtbl -> IsClosedType(This)
#endif /* COBJMACROS */
#endif /* C style interface */
HRESULT STDMETHODCALLTYPE IDebugExtendedField_GetExtendedKind_Proxy(
IDebugExtendedField * This,
/* [out] */ FIELD_KIND_EX *pdwKind);
void __RPC_STUB IDebugExtendedField_GetExtendedKind_Stub(
IRpcStubBuffer *This,
IRpcChannelBuffer *_pRpcChannelBuffer,
PRPC_MESSAGE _pRpcMessage,
DWORD *_pdwStubPhase);
HRESULT STDMETHODCALLTYPE IDebugExtendedField_IsClosedType_Proxy(
IDebugExtendedField * This);
void __RPC_STUB IDebugExtendedField_IsClosedType_Stub(
IRpcStubBuffer *This,
IRpcChannelBuffer *_pRpcChannelBuffer,
PRPC_MESSAGE _pRpcMessage,
DWORD *_pdwStubPhase);
#endif /* __IDebugExtendedField_INTERFACE_DEFINED__ */
#ifndef __IDebugPrimitiveTypeField_INTERFACE_DEFINED__
#define __IDebugPrimitiveTypeField_INTERFACE_DEFINED__
/* interface IDebugPrimitiveTypeField */
/* [unique][uuid][object] */
EXTERN_C const IID IID_IDebugPrimitiveTypeField;
#if defined(__cplusplus) && !defined(CINTERFACE)
MIDL_INTERFACE("7a739554-3fc6-43ee-981d-f49171151393")
IDebugPrimitiveTypeField : public IDebugField
{
public:
virtual HRESULT STDMETHODCALLTYPE GetPrimitiveType(
/* [out] */ DWORD *pdwType) = 0;
};
#else /* C style interface */
typedef struct IDebugPrimitiveTypeFieldVtbl
{
BEGIN_INTERFACE
HRESULT ( STDMETHODCALLTYPE *QueryInterface )(
IDebugPrimitiveTypeField * This,
/* [in] */ REFIID riid,
/* [iid_is][out] */ void **ppvObject);
ULONG ( STDMETHODCALLTYPE *AddRef )(
IDebugPrimitiveTypeField * This);
ULONG ( STDMETHODCALLTYPE *Release )(
IDebugPrimitiveTypeField * This);
HRESULT ( STDMETHODCALLTYPE *GetInfo )(
IDebugPrimitiveTypeField * This,
/* [in] */ FIELD_INFO_FIELDS dwFields,
/* [out] */ FIELD_INFO *pFieldInfo);
HRESULT ( STDMETHODCALLTYPE *GetKind )(
IDebugPrimitiveTypeField * This,
/* [out] */ FIELD_KIND *pdwKind);
HRESULT ( STDMETHODCALLTYPE *GetType )(
IDebugPrimitiveTypeField * This,
/* [out] */ IDebugField **ppType);
HRESULT ( STDMETHODCALLTYPE *GetContainer )(
IDebugPrimitiveTypeField * This,
/* [out] */ IDebugContainerField **ppContainerField);
HRESULT ( STDMETHODCALLTYPE *GetAddress )(
IDebugPrimitiveTypeField * This,
/* [out] */ IDebugAddress **ppAddress);
HRESULT ( STDMETHODCALLTYPE *GetSize )(
IDebugPrimitiveTypeField * This,
/* [out] */ DWORD *pdwSize);
HRESULT ( STDMETHODCALLTYPE *GetExtendedInfo )(
IDebugPrimitiveTypeField * This,
/* [in] */ REFGUID guidExtendedInfo,
/* [length_is][size_is][out] */ BYTE **prgBuffer,
/* [out][in] */ DWORD *pdwLen);
HRESULT ( STDMETHODCALLTYPE *Equal )(
IDebugPrimitiveTypeField * This,
/* [in] */ IDebugField *pField);
HRESULT ( STDMETHODCALLTYPE *GetTypeInfo )(
IDebugPrimitiveTypeField * This,
/* [out] */ TYPE_INFO *pTypeInfo);
HRESULT ( STDMETHODCALLTYPE *GetPrimitiveType )(
IDebugPrimitiveTypeField * This,
/* [out] */ DWORD *pdwType);
END_INTERFACE
} IDebugPrimitiveTypeFieldVtbl;
interface IDebugPrimitiveTypeField
{
CONST_VTBL struct IDebugPrimitiveTypeFieldVtbl *lpVtbl;
};
#ifdef COBJMACROS
#define IDebugPrimitiveTypeField_QueryInterface(This,riid,ppvObject) \
(This)->lpVtbl -> QueryInterface(This,riid,ppvObject)
#define IDebugPrimitiveTypeField_AddRef(This) \
(This)->lpVtbl -> AddRef(This)
#define IDebugPrimitiveTypeField_Release(This) \
(This)->lpVtbl -> Release(This)
#define IDebugPrimitiveTypeField_GetInfo(This,dwFields,pFieldInfo) \
(This)->lpVtbl -> GetInfo(This,dwFields,pFieldInfo)
#define IDebugPrimitiveTypeField_GetKind(This,pdwKind) \
(This)->lpVtbl -> GetKind(This,pdwKind)
#define IDebugPrimitiveTypeField_GetType(This,ppType) \
(This)->lpVtbl -> GetType(This,ppType)
#define IDebugPrimitiveTypeField_GetContainer(This,ppContainerField) \
(This)->lpVtbl -> GetContainer(This,ppContainerField)
#define IDebugPrimitiveTypeField_GetAddress(This,ppAddress) \
(This)->lpVtbl -> GetAddress(This,ppAddress)
#define IDebugPrimitiveTypeField_GetSize(This,pdwSize) \
(This)->lpVtbl -> GetSize(This,pdwSize)
#define IDebugPrimitiveTypeField_GetExtendedInfo(This,guidExtendedInfo,prgBuffer,pdwLen) \
(This)->lpVtbl -> GetExtendedInfo(This,guidExtendedInfo,prgBuffer,pdwLen)
#define IDebugPrimitiveTypeField_Equal(This,pField) \
(This)->lpVtbl -> Equal(This,pField)
#define IDebugPrimitiveTypeField_GetTypeInfo(This,pTypeInfo) \
(This)->lpVtbl -> GetTypeInfo(This,pTypeInfo)
#define IDebugPrimitiveTypeField_GetPrimitiveType(This,pdwType) \
(This)->lpVtbl -> GetPrimitiveType(This,pdwType)
#endif /* COBJMACROS */
#endif /* C style interface */
HRESULT STDMETHODCALLTYPE IDebugPrimitiveTypeField_GetPrimitiveType_Proxy(
IDebugPrimitiveTypeField * This,
/* [out] */ DWORD *pdwType);
void __RPC_STUB IDebugPrimitiveTypeField_GetPrimitiveType_Stub(
IRpcStubBuffer *This,
IRpcChannelBuffer *_pRpcChannelBuffer,
PRPC_MESSAGE _pRpcMessage,
DWORD *_pdwStubPhase);
#endif /* __IDebugPrimitiveTypeField_INTERFACE_DEFINED__ */
#ifndef __IDebugContainerField_INTERFACE_DEFINED__
#define __IDebugContainerField_INTERFACE_DEFINED__
/* interface IDebugContainerField */
/* [unique][uuid][object] */
EXTERN_C const IID IID_IDebugContainerField;
#if defined(__cplusplus) && !defined(CINTERFACE)
MIDL_INTERFACE("c2e34eb2-8b9d-11d2-9014-00c04fa38338")
IDebugContainerField : public IDebugField
{
public:
virtual HRESULT STDMETHODCALLTYPE EnumFields(
/* [in] */ FIELD_KIND dwKindFilter,
/* [in] */ FIELD_MODIFIERS dwModifiersFilter,
/* [full][in] */ LPCOLESTR pszNameFilter,
/* [in] */ NAME_MATCH nameMatch,
/* [out] */ IEnumDebugFields **ppEnum) = 0;
};
#else /* C style interface */
typedef struct IDebugContainerFieldVtbl
{
BEGIN_INTERFACE
HRESULT ( STDMETHODCALLTYPE *QueryInterface )(
IDebugContainerField * This,
/* [in] */ REFIID riid,
/* [iid_is][out] */ void **ppvObject);
ULONG ( STDMETHODCALLTYPE *AddRef )(
IDebugContainerField * This);
ULONG ( STDMETHODCALLTYPE *Release )(
IDebugContainerField * This);
HRESULT ( STDMETHODCALLTYPE *GetInfo )(
IDebugContainerField * This,
/* [in] */ FIELD_INFO_FIELDS dwFields,
/* [out] */ FIELD_INFO *pFieldInfo);
HRESULT ( STDMETHODCALLTYPE *GetKind )(
IDebugContainerField * This,
/* [out] */ FIELD_KIND *pdwKind);
HRESULT ( STDMETHODCALLTYPE *GetType )(
IDebugContainerField * This,
/* [out] */ IDebugField **ppType);
HRESULT ( STDMETHODCALLTYPE *GetContainer )(
IDebugContainerField * This,
/* [out] */ IDebugContainerField **ppContainerField);
HRESULT ( STDMETHODCALLTYPE *GetAddress )(
IDebugContainerField * This,
/* [out] */ IDebugAddress **ppAddress);
HRESULT ( STDMETHODCALLTYPE *GetSize )(
IDebugContainerField * This,
/* [out] */ DWORD *pdwSize);
HRESULT ( STDMETHODCALLTYPE *GetExtendedInfo )(
IDebugContainerField * This,
/* [in] */ REFGUID guidExtendedInfo,
/* [length_is][size_is][out] */ BYTE **prgBuffer,
/* [out][in] */ DWORD *pdwLen);
HRESULT ( STDMETHODCALLTYPE *Equal )(
IDebugContainerField * This,
/* [in] */ IDebugField *pField);
HRESULT ( STDMETHODCALLTYPE *GetTypeInfo )(
IDebugContainerField * This,
/* [out] */ TYPE_INFO *pTypeInfo);
HRESULT ( STDMETHODCALLTYPE *EnumFields )(
IDebugContainerField * This,
/* [in] */ FIELD_KIND dwKindFilter,
/* [in] */ FIELD_MODIFIERS dwModifiersFilter,
/* [full][in] */ LPCOLESTR pszNameFilter,
/* [in] */ NAME_MATCH nameMatch,
/* [out] */ IEnumDebugFields **ppEnum);
END_INTERFACE
} IDebugContainerFieldVtbl;
interface IDebugContainerField
{
CONST_VTBL struct IDebugContainerFieldVtbl *lpVtbl;
};
#ifdef COBJMACROS
#define IDebugContainerField_QueryInterface(This,riid,ppvObject) \
(This)->lpVtbl -> QueryInterface(This,riid,ppvObject)
#define IDebugContainerField_AddRef(This) \
(This)->lpVtbl -> AddRef(This)
#define IDebugContainerField_Release(This) \
(This)->lpVtbl -> Release(This)
#define IDebugContainerField_GetInfo(This,dwFields,pFieldInfo) \
(This)->lpVtbl -> GetInfo(This,dwFields,pFieldInfo)
#define IDebugContainerField_GetKind(This,pdwKind) \
(This)->lpVtbl -> GetKind(This,pdwKind)
#define IDebugContainerField_GetType(This,ppType) \
(This)->lpVtbl -> GetType(This,ppType)
#define IDebugContainerField_GetContainer(This,ppContainerField) \
(This)->lpVtbl -> GetContainer(This,ppContainerField)
#define IDebugContainerField_GetAddress(This,ppAddress) \
(This)->lpVtbl -> GetAddress(This,ppAddress)
#define IDebugContainerField_GetSize(This,pdwSize) \
(This)->lpVtbl -> GetSize(This,pdwSize)
#define IDebugContainerField_GetExtendedInfo(This,guidExtendedInfo,prgBuffer,pdwLen) \
(This)->lpVtbl -> GetExtendedInfo(This,guidExtendedInfo,prgBuffer,pdwLen)
#define IDebugContainerField_Equal(This,pField) \
(This)->lpVtbl -> Equal(This,pField)
#define IDebugContainerField_GetTypeInfo(This,pTypeInfo) \
(This)->lpVtbl -> GetTypeInfo(This,pTypeInfo)
#define IDebugContainerField_EnumFields(This,dwKindFilter,dwModifiersFilter,pszNameFilter,nameMatch,ppEnum) \
(This)->lpVtbl -> EnumFields(This,dwKindFilter,dwModifiersFilter,pszNameFilter,nameMatch,ppEnum)
#endif /* COBJMACROS */
#endif /* C style interface */
HRESULT STDMETHODCALLTYPE IDebugContainerField_EnumFields_Proxy(
IDebugContainerField * This,
/* [in] */ FIELD_KIND dwKindFilter,
/* [in] */ FIELD_MODIFIERS dwModifiersFilter,
/* [full][in] */ LPCOLESTR pszNameFilter,
/* [in] */ NAME_MATCH nameMatch,
/* [out] */ IEnumDebugFields **ppEnum);
void __RPC_STUB IDebugContainerField_EnumFields_Stub(
IRpcStubBuffer *This,
IRpcChannelBuffer *_pRpcChannelBuffer,
PRPC_MESSAGE _pRpcMessage,
DWORD *_pdwStubPhase);
#endif /* __IDebugContainerField_INTERFACE_DEFINED__ */
#ifndef __IDebugMethodField_INTERFACE_DEFINED__
#define __IDebugMethodField_INTERFACE_DEFINED__
/* interface IDebugMethodField */
/* [unique][uuid][object] */
EXTERN_C const IID IID_IDebugMethodField;
#if defined(__cplusplus) && !defined(CINTERFACE)
MIDL_INTERFACE("c2e34eb4-8b9d-11d2-9014-00c04fa38338")
IDebugMethodField : public IDebugContainerField
{
public:
virtual HRESULT STDMETHODCALLTYPE EnumParameters(
/* [out] */ IEnumDebugFields **ppParams) = 0;
virtual HRESULT STDMETHODCALLTYPE GetThis(
/* [out] */ IDebugClassField **ppClass) = 0;
virtual HRESULT STDMETHODCALLTYPE EnumAllLocals(
/* [in] */ IDebugAddress *pAddress,
/* [out] */ IEnumDebugFields **ppLocals) = 0;
virtual HRESULT STDMETHODCALLTYPE EnumLocals(
/* [in] */ IDebugAddress *pAddress,
/* [out] */ IEnumDebugFields **ppLocals) = 0;
virtual HRESULT STDMETHODCALLTYPE IsCustomAttributeDefined(
/* [full][in] */ LPCOLESTR pszCustomAttributeName) = 0;
virtual HRESULT STDMETHODCALLTYPE EnumStaticLocals(
/* [out] */ IEnumDebugFields **ppLocals) = 0;
virtual HRESULT STDMETHODCALLTYPE GetGlobalContainer(
/* [out] */ IDebugClassField **ppClass) = 0;
virtual HRESULT STDMETHODCALLTYPE EnumArguments(
/* [out] */ IEnumDebugFields **ppParams) = 0;
};
#else /* C style interface */
typedef struct IDebugMethodFieldVtbl
{
BEGIN_INTERFACE
HRESULT ( STDMETHODCALLTYPE *QueryInterface )(
IDebugMethodField * This,
/* [in] */ REFIID riid,
/* [iid_is][out] */ void **ppvObject);
ULONG ( STDMETHODCALLTYPE *AddRef )(
IDebugMethodField * This);
ULONG ( STDMETHODCALLTYPE *Release )(
IDebugMethodField * This);
HRESULT ( STDMETHODCALLTYPE *GetInfo )(
IDebugMethodField * This,
/* [in] */ FIELD_INFO_FIELDS dwFields,
/* [out] */ FIELD_INFO *pFieldInfo);
HRESULT ( STDMETHODCALLTYPE *GetKind )(
IDebugMethodField * This,
/* [out] */ FIELD_KIND *pdwKind);
HRESULT ( STDMETHODCALLTYPE *GetType )(
IDebugMethodField * This,
/* [out] */ IDebugField **ppType);
HRESULT ( STDMETHODCALLTYPE *GetContainer )(
IDebugMethodField * This,
/* [out] */ IDebugContainerField **ppContainerField);
HRESULT ( STDMETHODCALLTYPE *GetAddress )(
IDebugMethodField * This,
/* [out] */ IDebugAddress **ppAddress);
HRESULT ( STDMETHODCALLTYPE *GetSize )(
IDebugMethodField * This,
/* [out] */ DWORD *pdwSize);
HRESULT ( STDMETHODCALLTYPE *GetExtendedInfo )(
IDebugMethodField * This,
/* [in] */ REFGUID guidExtendedInfo,
/* [length_is][size_is][out] */ BYTE **prgBuffer,
/* [out][in] */ DWORD *pdwLen);
HRESULT ( STDMETHODCALLTYPE *Equal )(
IDebugMethodField * This,
/* [in] */ IDebugField *pField);
HRESULT ( STDMETHODCALLTYPE *GetTypeInfo )(
IDebugMethodField * This,
/* [out] */ TYPE_INFO *pTypeInfo);
HRESULT ( STDMETHODCALLTYPE *EnumFields )(
IDebugMethodField * This,
/* [in] */ FIELD_KIND dwKindFilter,
/* [in] */ FIELD_MODIFIERS dwModifiersFilter,
/* [full][in] */ LPCOLESTR pszNameFilter,
/* [in] */ NAME_MATCH nameMatch,
/* [out] */ IEnumDebugFields **ppEnum);
HRESULT ( STDMETHODCALLTYPE *EnumParameters )(
IDebugMethodField * This,
/* [out] */ IEnumDebugFields **ppParams);
HRESULT ( STDMETHODCALLTYPE *GetThis )(
IDebugMethodField * This,
/* [out] */ IDebugClassField **ppClass);
HRESULT ( STDMETHODCALLTYPE *EnumAllLocals )(
IDebugMethodField * This,
/* [in] */ IDebugAddress *pAddress,
/* [out] */ IEnumDebugFields **ppLocals);
HRESULT ( STDMETHODCALLTYPE *EnumLocals )(
IDebugMethodField * This,
/* [in] */ IDebugAddress *pAddress,
/* [out] */ IEnumDebugFields **ppLocals);
HRESULT ( STDMETHODCALLTYPE *IsCustomAttributeDefined )(
IDebugMethodField * This,
/* [full][in] */ LPCOLESTR pszCustomAttributeName);
HRESULT ( STDMETHODCALLTYPE *EnumStaticLocals )(
IDebugMethodField * This,
/* [out] */ IEnumDebugFields **ppLocals);
HRESULT ( STDMETHODCALLTYPE *GetGlobalContainer )(
IDebugMethodField * This,
/* [out] */ IDebugClassField **ppClass);
HRESULT ( STDMETHODCALLTYPE *EnumArguments )(
IDebugMethodField * This,
/* [out] */ IEnumDebugFields **ppParams);
END_INTERFACE
} IDebugMethodFieldVtbl;
interface IDebugMethodField
{
CONST_VTBL struct IDebugMethodFieldVtbl *lpVtbl;
};
#ifdef COBJMACROS
#define IDebugMethodField_QueryInterface(This,riid,ppvObject) \
(This)->lpVtbl -> QueryInterface(This,riid,ppvObject)
#define IDebugMethodField_AddRef(This) \
(This)->lpVtbl -> AddRef(This)
#define IDebugMethodField_Release(This) \
(This)->lpVtbl -> Release(This)
#define IDebugMethodField_GetInfo(This,dwFields,pFieldInfo) \
(This)->lpVtbl -> GetInfo(This,dwFields,pFieldInfo)
#define IDebugMethodField_GetKind(This,pdwKind) \
(This)->lpVtbl -> GetKind(This,pdwKind)
#define IDebugMethodField_GetType(This,ppType) \
(This)->lpVtbl -> GetType(This,ppType)
#define IDebugMethodField_GetContainer(This,ppContainerField) \
(This)->lpVtbl -> GetContainer(This,ppContainerField)
#define IDebugMethodField_GetAddress(This,ppAddress) \
(This)->lpVtbl -> GetAddress(This,ppAddress)
#define IDebugMethodField_GetSize(This,pdwSize) \
(This)->lpVtbl -> GetSize(This,pdwSize)
#define IDebugMethodField_GetExtendedInfo(This,guidExtendedInfo,prgBuffer,pdwLen) \
(This)->lpVtbl -> GetExtendedInfo(This,guidExtendedInfo,prgBuffer,pdwLen)
#define IDebugMethodField_Equal(This,pField) \
(This)->lpVtbl -> Equal(This,pField)
#define IDebugMethodField_GetTypeInfo(This,pTypeInfo) \
(This)->lpVtbl -> GetTypeInfo(This,pTypeInfo)
#define IDebugMethodField_EnumFields(This,dwKindFilter,dwModifiersFilter,pszNameFilter,nameMatch,ppEnum) \
(This)->lpVtbl -> EnumFields(This,dwKindFilter,dwModifiersFilter,pszNameFilter,nameMatch,ppEnum)
#define IDebugMethodField_EnumParameters(This,ppParams) \
(This)->lpVtbl -> EnumParameters(This,ppParams)
#define IDebugMethodField_GetThis(This,ppClass) \
(This)->lpVtbl -> GetThis(This,ppClass)
#define IDebugMethodField_EnumAllLocals(This,pAddress,ppLocals) \
(This)->lpVtbl -> EnumAllLocals(This,pAddress,ppLocals)
#define IDebugMethodField_EnumLocals(This,pAddress,ppLocals) \
(This)->lpVtbl -> EnumLocals(This,pAddress,ppLocals)
#define IDebugMethodField_IsCustomAttributeDefined(This,pszCustomAttributeName) \
(This)->lpVtbl -> IsCustomAttributeDefined(This,pszCustomAttributeName)
#define IDebugMethodField_EnumStaticLocals(This,ppLocals) \
(This)->lpVtbl -> EnumStaticLocals(This,ppLocals)
#define IDebugMethodField_GetGlobalContainer(This,ppClass) \
(This)->lpVtbl -> GetGlobalContainer(This,ppClass)
#define IDebugMethodField_EnumArguments(This,ppParams) \
(This)->lpVtbl -> EnumArguments(This,ppParams)
#endif /* COBJMACROS */
#endif /* C style interface */
HRESULT STDMETHODCALLTYPE IDebugMethodField_EnumParameters_Proxy(
IDebugMethodField * This,
/* [out] */ IEnumDebugFields **ppParams);
void __RPC_STUB IDebugMethodField_EnumParameters_Stub(
IRpcStubBuffer *This,
IRpcChannelBuffer *_pRpcChannelBuffer,
PRPC_MESSAGE _pRpcMessage,
DWORD *_pdwStubPhase);
HRESULT STDMETHODCALLTYPE IDebugMethodField_GetThis_Proxy(
IDebugMethodField * This,
/* [out] */ IDebugClassField **ppClass);
void __RPC_STUB IDebugMethodField_GetThis_Stub(
IRpcStubBuffer *This,
IRpcChannelBuffer *_pRpcChannelBuffer,
PRPC_MESSAGE _pRpcMessage,
DWORD *_pdwStubPhase);
HRESULT STDMETHODCALLTYPE IDebugMethodField_EnumAllLocals_Proxy(
IDebugMethodField * This,
/* [in] */ IDebugAddress *pAddress,
/* [out] */ IEnumDebugFields **ppLocals);
void __RPC_STUB IDebugMethodField_EnumAllLocals_Stub(
IRpcStubBuffer *This,
IRpcChannelBuffer *_pRpcChannelBuffer,
PRPC_MESSAGE _pRpcMessage,
DWORD *_pdwStubPhase);
HRESULT STDMETHODCALLTYPE IDebugMethodField_EnumLocals_Proxy(
IDebugMethodField * This,
/* [in] */ IDebugAddress *pAddress,
/* [out] */ IEnumDebugFields **ppLocals);
void __RPC_STUB IDebugMethodField_EnumLocals_Stub(
IRpcStubBuffer *This,
IRpcChannelBuffer *_pRpcChannelBuffer,
PRPC_MESSAGE _pRpcMessage,
DWORD *_pdwStubPhase);
HRESULT STDMETHODCALLTYPE IDebugMethodField_IsCustomAttributeDefined_Proxy(
IDebugMethodField * This,
/* [full][in] */ LPCOLESTR pszCustomAttributeName);
void __RPC_STUB IDebugMethodField_IsCustomAttributeDefined_Stub(
IRpcStubBuffer *This,
IRpcChannelBuffer *_pRpcChannelBuffer,
PRPC_MESSAGE _pRpcMessage,
DWORD *_pdwStubPhase);
HRESULT STDMETHODCALLTYPE IDebugMethodField_EnumStaticLocals_Proxy(
IDebugMethodField * This,
/* [out] */ IEnumDebugFields **ppLocals);
void __RPC_STUB IDebugMethodField_EnumStaticLocals_Stub(
IRpcStubBuffer *This,
IRpcChannelBuffer *_pRpcChannelBuffer,
PRPC_MESSAGE _pRpcMessage,
DWORD *_pdwStubPhase);
HRESULT STDMETHODCALLTYPE IDebugMethodField_GetGlobalContainer_Proxy(
IDebugMethodField * This,
/* [out] */ IDebugClassField **ppClass);
void __RPC_STUB IDebugMethodField_GetGlobalContainer_Stub(
IRpcStubBuffer *This,
IRpcChannelBuffer *_pRpcChannelBuffer,
PRPC_MESSAGE _pRpcMessage,
DWORD *_pdwStubPhase);
HRESULT STDMETHODCALLTYPE IDebugMethodField_EnumArguments_Proxy(
IDebugMethodField * This,
/* [out] */ IEnumDebugFields **ppParams);
void __RPC_STUB IDebugMethodField_EnumArguments_Stub(
IRpcStubBuffer *This,
IRpcChannelBuffer *_pRpcChannelBuffer,
PRPC_MESSAGE _pRpcMessage,
DWORD *_pdwStubPhase);
#endif /* __IDebugMethodField_INTERFACE_DEFINED__ */
#ifndef __IDebugThisAdjust_INTERFACE_DEFINED__
#define __IDebugThisAdjust_INTERFACE_DEFINED__
/* interface IDebugThisAdjust */
/* [unique][uuid][object] */
EXTERN_C const IID IID_IDebugThisAdjust;
#if defined(__cplusplus) && !defined(CINTERFACE)
MIDL_INTERFACE("49473E34-D4CC-49c8-BF62-79A08D2134A5")
IDebugThisAdjust : public IUnknown
{
public:
virtual HRESULT STDMETHODCALLTYPE GetThisAdjustor(
/* [out] */ LONG32 *pThisAdjust) = 0;
};
#else /* C style interface */
typedef struct IDebugThisAdjustVtbl
{
BEGIN_INTERFACE
HRESULT ( STDMETHODCALLTYPE *QueryInterface )(
IDebugThisAdjust * This,
/* [in] */ REFIID riid,
/* [iid_is][out] */ void **ppvObject);
ULONG ( STDMETHODCALLTYPE *AddRef )(
IDebugThisAdjust * This);
ULONG ( STDMETHODCALLTYPE *Release )(
IDebugThisAdjust * This);
HRESULT ( STDMETHODCALLTYPE *GetThisAdjustor )(
IDebugThisAdjust * This,
/* [out] */ LONG32 *pThisAdjust);
END_INTERFACE
} IDebugThisAdjustVtbl;
interface IDebugThisAdjust
{
CONST_VTBL struct IDebugThisAdjustVtbl *lpVtbl;
};
#ifdef COBJMACROS
#define IDebugThisAdjust_QueryInterface(This,riid,ppvObject) \
(This)->lpVtbl -> QueryInterface(This,riid,ppvObject)
#define IDebugThisAdjust_AddRef(This) \
(This)->lpVtbl -> AddRef(This)
#define IDebugThisAdjust_Release(This) \
(This)->lpVtbl -> Release(This)
#define IDebugThisAdjust_GetThisAdjustor(This,pThisAdjust) \
(This)->lpVtbl -> GetThisAdjustor(This,pThisAdjust)
#endif /* COBJMACROS */
#endif /* C style interface */
HRESULT STDMETHODCALLTYPE IDebugThisAdjust_GetThisAdjustor_Proxy(
IDebugThisAdjust * This,
/* [out] */ LONG32 *pThisAdjust);
void __RPC_STUB IDebugThisAdjust_GetThisAdjustor_Stub(
IRpcStubBuffer *This,
IRpcChannelBuffer *_pRpcChannelBuffer,
PRPC_MESSAGE _pRpcMessage,
DWORD *_pdwStubPhase);
#endif /* __IDebugThisAdjust_INTERFACE_DEFINED__ */
/* interface __MIDL_itf_sh_0472 */
/* [local] */
typedef
enum ConstructorMatchOptions
{ crAll = 0,
crNonStatic = crAll + 1,
crStatic = crNonStatic + 1
} CONSTRUCTOR_ENUM;
extern RPC_IF_HANDLE __MIDL_itf_sh_0472_v0_0_c_ifspec;
extern RPC_IF_HANDLE __MIDL_itf_sh_0472_v0_0_s_ifspec;
#ifndef __IDebugClassField_INTERFACE_DEFINED__
#define __IDebugClassField_INTERFACE_DEFINED__
/* interface IDebugClassField */
/* [unique][uuid][object] */
EXTERN_C const IID IID_IDebugClassField;
#if defined(__cplusplus) && !defined(CINTERFACE)
MIDL_INTERFACE("c2e34eb5-8b9d-11d2-9014-00c04fa38338")
IDebugClassField : public IDebugContainerField
{
public:
virtual HRESULT STDMETHODCALLTYPE EnumBaseClasses(
/* [out] */ IEnumDebugFields **ppEnum) = 0;
virtual HRESULT STDMETHODCALLTYPE DoesInterfaceExist(
/* [full][in] */ LPCOLESTR pszInterfaceName) = 0;
virtual HRESULT STDMETHODCALLTYPE EnumNestedClasses(
/* [out] */ IEnumDebugFields **ppEnum) = 0;
virtual HRESULT STDMETHODCALLTYPE GetEnclosingClass(
/* [out] */ IDebugClassField **ppClassField) = 0;
virtual HRESULT STDMETHODCALLTYPE EnumInterfacesImplemented(
/* [out] */ IEnumDebugFields **ppEnum) = 0;
virtual HRESULT STDMETHODCALLTYPE EnumConstructors(
/* [in] */ CONSTRUCTOR_ENUM cMatch,
/* [out] */ IEnumDebugFields **ppEnum) = 0;
virtual HRESULT STDMETHODCALLTYPE GetDefaultIndexer(
/* [out] */ BSTR *pbstrIndexer) = 0;
virtual HRESULT STDMETHODCALLTYPE EnumNestedEnums(
/* [out] */ IEnumDebugFields **ppEnum) = 0;
};
#else /* C style interface */
typedef struct IDebugClassFieldVtbl
{
BEGIN_INTERFACE
HRESULT ( STDMETHODCALLTYPE *QueryInterface )(
IDebugClassField * This,
/* [in] */ REFIID riid,
/* [iid_is][out] */ void **ppvObject);
ULONG ( STDMETHODCALLTYPE *AddRef )(
IDebugClassField * This);
ULONG ( STDMETHODCALLTYPE *Release )(
IDebugClassField * This);
HRESULT ( STDMETHODCALLTYPE *GetInfo )(
IDebugClassField * This,
/* [in] */ FIELD_INFO_FIELDS dwFields,
/* [out] */ FIELD_INFO *pFieldInfo);
HRESULT ( STDMETHODCALLTYPE *GetKind )(
IDebugClassField * This,
/* [out] */ FIELD_KIND *pdwKind);
HRESULT ( STDMETHODCALLTYPE *GetType )(
IDebugClassField * This,
/* [out] */ IDebugField **ppType);
HRESULT ( STDMETHODCALLTYPE *GetContainer )(
IDebugClassField * This,
/* [out] */ IDebugContainerField **ppContainerField);
HRESULT ( STDMETHODCALLTYPE *GetAddress )(
IDebugClassField * This,
/* [out] */ IDebugAddress **ppAddress);
HRESULT ( STDMETHODCALLTYPE *GetSize )(
IDebugClassField * This,
/* [out] */ DWORD *pdwSize);
HRESULT ( STDMETHODCALLTYPE *GetExtendedInfo )(
IDebugClassField * This,
/* [in] */ REFGUID guidExtendedInfo,
/* [length_is][size_is][out] */ BYTE **prgBuffer,
/* [out][in] */ DWORD *pdwLen);
HRESULT ( STDMETHODCALLTYPE *Equal )(
IDebugClassField * This,
/* [in] */ IDebugField *pField);
HRESULT ( STDMETHODCALLTYPE *GetTypeInfo )(
IDebugClassField * This,
/* [out] */ TYPE_INFO *pTypeInfo);
HRESULT ( STDMETHODCALLTYPE *EnumFields )(
IDebugClassField * This,
/* [in] */ FIELD_KIND dwKindFilter,
/* [in] */ FIELD_MODIFIERS dwModifiersFilter,
/* [full][in] */ LPCOLESTR pszNameFilter,
/* [in] */ NAME_MATCH nameMatch,
/* [out] */ IEnumDebugFields **ppEnum);
HRESULT ( STDMETHODCALLTYPE *EnumBaseClasses )(
IDebugClassField * This,
/* [out] */ IEnumDebugFields **ppEnum);
HRESULT ( STDMETHODCALLTYPE *DoesInterfaceExist )(
IDebugClassField * This,
/* [full][in] */ LPCOLESTR pszInterfaceName);
HRESULT ( STDMETHODCALLTYPE *EnumNestedClasses )(
IDebugClassField * This,
/* [out] */ IEnumDebugFields **ppEnum);
HRESULT ( STDMETHODCALLTYPE *GetEnclosingClass )(
IDebugClassField * This,
/* [out] */ IDebugClassField **ppClassField);
HRESULT ( STDMETHODCALLTYPE *EnumInterfacesImplemented )(
IDebugClassField * This,
/* [out] */ IEnumDebugFields **ppEnum);
HRESULT ( STDMETHODCALLTYPE *EnumConstructors )(
IDebugClassField * This,
/* [in] */ CONSTRUCTOR_ENUM cMatch,
/* [out] */ IEnumDebugFields **ppEnum);
HRESULT ( STDMETHODCALLTYPE *GetDefaultIndexer )(
IDebugClassField * This,
/* [out] */ BSTR *pbstrIndexer);
HRESULT ( STDMETHODCALLTYPE *EnumNestedEnums )(
IDebugClassField * This,
/* [out] */ IEnumDebugFields **ppEnum);
END_INTERFACE
} IDebugClassFieldVtbl;
interface IDebugClassField
{
CONST_VTBL struct IDebugClassFieldVtbl *lpVtbl;
};
#ifdef COBJMACROS
#define IDebugClassField_QueryInterface(This,riid,ppvObject) \
(This)->lpVtbl -> QueryInterface(This,riid,ppvObject)
#define IDebugClassField_AddRef(This) \
(This)->lpVtbl -> AddRef(This)
#define IDebugClassField_Release(This) \
(This)->lpVtbl -> Release(This)
#define IDebugClassField_GetInfo(This,dwFields,pFieldInfo) \
(This)->lpVtbl -> GetInfo(This,dwFields,pFieldInfo)
#define IDebugClassField_GetKind(This,pdwKind) \
(This)->lpVtbl -> GetKind(This,pdwKind)
#define IDebugClassField_GetType(This,ppType) \
(This)->lpVtbl -> GetType(This,ppType)
#define IDebugClassField_GetContainer(This,ppContainerField) \
(This)->lpVtbl -> GetContainer(This,ppContainerField)
#define IDebugClassField_GetAddress(This,ppAddress) \
(This)->lpVtbl -> GetAddress(This,ppAddress)
#define IDebugClassField_GetSize(This,pdwSize) \
(This)->lpVtbl -> GetSize(This,pdwSize)
#define IDebugClassField_GetExtendedInfo(This,guidExtendedInfo,prgBuffer,pdwLen) \
(This)->lpVtbl -> GetExtendedInfo(This,guidExtendedInfo,prgBuffer,pdwLen)
#define IDebugClassField_Equal(This,pField) \
(This)->lpVtbl -> Equal(This,pField)
#define IDebugClassField_GetTypeInfo(This,pTypeInfo) \
(This)->lpVtbl -> GetTypeInfo(This,pTypeInfo)
#define IDebugClassField_EnumFields(This,dwKindFilter,dwModifiersFilter,pszNameFilter,nameMatch,ppEnum) \
(This)->lpVtbl -> EnumFields(This,dwKindFilter,dwModifiersFilter,pszNameFilter,nameMatch,ppEnum)
#define IDebugClassField_EnumBaseClasses(This,ppEnum) \
(This)->lpVtbl -> EnumBaseClasses(This,ppEnum)
#define IDebugClassField_DoesInterfaceExist(This,pszInterfaceName) \
(This)->lpVtbl -> DoesInterfaceExist(This,pszInterfaceName)
#define IDebugClassField_EnumNestedClasses(This,ppEnum) \
(This)->lpVtbl -> EnumNestedClasses(This,ppEnum)
#define IDebugClassField_GetEnclosingClass(This,ppClassField) \
(This)->lpVtbl -> GetEnclosingClass(This,ppClassField)
#define IDebugClassField_EnumInterfacesImplemented(This,ppEnum) \
(This)->lpVtbl -> EnumInterfacesImplemented(This,ppEnum)
#define IDebugClassField_EnumConstructors(This,cMatch,ppEnum) \
(This)->lpVtbl -> EnumConstructors(This,cMatch,ppEnum)
#define IDebugClassField_GetDefaultIndexer(This,pbstrIndexer) \
(This)->lpVtbl -> GetDefaultIndexer(This,pbstrIndexer)
#define IDebugClassField_EnumNestedEnums(This,ppEnum) \
(This)->lpVtbl -> EnumNestedEnums(This,ppEnum)
#endif /* COBJMACROS */
#endif /* C style interface */
HRESULT STDMETHODCALLTYPE IDebugClassField_EnumBaseClasses_Proxy(
IDebugClassField * This,
/* [out] */ IEnumDebugFields **ppEnum);
void __RPC_STUB IDebugClassField_EnumBaseClasses_Stub(
IRpcStubBuffer *This,
IRpcChannelBuffer *_pRpcChannelBuffer,
PRPC_MESSAGE _pRpcMessage,
DWORD *_pdwStubPhase);
HRESULT STDMETHODCALLTYPE IDebugClassField_DoesInterfaceExist_Proxy(
IDebugClassField * This,
/* [full][in] */ LPCOLESTR pszInterfaceName);
void __RPC_STUB IDebugClassField_DoesInterfaceExist_Stub(
IRpcStubBuffer *This,
IRpcChannelBuffer *_pRpcChannelBuffer,
PRPC_MESSAGE _pRpcMessage,
DWORD *_pdwStubPhase);
HRESULT STDMETHODCALLTYPE IDebugClassField_EnumNestedClasses_Proxy(
IDebugClassField * This,
/* [out] */ IEnumDebugFields **ppEnum);
void __RPC_STUB IDebugClassField_EnumNestedClasses_Stub(
IRpcStubBuffer *This,
IRpcChannelBuffer *_pRpcChannelBuffer,
PRPC_MESSAGE _pRpcMessage,
DWORD *_pdwStubPhase);
HRESULT STDMETHODCALLTYPE IDebugClassField_GetEnclosingClass_Proxy(
IDebugClassField * This,
/* [out] */ IDebugClassField **ppClassField);
void __RPC_STUB IDebugClassField_GetEnclosingClass_Stub(
IRpcStubBuffer *This,
IRpcChannelBuffer *_pRpcChannelBuffer,
PRPC_MESSAGE _pRpcMessage,
DWORD *_pdwStubPhase);
HRESULT STDMETHODCALLTYPE IDebugClassField_EnumInterfacesImplemented_Proxy(
IDebugClassField * This,
/* [out] */ IEnumDebugFields **ppEnum);
void __RPC_STUB IDebugClassField_EnumInterfacesImplemented_Stub(
IRpcStubBuffer *This,
IRpcChannelBuffer *_pRpcChannelBuffer,
PRPC_MESSAGE _pRpcMessage,
DWORD *_pdwStubPhase);
HRESULT STDMETHODCALLTYPE IDebugClassField_EnumConstructors_Proxy(
IDebugClassField * This,
/* [in] */ CONSTRUCTOR_ENUM cMatch,
/* [out] */ IEnumDebugFields **ppEnum);
void __RPC_STUB IDebugClassField_EnumConstructors_Stub(
IRpcStubBuffer *This,
IRpcChannelBuffer *_pRpcChannelBuffer,
PRPC_MESSAGE _pRpcMessage,
DWORD *_pdwStubPhase);
HRESULT STDMETHODCALLTYPE IDebugClassField_GetDefaultIndexer_Proxy(
IDebugClassField * This,
/* [out] */ BSTR *pbstrIndexer);
void __RPC_STUB IDebugClassField_GetDefaultIndexer_Stub(
IRpcStubBuffer *This,
IRpcChannelBuffer *_pRpcChannelBuffer,
PRPC_MESSAGE _pRpcMessage,
DWORD *_pdwStubPhase);
HRESULT STDMETHODCALLTYPE IDebugClassField_EnumNestedEnums_Proxy(
IDebugClassField * This,
/* [out] */ IEnumDebugFields **ppEnum);
void __RPC_STUB IDebugClassField_EnumNestedEnums_Stub(
IRpcStubBuffer *This,
IRpcChannelBuffer *_pRpcChannelBuffer,
PRPC_MESSAGE _pRpcMessage,
DWORD *_pdwStubPhase);
#endif /* __IDebugClassField_INTERFACE_DEFINED__ */
#ifndef __IDebugModOpt_INTERFACE_DEFINED__
#define __IDebugModOpt_INTERFACE_DEFINED__
/* interface IDebugModOpt */
/* [unique][uuid][object] */
EXTERN_C const IID IID_IDebugModOpt;
#if defined(__cplusplus) && !defined(CINTERFACE)
MIDL_INTERFACE("B90282FC-2D44-4050-A7B2-BF3BCFF8BAF1")
IDebugModOpt : public IUnknown
{
public:
virtual HRESULT STDMETHODCALLTYPE GetModOpts(
/* [in] */ ULONG celt,
/* [length_is][size_is][out] */ BSTR *rgelt,
/* [out][in] */ ULONG *pceltFetched) = 0;
};
#else /* C style interface */
typedef struct IDebugModOptVtbl
{
BEGIN_INTERFACE
HRESULT ( STDMETHODCALLTYPE *QueryInterface )(
IDebugModOpt * This,
/* [in] */ REFIID riid,
/* [iid_is][out] */ void **ppvObject);
ULONG ( STDMETHODCALLTYPE *AddRef )(
IDebugModOpt * This);
ULONG ( STDMETHODCALLTYPE *Release )(
IDebugModOpt * This);
HRESULT ( STDMETHODCALLTYPE *GetModOpts )(
IDebugModOpt * This,
/* [in] */ ULONG celt,
/* [length_is][size_is][out] */ BSTR *rgelt,
/* [out][in] */ ULONG *pceltFetched);
END_INTERFACE
} IDebugModOptVtbl;
interface IDebugModOpt
{
CONST_VTBL struct IDebugModOptVtbl *lpVtbl;
};
#ifdef COBJMACROS
#define IDebugModOpt_QueryInterface(This,riid,ppvObject) \
(This)->lpVtbl -> QueryInterface(This,riid,ppvObject)
#define IDebugModOpt_AddRef(This) \
(This)->lpVtbl -> AddRef(This)
#define IDebugModOpt_Release(This) \
(This)->lpVtbl -> Release(This)
#define IDebugModOpt_GetModOpts(This,celt,rgelt,pceltFetched) \
(This)->lpVtbl -> GetModOpts(This,celt,rgelt,pceltFetched)
#endif /* COBJMACROS */
#endif /* C style interface */
HRESULT STDMETHODCALLTYPE IDebugModOpt_GetModOpts_Proxy(
IDebugModOpt * This,
/* [in] */ ULONG celt,
/* [length_is][size_is][out] */ BSTR *rgelt,
/* [out][in] */ ULONG *pceltFetched);
void __RPC_STUB IDebugModOpt_GetModOpts_Stub(
IRpcStubBuffer *This,
IRpcChannelBuffer *_pRpcChannelBuffer,
PRPC_MESSAGE _pRpcMessage,
DWORD *_pdwStubPhase);
#endif /* __IDebugModOpt_INTERFACE_DEFINED__ */
#ifndef __IDebugPropertyField_INTERFACE_DEFINED__
#define __IDebugPropertyField_INTERFACE_DEFINED__
/* interface IDebugPropertyField */
/* [unique][uuid][object] */
EXTERN_C const IID IID_IDebugPropertyField;
#if defined(__cplusplus) && !defined(CINTERFACE)
MIDL_INTERFACE("c2e34eb6-8b9d-11d2-9014-00c04fa38338")
IDebugPropertyField : public IDebugContainerField
{
public:
virtual HRESULT STDMETHODCALLTYPE GetPropertyGetter(
/* [out] */ IDebugMethodField **ppField) = 0;
virtual HRESULT STDMETHODCALLTYPE GetPropertySetter(
/* [out] */ IDebugMethodField **ppField) = 0;
};
#else /* C style interface */
typedef struct IDebugPropertyFieldVtbl
{
BEGIN_INTERFACE
HRESULT ( STDMETHODCALLTYPE *QueryInterface )(
IDebugPropertyField * This,
/* [in] */ REFIID riid,
/* [iid_is][out] */ void **ppvObject);
ULONG ( STDMETHODCALLTYPE *AddRef )(
IDebugPropertyField * This);
ULONG ( STDMETHODCALLTYPE *Release )(
IDebugPropertyField * This);
HRESULT ( STDMETHODCALLTYPE *GetInfo )(
IDebugPropertyField * This,
/* [in] */ FIELD_INFO_FIELDS dwFields,
/* [out] */ FIELD_INFO *pFieldInfo);
HRESULT ( STDMETHODCALLTYPE *GetKind )(
IDebugPropertyField * This,
/* [out] */ FIELD_KIND *pdwKind);
HRESULT ( STDMETHODCALLTYPE *GetType )(
IDebugPropertyField * This,
/* [out] */ IDebugField **ppType);
HRESULT ( STDMETHODCALLTYPE *GetContainer )(
IDebugPropertyField * This,
/* [out] */ IDebugContainerField **ppContainerField);
HRESULT ( STDMETHODCALLTYPE *GetAddress )(
IDebugPropertyField * This,
/* [out] */ IDebugAddress **ppAddress);
HRESULT ( STDMETHODCALLTYPE *GetSize )(
IDebugPropertyField * This,
/* [out] */ DWORD *pdwSize);
HRESULT ( STDMETHODCALLTYPE *GetExtendedInfo )(
IDebugPropertyField * This,
/* [in] */ REFGUID guidExtendedInfo,
/* [length_is][size_is][out] */ BYTE **prgBuffer,
/* [out][in] */ DWORD *pdwLen);
HRESULT ( STDMETHODCALLTYPE *Equal )(
IDebugPropertyField * This,
/* [in] */ IDebugField *pField);
HRESULT ( STDMETHODCALLTYPE *GetTypeInfo )(
IDebugPropertyField * This,
/* [out] */ TYPE_INFO *pTypeInfo);
HRESULT ( STDMETHODCALLTYPE *EnumFields )(
IDebugPropertyField * This,
/* [in] */ FIELD_KIND dwKindFilter,
/* [in] */ FIELD_MODIFIERS dwModifiersFilter,
/* [full][in] */ LPCOLESTR pszNameFilter,
/* [in] */ NAME_MATCH nameMatch,
/* [out] */ IEnumDebugFields **ppEnum);
HRESULT ( STDMETHODCALLTYPE *GetPropertyGetter )(
IDebugPropertyField * This,
/* [out] */ IDebugMethodField **ppField);
HRESULT ( STDMETHODCALLTYPE *GetPropertySetter )(
IDebugPropertyField * This,
/* [out] */ IDebugMethodField **ppField);
END_INTERFACE
} IDebugPropertyFieldVtbl;
interface IDebugPropertyField
{
CONST_VTBL struct IDebugPropertyFieldVtbl *lpVtbl;
};
#ifdef COBJMACROS
#define IDebugPropertyField_QueryInterface(This,riid,ppvObject) \
(This)->lpVtbl -> QueryInterface(This,riid,ppvObject)
#define IDebugPropertyField_AddRef(This) \
(This)->lpVtbl -> AddRef(This)
#define IDebugPropertyField_Release(This) \
(This)->lpVtbl -> Release(This)
#define IDebugPropertyField_GetInfo(This,dwFields,pFieldInfo) \
(This)->lpVtbl -> GetInfo(This,dwFields,pFieldInfo)
#define IDebugPropertyField_GetKind(This,pdwKind) \
(This)->lpVtbl -> GetKind(This,pdwKind)
#define IDebugPropertyField_GetType(This,ppType) \
(This)->lpVtbl -> GetType(This,ppType)
#define IDebugPropertyField_GetContainer(This,ppContainerField) \
(This)->lpVtbl -> GetContainer(This,ppContainerField)
#define IDebugPropertyField_GetAddress(This,ppAddress) \
(This)->lpVtbl -> GetAddress(This,ppAddress)
#define IDebugPropertyField_GetSize(This,pdwSize) \
(This)->lpVtbl -> GetSize(This,pdwSize)
#define IDebugPropertyField_GetExtendedInfo(This,guidExtendedInfo,prgBuffer,pdwLen) \
(This)->lpVtbl -> GetExtendedInfo(This,guidExtendedInfo,prgBuffer,pdwLen)
#define IDebugPropertyField_Equal(This,pField) \
(This)->lpVtbl -> Equal(This,pField)
#define IDebugPropertyField_GetTypeInfo(This,pTypeInfo) \
(This)->lpVtbl -> GetTypeInfo(This,pTypeInfo)
#define IDebugPropertyField_EnumFields(This,dwKindFilter,dwModifiersFilter,pszNameFilter,nameMatch,ppEnum) \
(This)->lpVtbl -> EnumFields(This,dwKindFilter,dwModifiersFilter,pszNameFilter,nameMatch,ppEnum)
#define IDebugPropertyField_GetPropertyGetter(This,ppField) \
(This)->lpVtbl -> GetPropertyGetter(This,ppField)
#define IDebugPropertyField_GetPropertySetter(This,ppField) \
(This)->lpVtbl -> GetPropertySetter(This,ppField)
#endif /* COBJMACROS */
#endif /* C style interface */
HRESULT STDMETHODCALLTYPE IDebugPropertyField_GetPropertyGetter_Proxy(
IDebugPropertyField * This,
/* [out] */ IDebugMethodField **ppField);
void __RPC_STUB IDebugPropertyField_GetPropertyGetter_Stub(
IRpcStubBuffer *This,
IRpcChannelBuffer *_pRpcChannelBuffer,
PRPC_MESSAGE _pRpcMessage,
DWORD *_pdwStubPhase);
HRESULT STDMETHODCALLTYPE IDebugPropertyField_GetPropertySetter_Proxy(
IDebugPropertyField * This,
/* [out] */ IDebugMethodField **ppField);
void __RPC_STUB IDebugPropertyField_GetPropertySetter_Stub(
IRpcStubBuffer *This,
IRpcChannelBuffer *_pRpcChannelBuffer,
PRPC_MESSAGE _pRpcMessage,
DWORD *_pdwStubPhase);
#endif /* __IDebugPropertyField_INTERFACE_DEFINED__ */
#ifndef __IDebugArrayField_INTERFACE_DEFINED__
#define __IDebugArrayField_INTERFACE_DEFINED__
/* interface IDebugArrayField */
/* [unique][uuid][object] */
EXTERN_C const IID IID_IDebugArrayField;
#if defined(__cplusplus) && !defined(CINTERFACE)
MIDL_INTERFACE("c2e34eb7-8b9d-11d2-9014-00c04fa38338")
IDebugArrayField : public IDebugContainerField
{
public:
virtual HRESULT STDMETHODCALLTYPE GetNumberOfElements(
/* [out] */ DWORD *pdwNumElements) = 0;
virtual HRESULT STDMETHODCALLTYPE GetElementType(
/* [out] */ IDebugField **ppType) = 0;
virtual HRESULT STDMETHODCALLTYPE GetRank(
/* [out] */ DWORD *pdwRank) = 0;
};
#else /* C style interface */
typedef struct IDebugArrayFieldVtbl
{
BEGIN_INTERFACE
HRESULT ( STDMETHODCALLTYPE *QueryInterface )(
IDebugArrayField * This,
/* [in] */ REFIID riid,
/* [iid_is][out] */ void **ppvObject);
ULONG ( STDMETHODCALLTYPE *AddRef )(
IDebugArrayField * This);
ULONG ( STDMETHODCALLTYPE *Release )(
IDebugArrayField * This);
HRESULT ( STDMETHODCALLTYPE *GetInfo )(
IDebugArrayField * This,
/* [in] */ FIELD_INFO_FIELDS dwFields,
/* [out] */ FIELD_INFO *pFieldInfo);
HRESULT ( STDMETHODCALLTYPE *GetKind )(
IDebugArrayField * This,
/* [out] */ FIELD_KIND *pdwKind);
HRESULT ( STDMETHODCALLTYPE *GetType )(
IDebugArrayField * This,
/* [out] */ IDebugField **ppType);
HRESULT ( STDMETHODCALLTYPE *GetContainer )(
IDebugArrayField * This,
/* [out] */ IDebugContainerField **ppContainerField);
HRESULT ( STDMETHODCALLTYPE *GetAddress )(
IDebugArrayField * This,
/* [out] */ IDebugAddress **ppAddress);
HRESULT ( STDMETHODCALLTYPE *GetSize )(
IDebugArrayField * This,
/* [out] */ DWORD *pdwSize);
HRESULT ( STDMETHODCALLTYPE *GetExtendedInfo )(
IDebugArrayField * This,
/* [in] */ REFGUID guidExtendedInfo,
/* [length_is][size_is][out] */ BYTE **prgBuffer,
/* [out][in] */ DWORD *pdwLen);
HRESULT ( STDMETHODCALLTYPE *Equal )(
IDebugArrayField * This,
/* [in] */ IDebugField *pField);
HRESULT ( STDMETHODCALLTYPE *GetTypeInfo )(
IDebugArrayField * This,
/* [out] */ TYPE_INFO *pTypeInfo);
HRESULT ( STDMETHODCALLTYPE *EnumFields )(
IDebugArrayField * This,
/* [in] */ FIELD_KIND dwKindFilter,
/* [in] */ FIELD_MODIFIERS dwModifiersFilter,
/* [full][in] */ LPCOLESTR pszNameFilter,
/* [in] */ NAME_MATCH nameMatch,
/* [out] */ IEnumDebugFields **ppEnum);
HRESULT ( STDMETHODCALLTYPE *GetNumberOfElements )(
IDebugArrayField * This,
/* [out] */ DWORD *pdwNumElements);
HRESULT ( STDMETHODCALLTYPE *GetElementType )(
IDebugArrayField * This,
/* [out] */ IDebugField **ppType);
HRESULT ( STDMETHODCALLTYPE *GetRank )(
IDebugArrayField * This,
/* [out] */ DWORD *pdwRank);
END_INTERFACE
} IDebugArrayFieldVtbl;
interface IDebugArrayField
{
CONST_VTBL struct IDebugArrayFieldVtbl *lpVtbl;
};
#ifdef COBJMACROS
#define IDebugArrayField_QueryInterface(This,riid,ppvObject) \
(This)->lpVtbl -> QueryInterface(This,riid,ppvObject)
#define IDebugArrayField_AddRef(This) \
(This)->lpVtbl -> AddRef(This)
#define IDebugArrayField_Release(This) \
(This)->lpVtbl -> Release(This)
#define IDebugArrayField_GetInfo(This,dwFields,pFieldInfo) \
(This)->lpVtbl -> GetInfo(This,dwFields,pFieldInfo)
#define IDebugArrayField_GetKind(This,pdwKind) \
(This)->lpVtbl -> GetKind(This,pdwKind)
#define IDebugArrayField_GetType(This,ppType) \
(This)->lpVtbl -> GetType(This,ppType)
#define IDebugArrayField_GetContainer(This,ppContainerField) \
(This)->lpVtbl -> GetContainer(This,ppContainerField)
#define IDebugArrayField_GetAddress(This,ppAddress) \
(This)->lpVtbl -> GetAddress(This,ppAddress)
#define IDebugArrayField_GetSize(This,pdwSize) \
(This)->lpVtbl -> GetSize(This,pdwSize)
#define IDebugArrayField_GetExtendedInfo(This,guidExtendedInfo,prgBuffer,pdwLen) \
(This)->lpVtbl -> GetExtendedInfo(This,guidExtendedInfo,prgBuffer,pdwLen)
#define IDebugArrayField_Equal(This,pField) \
(This)->lpVtbl -> Equal(This,pField)
#define IDebugArrayField_GetTypeInfo(This,pTypeInfo) \
(This)->lpVtbl -> GetTypeInfo(This,pTypeInfo)
#define IDebugArrayField_EnumFields(This,dwKindFilter,dwModifiersFilter,pszNameFilter,nameMatch,ppEnum) \
(This)->lpVtbl -> EnumFields(This,dwKindFilter,dwModifiersFilter,pszNameFilter,nameMatch,ppEnum)
#define IDebugArrayField_GetNumberOfElements(This,pdwNumElements) \
(This)->lpVtbl -> GetNumberOfElements(This,pdwNumElements)
#define IDebugArrayField_GetElementType(This,ppType) \
(This)->lpVtbl -> GetElementType(This,ppType)
#define IDebugArrayField_GetRank(This,pdwRank) \
(This)->lpVtbl -> GetRank(This,pdwRank)
#endif /* COBJMACROS */
#endif /* C style interface */
HRESULT STDMETHODCALLTYPE IDebugArrayField_GetNumberOfElements_Proxy(
IDebugArrayField * This,
/* [out] */ DWORD *pdwNumElements);
void __RPC_STUB IDebugArrayField_GetNumberOfElements_Stub(
IRpcStubBuffer *This,
IRpcChannelBuffer *_pRpcChannelBuffer,
PRPC_MESSAGE _pRpcMessage,
DWORD *_pdwStubPhase);
HRESULT STDMETHODCALLTYPE IDebugArrayField_GetElementType_Proxy(
IDebugArrayField * This,
/* [out] */ IDebugField **ppType);
void __RPC_STUB IDebugArrayField_GetElementType_Stub(
IRpcStubBuffer *This,
IRpcChannelBuffer *_pRpcChannelBuffer,
PRPC_MESSAGE _pRpcMessage,
DWORD *_pdwStubPhase);
HRESULT STDMETHODCALLTYPE IDebugArrayField_GetRank_Proxy(
IDebugArrayField * This,
/* [out] */ DWORD *pdwRank);
void __RPC_STUB IDebugArrayField_GetRank_Stub(
IRpcStubBuffer *This,
IRpcChannelBuffer *_pRpcChannelBuffer,
PRPC_MESSAGE _pRpcMessage,
DWORD *_pdwStubPhase);
#endif /* __IDebugArrayField_INTERFACE_DEFINED__ */
#ifndef __IDebugPointerField_INTERFACE_DEFINED__
#define __IDebugPointerField_INTERFACE_DEFINED__
/* interface IDebugPointerField */
/* [unique][uuid][object] */
EXTERN_C const IID IID_IDebugPointerField;
#if defined(__cplusplus) && !defined(CINTERFACE)
MIDL_INTERFACE("c2e34eb8-8b9d-11d2-9014-00c04fa38338")
IDebugPointerField : public IDebugContainerField
{
public:
virtual HRESULT STDMETHODCALLTYPE GetDereferencedField(
/* [out] */ IDebugField **ppField) = 0;
};
#else /* C style interface */
typedef struct IDebugPointerFieldVtbl
{
BEGIN_INTERFACE
HRESULT ( STDMETHODCALLTYPE *QueryInterface )(
IDebugPointerField * This,
/* [in] */ REFIID riid,
/* [iid_is][out] */ void **ppvObject);
ULONG ( STDMETHODCALLTYPE *AddRef )(
IDebugPointerField * This);
ULONG ( STDMETHODCALLTYPE *Release )(
IDebugPointerField * This);
HRESULT ( STDMETHODCALLTYPE *GetInfo )(
IDebugPointerField * This,
/* [in] */ FIELD_INFO_FIELDS dwFields,
/* [out] */ FIELD_INFO *pFieldInfo);
HRESULT ( STDMETHODCALLTYPE *GetKind )(
IDebugPointerField * This,
/* [out] */ FIELD_KIND *pdwKind);
HRESULT ( STDMETHODCALLTYPE *GetType )(
IDebugPointerField * This,
/* [out] */ IDebugField **ppType);
HRESULT ( STDMETHODCALLTYPE *GetContainer )(
IDebugPointerField * This,
/* [out] */ IDebugContainerField **ppContainerField);
HRESULT ( STDMETHODCALLTYPE *GetAddress )(
IDebugPointerField * This,
/* [out] */ IDebugAddress **ppAddress);
HRESULT ( STDMETHODCALLTYPE *GetSize )(
IDebugPointerField * This,
/* [out] */ DWORD *pdwSize);
HRESULT ( STDMETHODCALLTYPE *GetExtendedInfo )(
IDebugPointerField * This,
/* [in] */ REFGUID guidExtendedInfo,
/* [length_is][size_is][out] */ BYTE **prgBuffer,
/* [out][in] */ DWORD *pdwLen);
HRESULT ( STDMETHODCALLTYPE *Equal )(
IDebugPointerField * This,
/* [in] */ IDebugField *pField);
HRESULT ( STDMETHODCALLTYPE *GetTypeInfo )(
IDebugPointerField * This,
/* [out] */ TYPE_INFO *pTypeInfo);
HRESULT ( STDMETHODCALLTYPE *EnumFields )(
IDebugPointerField * This,
/* [in] */ FIELD_KIND dwKindFilter,
/* [in] */ FIELD_MODIFIERS dwModifiersFilter,
/* [full][in] */ LPCOLESTR pszNameFilter,
/* [in] */ NAME_MATCH nameMatch,
/* [out] */ IEnumDebugFields **ppEnum);
HRESULT ( STDMETHODCALLTYPE *GetDereferencedField )(
IDebugPointerField * This,
/* [out] */ IDebugField **ppField);
END_INTERFACE
} IDebugPointerFieldVtbl;
interface IDebugPointerField
{
CONST_VTBL struct IDebugPointerFieldVtbl *lpVtbl;
};
#ifdef COBJMACROS
#define IDebugPointerField_QueryInterface(This,riid,ppvObject) \
(This)->lpVtbl -> QueryInterface(This,riid,ppvObject)
#define IDebugPointerField_AddRef(This) \
(This)->lpVtbl -> AddRef(This)
#define IDebugPointerField_Release(This) \
(This)->lpVtbl -> Release(This)
#define IDebugPointerField_GetInfo(This,dwFields,pFieldInfo) \
(This)->lpVtbl -> GetInfo(This,dwFields,pFieldInfo)
#define IDebugPointerField_GetKind(This,pdwKind) \
(This)->lpVtbl -> GetKind(This,pdwKind)
#define IDebugPointerField_GetType(This,ppType) \
(This)->lpVtbl -> GetType(This,ppType)
#define IDebugPointerField_GetContainer(This,ppContainerField) \
(This)->lpVtbl -> GetContainer(This,ppContainerField)
#define IDebugPointerField_GetAddress(This,ppAddress) \
(This)->lpVtbl -> GetAddress(This,ppAddress)
#define IDebugPointerField_GetSize(This,pdwSize) \
(This)->lpVtbl -> GetSize(This,pdwSize)
#define IDebugPointerField_GetExtendedInfo(This,guidExtendedInfo,prgBuffer,pdwLen) \
(This)->lpVtbl -> GetExtendedInfo(This,guidExtendedInfo,prgBuffer,pdwLen)
#define IDebugPointerField_Equal(This,pField) \
(This)->lpVtbl -> Equal(This,pField)
#define IDebugPointerField_GetTypeInfo(This,pTypeInfo) \
(This)->lpVtbl -> GetTypeInfo(This,pTypeInfo)
#define IDebugPointerField_EnumFields(This,dwKindFilter,dwModifiersFilter,pszNameFilter,nameMatch,ppEnum) \
(This)->lpVtbl -> EnumFields(This,dwKindFilter,dwModifiersFilter,pszNameFilter,nameMatch,ppEnum)
#define IDebugPointerField_GetDereferencedField(This,ppField) \
(This)->lpVtbl -> GetDereferencedField(This,ppField)
#endif /* COBJMACROS */
#endif /* C style interface */
HRESULT STDMETHODCALLTYPE IDebugPointerField_GetDereferencedField_Proxy(
IDebugPointerField * This,
/* [out] */ IDebugField **ppField);
void __RPC_STUB IDebugPointerField_GetDereferencedField_Stub(
IRpcStubBuffer *This,
IRpcChannelBuffer *_pRpcChannelBuffer,
PRPC_MESSAGE _pRpcMessage,
DWORD *_pdwStubPhase);
#endif /* __IDebugPointerField_INTERFACE_DEFINED__ */
#ifndef __IDebugEnumField_INTERFACE_DEFINED__
#define __IDebugEnumField_INTERFACE_DEFINED__
/* interface IDebugEnumField */
/* [unique][uuid][object] */
EXTERN_C const IID IID_IDebugEnumField;
#if defined(__cplusplus) && !defined(CINTERFACE)
MIDL_INTERFACE("c2e34eb9-8b9d-11d2-9014-00c04fa38338")
IDebugEnumField : public IDebugContainerField
{
public:
virtual HRESULT STDMETHODCALLTYPE GetUnderlyingSymbol(
/* [out] */ IDebugField **ppField) = 0;
virtual HRESULT STDMETHODCALLTYPE GetStringFromValue(
/* [in] */ ULONGLONG value,
/* [out] */ BSTR *pbstrValue) = 0;
virtual HRESULT STDMETHODCALLTYPE GetValueFromString(
/* [full][in] */ LPCOLESTR pszValue,
/* [out] */ ULONGLONG *pvalue) = 0;
virtual HRESULT STDMETHODCALLTYPE GetValueFromStringCaseInsensitive(
/* [full][in] */ LPCOLESTR pszValue,
/* [out] */ ULONGLONG *pvalue) = 0;
};
#else /* C style interface */
typedef struct IDebugEnumFieldVtbl
{
BEGIN_INTERFACE
HRESULT ( STDMETHODCALLTYPE *QueryInterface )(
IDebugEnumField * This,
/* [in] */ REFIID riid,
/* [iid_is][out] */ void **ppvObject);
ULONG ( STDMETHODCALLTYPE *AddRef )(
IDebugEnumField * This);
ULONG ( STDMETHODCALLTYPE *Release )(
IDebugEnumField * This);
HRESULT ( STDMETHODCALLTYPE *GetInfo )(
IDebugEnumField * This,
/* [in] */ FIELD_INFO_FIELDS dwFields,
/* [out] */ FIELD_INFO *pFieldInfo);
HRESULT ( STDMETHODCALLTYPE *GetKind )(
IDebugEnumField * This,
/* [out] */ FIELD_KIND *pdwKind);
HRESULT ( STDMETHODCALLTYPE *GetType )(
IDebugEnumField * This,
/* [out] */ IDebugField **ppType);
HRESULT ( STDMETHODCALLTYPE *GetContainer )(
IDebugEnumField * This,
/* [out] */ IDebugContainerField **ppContainerField);
HRESULT ( STDMETHODCALLTYPE *GetAddress )(
IDebugEnumField * This,
/* [out] */ IDebugAddress **ppAddress);
HRESULT ( STDMETHODCALLTYPE *GetSize )(
IDebugEnumField * This,
/* [out] */ DWORD *pdwSize);
HRESULT ( STDMETHODCALLTYPE *GetExtendedInfo )(
IDebugEnumField * This,
/* [in] */ REFGUID guidExtendedInfo,
/* [length_is][size_is][out] */ BYTE **prgBuffer,
/* [out][in] */ DWORD *pdwLen);
HRESULT ( STDMETHODCALLTYPE *Equal )(
IDebugEnumField * This,
/* [in] */ IDebugField *pField);
HRESULT ( STDMETHODCALLTYPE *GetTypeInfo )(
IDebugEnumField * This,
/* [out] */ TYPE_INFO *pTypeInfo);
HRESULT ( STDMETHODCALLTYPE *EnumFields )(
IDebugEnumField * This,
/* [in] */ FIELD_KIND dwKindFilter,
/* [in] */ FIELD_MODIFIERS dwModifiersFilter,
/* [full][in] */ LPCOLESTR pszNameFilter,
/* [in] */ NAME_MATCH nameMatch,
/* [out] */ IEnumDebugFields **ppEnum);
HRESULT ( STDMETHODCALLTYPE *GetUnderlyingSymbol )(
IDebugEnumField * This,
/* [out] */ IDebugField **ppField);
HRESULT ( STDMETHODCALLTYPE *GetStringFromValue )(
IDebugEnumField * This,
/* [in] */ ULONGLONG value,
/* [out] */ BSTR *pbstrValue);
HRESULT ( STDMETHODCALLTYPE *GetValueFromString )(
IDebugEnumField * This,
/* [full][in] */ LPCOLESTR pszValue,
/* [out] */ ULONGLONG *pvalue);
HRESULT ( STDMETHODCALLTYPE *GetValueFromStringCaseInsensitive )(
IDebugEnumField * This,
/* [full][in] */ LPCOLESTR pszValue,
/* [out] */ ULONGLONG *pvalue);
END_INTERFACE
} IDebugEnumFieldVtbl;
interface IDebugEnumField
{
CONST_VTBL struct IDebugEnumFieldVtbl *lpVtbl;
};
#ifdef COBJMACROS
#define IDebugEnumField_QueryInterface(This,riid,ppvObject) \
(This)->lpVtbl -> QueryInterface(This,riid,ppvObject)
#define IDebugEnumField_AddRef(This) \
(This)->lpVtbl -> AddRef(This)
#define IDebugEnumField_Release(This) \
(This)->lpVtbl -> Release(This)
#define IDebugEnumField_GetInfo(This,dwFields,pFieldInfo) \
(This)->lpVtbl -> GetInfo(This,dwFields,pFieldInfo)
#define IDebugEnumField_GetKind(This,pdwKind) \
(This)->lpVtbl -> GetKind(This,pdwKind)
#define IDebugEnumField_GetType(This,ppType) \
(This)->lpVtbl -> GetType(This,ppType)
#define IDebugEnumField_GetContainer(This,ppContainerField) \
(This)->lpVtbl -> GetContainer(This,ppContainerField)
#define IDebugEnumField_GetAddress(This,ppAddress) \
(This)->lpVtbl -> GetAddress(This,ppAddress)
#define IDebugEnumField_GetSize(This,pdwSize) \
(This)->lpVtbl -> GetSize(This,pdwSize)
#define IDebugEnumField_GetExtendedInfo(This,guidExtendedInfo,prgBuffer,pdwLen) \
(This)->lpVtbl -> GetExtendedInfo(This,guidExtendedInfo,prgBuffer,pdwLen)
#define IDebugEnumField_Equal(This,pField) \
(This)->lpVtbl -> Equal(This,pField)
#define IDebugEnumField_GetTypeInfo(This,pTypeInfo) \
(This)->lpVtbl -> GetTypeInfo(This,pTypeInfo)
#define IDebugEnumField_EnumFields(This,dwKindFilter,dwModifiersFilter,pszNameFilter,nameMatch,ppEnum) \
(This)->lpVtbl -> EnumFields(This,dwKindFilter,dwModifiersFilter,pszNameFilter,nameMatch,ppEnum)
#define IDebugEnumField_GetUnderlyingSymbol(This,ppField) \
(This)->lpVtbl -> GetUnderlyingSymbol(This,ppField)
#define IDebugEnumField_GetStringFromValue(This,value,pbstrValue) \
(This)->lpVtbl -> GetStringFromValue(This,value,pbstrValue)
#define IDebugEnumField_GetValueFromString(This,pszValue,pvalue) \
(This)->lpVtbl -> GetValueFromString(This,pszValue,pvalue)
#define IDebugEnumField_GetValueFromStringCaseInsensitive(This,pszValue,pvalue) \
(This)->lpVtbl -> GetValueFromStringCaseInsensitive(This,pszValue,pvalue)
#endif /* COBJMACROS */
#endif /* C style interface */
HRESULT STDMETHODCALLTYPE IDebugEnumField_GetUnderlyingSymbol_Proxy(
IDebugEnumField * This,
/* [out] */ IDebugField **ppField);
void __RPC_STUB IDebugEnumField_GetUnderlyingSymbol_Stub(
IRpcStubBuffer *This,
IRpcChannelBuffer *_pRpcChannelBuffer,
PRPC_MESSAGE _pRpcMessage,
DWORD *_pdwStubPhase);
HRESULT STDMETHODCALLTYPE IDebugEnumField_GetStringFromValue_Proxy(
IDebugEnumField * This,
/* [in] */ ULONGLONG value,
/* [out] */ BSTR *pbstrValue);
void __RPC_STUB IDebugEnumField_GetStringFromValue_Stub(
IRpcStubBuffer *This,
IRpcChannelBuffer *_pRpcChannelBuffer,
PRPC_MESSAGE _pRpcMessage,
DWORD *_pdwStubPhase);
HRESULT STDMETHODCALLTYPE IDebugEnumField_GetValueFromString_Proxy(
IDebugEnumField * This,
/* [full][in] */ LPCOLESTR pszValue,
/* [out] */ ULONGLONG *pvalue);
void __RPC_STUB IDebugEnumField_GetValueFromString_Stub(
IRpcStubBuffer *This,
IRpcChannelBuffer *_pRpcChannelBuffer,
PRPC_MESSAGE _pRpcMessage,
DWORD *_pdwStubPhase);
HRESULT STDMETHODCALLTYPE IDebugEnumField_GetValueFromStringCaseInsensitive_Proxy(
IDebugEnumField * This,
/* [full][in] */ LPCOLESTR pszValue,
/* [out] */ ULONGLONG *pvalue);
void __RPC_STUB IDebugEnumField_GetValueFromStringCaseInsensitive_Stub(
IRpcStubBuffer *This,
IRpcChannelBuffer *_pRpcChannelBuffer,
PRPC_MESSAGE _pRpcMessage,
DWORD *_pdwStubPhase);
#endif /* __IDebugEnumField_INTERFACE_DEFINED__ */
#ifndef __IDebugBitField_INTERFACE_DEFINED__
#define __IDebugBitField_INTERFACE_DEFINED__
/* interface IDebugBitField */
/* [unique][uuid][object] */
EXTERN_C const IID IID_IDebugBitField;
#if defined(__cplusplus) && !defined(CINTERFACE)
MIDL_INTERFACE("c2e34eba-8b9d-11d2-9014-00c04fa38338")
IDebugBitField : public IDebugField
{
public:
virtual HRESULT STDMETHODCALLTYPE GetStart(
/* [out] */ DWORD *pdwBitOffset) = 0;
};
#else /* C style interface */
typedef struct IDebugBitFieldVtbl
{
BEGIN_INTERFACE
HRESULT ( STDMETHODCALLTYPE *QueryInterface )(
IDebugBitField * This,
/* [in] */ REFIID riid,
/* [iid_is][out] */ void **ppvObject);
ULONG ( STDMETHODCALLTYPE *AddRef )(
IDebugBitField * This);
ULONG ( STDMETHODCALLTYPE *Release )(
IDebugBitField * This);
HRESULT ( STDMETHODCALLTYPE *GetInfo )(
IDebugBitField * This,
/* [in] */ FIELD_INFO_FIELDS dwFields,
/* [out] */ FIELD_INFO *pFieldInfo);
HRESULT ( STDMETHODCALLTYPE *GetKind )(
IDebugBitField * This,
/* [out] */ FIELD_KIND *pdwKind);
HRESULT ( STDMETHODCALLTYPE *GetType )(
IDebugBitField * This,
/* [out] */ IDebugField **ppType);
HRESULT ( STDMETHODCALLTYPE *GetContainer )(
IDebugBitField * This,
/* [out] */ IDebugContainerField **ppContainerField);
HRESULT ( STDMETHODCALLTYPE *GetAddress )(
IDebugBitField * This,
/* [out] */ IDebugAddress **ppAddress);
HRESULT ( STDMETHODCALLTYPE *GetSize )(
IDebugBitField * This,
/* [out] */ DWORD *pdwSize);
HRESULT ( STDMETHODCALLTYPE *GetExtendedInfo )(
IDebugBitField * This,
/* [in] */ REFGUID guidExtendedInfo,
/* [length_is][size_is][out] */ BYTE **prgBuffer,
/* [out][in] */ DWORD *pdwLen);
HRESULT ( STDMETHODCALLTYPE *Equal )(
IDebugBitField * This,
/* [in] */ IDebugField *pField);
HRESULT ( STDMETHODCALLTYPE *GetTypeInfo )(
IDebugBitField * This,
/* [out] */ TYPE_INFO *pTypeInfo);
HRESULT ( STDMETHODCALLTYPE *GetStart )(
IDebugBitField * This,
/* [out] */ DWORD *pdwBitOffset);
END_INTERFACE
} IDebugBitFieldVtbl;
interface IDebugBitField
{
CONST_VTBL struct IDebugBitFieldVtbl *lpVtbl;
};
#ifdef COBJMACROS
#define IDebugBitField_QueryInterface(This,riid,ppvObject) \
(This)->lpVtbl -> QueryInterface(This,riid,ppvObject)
#define IDebugBitField_AddRef(This) \
(This)->lpVtbl -> AddRef(This)
#define IDebugBitField_Release(This) \
(This)->lpVtbl -> Release(This)
#define IDebugBitField_GetInfo(This,dwFields,pFieldInfo) \
(This)->lpVtbl -> GetInfo(This,dwFields,pFieldInfo)
#define IDebugBitField_GetKind(This,pdwKind) \
(This)->lpVtbl -> GetKind(This,pdwKind)
#define IDebugBitField_GetType(This,ppType) \
(This)->lpVtbl -> GetType(This,ppType)
#define IDebugBitField_GetContainer(This,ppContainerField) \
(This)->lpVtbl -> GetContainer(This,ppContainerField)
#define IDebugBitField_GetAddress(This,ppAddress) \
(This)->lpVtbl -> GetAddress(This,ppAddress)
#define IDebugBitField_GetSize(This,pdwSize) \
(This)->lpVtbl -> GetSize(This,pdwSize)
#define IDebugBitField_GetExtendedInfo(This,guidExtendedInfo,prgBuffer,pdwLen) \
(This)->lpVtbl -> GetExtendedInfo(This,guidExtendedInfo,prgBuffer,pdwLen)
#define IDebugBitField_Equal(This,pField) \
(This)->lpVtbl -> Equal(This,pField)
#define IDebugBitField_GetTypeInfo(This,pTypeInfo) \
(This)->lpVtbl -> GetTypeInfo(This,pTypeInfo)
#define IDebugBitField_GetStart(This,pdwBitOffset) \
(This)->lpVtbl -> GetStart(This,pdwBitOffset)
#endif /* COBJMACROS */
#endif /* C style interface */
HRESULT STDMETHODCALLTYPE IDebugBitField_GetStart_Proxy(
IDebugBitField * This,
/* [out] */ DWORD *pdwBitOffset);
void __RPC_STUB IDebugBitField_GetStart_Stub(
IRpcStubBuffer *This,
IRpcChannelBuffer *_pRpcChannelBuffer,
PRPC_MESSAGE _pRpcMessage,
DWORD *_pdwStubPhase);
#endif /* __IDebugBitField_INTERFACE_DEFINED__ */
#ifndef __IDebugDynamicField_INTERFACE_DEFINED__
#define __IDebugDynamicField_INTERFACE_DEFINED__
/* interface IDebugDynamicField */
/* [unique][uuid][object] */
EXTERN_C const IID IID_IDebugDynamicField;
#if defined(__cplusplus) && !defined(CINTERFACE)
MIDL_INTERFACE("B5A2A5EA-D5AB-11d2-9033-00C04FA302A1")
IDebugDynamicField : public IDebugField
{
public:
};
#else /* C style interface */
typedef struct IDebugDynamicFieldVtbl
{
BEGIN_INTERFACE
HRESULT ( STDMETHODCALLTYPE *QueryInterface )(
IDebugDynamicField * This,
/* [in] */ REFIID riid,
/* [iid_is][out] */ void **ppvObject);
ULONG ( STDMETHODCALLTYPE *AddRef )(
IDebugDynamicField * This);
ULONG ( STDMETHODCALLTYPE *Release )(
IDebugDynamicField * This);
HRESULT ( STDMETHODCALLTYPE *GetInfo )(
IDebugDynamicField * This,
/* [in] */ FIELD_INFO_FIELDS dwFields,
/* [out] */ FIELD_INFO *pFieldInfo);
HRESULT ( STDMETHODCALLTYPE *GetKind )(
IDebugDynamicField * This,
/* [out] */ FIELD_KIND *pdwKind);
HRESULT ( STDMETHODCALLTYPE *GetType )(
IDebugDynamicField * This,
/* [out] */ IDebugField **ppType);
HRESULT ( STDMETHODCALLTYPE *GetContainer )(
IDebugDynamicField * This,
/* [out] */ IDebugContainerField **ppContainerField);
HRESULT ( STDMETHODCALLTYPE *GetAddress )(
IDebugDynamicField * This,
/* [out] */ IDebugAddress **ppAddress);
HRESULT ( STDMETHODCALLTYPE *GetSize )(
IDebugDynamicField * This,
/* [out] */ DWORD *pdwSize);
HRESULT ( STDMETHODCALLTYPE *GetExtendedInfo )(
IDebugDynamicField * This,
/* [in] */ REFGUID guidExtendedInfo,
/* [length_is][size_is][out] */ BYTE **prgBuffer,
/* [out][in] */ DWORD *pdwLen);
HRESULT ( STDMETHODCALLTYPE *Equal )(
IDebugDynamicField * This,
/* [in] */ IDebugField *pField);
HRESULT ( STDMETHODCALLTYPE *GetTypeInfo )(
IDebugDynamicField * This,
/* [out] */ TYPE_INFO *pTypeInfo);
END_INTERFACE
} IDebugDynamicFieldVtbl;
interface IDebugDynamicField
{
CONST_VTBL struct IDebugDynamicFieldVtbl *lpVtbl;
};
#ifdef COBJMACROS
#define IDebugDynamicField_QueryInterface(This,riid,ppvObject) \
(This)->lpVtbl -> QueryInterface(This,riid,ppvObject)
#define IDebugDynamicField_AddRef(This) \
(This)->lpVtbl -> AddRef(This)
#define IDebugDynamicField_Release(This) \
(This)->lpVtbl -> Release(This)
#define IDebugDynamicField_GetInfo(This,dwFields,pFieldInfo) \
(This)->lpVtbl -> GetInfo(This,dwFields,pFieldInfo)
#define IDebugDynamicField_GetKind(This,pdwKind) \
(This)->lpVtbl -> GetKind(This,pdwKind)
#define IDebugDynamicField_GetType(This,ppType) \
(This)->lpVtbl -> GetType(This,ppType)
#define IDebugDynamicField_GetContainer(This,ppContainerField) \
(This)->lpVtbl -> GetContainer(This,ppContainerField)
#define IDebugDynamicField_GetAddress(This,ppAddress) \
(This)->lpVtbl -> GetAddress(This,ppAddress)
#define IDebugDynamicField_GetSize(This,pdwSize) \
(This)->lpVtbl -> GetSize(This,pdwSize)
#define IDebugDynamicField_GetExtendedInfo(This,guidExtendedInfo,prgBuffer,pdwLen) \
(This)->lpVtbl -> GetExtendedInfo(This,guidExtendedInfo,prgBuffer,pdwLen)
#define IDebugDynamicField_Equal(This,pField) \
(This)->lpVtbl -> Equal(This,pField)
#define IDebugDynamicField_GetTypeInfo(This,pTypeInfo) \
(This)->lpVtbl -> GetTypeInfo(This,pTypeInfo)
#endif /* COBJMACROS */
#endif /* C style interface */
#endif /* __IDebugDynamicField_INTERFACE_DEFINED__ */
#ifndef __IDebugDynamicFieldCOMPlus_INTERFACE_DEFINED__
#define __IDebugDynamicFieldCOMPlus_INTERFACE_DEFINED__
/* interface IDebugDynamicFieldCOMPlus */
/* [unique][uuid][object] */
EXTERN_C const IID IID_IDebugDynamicFieldCOMPlus;
#if defined(__cplusplus) && !defined(CINTERFACE)
MIDL_INTERFACE("B5B20820-E233-11d2-9037-00C04FA302A1")
IDebugDynamicFieldCOMPlus : public IDebugDynamicField
{
public:
virtual HRESULT STDMETHODCALLTYPE GetTypeFromPrimitive(
/* [in] */ DWORD dwCorElementType,
/* [out] */ IDebugField **ppType) = 0;
virtual HRESULT STDMETHODCALLTYPE GetTypeFromTypeDef(
/* [in] */ ULONG32 ulAppDomainID,
/* [in] */ GUID guidModule,
/* [in] */ _mdToken tokClass,
/* [out] */ IDebugField **ppType) = 0;
};
#else /* C style interface */
typedef struct IDebugDynamicFieldCOMPlusVtbl
{
BEGIN_INTERFACE
HRESULT ( STDMETHODCALLTYPE *QueryInterface )(
IDebugDynamicFieldCOMPlus * This,
/* [in] */ REFIID riid,
/* [iid_is][out] */ void **ppvObject);
ULONG ( STDMETHODCALLTYPE *AddRef )(
IDebugDynamicFieldCOMPlus * This);
ULONG ( STDMETHODCALLTYPE *Release )(
IDebugDynamicFieldCOMPlus * This);
HRESULT ( STDMETHODCALLTYPE *GetInfo )(
IDebugDynamicFieldCOMPlus * This,
/* [in] */ FIELD_INFO_FIELDS dwFields,
/* [out] */ FIELD_INFO *pFieldInfo);
HRESULT ( STDMETHODCALLTYPE *GetKind )(
IDebugDynamicFieldCOMPlus * This,
/* [out] */ FIELD_KIND *pdwKind);
HRESULT ( STDMETHODCALLTYPE *GetType )(
IDebugDynamicFieldCOMPlus * This,
/* [out] */ IDebugField **ppType);
HRESULT ( STDMETHODCALLTYPE *GetContainer )(
IDebugDynamicFieldCOMPlus * This,
/* [out] */ IDebugContainerField **ppContainerField);
HRESULT ( STDMETHODCALLTYPE *GetAddress )(
IDebugDynamicFieldCOMPlus * This,
/* [out] */ IDebugAddress **ppAddress);
HRESULT ( STDMETHODCALLTYPE *GetSize )(
IDebugDynamicFieldCOMPlus * This,
/* [out] */ DWORD *pdwSize);
HRESULT ( STDMETHODCALLTYPE *GetExtendedInfo )(
IDebugDynamicFieldCOMPlus * This,
/* [in] */ REFGUID guidExtendedInfo,
/* [length_is][size_is][out] */ BYTE **prgBuffer,
/* [out][in] */ DWORD *pdwLen);
HRESULT ( STDMETHODCALLTYPE *Equal )(
IDebugDynamicFieldCOMPlus * This,
/* [in] */ IDebugField *pField);
HRESULT ( STDMETHODCALLTYPE *GetTypeInfo )(
IDebugDynamicFieldCOMPlus * This,
/* [out] */ TYPE_INFO *pTypeInfo);
HRESULT ( STDMETHODCALLTYPE *GetTypeFromPrimitive )(
IDebugDynamicFieldCOMPlus * This,
/* [in] */ DWORD dwCorElementType,
/* [out] */ IDebugField **ppType);
HRESULT ( STDMETHODCALLTYPE *GetTypeFromTypeDef )(
IDebugDynamicFieldCOMPlus * This,
/* [in] */ ULONG32 ulAppDomainID,
/* [in] */ GUID guidModule,
/* [in] */ _mdToken tokClass,
/* [out] */ IDebugField **ppType);
END_INTERFACE
} IDebugDynamicFieldCOMPlusVtbl;
interface IDebugDynamicFieldCOMPlus
{
CONST_VTBL struct IDebugDynamicFieldCOMPlusVtbl *lpVtbl;
};
#ifdef COBJMACROS
#define IDebugDynamicFieldCOMPlus_QueryInterface(This,riid,ppvObject) \
(This)->lpVtbl -> QueryInterface(This,riid,ppvObject)
#define IDebugDynamicFieldCOMPlus_AddRef(This) \
(This)->lpVtbl -> AddRef(This)
#define IDebugDynamicFieldCOMPlus_Release(This) \
(This)->lpVtbl -> Release(This)
#define IDebugDynamicFieldCOMPlus_GetInfo(This,dwFields,pFieldInfo) \
(This)->lpVtbl -> GetInfo(This,dwFields,pFieldInfo)
#define IDebugDynamicFieldCOMPlus_GetKind(This,pdwKind) \
(This)->lpVtbl -> GetKind(This,pdwKind)
#define IDebugDynamicFieldCOMPlus_GetType(This,ppType) \
(This)->lpVtbl -> GetType(This,ppType)
#define IDebugDynamicFieldCOMPlus_GetContainer(This,ppContainerField) \
(This)->lpVtbl -> GetContainer(This,ppContainerField)
#define IDebugDynamicFieldCOMPlus_GetAddress(This,ppAddress) \
(This)->lpVtbl -> GetAddress(This,ppAddress)
#define IDebugDynamicFieldCOMPlus_GetSize(This,pdwSize) \
(This)->lpVtbl -> GetSize(This,pdwSize)
#define IDebugDynamicFieldCOMPlus_GetExtendedInfo(This,guidExtendedInfo,prgBuffer,pdwLen) \
(This)->lpVtbl -> GetExtendedInfo(This,guidExtendedInfo,prgBuffer,pdwLen)
#define IDebugDynamicFieldCOMPlus_Equal(This,pField) \
(This)->lpVtbl -> Equal(This,pField)
#define IDebugDynamicFieldCOMPlus_GetTypeInfo(This,pTypeInfo) \
(This)->lpVtbl -> GetTypeInfo(This,pTypeInfo)
#define IDebugDynamicFieldCOMPlus_GetTypeFromPrimitive(This,dwCorElementType,ppType) \
(This)->lpVtbl -> GetTypeFromPrimitive(This,dwCorElementType,ppType)
#define IDebugDynamicFieldCOMPlus_GetTypeFromTypeDef(This,ulAppDomainID,guidModule,tokClass,ppType) \
(This)->lpVtbl -> GetTypeFromTypeDef(This,ulAppDomainID,guidModule,tokClass,ppType)
#endif /* COBJMACROS */
#endif /* C style interface */
HRESULT STDMETHODCALLTYPE IDebugDynamicFieldCOMPlus_GetTypeFromPrimitive_Proxy(
IDebugDynamicFieldCOMPlus * This,
/* [in] */ DWORD dwCorElementType,
/* [out] */ IDebugField **ppType);
void __RPC_STUB IDebugDynamicFieldCOMPlus_GetTypeFromPrimitive_Stub(
IRpcStubBuffer *This,
IRpcChannelBuffer *_pRpcChannelBuffer,
PRPC_MESSAGE _pRpcMessage,
DWORD *_pdwStubPhase);
HRESULT STDMETHODCALLTYPE IDebugDynamicFieldCOMPlus_GetTypeFromTypeDef_Proxy(
IDebugDynamicFieldCOMPlus * This,
/* [in] */ ULONG32 ulAppDomainID,
/* [in] */ GUID guidModule,
/* [in] */ _mdToken tokClass,
/* [out] */ IDebugField **ppType);
void __RPC_STUB IDebugDynamicFieldCOMPlus_GetTypeFromTypeDef_Stub(
IRpcStubBuffer *This,
IRpcChannelBuffer *_pRpcChannelBuffer,
PRPC_MESSAGE _pRpcMessage,
DWORD *_pdwStubPhase);
#endif /* __IDebugDynamicFieldCOMPlus_INTERFACE_DEFINED__ */
#ifndef __IDebugEngineSymbolProviderServices_INTERFACE_DEFINED__
#define __IDebugEngineSymbolProviderServices_INTERFACE_DEFINED__
/* interface IDebugEngineSymbolProviderServices */
/* [unique][uuid][object] */
EXTERN_C const IID IID_IDebugEngineSymbolProviderServices;
#if defined(__cplusplus) && !defined(CINTERFACE)
MIDL_INTERFACE("83919262-ACD6-11d2-9028-00C04FA302A1")
IDebugEngineSymbolProviderServices : public IUnknown
{
public:
virtual HRESULT STDMETHODCALLTYPE EnumCodeContexts(
/* [length_is][size_is][in] */ IDebugAddress **rgpAddresses,
/* [in] */ DWORD celtAddresses,
/* [out] */ IEnumDebugCodeContexts2 **ppEnum) = 0;
};
#else /* C style interface */
typedef struct IDebugEngineSymbolProviderServicesVtbl
{
BEGIN_INTERFACE
HRESULT ( STDMETHODCALLTYPE *QueryInterface )(
IDebugEngineSymbolProviderServices * This,
/* [in] */ REFIID riid,
/* [iid_is][out] */ void **ppvObject);
ULONG ( STDMETHODCALLTYPE *AddRef )(
IDebugEngineSymbolProviderServices * This);
ULONG ( STDMETHODCALLTYPE *Release )(
IDebugEngineSymbolProviderServices * This);
HRESULT ( STDMETHODCALLTYPE *EnumCodeContexts )(
IDebugEngineSymbolProviderServices * This,
/* [length_is][size_is][in] */ IDebugAddress **rgpAddresses,
/* [in] */ DWORD celtAddresses,
/* [out] */ IEnumDebugCodeContexts2 **ppEnum);
END_INTERFACE
} IDebugEngineSymbolProviderServicesVtbl;
interface IDebugEngineSymbolProviderServices
{
CONST_VTBL struct IDebugEngineSymbolProviderServicesVtbl *lpVtbl;
};
#ifdef COBJMACROS
#define IDebugEngineSymbolProviderServices_QueryInterface(This,riid,ppvObject) \
(This)->lpVtbl -> QueryInterface(This,riid,ppvObject)
#define IDebugEngineSymbolProviderServices_AddRef(This) \
(This)->lpVtbl -> AddRef(This)
#define IDebugEngineSymbolProviderServices_Release(This) \
(This)->lpVtbl -> Release(This)
#define IDebugEngineSymbolProviderServices_EnumCodeContexts(This,rgpAddresses,celtAddresses,ppEnum) \
(This)->lpVtbl -> EnumCodeContexts(This,rgpAddresses,celtAddresses,ppEnum)
#endif /* COBJMACROS */
#endif /* C style interface */
HRESULT STDMETHODCALLTYPE IDebugEngineSymbolProviderServices_EnumCodeContexts_Proxy(
IDebugEngineSymbolProviderServices * This,
/* [length_is][size_is][in] */ IDebugAddress **rgpAddresses,
/* [in] */ DWORD celtAddresses,
/* [out] */ IEnumDebugCodeContexts2 **ppEnum);
void __RPC_STUB IDebugEngineSymbolProviderServices_EnumCodeContexts_Stub(
IRpcStubBuffer *This,
IRpcChannelBuffer *_pRpcChannelBuffer,
PRPC_MESSAGE _pRpcMessage,
DWORD *_pdwStubPhase);
#endif /* __IDebugEngineSymbolProviderServices_INTERFACE_DEFINED__ */
/* interface __MIDL_itf_sh_0482 */
/* [local] */
typedef struct tagGUID_MODULES
{
DWORD ctResolvedModules;
/* [size_is] */ GUID *pguidResolvedModules;
} RESOLVED_MODULES;
extern RPC_IF_HANDLE __MIDL_itf_sh_0482_v0_0_c_ifspec;
extern RPC_IF_HANDLE __MIDL_itf_sh_0482_v0_0_s_ifspec;
#ifndef __IDebugEngineSymbolProviderServices2_INTERFACE_DEFINED__
#define __IDebugEngineSymbolProviderServices2_INTERFACE_DEFINED__
/* interface IDebugEngineSymbolProviderServices2 */
/* [unique][uuid][object] */
EXTERN_C const IID IID_IDebugEngineSymbolProviderServices2;
#if defined(__cplusplus) && !defined(CINTERFACE)
MIDL_INTERFACE("D318E959-22AB-4eea-9A06-962B11AFDC29")
IDebugEngineSymbolProviderServices2 : public IDebugEngineSymbolProviderServices
{
public:
virtual HRESULT STDMETHODCALLTYPE ResolveAssembly(
/* [in] */ ULONG32 ulAppDomainID,
/* [in] */ GUID guidModule,
/* [in] */ DWORD tokAssemblyReference,
/* [out] */ RESOLVED_MODULES *pResolvedModules) = 0;
virtual HRESULT STDMETHODCALLTYPE GetEngineProvidedDocumentPrefix(
/* [out] */ BSTR *bstrDocPrefix) = 0;
};
#else /* C style interface */
typedef struct IDebugEngineSymbolProviderServices2Vtbl
{
BEGIN_INTERFACE
HRESULT ( STDMETHODCALLTYPE *QueryInterface )(
IDebugEngineSymbolProviderServices2 * This,
/* [in] */ REFIID riid,
/* [iid_is][out] */ void **ppvObject);
ULONG ( STDMETHODCALLTYPE *AddRef )(
IDebugEngineSymbolProviderServices2 * This);
ULONG ( STDMETHODCALLTYPE *Release )(
IDebugEngineSymbolProviderServices2 * This);
HRESULT ( STDMETHODCALLTYPE *EnumCodeContexts )(
IDebugEngineSymbolProviderServices2 * This,
/* [length_is][size_is][in] */ IDebugAddress **rgpAddresses,
/* [in] */ DWORD celtAddresses,
/* [out] */ IEnumDebugCodeContexts2 **ppEnum);
HRESULT ( STDMETHODCALLTYPE *ResolveAssembly )(
IDebugEngineSymbolProviderServices2 * This,
/* [in] */ ULONG32 ulAppDomainID,
/* [in] */ GUID guidModule,
/* [in] */ DWORD tokAssemblyReference,
/* [out] */ RESOLVED_MODULES *pResolvedModules);
HRESULT ( STDMETHODCALLTYPE *GetEngineProvidedDocumentPrefix )(
IDebugEngineSymbolProviderServices2 * This,
/* [out] */ BSTR *bstrDocPrefix);
END_INTERFACE
} IDebugEngineSymbolProviderServices2Vtbl;
interface IDebugEngineSymbolProviderServices2
{
CONST_VTBL struct IDebugEngineSymbolProviderServices2Vtbl *lpVtbl;
};
#ifdef COBJMACROS
#define IDebugEngineSymbolProviderServices2_QueryInterface(This,riid,ppvObject) \
(This)->lpVtbl -> QueryInterface(This,riid,ppvObject)
#define IDebugEngineSymbolProviderServices2_AddRef(This) \
(This)->lpVtbl -> AddRef(This)
#define IDebugEngineSymbolProviderServices2_Release(This) \
(This)->lpVtbl -> Release(This)
#define IDebugEngineSymbolProviderServices2_EnumCodeContexts(This,rgpAddresses,celtAddresses,ppEnum) \
(This)->lpVtbl -> EnumCodeContexts(This,rgpAddresses,celtAddresses,ppEnum)
#define IDebugEngineSymbolProviderServices2_ResolveAssembly(This,ulAppDomainID,guidModule,tokAssemblyReference,pResolvedModules) \
(This)->lpVtbl -> ResolveAssembly(This,ulAppDomainID,guidModule,tokAssemblyReference,pResolvedModules)
#define IDebugEngineSymbolProviderServices2_GetEngineProvidedDocumentPrefix(This,bstrDocPrefix) \
(This)->lpVtbl -> GetEngineProvidedDocumentPrefix(This,bstrDocPrefix)
#endif /* COBJMACROS */
#endif /* C style interface */
HRESULT STDMETHODCALLTYPE IDebugEngineSymbolProviderServices2_ResolveAssembly_Proxy(
IDebugEngineSymbolProviderServices2 * This,
/* [in] */ ULONG32 ulAppDomainID,
/* [in] */ GUID guidModule,
/* [in] */ DWORD tokAssemblyReference,
/* [out] */ RESOLVED_MODULES *pResolvedModules);
void __RPC_STUB IDebugEngineSymbolProviderServices2_ResolveAssembly_Stub(
IRpcStubBuffer *This,
IRpcChannelBuffer *_pRpcChannelBuffer,
PRPC_MESSAGE _pRpcMessage,
DWORD *_pdwStubPhase);
HRESULT STDMETHODCALLTYPE IDebugEngineSymbolProviderServices2_GetEngineProvidedDocumentPrefix_Proxy(
IDebugEngineSymbolProviderServices2 * This,
/* [out] */ BSTR *bstrDocPrefix);
void __RPC_STUB IDebugEngineSymbolProviderServices2_GetEngineProvidedDocumentPrefix_Stub(
IRpcStubBuffer *This,
IRpcChannelBuffer *_pRpcChannelBuffer,
PRPC_MESSAGE _pRpcMessage,
DWORD *_pdwStubPhase);
#endif /* __IDebugEngineSymbolProviderServices2_INTERFACE_DEFINED__ */
#ifndef __IDebugAddress_INTERFACE_DEFINED__
#define __IDebugAddress_INTERFACE_DEFINED__
/* interface IDebugAddress */
/* [unique][uuid][object] */
enum enum_ADDRESS_KIND
{ ADDRESS_KIND_NATIVE = 0x1,
ADDRESS_KIND_UNMANAGED_THIS_RELATIVE = 0x2,
ADDRESS_KIND_UNMANAGED_PHYSICAL = 0x5,
ADDRESS_KIND_METADATA_METHOD = 0x10,
ADDRESS_KIND_METADATA_FIELD = 0x11,
ADDRESS_KIND_METADATA_LOCAL = 0x12,
ADDRESS_KIND_METADATA_PARAM = 0x13,
ADDRESS_KIND_METADATA_ARRAYELEM = 0x14,
ADDRESS_KIND_METADATA_RETVAL = 0x15
} ;
typedef DWORD ADDRESS_KIND;
typedef struct _tagNATIVE_ADDRESS
{
DWORD unknown;
} NATIVE_ADDRESS;
typedef struct _tagUNMANAGED_THIS_RELATIVE
{
DWORD dwOffset;
DWORD dwBitOffset;
DWORD dwBitLength;
} UNMANAGED_ADDRESS_THIS_RELATIVE;
typedef struct _tagUNMANAGED_ADDRESS_PHYSICAL
{
ULONGLONG offset;
} UNMANAGED_ADDRESS_PHYSICAL;
typedef struct _tagMETADATA_ADDRESS_METHOD
{
_mdToken tokMethod;
DWORD dwOffset;
DWORD dwVersion;
} METADATA_ADDRESS_METHOD;
typedef struct _tagMETADATA_ADDRESS_FIELD
{
_mdToken tokField;
} METADATA_ADDRESS_FIELD;
typedef struct _tagMETADATA_ADDRESS_LOCAL
{
_mdToken tokMethod;
IUnknown *pLocal;
DWORD dwIndex;
} METADATA_ADDRESS_LOCAL;
typedef struct _tagMETADATA_ADDRESS_PARAM
{
_mdToken tokMethod;
_mdToken tokParam;
DWORD dwIndex;
} METADATA_ADDRESS_PARAM;
typedef struct _tagMETADATA_ADDRESS_ARRAYELEM
{
_mdToken tokMethod;
DWORD dwIndex;
} METADATA_ADDRESS_ARRAYELEM;
typedef struct _tagMETADATA_ADDRESS_RETVAL
{
_mdToken tokMethod;
DWORD dwCorType;
DWORD dwSigSize;
BYTE rgSig[ 10 ];
} METADATA_ADDRESS_RETVAL;
typedef struct _tagDEBUG_ADDRESS_UNION
{
ADDRESS_KIND dwKind;
/* [switch_is] */ /* [switch_type] */ union __MIDL_IDebugAddress_0001
{
/* [case()] */ NATIVE_ADDRESS addrNative;
/* [case()] */ UNMANAGED_ADDRESS_THIS_RELATIVE addrThisRel;
/* [case()] */ UNMANAGED_ADDRESS_PHYSICAL addrUPhysical;
/* [case()] */ METADATA_ADDRESS_METHOD addrMethod;
/* [case()] */ METADATA_ADDRESS_FIELD addrField;
/* [case()] */ METADATA_ADDRESS_LOCAL addrLocal;
/* [case()] */ METADATA_ADDRESS_PARAM addrParam;
/* [case()] */ METADATA_ADDRESS_ARRAYELEM addrArrayElem;
/* [case()] */ METADATA_ADDRESS_RETVAL addrRetVal;
/* [default] */ DWORD unused;
} addr;
} DEBUG_ADDRESS_UNION;
typedef struct _tagDEBUG_ADDRESS
{
ULONG32 ulAppDomainID;
GUID guidModule;
_mdToken tokClass;
DEBUG_ADDRESS_UNION addr;
} DEBUG_ADDRESS;
EXTERN_C const IID IID_IDebugAddress;
#if defined(__cplusplus) && !defined(CINTERFACE)
MIDL_INTERFACE("c2e34ebb-8b9d-11d2-9014-00c04fa38338")
IDebugAddress : public IUnknown
{
public:
virtual HRESULT STDMETHODCALLTYPE GetAddress(
/* [out] */ DEBUG_ADDRESS *pAddress) = 0;
};
#else /* C style interface */
typedef struct IDebugAddressVtbl
{
BEGIN_INTERFACE
HRESULT ( STDMETHODCALLTYPE *QueryInterface )(
IDebugAddress * This,
/* [in] */ REFIID riid,
/* [iid_is][out] */ void **ppvObject);
ULONG ( STDMETHODCALLTYPE *AddRef )(
IDebugAddress * This);
ULONG ( STDMETHODCALLTYPE *Release )(
IDebugAddress * This);
HRESULT ( STDMETHODCALLTYPE *GetAddress )(
IDebugAddress * This,
/* [out] */ DEBUG_ADDRESS *pAddress);
END_INTERFACE
} IDebugAddressVtbl;
interface IDebugAddress
{
CONST_VTBL struct IDebugAddressVtbl *lpVtbl;
};
#ifdef COBJMACROS
#define IDebugAddress_QueryInterface(This,riid,ppvObject) \
(This)->lpVtbl -> QueryInterface(This,riid,ppvObject)
#define IDebugAddress_AddRef(This) \
(This)->lpVtbl -> AddRef(This)
#define IDebugAddress_Release(This) \
(This)->lpVtbl -> Release(This)
#define IDebugAddress_GetAddress(This,pAddress) \
(This)->lpVtbl -> GetAddress(This,pAddress)
#endif /* COBJMACROS */
#endif /* C style interface */
HRESULT STDMETHODCALLTYPE IDebugAddress_GetAddress_Proxy(
IDebugAddress * This,
/* [out] */ DEBUG_ADDRESS *pAddress);
void __RPC_STUB IDebugAddress_GetAddress_Stub(
IRpcStubBuffer *This,
IRpcChannelBuffer *_pRpcChannelBuffer,
PRPC_MESSAGE _pRpcMessage,
DWORD *_pdwStubPhase);
#endif /* __IDebugAddress_INTERFACE_DEFINED__ */
#ifndef __IDebugAddress2_INTERFACE_DEFINED__
#define __IDebugAddress2_INTERFACE_DEFINED__
/* interface IDebugAddress2 */
/* [unique][uuid][object] */
EXTERN_C const IID IID_IDebugAddress2;
#if defined(__cplusplus) && !defined(CINTERFACE)
MIDL_INTERFACE("877A0DA6-A43E-4046-9BE3-F916AFF4FA7B")
IDebugAddress2 : public IDebugAddress
{
public:
virtual HRESULT STDMETHODCALLTYPE GetProcessID(
/* [out] */ DWORD *pProcID) = 0;
};
#else /* C style interface */
typedef struct IDebugAddress2Vtbl
{
BEGIN_INTERFACE
HRESULT ( STDMETHODCALLTYPE *QueryInterface )(
IDebugAddress2 * This,
/* [in] */ REFIID riid,
/* [iid_is][out] */ void **ppvObject);
ULONG ( STDMETHODCALLTYPE *AddRef )(
IDebugAddress2 * This);
ULONG ( STDMETHODCALLTYPE *Release )(
IDebugAddress2 * This);
HRESULT ( STDMETHODCALLTYPE *GetAddress )(
IDebugAddress2 * This,
/* [out] */ DEBUG_ADDRESS *pAddress);
HRESULT ( STDMETHODCALLTYPE *GetProcessID )(
IDebugAddress2 * This,
/* [out] */ DWORD *pProcID);
END_INTERFACE
} IDebugAddress2Vtbl;
interface IDebugAddress2
{
CONST_VTBL struct IDebugAddress2Vtbl *lpVtbl;
};
#ifdef COBJMACROS
#define IDebugAddress2_QueryInterface(This,riid,ppvObject) \
(This)->lpVtbl -> QueryInterface(This,riid,ppvObject)
#define IDebugAddress2_AddRef(This) \
(This)->lpVtbl -> AddRef(This)
#define IDebugAddress2_Release(This) \
(This)->lpVtbl -> Release(This)
#define IDebugAddress2_GetAddress(This,pAddress) \
(This)->lpVtbl -> GetAddress(This,pAddress)
#define IDebugAddress2_GetProcessID(This,pProcID) \
(This)->lpVtbl -> GetProcessID(This,pProcID)
#endif /* COBJMACROS */
#endif /* C style interface */
HRESULT STDMETHODCALLTYPE IDebugAddress2_GetProcessID_Proxy(
IDebugAddress2 * This,
/* [out] */ DWORD *pProcID);
void __RPC_STUB IDebugAddress2_GetProcessID_Stub(
IRpcStubBuffer *This,
IRpcChannelBuffer *_pRpcChannelBuffer,
PRPC_MESSAGE _pRpcMessage,
DWORD *_pdwStubPhase);
#endif /* __IDebugAddress2_INTERFACE_DEFINED__ */
#ifndef __IEnumDebugFields_INTERFACE_DEFINED__
#define __IEnumDebugFields_INTERFACE_DEFINED__
/* interface IEnumDebugFields */
/* [unique][uuid][object] */
EXTERN_C const IID IID_IEnumDebugFields;
#if defined(__cplusplus) && !defined(CINTERFACE)
MIDL_INTERFACE("c2e34ebc-8b9d-11d2-9014-00c04fa38338")
IEnumDebugFields : public IUnknown
{
public:
virtual HRESULT STDMETHODCALLTYPE Next(
/* [in] */ ULONG celt,
/* [length_is][size_is][out] */ IDebugField **rgelt,
/* [out][in] */ ULONG *pceltFetched) = 0;
virtual HRESULT STDMETHODCALLTYPE Skip(
/* [in] */ ULONG celt) = 0;
virtual HRESULT STDMETHODCALLTYPE Reset( void) = 0;
virtual HRESULT STDMETHODCALLTYPE Clone(
/* [out] */ IEnumDebugFields **ppEnum) = 0;
virtual HRESULT STDMETHODCALLTYPE GetCount(
/* [out] */ ULONG *pcelt) = 0;
};
#else /* C style interface */
typedef struct IEnumDebugFieldsVtbl
{
BEGIN_INTERFACE
HRESULT ( STDMETHODCALLTYPE *QueryInterface )(
IEnumDebugFields * This,
/* [in] */ REFIID riid,
/* [iid_is][out] */ void **ppvObject);
ULONG ( STDMETHODCALLTYPE *AddRef )(
IEnumDebugFields * This);
ULONG ( STDMETHODCALLTYPE *Release )(
IEnumDebugFields * This);
HRESULT ( STDMETHODCALLTYPE *Next )(
IEnumDebugFields * This,
/* [in] */ ULONG celt,
/* [length_is][size_is][out] */ IDebugField **rgelt,
/* [out][in] */ ULONG *pceltFetched);
HRESULT ( STDMETHODCALLTYPE *Skip )(
IEnumDebugFields * This,
/* [in] */ ULONG celt);
HRESULT ( STDMETHODCALLTYPE *Reset )(
IEnumDebugFields * This);
HRESULT ( STDMETHODCALLTYPE *Clone )(
IEnumDebugFields * This,
/* [out] */ IEnumDebugFields **ppEnum);
HRESULT ( STDMETHODCALLTYPE *GetCount )(
IEnumDebugFields * This,
/* [out] */ ULONG *pcelt);
END_INTERFACE
} IEnumDebugFieldsVtbl;
interface IEnumDebugFields
{
CONST_VTBL struct IEnumDebugFieldsVtbl *lpVtbl;
};
#ifdef COBJMACROS
#define IEnumDebugFields_QueryInterface(This,riid,ppvObject) \
(This)->lpVtbl -> QueryInterface(This,riid,ppvObject)
#define IEnumDebugFields_AddRef(This) \
(This)->lpVtbl -> AddRef(This)
#define IEnumDebugFields_Release(This) \
(This)->lpVtbl -> Release(This)
#define IEnumDebugFields_Next(This,celt,rgelt,pceltFetched) \
(This)->lpVtbl -> Next(This,celt,rgelt,pceltFetched)
#define IEnumDebugFields_Skip(This,celt) \
(This)->lpVtbl -> Skip(This,celt)
#define IEnumDebugFields_Reset(This) \
(This)->lpVtbl -> Reset(This)
#define IEnumDebugFields_Clone(This,ppEnum) \
(This)->lpVtbl -> Clone(This,ppEnum)
#define IEnumDebugFields_GetCount(This,pcelt) \
(This)->lpVtbl -> GetCount(This,pcelt)
#endif /* COBJMACROS */
#endif /* C style interface */
HRESULT STDMETHODCALLTYPE IEnumDebugFields_Next_Proxy(
IEnumDebugFields * This,
/* [in] */ ULONG celt,
/* [length_is][size_is][out] */ IDebugField **rgelt,
/* [out][in] */ ULONG *pceltFetched);
void __RPC_STUB IEnumDebugFields_Next_Stub(
IRpcStubBuffer *This,
IRpcChannelBuffer *_pRpcChannelBuffer,
PRPC_MESSAGE _pRpcMessage,
DWORD *_pdwStubPhase);
HRESULT STDMETHODCALLTYPE IEnumDebugFields_Skip_Proxy(
IEnumDebugFields * This,
/* [in] */ ULONG celt);
void __RPC_STUB IEnumDebugFields_Skip_Stub(
IRpcStubBuffer *This,
IRpcChannelBuffer *_pRpcChannelBuffer,
PRPC_MESSAGE _pRpcMessage,
DWORD *_pdwStubPhase);
HRESULT STDMETHODCALLTYPE IEnumDebugFields_Reset_Proxy(
IEnumDebugFields * This);
void __RPC_STUB IEnumDebugFields_Reset_Stub(
IRpcStubBuffer *This,
IRpcChannelBuffer *_pRpcChannelBuffer,
PRPC_MESSAGE _pRpcMessage,
DWORD *_pdwStubPhase);
HRESULT STDMETHODCALLTYPE IEnumDebugFields_Clone_Proxy(
IEnumDebugFields * This,
/* [out] */ IEnumDebugFields **ppEnum);
void __RPC_STUB IEnumDebugFields_Clone_Stub(
IRpcStubBuffer *This,
IRpcChannelBuffer *_pRpcChannelBuffer,
PRPC_MESSAGE _pRpcMessage,
DWORD *_pdwStubPhase);
HRESULT STDMETHODCALLTYPE IEnumDebugFields_GetCount_Proxy(
IEnumDebugFields * This,
/* [out] */ ULONG *pcelt);
void __RPC_STUB IEnumDebugFields_GetCount_Stub(
IRpcStubBuffer *This,
IRpcChannelBuffer *_pRpcChannelBuffer,
PRPC_MESSAGE _pRpcMessage,
DWORD *_pdwStubPhase);
#endif /* __IEnumDebugFields_INTERFACE_DEFINED__ */
#ifndef __IEnumDebugAddresses_INTERFACE_DEFINED__
#define __IEnumDebugAddresses_INTERFACE_DEFINED__
/* interface IEnumDebugAddresses */
/* [unique][uuid][object] */
EXTERN_C const IID IID_IEnumDebugAddresses;
#if defined(__cplusplus) && !defined(CINTERFACE)
MIDL_INTERFACE("c2e34ebd-8b9d-11d2-9014-00c04fa38338")
IEnumDebugAddresses : public IUnknown
{
public:
virtual HRESULT STDMETHODCALLTYPE Next(
/* [in] */ ULONG celt,
/* [length_is][size_is][out] */ IDebugAddress **rgelt,
/* [out][in] */ ULONG *pceltFetched) = 0;
virtual HRESULT STDMETHODCALLTYPE Skip(
/* [in] */ ULONG celt) = 0;
virtual HRESULT STDMETHODCALLTYPE Reset( void) = 0;
virtual HRESULT STDMETHODCALLTYPE Clone(
/* [out] */ IEnumDebugAddresses **ppEnum) = 0;
virtual HRESULT STDMETHODCALLTYPE GetCount(
/* [out] */ ULONG *pcelt) = 0;
};
#else /* C style interface */
typedef struct IEnumDebugAddressesVtbl
{
BEGIN_INTERFACE
HRESULT ( STDMETHODCALLTYPE *QueryInterface )(
IEnumDebugAddresses * This,
/* [in] */ REFIID riid,
/* [iid_is][out] */ void **ppvObject);
ULONG ( STDMETHODCALLTYPE *AddRef )(
IEnumDebugAddresses * This);
ULONG ( STDMETHODCALLTYPE *Release )(
IEnumDebugAddresses * This);
HRESULT ( STDMETHODCALLTYPE *Next )(
IEnumDebugAddresses * This,
/* [in] */ ULONG celt,
/* [length_is][size_is][out] */ IDebugAddress **rgelt,
/* [out][in] */ ULONG *pceltFetched);
HRESULT ( STDMETHODCALLTYPE *Skip )(
IEnumDebugAddresses * This,
/* [in] */ ULONG celt);
HRESULT ( STDMETHODCALLTYPE *Reset )(
IEnumDebugAddresses * This);
HRESULT ( STDMETHODCALLTYPE *Clone )(
IEnumDebugAddresses * This,
/* [out] */ IEnumDebugAddresses **ppEnum);
HRESULT ( STDMETHODCALLTYPE *GetCount )(
IEnumDebugAddresses * This,
/* [out] */ ULONG *pcelt);
END_INTERFACE
} IEnumDebugAddressesVtbl;
interface IEnumDebugAddresses
{
CONST_VTBL struct IEnumDebugAddressesVtbl *lpVtbl;
};
#ifdef COBJMACROS
#define IEnumDebugAddresses_QueryInterface(This,riid,ppvObject) \
(This)->lpVtbl -> QueryInterface(This,riid,ppvObject)
#define IEnumDebugAddresses_AddRef(This) \
(This)->lpVtbl -> AddRef(This)
#define IEnumDebugAddresses_Release(This) \
(This)->lpVtbl -> Release(This)
#define IEnumDebugAddresses_Next(This,celt,rgelt,pceltFetched) \
(This)->lpVtbl -> Next(This,celt,rgelt,pceltFetched)
#define IEnumDebugAddresses_Skip(This,celt) \
(This)->lpVtbl -> Skip(This,celt)
#define IEnumDebugAddresses_Reset(This) \
(This)->lpVtbl -> Reset(This)
#define IEnumDebugAddresses_Clone(This,ppEnum) \
(This)->lpVtbl -> Clone(This,ppEnum)
#define IEnumDebugAddresses_GetCount(This,pcelt) \
(This)->lpVtbl -> GetCount(This,pcelt)
#endif /* COBJMACROS */
#endif /* C style interface */
HRESULT STDMETHODCALLTYPE IEnumDebugAddresses_Next_Proxy(
IEnumDebugAddresses * This,
/* [in] */ ULONG celt,
/* [length_is][size_is][out] */ IDebugAddress **rgelt,
/* [out][in] */ ULONG *pceltFetched);
void __RPC_STUB IEnumDebugAddresses_Next_Stub(
IRpcStubBuffer *This,
IRpcChannelBuffer *_pRpcChannelBuffer,
PRPC_MESSAGE _pRpcMessage,
DWORD *_pdwStubPhase);
HRESULT STDMETHODCALLTYPE IEnumDebugAddresses_Skip_Proxy(
IEnumDebugAddresses * This,
/* [in] */ ULONG celt);
void __RPC_STUB IEnumDebugAddresses_Skip_Stub(
IRpcStubBuffer *This,
IRpcChannelBuffer *_pRpcChannelBuffer,
PRPC_MESSAGE _pRpcMessage,
DWORD *_pdwStubPhase);
HRESULT STDMETHODCALLTYPE IEnumDebugAddresses_Reset_Proxy(
IEnumDebugAddresses * This);
void __RPC_STUB IEnumDebugAddresses_Reset_Stub(
IRpcStubBuffer *This,
IRpcChannelBuffer *_pRpcChannelBuffer,
PRPC_MESSAGE _pRpcMessage,
DWORD *_pdwStubPhase);
HRESULT STDMETHODCALLTYPE IEnumDebugAddresses_Clone_Proxy(
IEnumDebugAddresses * This,
/* [out] */ IEnumDebugAddresses **ppEnum);
void __RPC_STUB IEnumDebugAddresses_Clone_Stub(
IRpcStubBuffer *This,
IRpcChannelBuffer *_pRpcChannelBuffer,
PRPC_MESSAGE _pRpcMessage,
DWORD *_pdwStubPhase);
HRESULT STDMETHODCALLTYPE IEnumDebugAddresses_GetCount_Proxy(
IEnumDebugAddresses * This,
/* [out] */ ULONG *pcelt);
void __RPC_STUB IEnumDebugAddresses_GetCount_Stub(
IRpcStubBuffer *This,
IRpcChannelBuffer *_pRpcChannelBuffer,
PRPC_MESSAGE _pRpcMessage,
DWORD *_pdwStubPhase);
#endif /* __IEnumDebugAddresses_INTERFACE_DEFINED__ */
#ifndef __IDebugCustomAttributeQuery_INTERFACE_DEFINED__
#define __IDebugCustomAttributeQuery_INTERFACE_DEFINED__
/* interface IDebugCustomAttributeQuery */
/* [unique][uuid][object] */
EXTERN_C const IID IID_IDebugCustomAttributeQuery;
#if defined(__cplusplus) && !defined(CINTERFACE)
MIDL_INTERFACE("DFD37B5A-1E3A-4f15-8098-220ABADC620B")
IDebugCustomAttributeQuery : public IUnknown
{
public:
virtual HRESULT STDMETHODCALLTYPE IsCustomAttributeDefined(
/* [full][in] */ LPCOLESTR pszCustomAttributeName) = 0;
virtual HRESULT STDMETHODCALLTYPE GetCustomAttributeByName(
/* [full][in] */ LPCOLESTR pszCustomAttributeName,
/* [length_is][size_is][out][in] */ BYTE *ppBlob,
/* [out][in] */ DWORD *pdwLen) = 0;
};
#else /* C style interface */
typedef struct IDebugCustomAttributeQueryVtbl
{
BEGIN_INTERFACE
HRESULT ( STDMETHODCALLTYPE *QueryInterface )(
IDebugCustomAttributeQuery * This,
/* [in] */ REFIID riid,
/* [iid_is][out] */ void **ppvObject);
ULONG ( STDMETHODCALLTYPE *AddRef )(
IDebugCustomAttributeQuery * This);
ULONG ( STDMETHODCALLTYPE *Release )(
IDebugCustomAttributeQuery * This);
HRESULT ( STDMETHODCALLTYPE *IsCustomAttributeDefined )(
IDebugCustomAttributeQuery * This,
/* [full][in] */ LPCOLESTR pszCustomAttributeName);
HRESULT ( STDMETHODCALLTYPE *GetCustomAttributeByName )(
IDebugCustomAttributeQuery * This,
/* [full][in] */ LPCOLESTR pszCustomAttributeName,
/* [length_is][size_is][out][in] */ BYTE *ppBlob,
/* [out][in] */ DWORD *pdwLen);
END_INTERFACE
} IDebugCustomAttributeQueryVtbl;
interface IDebugCustomAttributeQuery
{
CONST_VTBL struct IDebugCustomAttributeQueryVtbl *lpVtbl;
};
#ifdef COBJMACROS
#define IDebugCustomAttributeQuery_QueryInterface(This,riid,ppvObject) \
(This)->lpVtbl -> QueryInterface(This,riid,ppvObject)
#define IDebugCustomAttributeQuery_AddRef(This) \
(This)->lpVtbl -> AddRef(This)
#define IDebugCustomAttributeQuery_Release(This) \
(This)->lpVtbl -> Release(This)
#define IDebugCustomAttributeQuery_IsCustomAttributeDefined(This,pszCustomAttributeName) \
(This)->lpVtbl -> IsCustomAttributeDefined(This,pszCustomAttributeName)
#define IDebugCustomAttributeQuery_GetCustomAttributeByName(This,pszCustomAttributeName,ppBlob,pdwLen) \
(This)->lpVtbl -> GetCustomAttributeByName(This,pszCustomAttributeName,ppBlob,pdwLen)
#endif /* COBJMACROS */
#endif /* C style interface */
HRESULT STDMETHODCALLTYPE IDebugCustomAttributeQuery_IsCustomAttributeDefined_Proxy(
IDebugCustomAttributeQuery * This,
/* [full][in] */ LPCOLESTR pszCustomAttributeName);
void __RPC_STUB IDebugCustomAttributeQuery_IsCustomAttributeDefined_Stub(
IRpcStubBuffer *This,
IRpcChannelBuffer *_pRpcChannelBuffer,
PRPC_MESSAGE _pRpcMessage,
DWORD *_pdwStubPhase);
HRESULT STDMETHODCALLTYPE IDebugCustomAttributeQuery_GetCustomAttributeByName_Proxy(
IDebugCustomAttributeQuery * This,
/* [full][in] */ LPCOLESTR pszCustomAttributeName,
/* [length_is][size_is][out][in] */ BYTE *ppBlob,
/* [out][in] */ DWORD *pdwLen);
void __RPC_STUB IDebugCustomAttributeQuery_GetCustomAttributeByName_Stub(
IRpcStubBuffer *This,
IRpcChannelBuffer *_pRpcChannelBuffer,
PRPC_MESSAGE _pRpcMessage,
DWORD *_pdwStubPhase);
#endif /* __IDebugCustomAttributeQuery_INTERFACE_DEFINED__ */
#ifndef __IDebugCustomAttribute_INTERFACE_DEFINED__
#define __IDebugCustomAttribute_INTERFACE_DEFINED__
/* interface IDebugCustomAttribute */
/* [unique][uuid][object] */
EXTERN_C const IID IID_IDebugCustomAttribute;
#if defined(__cplusplus) && !defined(CINTERFACE)
MIDL_INTERFACE("A3A37C5E-8D71-487d-A9E1-B9A1B3BA9CBB")
IDebugCustomAttribute : public IUnknown
{
public:
virtual HRESULT STDMETHODCALLTYPE GetParentField(
/* [out] */ IDebugField **ppField) = 0;
virtual HRESULT STDMETHODCALLTYPE GetAttributeTypeField(
/* [out] */ IDebugClassField **ppCAType) = 0;
virtual HRESULT STDMETHODCALLTYPE GetName(
/* [out] */ BSTR *bstrName) = 0;
virtual HRESULT STDMETHODCALLTYPE GetAttributeBytes(
/* [length_is][size_is][out][in] */ BYTE *ppBlob,
/* [out][in] */ DWORD *pdwLen) = 0;
};
#else /* C style interface */
typedef struct IDebugCustomAttributeVtbl
{
BEGIN_INTERFACE
HRESULT ( STDMETHODCALLTYPE *QueryInterface )(
IDebugCustomAttribute * This,
/* [in] */ REFIID riid,
/* [iid_is][out] */ void **ppvObject);
ULONG ( STDMETHODCALLTYPE *AddRef )(
IDebugCustomAttribute * This);
ULONG ( STDMETHODCALLTYPE *Release )(
IDebugCustomAttribute * This);
HRESULT ( STDMETHODCALLTYPE *GetParentField )(
IDebugCustomAttribute * This,
/* [out] */ IDebugField **ppField);
HRESULT ( STDMETHODCALLTYPE *GetAttributeTypeField )(
IDebugCustomAttribute * This,
/* [out] */ IDebugClassField **ppCAType);
HRESULT ( STDMETHODCALLTYPE *GetName )(
IDebugCustomAttribute * This,
/* [out] */ BSTR *bstrName);
HRESULT ( STDMETHODCALLTYPE *GetAttributeBytes )(
IDebugCustomAttribute * This,
/* [length_is][size_is][out][in] */ BYTE *ppBlob,
/* [out][in] */ DWORD *pdwLen);
END_INTERFACE
} IDebugCustomAttributeVtbl;
interface IDebugCustomAttribute
{
CONST_VTBL struct IDebugCustomAttributeVtbl *lpVtbl;
};
#ifdef COBJMACROS
#define IDebugCustomAttribute_QueryInterface(This,riid,ppvObject) \
(This)->lpVtbl -> QueryInterface(This,riid,ppvObject)
#define IDebugCustomAttribute_AddRef(This) \
(This)->lpVtbl -> AddRef(This)
#define IDebugCustomAttribute_Release(This) \
(This)->lpVtbl -> Release(This)
#define IDebugCustomAttribute_GetParentField(This,ppField) \
(This)->lpVtbl -> GetParentField(This,ppField)
#define IDebugCustomAttribute_GetAttributeTypeField(This,ppCAType) \
(This)->lpVtbl -> GetAttributeTypeField(This,ppCAType)
#define IDebugCustomAttribute_GetName(This,bstrName) \
(This)->lpVtbl -> GetName(This,bstrName)
#define IDebugCustomAttribute_GetAttributeBytes(This,ppBlob,pdwLen) \
(This)->lpVtbl -> GetAttributeBytes(This,ppBlob,pdwLen)
#endif /* COBJMACROS */
#endif /* C style interface */
HRESULT STDMETHODCALLTYPE IDebugCustomAttribute_GetParentField_Proxy(
IDebugCustomAttribute * This,
/* [out] */ IDebugField **ppField);
void __RPC_STUB IDebugCustomAttribute_GetParentField_Stub(
IRpcStubBuffer *This,
IRpcChannelBuffer *_pRpcChannelBuffer,
PRPC_MESSAGE _pRpcMessage,
DWORD *_pdwStubPhase);
HRESULT STDMETHODCALLTYPE IDebugCustomAttribute_GetAttributeTypeField_Proxy(
IDebugCustomAttribute * This,
/* [out] */ IDebugClassField **ppCAType);
void __RPC_STUB IDebugCustomAttribute_GetAttributeTypeField_Stub(
IRpcStubBuffer *This,
IRpcChannelBuffer *_pRpcChannelBuffer,
PRPC_MESSAGE _pRpcMessage,
DWORD *_pdwStubPhase);
HRESULT STDMETHODCALLTYPE IDebugCustomAttribute_GetName_Proxy(
IDebugCustomAttribute * This,
/* [out] */ BSTR *bstrName);
void __RPC_STUB IDebugCustomAttribute_GetName_Stub(
IRpcStubBuffer *This,
IRpcChannelBuffer *_pRpcChannelBuffer,
PRPC_MESSAGE _pRpcMessage,
DWORD *_pdwStubPhase);
HRESULT STDMETHODCALLTYPE IDebugCustomAttribute_GetAttributeBytes_Proxy(
IDebugCustomAttribute * This,
/* [length_is][size_is][out][in] */ BYTE *ppBlob,
/* [out][in] */ DWORD *pdwLen);
void __RPC_STUB IDebugCustomAttribute_GetAttributeBytes_Stub(
IRpcStubBuffer *This,
IRpcChannelBuffer *_pRpcChannelBuffer,
PRPC_MESSAGE _pRpcMessage,
DWORD *_pdwStubPhase);
#endif /* __IDebugCustomAttribute_INTERFACE_DEFINED__ */
#ifndef __IDebugCustomAttributeQuery2_INTERFACE_DEFINED__
#define __IDebugCustomAttributeQuery2_INTERFACE_DEFINED__
/* interface IDebugCustomAttributeQuery2 */
/* [unique][uuid][object] */
EXTERN_C const IID IID_IDebugCustomAttributeQuery2;
#if defined(__cplusplus) && !defined(CINTERFACE)
MIDL_INTERFACE("7D257F89-EF56-43c4-80FF-C89B064E4680")
IDebugCustomAttributeQuery2 : public IDebugCustomAttributeQuery
{
public:
virtual HRESULT STDMETHODCALLTYPE EnumCustomAttributes(
/* [out] */ IEnumDebugCustomAttributes **ppEnum) = 0;
};
#else /* C style interface */
typedef struct IDebugCustomAttributeQuery2Vtbl
{
BEGIN_INTERFACE
HRESULT ( STDMETHODCALLTYPE *QueryInterface )(
IDebugCustomAttributeQuery2 * This,
/* [in] */ REFIID riid,
/* [iid_is][out] */ void **ppvObject);
ULONG ( STDMETHODCALLTYPE *AddRef )(
IDebugCustomAttributeQuery2 * This);
ULONG ( STDMETHODCALLTYPE *Release )(
IDebugCustomAttributeQuery2 * This);
HRESULT ( STDMETHODCALLTYPE *IsCustomAttributeDefined )(
IDebugCustomAttributeQuery2 * This,
/* [full][in] */ LPCOLESTR pszCustomAttributeName);
HRESULT ( STDMETHODCALLTYPE *GetCustomAttributeByName )(
IDebugCustomAttributeQuery2 * This,
/* [full][in] */ LPCOLESTR pszCustomAttributeName,
/* [length_is][size_is][out][in] */ BYTE *ppBlob,
/* [out][in] */ DWORD *pdwLen);
HRESULT ( STDMETHODCALLTYPE *EnumCustomAttributes )(
IDebugCustomAttributeQuery2 * This,
/* [out] */ IEnumDebugCustomAttributes **ppEnum);
END_INTERFACE
} IDebugCustomAttributeQuery2Vtbl;
interface IDebugCustomAttributeQuery2
{
CONST_VTBL struct IDebugCustomAttributeQuery2Vtbl *lpVtbl;
};
#ifdef COBJMACROS
#define IDebugCustomAttributeQuery2_QueryInterface(This,riid,ppvObject) \
(This)->lpVtbl -> QueryInterface(This,riid,ppvObject)
#define IDebugCustomAttributeQuery2_AddRef(This) \
(This)->lpVtbl -> AddRef(This)
#define IDebugCustomAttributeQuery2_Release(This) \
(This)->lpVtbl -> Release(This)
#define IDebugCustomAttributeQuery2_IsCustomAttributeDefined(This,pszCustomAttributeName) \
(This)->lpVtbl -> IsCustomAttributeDefined(This,pszCustomAttributeName)
#define IDebugCustomAttributeQuery2_GetCustomAttributeByName(This,pszCustomAttributeName,ppBlob,pdwLen) \
(This)->lpVtbl -> GetCustomAttributeByName(This,pszCustomAttributeName,ppBlob,pdwLen)
#define IDebugCustomAttributeQuery2_EnumCustomAttributes(This,ppEnum) \
(This)->lpVtbl -> EnumCustomAttributes(This,ppEnum)
#endif /* COBJMACROS */
#endif /* C style interface */
HRESULT STDMETHODCALLTYPE IDebugCustomAttributeQuery2_EnumCustomAttributes_Proxy(
IDebugCustomAttributeQuery2 * This,
/* [out] */ IEnumDebugCustomAttributes **ppEnum);
void __RPC_STUB IDebugCustomAttributeQuery2_EnumCustomAttributes_Stub(
IRpcStubBuffer *This,
IRpcChannelBuffer *_pRpcChannelBuffer,
PRPC_MESSAGE _pRpcMessage,
DWORD *_pdwStubPhase);
#endif /* __IDebugCustomAttributeQuery2_INTERFACE_DEFINED__ */
#ifndef __IEnumDebugCustomAttributes_INTERFACE_DEFINED__
#define __IEnumDebugCustomAttributes_INTERFACE_DEFINED__
/* interface IEnumDebugCustomAttributes */
/* [unique][uuid][object] */
EXTERN_C const IID IID_IEnumDebugCustomAttributes;
#if defined(__cplusplus) && !defined(CINTERFACE)
MIDL_INTERFACE("D9089EF0-22D1-40b9-81D6-47CBDA9DC32C")
IEnumDebugCustomAttributes : public IUnknown
{
public:
virtual HRESULT STDMETHODCALLTYPE Next(
/* [in] */ ULONG celt,
/* [length_is][size_is][out] */ IDebugCustomAttribute **rgelt,
/* [out][in] */ ULONG *pceltFetched) = 0;
virtual HRESULT STDMETHODCALLTYPE Skip(
/* [in] */ ULONG celt) = 0;
virtual HRESULT STDMETHODCALLTYPE Reset( void) = 0;
virtual HRESULT STDMETHODCALLTYPE Clone(
/* [out] */ IEnumDebugCustomAttributes **ppEnum) = 0;
virtual HRESULT STDMETHODCALLTYPE GetCount(
/* [out] */ ULONG *pcelt) = 0;
};
#else /* C style interface */
typedef struct IEnumDebugCustomAttributesVtbl
{
BEGIN_INTERFACE
HRESULT ( STDMETHODCALLTYPE *QueryInterface )(
IEnumDebugCustomAttributes * This,
/* [in] */ REFIID riid,
/* [iid_is][out] */ void **ppvObject);
ULONG ( STDMETHODCALLTYPE *AddRef )(
IEnumDebugCustomAttributes * This);
ULONG ( STDMETHODCALLTYPE *Release )(
IEnumDebugCustomAttributes * This);
HRESULT ( STDMETHODCALLTYPE *Next )(
IEnumDebugCustomAttributes * This,
/* [in] */ ULONG celt,
/* [length_is][size_is][out] */ IDebugCustomAttribute **rgelt,
/* [out][in] */ ULONG *pceltFetched);
HRESULT ( STDMETHODCALLTYPE *Skip )(
IEnumDebugCustomAttributes * This,
/* [in] */ ULONG celt);
HRESULT ( STDMETHODCALLTYPE *Reset )(
IEnumDebugCustomAttributes * This);
HRESULT ( STDMETHODCALLTYPE *Clone )(
IEnumDebugCustomAttributes * This,
/* [out] */ IEnumDebugCustomAttributes **ppEnum);
HRESULT ( STDMETHODCALLTYPE *GetCount )(
IEnumDebugCustomAttributes * This,
/* [out] */ ULONG *pcelt);
END_INTERFACE
} IEnumDebugCustomAttributesVtbl;
interface IEnumDebugCustomAttributes
{
CONST_VTBL struct IEnumDebugCustomAttributesVtbl *lpVtbl;
};
#ifdef COBJMACROS
#define IEnumDebugCustomAttributes_QueryInterface(This,riid,ppvObject) \
(This)->lpVtbl -> QueryInterface(This,riid,ppvObject)
#define IEnumDebugCustomAttributes_AddRef(This) \
(This)->lpVtbl -> AddRef(This)
#define IEnumDebugCustomAttributes_Release(This) \
(This)->lpVtbl -> Release(This)
#define IEnumDebugCustomAttributes_Next(This,celt,rgelt,pceltFetched) \
(This)->lpVtbl -> Next(This,celt,rgelt,pceltFetched)
#define IEnumDebugCustomAttributes_Skip(This,celt) \
(This)->lpVtbl -> Skip(This,celt)
#define IEnumDebugCustomAttributes_Reset(This) \
(This)->lpVtbl -> Reset(This)
#define IEnumDebugCustomAttributes_Clone(This,ppEnum) \
(This)->lpVtbl -> Clone(This,ppEnum)
#define IEnumDebugCustomAttributes_GetCount(This,pcelt) \
(This)->lpVtbl -> GetCount(This,pcelt)
#endif /* COBJMACROS */
#endif /* C style interface */
HRESULT STDMETHODCALLTYPE IEnumDebugCustomAttributes_Next_Proxy(
IEnumDebugCustomAttributes * This,
/* [in] */ ULONG celt,
/* [length_is][size_is][out] */ IDebugCustomAttribute **rgelt,
/* [out][in] */ ULONG *pceltFetched);
void __RPC_STUB IEnumDebugCustomAttributes_Next_Stub(
IRpcStubBuffer *This,
IRpcChannelBuffer *_pRpcChannelBuffer,
PRPC_MESSAGE _pRpcMessage,
DWORD *_pdwStubPhase);
HRESULT STDMETHODCALLTYPE IEnumDebugCustomAttributes_Skip_Proxy(
IEnumDebugCustomAttributes * This,
/* [in] */ ULONG celt);
void __RPC_STUB IEnumDebugCustomAttributes_Skip_Stub(
IRpcStubBuffer *This,
IRpcChannelBuffer *_pRpcChannelBuffer,
PRPC_MESSAGE _pRpcMessage,
DWORD *_pdwStubPhase);
HRESULT STDMETHODCALLTYPE IEnumDebugCustomAttributes_Reset_Proxy(
IEnumDebugCustomAttributes * This);
void __RPC_STUB IEnumDebugCustomAttributes_Reset_Stub(
IRpcStubBuffer *This,
IRpcChannelBuffer *_pRpcChannelBuffer,
PRPC_MESSAGE _pRpcMessage,
DWORD *_pdwStubPhase);
HRESULT STDMETHODCALLTYPE IEnumDebugCustomAttributes_Clone_Proxy(
IEnumDebugCustomAttributes * This,
/* [out] */ IEnumDebugCustomAttributes **ppEnum);
void __RPC_STUB IEnumDebugCustomAttributes_Clone_Stub(
IRpcStubBuffer *This,
IRpcChannelBuffer *_pRpcChannelBuffer,
PRPC_MESSAGE _pRpcMessage,
DWORD *_pdwStubPhase);
HRESULT STDMETHODCALLTYPE IEnumDebugCustomAttributes_GetCount_Proxy(
IEnumDebugCustomAttributes * This,
/* [out] */ ULONG *pcelt);
void __RPC_STUB IEnumDebugCustomAttributes_GetCount_Stub(
IRpcStubBuffer *This,
IRpcChannelBuffer *_pRpcChannelBuffer,
PRPC_MESSAGE _pRpcMessage,
DWORD *_pdwStubPhase);
#endif /* __IEnumDebugCustomAttributes_INTERFACE_DEFINED__ */
#ifndef __SHLib_LIBRARY_DEFINED__
#define __SHLib_LIBRARY_DEFINED__
/* library SHLib */
/* [uuid] */
EXTERN_C const IID LIBID_SHLib;
EXTERN_C const CLSID CLSID_SHManaged;
#ifdef __cplusplus
class DECLSPEC_UUID("c2e34ebf-8b9d-11d2-9014-00c04fa38338")
SHManaged;
#endif
#endif /* __SHLib_LIBRARY_DEFINED__ */
/* Additional Prototypes for ALL interfaces */
unsigned long __RPC_USER BSTR_UserSize( unsigned long *, unsigned long , BSTR * );
unsigned char * __RPC_USER BSTR_UserMarshal( unsigned long *, unsigned char *, BSTR * );
unsigned char * __RPC_USER BSTR_UserUnmarshal(unsigned long *, unsigned char *, BSTR * );
void __RPC_USER BSTR_UserFree( unsigned long *, BSTR * );
/* end of Additional Prototypes */
#ifdef __cplusplus
}
#endif
#endif
|
[
"esen@other.ch"
] |
esen@other.ch
|
ade357e77e89c26dcd28be4defdc7e0c5428ccc2
|
03deb8becf4a1a71f9611c9bec4073765a2e5a4d
|
/C++/fibonacci_again.cpp
|
e7f5448c3b9693627417cdb97836e9c2832af8dc
|
[] |
no_license
|
SakibDipu/MyProgramming-CPP-
|
12bce4d57517dc091329c89b051ec59820286ddf
|
0d6cd9d9905fd86e7a877b8b21060e31c419a62d
|
refs/heads/master
| 2020-04-08T17:05:35.743421
| 2018-11-28T19:11:05
| 2018-11-28T19:11:05
| 159,550,146
| 1
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 361
|
cpp
|
#include<bits\\stdc++.h>
using namespace std;
long long int fibo(long long int a)
{
if(a==1 || a==2){
return 1;
}else{
return fibo(a-1)+fibo(a-2);
}
}
int main()
{
long long int n,i;
cout<<"HOW MANY NUMBERS YOU WANT TO SHOW IN FIB SERIES:"<<endl;
cin>>n;
for(i=1; i<=n; i++){
cout<<fibo(i)<<" ";
}
cout<<endl;
return 0;
}
|
[
"noreply@github.com"
] |
SakibDipu.noreply@github.com
|
7774ffb555b88d17e3c61f1507a3c6d15a1612e5
|
319a64131b728bd1ce81d70af598523338f9c417
|
/progress.h
|
94e51b6f4da5a8805057c13d719700404479ff35
|
[] |
no_license
|
POOOOOOOON/qt-for-printer
|
2c5db852b75bb6dc8c802274986888e2cd9fbfc0
|
6f920f5b88ea7575266d47c87137261850236deb
|
refs/heads/main
| 2023-06-13T23:56:56.866238
| 2021-07-14T03:06:39
| 2021-07-14T03:06:39
| 385,797,606
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 304
|
h
|
#ifndef PROGRESS_H
#define PROGRESS_H
#include <QDialog>
namespace Ui {
class Progress;
}
class Progress : public QDialog
{
Q_OBJECT
public:
explicit Progress(QWidget *parent = nullptr);
~Progress();
void setValue(int value);
private:
Ui::Progress *ui;
};
#endif // PROGRESS_H
|
[
"panzhenlu@tianren.com"
] |
panzhenlu@tianren.com
|
a64453db78a95d8ccdadc91be39a7a9a50587494
|
7d9fbe19e7c68bb64c734fc84e87c85f68a65e6f
|
/Unit/UHF_RFID/UHF_RFID.ino
|
b98cd81815f9e31049f8f8941e4ec027e45314c6
|
[
"MIT"
] |
permissive
|
Robotonics/M5-ProductExampleCodes
|
027859c98fc5db6884fda715eaf3c0751167ec4e
|
62768fd80d7daee999335c793870cd0454bdb89f
|
refs/heads/master
| 2023-03-19T12:27:47.699236
| 2021-03-19T09:18:21
| 2021-03-19T09:18:21
| null | 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 1,126
|
ino
|
#include <M5Stack.h>
#include "RFID_command.h"
UBYTE RFID_debug = 0;
String DATA_Str_Serial = "";
String DATA_Str_M5led = "";
UBYTE DATA_I[4096] = {}; //Used to store distance data
UWORD DATA_I_NUB = 0;
UBYTE DATA_Interim_order[40] = {};
UBYTE DATA_Interim_b = 0;
UBYTE FLAH_S = 0;
int comd = 0;
void setup()
{
M5.begin();
Serial2.begin(115200, SERIAL_8N1, 16, 17);//16.17
RFID_Delay(100);
RFID_Readcallback();
RFID_clean_data();
M5.Lcd.fillRect(0, 0, 340, 280, BLACK);
RFID_Set_transmission_Power(2600);
}
void loop()
{
M5.Lcd.fillCircle(310, 10, 6, GREEN);
RFID_Delay(150);
M5.Lcd.fillCircle(310, 10, 6, BLACK);
RFID_Delay(150);
comd = RFID_A_single_poll_of_instructions();
RFID_Delay(2000);
RFID_clean_data();
M5.Lcd.fillRect(0, 0, 340, 280, BLACK);
// RFID_Set_the_Select_mode(0x01);
// RFID_Delay(2000);
// RFID_clean_data();
// M5.Lcd.fillRect(0, 0, 340, 280, BLACK);
//
// RFID_The_label_store_writes_data(0x0000ffff)//或者0x00000000
// RFID_Delay(2000);
// RFID_clean_data();
// M5.Lcd.fillRect(0, 0, 340, 280, BLACK);
}
|
[
"1026025056@qq.com"
] |
1026025056@qq.com
|
ffed212b3fda977cfc85a1f554c144e7acad1632
|
667a5053545f3c0ee3f50be2a7b71aa931000402
|
/Namespaces/src/Namespaces.cpp
|
84478430deed075fcabdf4719bc8d89d83c0f3d1
|
[] |
no_license
|
ESpitler/CPP-practice-course-udemy-caveofprogramming
|
2b5b296b80cacd1302afbaa870d1eb89771c9f63
|
bd1caaae5f4247041dd28a81e58726e298790fb4
|
refs/heads/main
| 2023-02-05T10:53:59.437770
| 2021-01-03T00:25:50
| 2021-01-03T00:25:50
| 326,296,949
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 705
|
cpp
|
//============================================================================
// Name : Namespaces.cpp
// Author : Evan
// Version :
// Copyright : cc by 4.0
// Description : Hello World in C++, Ansi-style
//============================================================================
#include <iostream>
#include "Cat.h"
#include "Animals.h"
using namespace std;
using namespace tut;//before using a custom namespace make sure the file that refers to it is included above.
int main() {
Cat cat;
cat.speak();
cats::Cat cat2;
cat2.speak();
tut::Cat cat3;
cat3.speak();
cout << tut::CATNAME << endl;
cout << cats::CATNAME << endl;
cout << CATNAME << endl;
return 0;
}
|
[
"gonzo.engineer@gmail.com"
] |
gonzo.engineer@gmail.com
|
59cfee9693984396770fc2f0acd89767985b10b0
|
188058ec6dbe8b1a74bf584ecfa7843be560d2e5
|
/GodDK/io/InputStream.cxx
|
e9fb7b8a2f429b4ea12c964b1cf68b8ad74d9c23
|
[] |
no_license
|
mason105/red5cpp
|
636e82c660942e2b39c4bfebc63175c8539f7df0
|
fcf1152cb0a31560af397f24a46b8402e854536e
|
refs/heads/master
| 2021-01-10T07:21:31.412996
| 2007-08-23T06:29:17
| 2007-08-23T06:29:17
| 36,223,621
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 1,429
|
cxx
|
#ifdef HAVE_CONFIG_H
# include "config.h"
#endif
#include "io/InputStream.h"
#include "lang/String.h"
using goddk::lang::String;
#include "lang/NullPointerException.h"
using goddk::lang::NullPointerException;
using namespace goddk::io;
jint InputStream::available() throw (IOExceptionPtr)
{
return 0;
}
void InputStream::close() throw (IOExceptionPtr)
{
}
void InputStream::mark(jint readlimit) throw ()
{
}
bool InputStream::markSupported() throw ()
{
return false;
}
jint InputStream::read(bytearray& b) throw (IOExceptionPtr)
{
return read(b.data(), 0, b.size());
}
jint InputStream::read(byte* data, jint offset, jint length) throw (IOExceptionPtr)
{
if (!data)
THROWEXCEPTIONPTR(NullPointerException)
jint b = read();
if (b < 0)
return -1;
data[offset] = (byte) b;
jint i = 1;
try
{
while (i < length)
{
b = read();
if (b < 0)
break;
data[offset+i++] = (byte) b;
}
}
catch (IOException&)
{
// ignore
}
return i;
}
jint InputStream::skip(jint n) throw (IOExceptionPtr)
{
jint remaining = n;
byte skip[2048];
while (remaining > 0)
{
jint rc = read(skip, 0, remaining > 2048 ? 2048 : remaining);
if (rc < 0)
break;
remaining -= rc;
}
return n - remaining;
}
void InputStream::reset() throw (IOExceptionPtr)
{
THROWEXCEPTIONPTR1(IOException,"reset not supported");
}
|
[
"soaris@46205fef-a337-0410-8429-7db05d171fc8"
] |
soaris@46205fef-a337-0410-8429-7db05d171fc8
|
87fcdd21dc886d4eecad690bd79dfea19d13fff1
|
c16b28b726d1d470289c34aeae89305a57a9f4a8
|
/source/membrane.cpp
|
3a18aa54fd7bda8979ba6ca42ad77d18c33690e2
|
[] |
no_license
|
uic-lianglab/ompg-public
|
0f4b459957b9f265eaf1d965ca94fc996661988d
|
0b40af416159ca269af7ee3dbb189bc30c93d1de
|
refs/heads/master
| 2021-09-02T12:54:03.830135
| 2018-01-02T20:26:36
| 2018-01-02T20:26:36
| 115,475,766
| 2
| 3
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 6,602
|
cpp
|
#include "membrane.h"
#include "util.h"
#include "atom.h"
#include "pdb_reader.h"
#include <assert.h>
#include <fstream>
#include <iostream>
namespace {
/**
* @return true if line represent a PDB ATOM record from a membrane segment, false o/w
*/
bool is_pdb_membrane_atom_rec(const std::string &line) {
if (Pdb::is_atom_rec(line)) {
std::string token;
Pdb::get_atom_rec_token(token, line, PdbAtomSeg);
return token == "MEMB";
}
return false;
}
/**
* Map PDB atom name to an atom flavor
*/
VdwUtils::AtomFlavor parse_pdb_atom_flavor(const std::string &atom_rec_line) {
// Determine atom flavor
std::string token;
Pdb::get_atom_rec_token(token, atom_rec_line, PdbAtomName);
if (token.empty()) {
std::cout << "Warning: missing atom name for line:\n\t"
<< atom_rec_line << std::endl;
return VdwUtils::AF_UNDEF;
}
switch (token[0]) {
case 'C': return VdwUtils::AF_C;
case 'H': return VdwUtils::AF_H;
case 'O': return VdwUtils::AF_N;
case 'N': return VdwUtils::AF_N;
case 'S': return VdwUtils::AF_S;
case 'P': return VdwUtils::AF_P;
default:
std::cout << "Warning: unrecognized membrane atom type: " << token << std::endl
<< "\tfor line: " << atom_rec_line << std::endl;
return VdwUtils::AF_UNDEF;
};
}
/**
* Utility for finding minimum x, y, or z coordinate of a membrane
* among all atoms within membrane. Needed to initialize
* minimum extreme corner of grid bounding box.
* @param atoms - list of membrane atoms
*/
double find_min_coord_for_membrane(const Membrane::atom_list_t &atoms) {
double min_coord = std::numeric_limits<double>::max();
for (Membrane::atom_list_t::const_iterator atom_it = atoms.cbegin();
atom_it != atoms.cend(); ++atom_it) {
min_coord = std::min(std::min(std::min(min_coord, atom_it->x), atom_it->y), atom_it->z);
}
// Pad min coord by largest element diameter
min_coord -= VdwUtils::max_atom_diameter();
return min_coord;
}
/**
* If membrane atoms exist, will initialize a broad phase collision grid
*/
void conditional_init_membrane_grid(collision_grid &grid, Membrane::atom_list_t &atoms) {
// Early out if no atoms
if (atoms.empty()) {
return;
}
// Initialize grid dimensions
grid.init(VdwUtils::max_atom_diameter(), find_min_coord_for_membrane(atoms));
// Add membrane atoms to grid
const collision_grid::uint_t num_atoms =
static_cast<collision_grid::uint_t>(atoms.size());
for (collision_grid::uint_t i=0; i<num_atoms; ++i) {
assert(atoms[i].flavor != VdwUtils::AF_UNDEF);
assert(atoms[i].flavor < VdwUtils::AF_NUM);
grid.add(
i,
atoms[i].x,
atoms[i].y,
atoms[i].z,
VdwUtils::atom_flavor_to_vdw_radius[atoms[i].flavor]);
}
}
/**
* @return 1 if atoms overlap, 0 otherwise
*/
inline int atoms_overlap(const Atom &a, const Membrane::atom_t &b, const double ofac2) {
const double a_r_vdw = DG_ATOM_TYPE_TO_VDW_RADIUS(a._type);
const double b_r_vdw = VdwUtils::atom_flavor_to_vdw_radius[b.flavor];
const double disquare = a.disquare(b);
double sum_radii_square = a_r_vdw + b_r_vdw;
sum_radii_square *= sum_radii_square;
return (disquare < ofac2*sum_radii_square);
}
} // end of anonymous namespace
/**
* Initializes membrane from PDB file. Will wipe internal state before
* initializing even if parameters are invalid.
* @param pdb_path - path to PDB file containing membrane data
*/
void Membrane::init(const std::string& pdb_path) {
// Clear internal state
m_atoms.clear();
m_grid.clear();
// Early out if no PDB specified
if (pdb_path.empty()) {
return;
}
// Early out if PDB path is invalid
if (!FileExists(pdb_path)) {
std::cout << "Warning: membrane PDB file not found: " << pdb_path << std::endl;
return;
}
// Parse PDB file line by line
atom_t atom;
std::ifstream fpdb(pdb_path);
for (std::string line; std::getline(fpdb, line);) {
// Skip empty lines
if (line.empty()) {
continue;
}
// Skip non-atom records and non-membrane atoms
if (!is_pdb_membrane_atom_rec(line)) {
continue;
}
// Parse atom flavor
atom.flavor = parse_pdb_atom_flavor(line);
// Skip if unrecognized atom
if (atom.flavor == VdwUtils::AF_UNDEF) {
continue;
}
// Parse atom coordinates
Pdb::parse_atom_coords(atom, line);
// Add atom to membrane
m_atoms.push_back(atom);
} // end iteration over lines of PDB file
// Close file handle
fpdb.close();
// Add membrane atoms to bounding grid
conditional_init_membrane_grid(m_grid, m_atoms);
std::cout << "Initialized lipid membrane from "
<< pdb_path << "\n\twith " << m_atoms.size() << " atoms.\n";
}
/**
* @param atom - a protein atom to check collisions against membrane
* @param ofac2 - the squared overlap factor, if ratio of squared distance
* to a membrane atom and the squared sum of vdw radii is less than this
* value, then the atoms are colliding
* @return 1 if param atom collides with membrane atoms, 0 o/w
*/
int Membrane::collides(const Atom &atom, const double ofac2) const {
// Early out if no membrane loaded
if (m_atoms.empty()) {
return 0;
}
// Broad phase
collision_grid::element_set_t nearby_atoms;
m_grid.filter(nearby_atoms,
atom.x, atom.y, atom.z,
DG_ATOM_TYPE_TO_VDW_RADIUS(atom._type));
// Narrow phase
for (collision_grid::element_set_t::const_iterator i = nearby_atoms.cbegin();
i != nearby_atoms.cend(); ++i) {
// Bounds check
assert(*i >= 0);
assert(*i < static_cast<collision_grid::uint_t>(this->m_atoms.size()));
const atom_t &nearby_atom = this->m_atoms[*i];
assert(nearby_atom.flavor != VdwUtils::AF_UNDEF);
if (atoms_overlap(atom, nearby_atom, ofac2)) {
// Collision detected
return 1;
}
}
// No collisions detected
return 0;
}
|
[
"perezrat@uic.edu"
] |
perezrat@uic.edu
|
460eff035c97acf6f00f5e1338228cc9acdf413e
|
a4e41cf6e3b18b43382bbc85b4cb7d48e71d4563
|
/src/trader/oms.h
|
f981d74b8d53cfb8f561b88c53f2eb8232b2cbbb
|
[
"MIT"
] |
permissive
|
helloyhan/ft
|
5b83c7529cc750acd635be754ce6311fc3f5bce0
|
261ebf5ac532a7381b8fe844ae2e88fad7b0ab65
|
refs/heads/master
| 2023-05-10T03:13:16.251594
| 2021-05-29T02:15:44
| 2021-05-29T02:15:44
| null | 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 2,915
|
h
|
// Copyright [2020] <Copyright Kevin, kevin.lau.gd@gmail.com>
#ifndef FT_SRC_TRADER_OMS_H_
#define FT_SRC_TRADER_OMS_H_
#include <list>
#include <map>
#include <memory>
#include <set>
#include <string>
#include <thread>
#include <vector>
#include "ft/base/error_code.h"
#include "ft/base/market_data.h"
#include "ft/base/trade_msg.h"
#include "ft/component/position/manager.h"
#include "ft/component/yijinjing/journal/JournalReader.h"
#include "ft/component/yijinjing/journal/JournalWriter.h"
#include "ft/utils/spinlock.h"
#include "ft/utils/timer_thread.h"
#include "trader/gateway/gateway.h"
#include "trader/order.h"
#include "trader/risk/rms.h"
#include "trader/trader_db_updater.h"
namespace ft {
// 当前不支持销毁
class OrderManagementSystem {
public:
OrderManagementSystem();
bool Init(const FlareTraderConfig& config);
void ProcessCmd();
void operator()(const OrderAcceptance& rsp);
void operator()(const OrderRejection& rsp);
void operator()(const Trade& rsp);
void operator()(const OrderCancellation& rsp);
void operator()(const OrderCancelRejection& rsp);
private:
void ExecuteCmd(const TraderCommand& cmd);
bool SendOrder(const TraderCommand& cmd);
void DoCancelOrder(const Order& order, bool without_check);
void CancelOrder(uint64_t order_id, bool without_check);
void CancelForTicker(uint32_t ticker_id, bool without_check);
void CancelAll(bool without_check);
bool InitContractTable();
bool InitTraderDBConn();
bool InitMQ();
bool InitGateway();
bool InitAccount();
bool InitPositions();
bool InitTradeInfo();
bool InitRMS();
bool SubscribeMarketData();
void SendRspToStrategy(const Order& order, int this_traded, double price, int error_code);
void OnTick(const TickData& tick);
void OnAccount(const Account& account);
void OnPositions(std::vector<Position>* positions);
void OnTrades(std::vector<Trade>* trades);
bool OnTimer();
void OnSecondaryMarketTraded(const Trade& rsp); // 二级市场买卖
uint64_t next_order_id() { return next_oms_order_id_++; }
private:
std::shared_ptr<Gateway> gateway_{nullptr};
const FlareTraderConfig* config_;
std::vector<yijinjing::JournalReaderPtr> trade_msg_readers_;
std::vector<yijinjing::JournalWriterPtr> rsp_writers_;
std::map<std::string, std::size_t> strategy_name_to_index_;
std::set<std::string> subscription_set_;
std::map<uint32_t, std::vector<yijinjing::JournalWriterPtr>> md_dispatch_map_;
volatile bool is_logon_{false};
uint64_t next_oms_order_id_{1};
SpinLock spinlock_;
Account account_;
PositionManager pos_manager_;
TraderDBUpdater trader_db_updater_;
OrderMap order_map_;
std::unique_ptr<RiskManagementSystem> rms_{nullptr};
TimerThread timer_thread_;
};
} // namespace ft
#endif // FT_SRC_TRADER_OMS_H_
|
[
"kevin.lau.gd@gmail.com"
] |
kevin.lau.gd@gmail.com
|
3a4dc8da74415e5697da835eca11b3be3fa93bd6
|
1c33b6fd7fbf966a961ccd679ad2ba344f2fc05f
|
/UVA/Simple Division.cpp
|
5b2ccc21eda73ea88cf29a848e6186481932566f
|
[] |
no_license
|
zim2510/Online-Judge-Solves
|
f57170e5bf14f339944079ed62bed01bdc5b27e3
|
949ab3cfba0cc7ec4ffaa6f2b3e5b0c517d9377a
|
refs/heads/master
| 2022-01-07T10:23:12.653572
| 2019-05-19T11:30:58
| 2019-05-19T11:30:58
| 135,351,009
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 612
|
cpp
|
#include <bits/stdc++.h>
using namespace std;
int main()
{
freopen("out.txt", "w", stdout);
int nums[1000];
int num;
int n = 0;
while(scanf("%d", &num)==1){
if(!n && !num) break;
if(n && !num){
int diff[n-1];
for(int i = 0; i<n-1; i++){
diff[i] = abs(nums[i+1] - nums[i]);
}
int g = diff[0];
for(int i = 1; i<n-1; i++){
g = __gcd(diff[i], g);
}
printf("%d\n", g);
n = 0;
}
else nums[n++] = num;
}
}
|
[
"zim2510@gmail.com"
] |
zim2510@gmail.com
|
53d6ca8c1b05807232b183bd3727165a9a6cf078
|
f035962a634a1fb0cd3d0f1873b97c206efaacdd
|
/ph2bye/src/RcppExports.cpp
|
e9e276f0911f7eee48fffdf620c215361ffab7c7
|
[] |
no_license
|
allenzhuaz/ph2bye
|
409130ecd259a4ffe1560a9c12595ae7d45082c2
|
351eb3c306518e912ce201857504215d7870bb09
|
refs/heads/master
| 2021-01-20T20:24:13.097087
| 2019-08-06T18:55:46
| 2019-08-06T18:55:46
| 62,251,607
| 1
| 2
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 1,007
|
cpp
|
// This file was generated by Rcpp::compileAttributes
// Generator token: 10BE3573-1514-4C36-9D1C-5A225CD40393
#include <Rcpp.h>
using namespace Rcpp;
// PredPCpp
double PredPCpp(int x, int n, int nmax, double a, double b, double p0, double theta_t);
RcppExport SEXP ph2bye_PredPCpp(SEXP xSEXP, SEXP nSEXP, SEXP nmaxSEXP, SEXP aSEXP, SEXP bSEXP, SEXP p0SEXP, SEXP theta_tSEXP) {
BEGIN_RCPP
Rcpp::RObject __result;
Rcpp::RNGScope __rngScope;
Rcpp::traits::input_parameter< int >::type x(xSEXP);
Rcpp::traits::input_parameter< int >::type n(nSEXP);
Rcpp::traits::input_parameter< int >::type nmax(nmaxSEXP);
Rcpp::traits::input_parameter< double >::type a(aSEXP);
Rcpp::traits::input_parameter< double >::type b(bSEXP);
Rcpp::traits::input_parameter< double >::type p0(p0SEXP);
Rcpp::traits::input_parameter< double >::type theta_t(theta_tSEXP);
__result = Rcpp::wrap(PredPCpp(x, n, nmax, a, b, p0, theta_t));
return __result;
END_RCPP
}
|
[
"noreply@github.com"
] |
allenzhuaz.noreply@github.com
|
aaf6b0a35c11bd3757c2a9acfac94932cf7d2fd0
|
60a15a584b00895e47628c5a485bd1f14cfeebbe
|
/AWIN/ctrl_groupbox.h
|
5701cba5c53fc3244d057561d0d35f45359029b4
|
[] |
no_license
|
fcccode/vt5
|
ce4c1d8fe819715f2580586c8113cfedf2ab44ac
|
c88049949ebb999304f0fc7648f3d03f6501c65b
|
refs/heads/master
| 2020-09-27T22:56:55.348501
| 2019-06-17T20:39:46
| 2019-06-17T20:39:46
| null | 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 4,653
|
h
|
#pragma once
#include "win_base.h"
#define GBCTRL_DS_ROUND_RECT 0
#define GBCTRL_DS_SIMPLE_RECT 1
class group_box_ctrl : public win_impl
{
public:
group_box_ctrl();
virtual ~group_box_ctrl();
public:
virtual void handle_init();
virtual LRESULT on_paint();
virtual LRESULT on_destroy();
virtual bool subclass( HWND hwnd, bool f_nccreate = false );
void set_text( HINSTANCE hrc, UINT nID );
void set_text( char *psz );
void set_offset( int n ) {m_cx_offset = n;}
void set_icon( HINSTANCE hrc, uint id );
void set_colors( COLORREF color_back, COLORREF color_text );
void set_draw_style( int nstyle );
void set_text_align( int nalign );
void set_text_valign( int nalign );
protected:
HICON m_hicon;
HFONT m_font;
COLORREF m_color, m_color_text;
int m_ndraw_style;
int m_nalign;
int m_nvalign;
char *m_psz_text;
int m_cx_offset;
};
inline
group_box_ctrl::group_box_ctrl()
{
m_hicon = 0;
m_font = 0;
m_ndraw_style = GBCTRL_DS_ROUND_RECT;
m_nalign = DT_LEFT;
m_nvalign = DT_VCENTER;
m_color_text = RGB( 255, 255, 255 );
m_color = RGB( 192, 192, 192 );
m_psz_text = 0;
m_cx_offset = 24;
}
inline
group_box_ctrl::~group_box_ctrl()
{
if( m_hicon )::DestroyIcon( m_hicon );
_assert( m_font == 0 );
if( m_psz_text )
::free( m_psz_text );
}
inline
void group_box_ctrl::handle_init()
{
_assert( m_font == 0 );
LOGFONT lf;
::GetObject( ::GetStockObject( DEFAULT_GUI_FONT ), sizeof( lf ), &lf );
lf.lfWeight = FW_BOLD;
lf.lfHeight = 14;
m_font = ::CreateFontIndirect( &lf );
}
inline
LRESULT group_box_ctrl::on_destroy()
{
if( m_font )
::DeleteObject( m_font );
m_font = 0;
return win_impl::on_destroy();
}
inline
bool group_box_ctrl::subclass( HWND hwnd, bool f_nccreate )
{
char buf[1024];
::GetWindowText( hwnd, buf, sizeof(buf)-1 );
::SetWindowText( hwnd, "" );
if( m_psz_text )::free( m_psz_text );
m_psz_text = _tcsdup( buf );
return win_impl::subclass( hwnd, f_nccreate );
};
inline
LRESULT group_box_ctrl::on_paint()
{
PAINTSTRUCT ps;
HDC hdc = ::BeginPaint( handle(), &ps );
HFONT hold = (HFONT)::SelectObject( hdc, m_font );
char *psz_text = m_psz_text;
char sz[1024];
if( !psz_text )
{
::GetWindowText( handle(), sz, sizeof( sz ) );
psz_text = sz;
}
_rect rect_client;
::GetClientRect( handle(), &rect_client );
{
HBRUSH hbrush = ::CreateSolidBrush( m_color );
HBRUSH hold_brush = (HBRUSH)::SelectObject( hdc, hbrush );
HPEN hpen = ::CreatePen( PS_SOLID, 1, m_color );
HPEN hold_pen = (HPEN)::SelectObject( hdc, hpen );
if( m_ndraw_style == GBCTRL_DS_ROUND_RECT )
::RoundRect( hdc, rect_client.left, rect_client.top, rect_client.right, rect_client.bottom, 5, 5 );
else if( m_ndraw_style == GBCTRL_DS_SIMPLE_RECT )
::Rectangle( hdc, rect_client.left, rect_client.top, rect_client.right, rect_client.bottom );
::SelectObject( hdc, hold_brush );
::SelectObject( hdc, hold_pen );
//???
::DeleteObject( hbrush );
::DeleteObject( hpen );
}
//draw icon
if( m_hicon )
::DrawIconEx( hdc, rect_client.left+rect_client.height()/2-8, rect_client.vcenter()-8, m_hicon, 16, 16, 0, 0, DI_NORMAL );
//draw text
_rect rc_text( rect_client );
if( m_nalign == DT_LEFT )
rc_text.left += m_cx_offset;
else if( m_nalign == DT_RIGHT )
rc_text.right -= 12;
::SetBkMode( hdc, TRANSPARENT );
::SetTextColor( hdc, m_color_text );
if( _tcslen( psz_text ) )
{
_rect rc_calc( 0, 0, rc_text.width(), 0 );
::DrawText( hdc, psz_text, -1, &rc_calc, DT_LEFT|DT_CALCRECT );
rc_text.top = rc_text.top + ( rc_text.height() - rc_calc.height() ) / 2;
rc_text.bottom = rc_text.top + rc_calc.height();
::DrawText( hdc, psz_text, -1, &rc_text, m_nalign | m_nvalign );
}
::SelectObject( hdc, hold );
::EndPaint( handle(), &ps );
return 0;
}
inline
void group_box_ctrl::set_colors( COLORREF color_back, COLORREF color_text )
{
m_color_text = color_text;
m_color = color_back;
}
inline
void group_box_ctrl::set_draw_style( int nstyle )
{
m_ndraw_style = nstyle;
}
inline
void group_box_ctrl::set_text_align( int nalign )
{
m_nalign = nalign;
}
inline
void group_box_ctrl::set_text_valign( int nvalign )
{
m_nvalign = nvalign;
}
inline
void group_box_ctrl::set_text( HINSTANCE hrc, UINT nID )
{
if( m_psz_text )
::free( m_psz_text ); m_psz_text = 0;
char sz[250] = {0};
LoadString( hrc, nID, sz, sizeof( sz ) );
m_psz_text = _tcsdup( sz );
}
inline
void group_box_ctrl::set_text( char *psz )
{
if( m_psz_text )
::free( m_psz_text ); m_psz_text = 0;
m_psz_text = _tcsdup( psz );
}
inline
void group_box_ctrl::set_icon( HINSTANCE hrc, uint id )
{
m_hicon = ::LoadIcon( hrc, MAKEINTRESOURCE( id ) );
}
|
[
"videotestc@gmail.com"
] |
videotestc@gmail.com
|
e22f2e36ae04fb06498a0215f3e29f299439d5bd
|
27bb5ed9eb1011c581cdb76d96979a7a9acd63ba
|
/aws-cpp-sdk-apigateway/source/model/GetUsagePlanKeyRequest.cpp
|
238b4f6d3f4ef10bc07a1c1aec1b71b6d05a7f7c
|
[
"Apache-2.0",
"JSON",
"MIT"
] |
permissive
|
exoscale/aws-sdk-cpp
|
5394055f0876a0dafe3c49bf8e804d3ddf3ccc54
|
0876431920136cf638e1748d504d604c909bb596
|
refs/heads/master
| 2023-08-25T11:55:20.271984
| 2017-05-05T17:32:25
| 2017-05-05T17:32:25
| 90,744,509
| 0
| 0
| null | 2017-05-09T12:43:30
| 2017-05-09T12:43:30
| null |
UTF-8
|
C++
| false
| false
| 1,008
|
cpp
|
/*
* Copyright 2010-2016 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
#include <aws/apigateway/model/GetUsagePlanKeyRequest.h>
#include <aws/core/utils/json/JsonSerializer.h>
#include <utility>
using namespace Aws::APIGateway::Model;
using namespace Aws::Utils::Json;
using namespace Aws::Utils;
GetUsagePlanKeyRequest::GetUsagePlanKeyRequest() :
m_usagePlanIdHasBeenSet(false),
m_keyIdHasBeenSet(false)
{
}
Aws::String GetUsagePlanKeyRequest::SerializePayload() const
{
return "";
}
|
[
"henso@amazon.com"
] |
henso@amazon.com
|
a4d78b21a0bc687db0269752eacc546e8a696b5e
|
38e8bfbbb47150a2bfd37d7e5f4ab952673806f2
|
/FractalCreator/RGB.cpp
|
b886657c8fa835a9155a5aab5c68915d59d130bd
|
[] |
no_license
|
ObserverMoment/mandelbrot-bitmap-creator
|
df67c18caf2a50e26905fc8c072e0ac92bfe9834
|
f5dc04e8508ba84a919e63256f327968287aa5de
|
refs/heads/master
| 2021-08-26T06:40:32.030876
| 2017-11-21T23:13:09
| 2017-11-21T23:13:09
| 111,611,573
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 1,001
|
cpp
|
//
// RGB.cpp
// FractalCreator
//
// Created by Rich Beans on 14/09/2017.
// Copyright © 2017 Rich Beans. All rights reserved.
//
#include "RGB.hpp"
// Because when we are calculating the colour we are using a uint8_t we do not need to worry about the value of the below operations falling outside of the 0 to 255 range. Values outside of this range will automatically "wrap" as high order bits are just discarded when maximum value of the data type is reached.
RGB operator-(const RGB& first, const RGB& second) {
return RGB(first.r - second.r, first.g - second.g, first.b - second.b);
};
RGB operator+(const RGB& first, const RGB& second) {
return RGB(first.r + second.r, first.g + second.g, first.b + second.b);
};
RGB operator*(const RGB& first, const RGB& second) {
return RGB(first.r * second.r, first.g * second.g, first.b * second.b);
};
RGB operator/(const RGB& first, const RGB& second) {
return RGB(first.r / second.r, first.g / second.g, first.b / second.b);
};
|
[
"bosonsoul@gmail.com"
] |
bosonsoul@gmail.com
|
0729496e547af8443a00f1a8c33ebdb5fe0bc9dc
|
95acee9b8c5988521b75bcdaeee582d0f7f5474e
|
/src/Game.h
|
cd32190333db4d74c4033fbf708cd81aadf82812
|
[] |
no_license
|
VeskeOrion/veske-game-engine
|
fa9aa57d711c9a97ce3e3e3258c91c13d6e1a2e8
|
4ac511a325b5f43494a8d4276af8a17b70bb5b3f
|
refs/heads/master
| 2021-10-25T19:54:55.946681
| 2019-04-06T17:17:32
| 2019-04-06T17:17:32
| 108,694,622
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 1,264
|
h
|
//----------------------------------------------------------------------------------------//
// Game.h
// Contains a class that represents the game and all of its subsystems. This class is
// essentially the main method (in fact, the main method is in Game.cpp). It contains static
// unique pointers to all of the subsytems of the game: Window, Renderer, Logger, Audio,
// Input, and World. Pointers to all of these subsystems can be accessed via
// Game::subsystem_name, like Game::world->run() or Game::input->getKeyDown(Input::Key::A).
// To start a game, Game::start() must be called, which will initialize all the subsytems
// and run the World.
//----------------------------------------------------------------------------------------//
#ifndef GAME_H
#define GAME_H
#include <memory>
#include <SDL.h>
#include "Window.h"
#include "Renderer.h"
#include "Logger.h"
#include "World.h"
#include "Input.h"
class Game {
private:
Game();
~Game();
public:
static int start();
static std::unique_ptr<Window> window;
static std::unique_ptr<Renderer> renderer;
static std::unique_ptr<Logger> logger;
//static std::unique_ptr<Audio> audio;
static std::unique_ptr<Input> input;
static std::unique_ptr<World> world;
};
#endif // GAME_H
|
[
"veske@uga.edu"
] |
veske@uga.edu
|
f4bbc9f2990c9f50d5285e619702df80cafcb22c
|
7bee86f3325e6ddf10626e289c8b77a24d7d9eb7
|
/Assignment_4.cpp
|
548750850ef15cd9073337e28ce4dc61bc7146d1
|
[] |
no_license
|
MarilizePi/Foothill_College_CS_2A
|
0215e9bc7bdc19340b525c350f1677f0791308b9
|
dffa56dda03674533d50e1697c65e46ff817598d
|
refs/heads/master
| 2020-05-29T11:24:55.662170
| 2019-06-20T01:15:48
| 2019-06-20T01:15:48
| 189,113,233
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 5,498
|
cpp
|
#include <iostream>
#include <string>
#include <sstream>
using namespace std;
int main()
{
int initial_stamps = 0;
int final_stamps = 0;
const int FREE_YOGURT = 10;
int userInputInt;
string userInputStr;
char userInputChar;
bool quit;
quit = false;
while (!quit)
{
cout << "Menu: " << endl;
cout << "P (process Purchase)" << endl;
cout << "S (Shut down)" << endl << endl;
cout << "Your choice: ";
getline(cin, userInputStr);
userInputChar = userInputStr[0];
if (toupper(userInputChar) == 'P')
{
cout << "\n" << "How many yogurts would you like to buy? ";
getline(cin, userInputStr);
istringstream(userInputStr) >> userInputInt;
initial_stamps = userInputInt;
final_stamps += userInputInt;
cout << "\n" << "You just earned " << initial_stamps
<< " stamps and have a total of " << final_stamps
<< " stamps to use." << endl << endl;
if (final_stamps >= FREE_YOGURT)
{
cout << "You qualify for a free yogurt. ";
cout << "Would you like to use your credits ? (Y or N) ";
getline(cin, userInputStr);
userInputChar = userInputStr[0];
if (toupper(userInputChar) == 'Y')
{
final_stamps -= FREE_YOGURT;
cout << "\n" << "Enjoy your yogurt!" << endl;
cout << "You now have " << final_stamps
<< " stamps." << endl << endl;
}
/* Since I didn't know (yet) how to return to the specific loop,
I decided to repeate some lines of code.*/
else
{
if (toupper(userInputChar) == 'N')
{
cout << "\n" << "How many yogurts would you like to buy? ";
getline(cin, userInputStr);
istringstream(userInputStr) >> userInputInt;
initial_stamps = userInputInt;
final_stamps += userInputInt;
cout << "\n" << "You just earned " << initial_stamps
<< " stamps and have a total of " << final_stamps
<< " stamps to use." << endl << endl;
}
}
}
}
else if (toupper(userInputChar) == 'S')
{
cout << "See you next time!" << endl;
quit = true;
}
else
{
if (toupper(userInputChar) != 'P' || toupper(userInputChar) != 'S')
{
cout << "*** Use P or S, please. ***" << endl << endl;
continue;
}
}
}
return 0;
}
/*------------------- Run 1---------------------
Menu:
P (process Purchase)
S (Shut down)
Your choice: p
How many yogurts would you like to buy? 7
You just earned 7 stamps and have a total of 7 stamps to use.
Menu:
P (process Purchase)
S (Shut down)
Your choice: purchase
How many yogurts would you like to buy? 7
You just earned 7 stamps and have a total of 14 stamps to use.
You qualify for a free yogurt. Would you like to use your credits ? (Y or N) y
Enjoy your yogurt!
You now have 4 stamps.
Menu:
P (process Purchase)
S (Shut down)
Your choice: puppy
How many yogurts would you like to buy? 8
You just earned 8 stamps and have a total of 12 stamps to use.
You qualify for a free yogurt. Would you like to use your credits ? (Y or N) yes
Enjoy your yogurt!
You now have 2 stamps.
Menu:
P (process Purchase)
S (Shut down)
Your choice: shut
See you next time!
Press any key to continue . . .
------------------- Run 2---------------------
Menu:
P (process Purchase)
S (Shut down)
Your choice: pp
How many yogurts would you like to buy? 5
You just earned 5 stamps and have a total of 5 stamps to use.
Menu:
P (process Purchase)
S (Shut down)
Your choice: t
*** Use P or S, please. ***
Menu:
P (process Purchase)
S (Shut down)
Your choice: 9
*** Use P or S, please. ***
Menu:
P (process Purchase)
S (Shut down)
Your choice: .
*** Use P or S, please. ***
Menu:
P (process Purchase)
S (Shut down)
Your choice: p
How many yogurts would you like to buy? 9
You just earned 9 stamps and have a total of 14 stamps to use.
You qualify for a free yogurt. Would you like to use your credits ? (Y or N) n
How many yogurts would you like to buy? 3
You just earned 3 stamps and have a total of 17 stamps to use.
Menu:
P (process Purchase)
S (Shut down)
Your choice: p
How many yogurts would you like to buy? 0
You just earned 0 stamps and have a total of 17 stamps to use.
You qualify for a free yogurt. Would you like to use your credits ? (Y or N) nope
How many yogurts would you like to buy? 1
You just earned 1 stamps and have a total of 18 stamps to use.
Menu:
P (process Purchase)
S (Shut down)
Your choice: p
How many yogurts would you like to buy? 10
You just earned 10 stamps and have a total of 28 stamps to use.
You qualify for a free yogurt. Would you like to use your credits ? (Y or N) y
Enjoy your yogurt!
You now have 18 stamps.
Menu:
P (process Purchase)
S (Shut down)
Your choice: p
How many yogurts would you like to buy? 0
You just earned 0 stamps and have a total of 18 stamps to use.
You qualify for a free yogurt. Would you like to use your credits ? (Y or N) y
Enjoy your yogurt!
You now have 8 stamps.
Menu:
P (process Purchase)
S (Shut down)
Your choice: s
See you next time!
Press any key to continue . . .
---------------------------------------------*/
|
[
"marilizepi@gmail.com"
] |
marilizepi@gmail.com
|
85baa6a13f4bd86146e3bc118d0556fca11359ec
|
2fa5c8d10d597fe1d590542596994fdbd016fddc
|
/dataset/simulation_experiment/Type1/1/Base3.cpp
|
869780a44878b67b6c85c63abce16cba6509f8b1
|
[] |
no_license
|
guoliang72/colllectivePR
|
715ea332a147e115ac30326a013e19d80f4638a1
|
f9223e1d1aaa34ac377e75994c02c69033cd0d7f
|
refs/heads/master
| 2020-04-24T06:55:28.611842
| 2019-02-22T11:31:27
| 2019-02-22T11:31:27
| 171,782,140
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 395
|
cpp
|
#include <stdio.h>
int main(){
int i;
int n;
double a;
double sum;
sum=0;
scanf("%d",&n);
for(i=0;i<n;i=i+1){
scanf("%lf",&a);
if(a<100){
a=100;
}else if(a>=100 && a<200){
a=0.1*a;
}else if(a>=200 && a<500){
a=0.3*a;
}else if(a>=500){
a=0.5*a;
}
sum=sum+a;
}
printf("%.2lf\n",sum);
return 0;
}
|
[
"guoliang72@qq.com"
] |
guoliang72@qq.com
|
bd408c423cc003906786a0520eedc22cb08f582d
|
41e107a91f6307d3c78b211ff12afddc832d5926
|
/ugine/src/ugine/layer_stack.cc
|
3999e24702dab2add8ee6c50675acf885981f365
|
[
"Apache-2.0"
] |
permissive
|
AdrianOrcik/ugine
|
8e5bb43f0d9e32ff9be82389649728d5815221e9
|
4f5a9a5641c834834d9e18fc5b85b55140544568
|
refs/heads/master
| 2022-11-05T08:22:29.090685
| 2020-06-20T19:54:57
| 2020-06-20T19:54:57
| 245,837,032
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 734
|
cc
|
#include "uepch.h"
#include "layer_stack.h"
namespace Ugine
{
LayerStack::LayerStack()
{
}
LayerStack::~LayerStack()
{
for (Layer* layer : layers_)
delete layer;
}
void LayerStack::PushLayer(Layer* layer)
{
layers_.emplace(layers_.begin() + layerIndex_, layer);
layerIndex_++;
}
void LayerStack::PushOverlay(Layer* overlay)
{
layers_.push_back(overlay);
}
void LayerStack::PopLayer(Layer* layer)
{
auto it = std::find(layers_.begin(), layers_.end(), layer);
if (it != layers_.end())
{
layers_.erase(it);
layerIndex_--;
}
}
void LayerStack::PopOverlay(Layer* overlay)
{
auto it = std::find(layers_.begin(), layers_.end(), overlay);
if (it != layers_.end())
layers_.erase(it);
}
}
|
[
"adrian.orcik@gmail.com"
] |
adrian.orcik@gmail.com
|
58b01478c0e31ebd795d6a5a0d8949f083c0aec8
|
2367e655305a00dd84f7aa0b1fa18501d2511c52
|
/KwSing_iphone/.svn/pristine/d3/d3a472400b52025f46f6be7c547a68a220052a9d.svn-base
|
080df86e0dda17b482aef69912d2a5f3fba3da68
|
[] |
no_license
|
XClouded/dev_project
|
a165e7a313d182ed5f90e8dcef0e167dce1f6307
|
c938277aaf73992923e6d6d1ededd8ef3629a38f
|
refs/heads/master
| 2021-01-22T17:03:32.375508
| 2014-11-26T08:23:37
| 2014-11-26T08:23:37
| null | 0
| 0
| null | null | null | null |
GB18030
|
C++
| false
| false
| 654
|
/***********************************************************************************************************
File: preamp.h
Desc: 用于放大16 bit wav信号的类PreAmp的定义文件，可以把wav信号按照要求的db数进行放大和缩小
Author: Wang Lei
Date: May, 2008
***********************************************************************************************************/
#ifndef PREAMP_H
#define PREAMP_H
class PreAmp
{
public:
PreAmp();
~PreAmp();
bool process(void * pWav, int nLen, int nDB);
static const unsigned long table_size = 65536;
private:
void make_table(float ratio);
signed short * m_table;
int m_db;
};
#endif
|
[
"wangmingjob@gmail.com"
] |
wangmingjob@gmail.com
|
|
c1cae12fb9c68557d7e2802793581eaec924fc37
|
523badc1b9f85de3d37c2cfa092dc24cbb3a0e08
|
/bus_mgr_lib_prj/bus_mgr.h
|
876f6ed095c2d753e17100324886b2239dd49ee9
|
[] |
no_license
|
yiliangwu880/libevent_prj
|
2b3f222043c91cd623143ab6331aba2d657d5dc4
|
48badafc0bf2b9f97d64b848877dbe8da37ef67d
|
refs/heads/master
| 2021-05-05T03:11:10.936226
| 2019-07-13T07:35:32
| 2019-07-13T07:35:32
| 119,790,929
| 0
| 0
| null | null | null | null |
GB18030
|
C++
| false
| false
| 1,460
|
h
|
/*
author: yiliang.wu
功能：busmgr 管理进程和进程之间的连接, mgr 和 p必须同一台机器
*/
#pragma once
#include "include_all.h"
#include <map>
#include "channel.h"
#include "utility/misc.h"
#include <memory.h>
#include "bus_typedef.h"
//mc = mgr connector, p 通过socket连接mgr, 在mgr进程的connector
class MgrConnector : public ListenerConnector
{
public:
template<class ResMsg>
bool Send(const ResMsg &res)
{
MsgPack pack;
memcpy(pack.data, &res, sizeof(res));
pack.len = sizeof(res);
return send_data(pack);
}
template<class ResMsg>
bool SendError(ResMsg &res, const std::string &msg, uint16 error_code = 1)
{
res.error_code = error_code;
memcpy(res.error_msg, msg.c_str(), msg.length() + 1);
MsgPack pack;
memcpy(pack.data, &res, sizeof(res));
pack.len = sizeof(res);
return send_data(pack);
}
private:
virtual void OnRecv(const MsgPack &msg) override;
virtual void OnConnected() override;
virtual void onDisconnected();
private:
};
//检查outer channel 读写定时器
class CheckOuterChannelTimer : public BaseLeTimer
{
private:
virtual void OnTimer(void *user_data) override;
};
//bus mgr总管理器,一切从这里出发
class BusMgr
{
public:
static BusMgr &Instance()
{
static BusMgr d;
return d;
}
bool Init(unsigned short listen_port);
void Run();
MgrConnector *FindMc(uint64 mc_id);
private:
Listener<MgrConnector> m_listener;
CheckOuterChannelTimer m_timer;
};
|
[
"30390012@qq.com"
] |
30390012@qq.com
|
1a37cc63b1eea59e35f2bd9f8d80c9380ea5fa3b
|
8a431e5d895785ef0e81037485e8d53d2dba8083
|
/1-intro/fibonacci_last_digit/fibonacci_last_digit.cpp
|
1b0a0650eab4824cc5bbd3f066219600ba2db378
|
[] |
no_license
|
reazh/algo-toolbox
|
a94128dfbe5165f5f5c5f76ef3722d15aa511bd6
|
7e4e73f223d944e0b95f6a13ad459d588abeda6d
|
refs/heads/master
| 2021-05-31T07:40:04.424761
| 2016-05-23T03:34:58
| 2016-05-23T03:34:58
| null | 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 208
|
cpp
|
#include <iostream>
int get_fibonacci_last_digit(int n) {
//write your code here
return 0;
}
int main() {
int n;
std::cin >> n;
int c = get_fibonacci_last_digit(n);
std::cout << c << '\n';
}
|
[
"rhasan@gmail.com"
] |
rhasan@gmail.com
|
c193f22a931ea47419701613cab4d429c7041f5e
|
ed649693468835126ae0bc56a9a9745cbbe02750
|
/alljoyn_core/router/winrt/proximity/ProximityListener.h
|
cb33346d2da5015cac38ee08c1ca3431591cdd26
|
[] |
no_license
|
tkellogg/alljoyn-core
|
982304d78da73f07f888c7cbd56731342585d9a5
|
931ed98b3f5e5dbd40ffb529a78825f28cc59037
|
refs/heads/master
| 2020-12-25T18:22:32.166135
| 2014-07-17T13:56:18
| 2014-07-17T13:58:56
| 21,984,205
| 2
| 1
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 1,275
|
h
|
/**
* @file
* ProximityListener is to notify status changes of the proximity connection.
*/
/******************************************************************************
* Copyright (c) 2012, AllSeen Alliance. All rights reserved.
*
* Permission to use, copy, modify, and/or distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
******************************************************************************/
#ifndef _PROXIMITY_LISTENER_H
#define _PROXIMITY_LISTENER_H
namespace ajn {
class ProximityListener {
public:
virtual void OnProximityDisconnected() = 0;
};
} // namespace ajn
#endif
|
[
"gerritadmin@allseenalliance.org"
] |
gerritadmin@allseenalliance.org
|
c3f1c0ca05c35e30b2a9db176a18ee77e7327763
|
7345e04e6bad0b9f5484a08d4c36af512564ee5f
|
/hazelcast/include/hazelcast/client/config/ssl_config.h
|
7417b0a9f57c77b92724f96cf5f4a1c1aed755e6
|
[
"Apache-2.0"
] |
permissive
|
hojuara/hazelcast-cpp-client
|
0d1afe48bd409cb8bd557f6904342f8dd1a369db
|
036cae2363c56ce9357cecc883b7e4ba1149a09b
|
refs/heads/master
| 2023-01-28T03:37:20.893981
| 2020-12-11T16:15:43
| 2020-12-11T16:15:43
| null | 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 5,123
|
h
|
/*
* Copyright (c) 2008-2020, Hazelcast, Inc. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#pragma once
#include <string>
#include <vector>
#include "hazelcast/util/hazelcast_dll.h"
#if defined(WIN32) || defined(_WIN32) || defined(WIN64) || defined(_WIN64)
#pragma warning(push)
#pragma warning(disable: 4251) //for dll export
#endif
namespace hazelcast {
namespace client {
namespace config {
enum HAZELCAST_API ssl_protocol
{
/// Generic SSL version 2.
sslv2 = 0, // boost::asio::ssl::context_base::sslv2
/// Generic SSL version 3.
sslv3 = 3, // boost::asio::ssl::context_base::sslv3
/// Generic TLS version 1.
tlsv1 = 6, // boost::asio::ssl::context_base::tlsv1
/// Generic SSL/TLS.
sslv23 = 9, // boost::asio::ssl::context_base::sslv23
/// Generic TLS version 1.1.
tlsv11 = 12, // boost::asio::ssl::context_base::tlsv11,
/// Generic TLS version 1.2.
tlsv12 = 15, // boost::asio::ssl::context_base::tlsv12
};
/**
* Contains configuration parameters for client network related behaviour
*/
class HAZELCAST_API ssl_config {
public:
/**
* Default protocol is tlsv12 and ssl is disabled by default
*/
ssl_config();
/**
* Returns if this configuration is enabled.
*
* @return true if enabled, false otherwise
*/
bool is_enabled() const;
/**
* Enables and disables this configuration.
*
* @param isEnabled true to enable, false to disable
*/
ssl_config &set_enabled(bool is_enabled);
/**
* Sets the ssl protocol to be used for this SSL socket.
*
* @param protocol One of the supported protocols
*/
ssl_config &set_protocol(ssl_protocol protocol);
/**
* @return The configured SSL protocol
*/
ssl_protocol get_protocol() const;
/**
* @return The list of all configured certificate verify files for the client.
*/
const std::vector<std::string> &get_verify_files() const;
/**
* This API calls the OpenSSL SSL_CTX_load_verify_locations method underneath while starting the client
* with this configuration. The validity of the files are checked only when the client starts. Hence,
* this call will not do any error checking. Error checking is performed only when the certificates are
* actually loaded during client start.
*
* @param filename the name of a file containing certification authority certificates in PEM format.
*/
ssl_config &add_verify_file(const std::string &filename);
/**
* @return Returns the use configured cipher list string.
*/
const std::string &get_cipher_list() const;
/**
* @param ciphers The list of ciphers to be used. During client start, if this API was set then the
* SSL_CTX_set_cipher_list (https://www.openssl.org/docs/man1.0.2/ssl/SSL_set_cipher_list.html) is
* called with the provided ciphers string. The values and the format of the ciphers are described here:
* https://www.openssl.org/docs/man1.0.2/apps/ciphers.html Some examples values for the string are:
* "HIGH", "MEDIUM", "LOW", etc.
*
* If non of the provided ciphers could be selected the client initialization will fail.
*
*/
ssl_config &set_cipher_list(const std::string &ciphers);
private:
bool enabled_;
ssl_protocol ssl_protocol_;
std::vector<std::string> client_verify_files_;
std::string cipher_list_;
};
}
}
}
#if defined(WIN32) || defined(_WIN32) || defined(WIN64) || defined(_WIN64)
#pragma warning(pop)
#endif
|
[
"noreply@github.com"
] |
hojuara.noreply@github.com
|
0bd2be133cb154059838ae94ef136c163f8bd731
|
cb7ae10692a3692cad7d500cddadfbf7ea4f4a1a
|
/c/ParticleFilter/sirTest.cpp
|
be65a3d0f68782bf9e09f96ce4db61b1c7a68fee
|
[] |
no_license
|
UCSD-SEELab/ContextEngine27
|
c715b32ab08a94224b289a7e00d8d51d6cfc9e84
|
754458c919d96a338d010a6eab31bcb93ee73e09
|
refs/heads/master
| 2021-06-16T07:16:31.951345
| 2017-04-27T19:52:07
| 2017-04-27T19:52:07
| 62,247,545
| 1
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 4,330
|
cpp
|
// this version runs on rpi or osx
#include "smctc.hh"
#include "pffuncs.hh"
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <fstream>
#include <string.h>
#include <sys/time.h>
using namespace std;
typedef unsigned long long timestamp_t;
static timestamp_t
get_timestamp ()
{
struct timeval now;
gettimeofday (&now, NULL);
return now.tv_usec + (timestamp_t)now.tv_sec * 1000000;
}
///The observations
cv_obs * y;
long load_data(char const * szName, cv_obs** y);
double integrand_mean_y(const cv_state&, void*);
double prevY = 0;
int sampleIndex =0;
// double integrand_mean_y(const cv_state&, void*);
// double integrand_var_x(const cv_state&, void*);
double integrand_var_y(const cv_state&, void*);
int main()
{
//Assigning number of particles
long arg = 100;
//Setting up the output file
// string fileNameStr = "100data80.csv";
//ofstream outFile;
//outFile.open (fileNameStr.c_str());
char fileNameStr[100] = "100data80.csv";
FILE* fp = fopen(fileNameStr, "w");
//Number of iterations.
long lIterates = 10; // was argv3
//Assigning number of particles
long lNumber = 100;
//Load observations
load_data("data80.csv", &y);
//Initialise and run the sampler
smc::sampler<cv_state> Sampler(lNumber, SMC_HISTORY_NONE);
smc::moveset<cv_state> Moveset(fInitialise, fMove, NULL);
timestamp_t t0 = get_timestamp();
Sampler.SetResampleParams(SMC_RESAMPLE_RESIDUAL, 0.5);
timestamp_t t1 = get_timestamp();
// cout << "The Set ResampleParams Ex Time" << (t1 - t0) / 1000000.0L <<endl;
t0 = get_timestamp();
Sampler.SetMoveSet(Moveset);
t1 = get_timestamp();
// cout << "The Set Move Set Ex Time" << (t1 - t0) / 1000000.0L <<endl;
t0 = get_timestamp();
Sampler.Initialise();
t1 = get_timestamp();
//cout << "The Initialise Ex Time" << (t1 - t0) / 1000000.0L <<endl;
// Process
double aveIter = 0.0;
double cur = 0.0;
double aveInter = 0.0;
for(int n=1 ; n < lIterates ; ++n) {
// Iterate moves the particles
//Check if ltime is the same as y[lindex].xposition.
//So we can update the index after is used on the particles
t0 = get_timestamp();
Sampler.Iterate();
t1 = get_timestamp();
cur = ((t1 - t0) / 1000000.0L);
// cout << "Iter:" << cur << endl;
aveIter += cur;
double xm,xv,ym,yv;
t0 = get_timestamp();
// xm = Sampler.Integrate(integrand_mean_x,NULL);
// xv = Sampler.Integrate(integrand_var_x, (void*)&xm);
ym = Sampler.Integrate(integrand_mean_y,NULL);
yv = Sampler.Integrate(integrand_var_y, (void*)&ym);
// printf("Cur var ym %f, Prev ym: %f\n", ym, prevY);
// Checking if we reached a sample
//So we can update the index
if ((n) == y[sampleIndex].x_pos){
// printf("The sample index in main %d\n", sampleIndex);
// printf("n: %d, xpos:%f\n",(n), y[sampleIndex].x_pos);
sampleIndex++;
}
prevY = ym;
t1 = get_timestamp();
cur = ((t1 - t0) / 1000000.0L);
aveInter += cur;
// cout << "Inte:" << (t1 - t0) / 1000000.0L <<"\n " << endl;
//cout << "Sample num:"<< n << " "<< ym << ","<< yv << "," << endl;
//outFile << n <<","<<ym << "\n";
fprintf(fp, "%d,%.6f\n", n, ym);
//cout << ym<< ",";
}
//outFile.close();
fclose(fp);
//cout << "Iter Ave"<< aveIter/lIterates <<endl;
//cout << "Itegrate Ave"<< aveInter/lIterates <<endl;
}
long load_data(char const * szName, cv_obs** yp)
{
FILE * fObs = fopen(szName,"rt");
char* szBuffer = new char[1024];
fgets(szBuffer, 1024, fObs);
long lIterates = strtol(szBuffer, NULL, 10);
*yp = new cv_obs[lIterates];
for(long i = 0; i < lIterates; ++i)
{
fgets(szBuffer, 1024, fObs);
(*yp)[i].x_pos = strtod(strtok(szBuffer, ",\r\n "), NULL);
(*yp)[i].y_pos = strtod(strtok(NULL, ",\r\n "), NULL);
printf("y:%f, x:%f \n", (*yp)[i].y_pos, (*yp)[i].x_pos);
}
fclose(fObs);
printf("%s\n","Done with file" );
delete [] szBuffer;
return lIterates;
}
double integrand_mean_y(const cv_state& s, void *)
{
return s.y_pos;
}
double integrand_var_y(const cv_state& s, void* vmy)
{
double* dmy = (double*)vmy;
double d = (s.y_pos - (*dmy));
return d*d;
}
|
[
"csc019@eng.ucsd.edu"
] |
csc019@eng.ucsd.edu
|
3a4cadf2bc66ddb722cb381883e537a4f3e7c83a
|
fd4103e6f5116c776249b00171d8639313f05bc1
|
/Src/PartModelingEngine/PmeExplicitModelObjectReference.cpp
|
405b5471a693605017a5408a784102cf09bb273c
|
[] |
no_license
|
Wanghuaichen/TransCAD
|
481f3b4e54cc066dde8679617a5b32ac2041911b
|
35ca89af456065925984492eb23a0543e3125bb8
|
refs/heads/master
| 2020-03-25T03:54:51.488397
| 2018-06-25T17:38:39
| 2018-06-25T17:38:39
| 143,367,529
| 2
| 1
| null | 2018-08-03T02:30:03
| 2018-08-03T02:30:03
| null |
UTF-8
|
C++
| false
| false
| 571
|
cpp
|
#include "StdAfx.h"
#include ".\pmeexplicitmodelobjectreference.h"
#include ".\PmeExceptionTest.h"
#include ".\PmeArgumentNullException.h"
#include ".\PmeExplicitModelObject.h"
PME_IMPLEMENT_RUNTIME_TYPE(PmeExplicitModelObjectReference, PmeReference)
PmeExplicitModelObjectReference::PmeExplicitModelObjectReference(PmePart * pPart, PmeExplicitModelObject * pObject)
: PmeReference(pPart)
{
PmeThrowExceptionIf<PmeArgumentNullException>(!pObject);
SetReferenceeName(pObject->GetName());
}
PmeExplicitModelObjectReference::~PmeExplicitModelObjectReference(void)
{
}
|
[
"kyk5415@gmail.com"
] |
kyk5415@gmail.com
|
a9ea895d0ab5e1c566dc2fcf20b57393221c2960
|
decefb13f8a603c1f5cc7eb00634b4649915204f
|
/packages/node-mobile/deps/v8/src/inspector/v8-console-message.h
|
cca5b47265f10b32fdfc1ddf587557856185d212
|
[
"BSD-3-Clause",
"Apache-2.0",
"bzip2-1.0.6",
"SunPro",
"LicenseRef-scancode-free-unknown",
"Zlib",
"CC0-1.0",
"ISC",
"LicenseRef-scancode-public-domain",
"ICU",
"MIT",
"LicenseRef-scancode-public-domain-disclaimer",
"Artistic-2.0",
"NTP",
"LicenseRef-scancode-unknown-license-reference",
"BSD-2-Clause",
"LicenseRef-scancode-openssl",
"LicenseRef-scancode-unicode",
"NAIST-2003"
] |
permissive
|
open-pwa/open-pwa
|
f092b377dc6cb04123a16ef96811ad09a9956c26
|
4c88c8520b4f6e7af8701393fd2cedbe1b209e8f
|
refs/heads/master
| 2022-05-28T22:05:19.514921
| 2022-05-20T07:27:10
| 2022-05-20T07:27:10
| 247,925,596
| 24
| 1
|
Apache-2.0
| 2021-08-10T07:38:42
| 2020-03-17T09:13:00
|
C++
|
UTF-8
|
C++
| false
| false
| 4,571
|
h
|
// Copyright 2016 the V8 project 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 V8_INSPECTOR_V8_CONSOLE_MESSAGE_H_
#define V8_INSPECTOR_V8_CONSOLE_MESSAGE_H_
#include <deque>
#include <map>
#include <set>
#include "include/v8.h"
#include "src/inspector/protocol/Console.h"
#include "src/inspector/protocol/Forward.h"
#include "src/inspector/protocol/Runtime.h"
namespace v8_inspector {
class InspectedContext;
class V8InspectorImpl;
class V8InspectorSessionImpl;
class V8StackTraceImpl;
enum class V8MessageOrigin { kConsole, kException, kRevokedException };
enum class ConsoleAPIType {
kLog,
kDebug,
kInfo,
kError,
kWarning,
kDir,
kDirXML,
kTable,
kTrace,
kStartGroup,
kStartGroupCollapsed,
kEndGroup,
kClear,
kAssert,
kTimeEnd,
kCount
};
class V8ConsoleMessage {
public:
~V8ConsoleMessage();
static std::unique_ptr<V8ConsoleMessage> createForConsoleAPI(
v8::Local<v8::Context> v8Context, int contextId, int groupId,
V8InspectorImpl* inspector, double timestamp, ConsoleAPIType,
const std::vector<v8::Local<v8::Value>>& arguments,
const String16& consoleContext, std::unique_ptr<V8StackTraceImpl>);
static std::unique_ptr<V8ConsoleMessage> createForException(
double timestamp, const String16& detailedMessage, const String16& url,
unsigned lineNumber, unsigned columnNumber,
std::unique_ptr<V8StackTraceImpl>, int scriptId, v8::Isolate*,
const String16& message, int contextId, v8::Local<v8::Value> exception,
unsigned exceptionId);
static std::unique_ptr<V8ConsoleMessage> createForRevokedException(
double timestamp, const String16& message, unsigned revokedExceptionId);
V8MessageOrigin origin() const;
void reportToFrontend(protocol::Console::Frontend*) const;
void reportToFrontend(protocol::Runtime::Frontend*, V8InspectorSessionImpl*,
bool generatePreview) const;
ConsoleAPIType type() const;
void contextDestroyed(int contextId);
int estimatedSize() const {
return m_v8Size + static_cast<int>(m_message.length() * sizeof(UChar));
}
private:
V8ConsoleMessage(V8MessageOrigin, double timestamp, const String16& message);
using Arguments = std::vector<std::unique_ptr<v8::Global<v8::Value>>>;
std::unique_ptr<protocol::Array<protocol::Runtime::RemoteObject>>
wrapArguments(V8InspectorSessionImpl*, bool generatePreview) const;
std::unique_ptr<protocol::Runtime::RemoteObject> wrapException(
V8InspectorSessionImpl*, bool generatePreview) const;
void setLocation(const String16& url, unsigned lineNumber,
unsigned columnNumber, std::unique_ptr<V8StackTraceImpl>,
int scriptId);
V8MessageOrigin m_origin;
double m_timestamp;
String16 m_message;
String16 m_url;
unsigned m_lineNumber;
unsigned m_columnNumber;
std::unique_ptr<V8StackTraceImpl> m_stackTrace;
int m_scriptId;
int m_contextId;
ConsoleAPIType m_type;
unsigned m_exceptionId;
unsigned m_revokedExceptionId;
int m_v8Size = 0;
Arguments m_arguments;
String16 m_detailedMessage;
String16 m_consoleContext;
};
class V8ConsoleMessageStorage {
public:
V8ConsoleMessageStorage(V8InspectorImpl*, int contextGroupId);
~V8ConsoleMessageStorage();
int contextGroupId() { return m_contextGroupId; }
const std::deque<std::unique_ptr<V8ConsoleMessage>>& messages() const {
return m_messages;
}
void addMessage(std::unique_ptr<V8ConsoleMessage>);
void contextDestroyed(int contextId);
void clear();
bool shouldReportDeprecationMessage(int contextId, const String16& method);
int count(int contextId, const String16& id);
bool countReset(int contextId, const String16& id);
void time(int contextId, const String16& id);
double timeLog(int contextId, const String16& id);
double timeEnd(int contextId, const String16& id);
bool hasTimer(int contextId, const String16& id);
private:
V8InspectorImpl* m_inspector;
int m_contextGroupId;
int m_estimatedSize = 0;
std::deque<std::unique_ptr<V8ConsoleMessage>> m_messages;
struct PerContextData {
std::set<String16> m_reportedDeprecationMessages;
// Corresponds to https://console.spec.whatwg.org/#count-map
std::map<String16, int> m_count;
// Corresponds to https://console.spec.whatwg.org/#timer-table
std::map<String16, double> m_time;
};
std::map<int, PerContextData> m_data;
};
} // namespace v8_inspector
#endif // V8_INSPECTOR_V8_CONSOLE_MESSAGE_H_
|
[
"frank@lemanschik.com"
] |
frank@lemanschik.com
|
8e2ed737193dc1c910276ec40b59d15828014542
|
63c71060f36866bca4ac27304cef6d5755fdc35c
|
/src/TransServer/Torturer/main.cpp
|
53e83d14d3c229f77caade5c58056868f61cde4b
|
[] |
no_license
|
15831944/barry_dev
|
bc8441cbfbd4b62fbb42bee3dcb79ff7f5fcaf8a
|
d4a83421458aa28ca293caa7a5567433e9358596
|
refs/heads/master
| 2022-03-24T07:00:26.810732
| 2015-12-22T07:19:58
| 2015-12-22T07:19:58
| null | 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 8,696
|
cpp
|
////////////////////////////////////////////////////////////////////////////
//
// Copyright (C) 2005
// Packet Engineering, Inc. All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification is not permitted unless authorized in writing by a duly
// appointed officer of Packet Engineering, Inc. or its derivatives
//
// Description:
// This file is automatically generated by the TorturerGen facility.
//
// Modification History:
// 06/08/2011: Created by Ketty
////////////////////////////////////////////////////////////////////////////
#include "AppMgr/App.h"
#include "Debug/Debug.h"
#include "Porting/Sleep.h"
#include "XmlUtil/XmlTag.h"
#include "TransClient/Tester/main.cpp"
#include "TransServer/Tester/main.cpp"
#include "TransServer/Torturer/TransCheck.h"
#include "Util/OmnNew.h"
#include "util2/global_data.h"
#include <sys/types.h>
#include <signal.h>
#include <sys/wait.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <sys/sem.h>
using namespace std;
union semun
{
int val;
struct semid_ds *buf;
unsigned short *arry;
};
int gAosLogLevel = 5;
char *firstAddr = 0;
char *triesAddr = 0;
char *clientSyncAddr = 0;
char *serverSyncAddr = 0;
int firstAddrSize = 0;
int syncAddrSize = 0;
int semidTries;
int semidClient;
int semidServer;
int semidKillClient;
int semidKillServer;
int semaphoreP(int semid);
int semaphoreV(int semid);
int cltSendConnNum = 5; // change by config
int shareMemConnSize = 0;
u32 totalTransNum = 2000000;
int clientMain(int, char**);
int serverMain(int, char**);
void testStart(int child_client_pid, int child_server_pid, int argc, char **argv);
int redirectOutPut(bool server);
void getSmareMemory(int size, const char* fn, char ** addr);
void semaphore(const char* fn, int &semid);
int status;
// totalNransNum ---(need)--- firstAddrSize
// 4096000 ---(need)--- 4096 * 2000
// 2048000 ---(need)--- 4096 * 1000
int
main(int argc, char **argv)
{
signal(SIGUSR1, AosTransCheckGetSignal);
signal(SIGUSR2, AosTransCheckGetSignal);
int child_client_pid;
int child_server_pid;
const char *cmd = "rm /home/ice/AOS/src/TransClient/Tester/Data/* /home/ice/AOS/src/TransServer/Tester/Data/* server_* client_*";
system(cmd);
cout << "-------------------Parent ID:\t" << getpid() << " -------------" << endl;
// get share memory.
int size = getpagesize();
cout << "------ getpagesize():" << size << endl;
firstAddrSize = size * 1000; // can change.
if(totalTransNum * 2 > (int)firstAddrSize)
{
cout << "--------- share memory is too small!" << endl;
return 0;
}
syncAddrSize = firstAddrSize * 2;
getSmareMemory(firstAddrSize, "a", &firstAddr);
getSmareMemory(size, "b", &triesAddr);
getSmareMemory(syncAddrSize, "c", &clientSyncAddr);
getSmareMemory(syncAddrSize, "d", &serverSyncAddr);
shareMemConnSize = syncAddrSize/cltSendConnNum;
cout << "firstAddr:" << (int)firstAddr
<< "; triesAddr:" << (int)triesAddr
<< "; clientSyncAddr:" << (int)clientSyncAddr
<< "; serverSyncAddr:" << (int)serverSyncAddr << endl;
semaphore("e", semidTries);
semaphore("f", semidClient);
semaphore("g", semidServer);
semaphore("h", semidKillClient);
semaphore("i", semidKillServer);
// start client ans server.
if ((child_server_pid=fork())== 0)
{
cout << "----------------init start server:\t" << getpid() << " -----------" << endl;
redirectOutPut(true);
serverMain(argc, argv);
}
else
{
if ((child_client_pid=fork())== 0)
{
cout << "---------------init start client: \t" << getpid() << " --------" << endl;
redirectOutPut(false);
clientMain(argc, argv);
}
else
{
//testStart(child_client_pid, child_server_pid, argc, argv);
}
}
while(1)
{
wait(&status);
OmnSleep(200);
}
return 0;
}
void
getSmareMemory(int size, const char* fn, char ** addr)
{
int shmid;
key_t key = ftok(fn, 0);
struct shmid_ds dsbuf;
if( (shmid=shmget(key, size, 0664|IPC_CREAT)) < 0 )
{
perror("share memery allocate error!");
exit(1);
}
shmctl(shmid, IPC_STAT, &dsbuf);
*addr = (char*)shmat(shmid, NULL, 0);
if((int)*addr == -1)
{
perror("share memery load error!");
exit(1);
}
memset(*addr, 0, size);
}
void
semaphore(const char* fn, int &semid)
{
//semaphore
key_t key = ftok(fn, 0);
if( (semid=semget(key, 1, 0664|IPC_CREAT)) < 0)
{
perror("semaphore init error!");
exit(1);
}
union semun arg;
arg.val= 1;
if (semctl(semid, 0, SETVAL, arg) < 0 )
{
perror("semaphore reset error!");
exit(1);
}
}
void
testStart(int child_client_pid, int child_server_pid, int argc, char **argv)
{
bool killedClient = false;
bool killedServer = false;
//int num = 30;
//int add = 10;
while(1)
{
int time = rand() % 60 + 20;
//int time = rand() % num + 20;
//num = num + add;
//add = add + 5;
cout << "..........................."
<< "parent sleep:" << time
<< ",to kill Server or client"
<< "..........................."
<< endl;
OmnSleep(time);
int aa = rand() & 0x0001;
//int aa = 0;
if ( aa == 1 && !killedClient)
{
cout << ">>>>>>>>------>>>>>>>>--------killclient:\t"
<< child_client_pid << "(" << getpid() << ")"
<< "------<<<<<<<<<<-----------<<<<<<<<"
<< endl;
//cout << "want kill client lock1" << endl;
semaphoreP(semidKillClient);
kill(child_client_pid, 9);
//cout << "kill client lock1" << endl;
semaphoreV(semidKillClient);
//cout << "kill client unlock1" << endl;
wait(&status);
killedClient = true;
//The possibility of 10 percent to kill server
/*
if((rand()%100) < 10 && !killedServer)
{
cout << ">>>>>>>>>------->>>>>>>>--------killserver(after kill client):\t"
<< child_server_pid << "(" << getpid() << ")"
<< "-----------<<<<<<<<-------------<<<<<<<"
<< endl;
cout << "want kill server lock1" << endl;
semaphoreP(semidKillServer);
kill(child_server_pid, 9);
cout << "kill server lock1" << endl;
semaphoreV(semidKillServer);
cout << "kill server unlock1" << endl;
wait(&status);
killedServer = true;
}
*/
}
else if(!killedServer)
{
cout << ">>>>>>>>--------->>>>>>>>>-------killserver:\t"
<< child_server_pid << "(" << getpid() << ")"
<< "----------<<<<<<<<<<----------<<<<<<<<"
<< endl;
//cout << "want kill server lock2" << endl;
semaphoreP(semidKillServer);
//cout << "kill server lock2" << endl;
kill(child_server_pid, 9);
semaphoreV(semidKillServer);
//cout << "kill server unlock2" << endl;
wait(&status);
killedServer = true;
//The possibility of 10 percent to kill client
/*
if((rand()%100) < 10 && !killedClient)
{
cout << ">>>>>>>>>>---------->>>>>>>>>>>>>>---------killclient(after kill server):\t"
<< child_client_pid << "(" << getpid() << ")"
<< "----------------<<<<<<<<<<<<<<<<<<--------------------<<<<<<<<<<<<"
<< endl;
cout << "want kill client lock2" << endl;
semaphoreP(semidKillClient);
cout << "kill client lock2" << endl;
kill(child_client_pid, 9);
semaphoreV(semidKillClient);
cout << "kill client unlock2" << endl;
wait(&status);
killedClient = true;
}
*/
}
if(killedClient)
{
if ((child_client_pid=fork())== 0)
{
OmnSleep(rand()% 10);
cout << "-----*********------*********--------start client: "
<< getpid()
<< " -----********-------********" << endl;
redirectOutPut(false);
clientMain(argc, argv);
}
killedClient = false;
}
if(killedServer)
{
if ((child_server_pid=fork())== 0)
{
OmnSleep(rand()% 10);
cout << "-----*******-----********----------start server: "
<< getpid()
<< " ----------****-----*********" << endl;
redirectOutPut(true);
serverMain(argc, argv);
}
killedServer = false;
}
}
}
int redirectOutPut(bool server)
{
//return 0;
close(STDOUT_FILENO);
OmnString filename;
if (server)
{
filename = "server_";
}
else
{
filename = "client_";
}
filename << getpid();
int fd = open(filename.data(), O_RDWR|O_CREAT, S_IREAD | S_IWRITE);
int fd2 = dup2(fd, STDOUT_FILENO);
if (fd != fd2)
{
close(fd);
}
return 0;
}
int semaphoreV(int semid)
{
//cout << "v" << (int)pthread_self()<<endl;
struct sembuf sem_b;
sem_b.sem_num = 0;
sem_b.sem_op = 1;
sem_b.sem_flg = SEM_UNDO;
if (semop(semid, &sem_b, 1) == -1)
{
perror("opr v error!");
return -1;
}
return 0;
}
int semaphoreP(int semid)
{
//cout << "p" << (int)pthread_self()<<endl;
struct sembuf sem_b;
sem_b.sem_num = 0;
sem_b.sem_op = -1;
sem_b.sem_flg = SEM_UNDO;
if (semop(semid, &sem_b, 1) == -1)
{
perror("opr p error!");
return -1;
}
return 0;
}
|
[
"barryniu@jimodb.com"
] |
barryniu@jimodb.com
|
d2b805c5b541da1fe386cbe74ab80c0ddc83bcf6
|
7d467aac466f3077f0586b18e9f0fc665b5b6868
|
/example_c/i8086tools/7run/i8086/VM.cpp
|
4479761c44b1470018dadd4aa21c5ed4300e7129
|
[
"LicenseRef-scancode-public-domain-disclaimer"
] |
permissive
|
Bo0km4n/rust-disassembler-x86-8086
|
b443525a59b0024c763954331af1f1dd534dcd4f
|
64de7149fc036c6d4c21731ba0aa68a4d18ad099
|
refs/heads/master
| 2020-04-09T04:44:13.245341
| 2019-02-27T07:09:10
| 2019-02-27T07:09:10
| 160,034,490
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 3,988
|
cpp
|
#include "VM.h"
#include "disasm.h"
#include "regs.h"
#include <stdio.h>
#include <string.h>
#include <sys/stat.h>
using namespace i8086;
const char *i8086::header = " AX BX CX DX SP BP SI DI FLAGS IP\n";
bool VM::ptable[256];
void VM::showHeader() {
fprintf(stderr, header);
}
void VM::debug(uint16_t ip, const OpCode &op) {
debugsym(ip);
fprintf(stderr,
"%04x %04x %04x %04x %04x %04x %04x %04x %c%c%c%c %04x:%-12s %s",
r[0], r[3], r[1], r[2], r[4], r[5], r[6], r[7],
"-O"[OF], "-S"[SF], "-Z"[ZF], "-C"[CF],
ip, hexdump(text + ip, op.len).c_str(), op.str().c_str());
if (trace >= 3) {
int ad1 = addr(op.opr1);
int ad2 = addr(op.opr2);
if (ad1 >= 0) {
if (op.opr1.w)
fprintf(stderr, " ;[%04x]%04x", ad1, read16(ad1));
else
fprintf(stderr, " ;[%04x]%02x", ad1, read8(ad1));
}
if (ad2 >= 0) {
if (op.opr2.w)
fprintf(stderr, " ;[%04x]%04x", ad2, read16(ad2));
else
fprintf(stderr, " ;[%04x]%02x", ad2, read8(ad2));
}
}
fprintf(stderr, "\n");
}
static bool initialized;
void VM::init() {
if (!initialized) {
for (int i = 0; i < 256; i++) {
int n = 0;
for (int j = 1; j < 256; j += j) {
if (i & j) n++;
}
ptable[i] = (n & 1) == 0;
}
initialized = true;
}
uint16_t tmp = 0x1234;
uint8_t *p = (uint8_t *) r;
if (*(uint8_t *) & tmp == 0x34) {
for (int i = 0; i < 4; i++) {
r8[i] = p + i * 2;
r8[i + 4] = r8[i] + 1;
}
} else {
for (int i = 0; i < 4; i++) {
r8[i] = p + i * 2 + 1;
r8[i + 4] = r8[i] - 1;
}
}
}
VM::VM() : IP(0), start_sp(0) {
init();
memset(r, 0, sizeof (r));
OF = DF = SF = ZF = AF = PF = CF = false;
}
VM::VM(const VM &vm) : VMBase(vm) {
init();
memcpy(r, vm.r, sizeof (r));
IP = vm.IP;
OF = vm.OF;
DF = vm.DF;
SF = vm.SF;
ZF = vm.ZF;
AF = vm.AF;
PF = vm.PF;
CF = vm.CF;
start_sp = vm.start_sp;
}
VM::~VM() {
}
bool VM::load(const std::string& fn, FILE* f, size_t size) {
if (!VMBase::load(fn, f, size)) return false;
IP = 0;
return true;
}
int VM::addr(const Operand &opr) {
switch (opr.type) {
case Ptr: return uint16_t(opr.value);
case ModRM + 0: return uint16_t(BX + SI + opr.value);
case ModRM + 1: return uint16_t(BX + DI + opr.value);
case ModRM + 2: return uint16_t(BP + SI + opr.value);
case ModRM + 3: return uint16_t(BP + DI + opr.value);
case ModRM + 4: return uint16_t(SI + opr.value);
case ModRM + 5: return uint16_t(DI + opr.value);
case ModRM + 6: return uint16_t(BP + opr.value);
case ModRM + 7: return uint16_t(BX + opr.value);
}
return -1;
}
void VM::run2() {
while (!hasExited) run1();
}
void VM::disasm() {
int addr = 0, undef = 0;
while (addr < (int) tsize) {
showsym(addr);
OpCode op = disasm1(text, addr, tsize);
disout(text, addr, op.len, disstr(op));
if (op.undef()) undef++;
addr += op.len;
}
if (undef) printf("undefined: %d\n", undef);
}
std::string VM::disstr(const OpCode &op) {
std::string ret = op.str();
if (op.opr1.type == Addr) {
std::map<int, Symbol>::iterator it = syms[1].find(op.opr1.value);
if (it != syms[1].end()) {
ret += " ; " + it->second.name;
}
}
if (op.opr2.type == Addr) {
std::map<int, Symbol>::iterator it = syms[1].find(op.opr2.value);
if (it != syms[1].end()) {
ret += " ; " + it->second.name;
}
}
return ret;
}
|
[
"pokopenkatuya@gmail.com"
] |
pokopenkatuya@gmail.com
|
21c901ae498642254ba5e2281c4ba5851f75dc3d
|
40a068ffc3ee07c337a61f2029d1e727f4e5179d
|
/codechef/SeptemberCookOff/1.cpp
|
9239a6bddbdc75522e9202a27b7ff33ae8e50e41
|
[] |
no_license
|
Sayak7D1/Competitive-programming
|
1b67624a25c6836425eae7795f7566729ba75491
|
99fb1d86719f8d897523e935b32d2374f24ea46d
|
refs/heads/main
| 2022-12-26T13:39:23.676494
| 2020-10-02T14:08:26
| 2020-10-02T14:08:26
| 300,334,633
| 0
| 2
| null | 2020-10-02T14:08:28
| 2020-10-01T15:48:12
|
C++
|
UTF-8
|
C++
| false
| false
| 543
|
cpp
|
#include<bits/stdc++.h>
using namespace std;
int main(){
int t;
cin >> t;
for(t;t>0;t--){
int n,k,l;
cin >>n >>k >>l;
if(n!=1&&k==1){
cout<<-1<<'\n';
continue;
}
if((float)((float)n/(float)k) > l){
cout<<-1<<'\n';
continue;
}
int over=n;
int player=1;
while(over!=0){
cout<<player++<<' ';
if(player>k) player=1;
over--;
}
cout<<'\n';
}
return 0;
}
|
[
"noreply@github.com"
] |
Sayak7D1.noreply@github.com
|
fb8c721eb5e2be8f76b0d1292f050eb8e9068281
|
c397bb468d86f000868fee4fdbe288ceb5994420
|
/inc/ToGraphvizWriter.h
|
b9fee989b9e9ded84f71040346fb8463812fc8e3
|
[
"MIT"
] |
permissive
|
dueringa/WikiWalker
|
41cc83a43a3d01e4d245ba5d6d2d9a572a8077d2
|
24a83936efac1e217af949275b0677861c216957
|
refs/heads/master
| 2021-01-19T06:27:50.719969
| 2018-04-19T18:40:03
| 2018-04-19T18:40:03
| 87,462,913
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 968
|
h
|
//! \file ToGraphvizWriter.h
#ifndef WIKIWALKER_TOGRAPHVIZWRITER_H
#define WIKIWALKER_TOGRAPHVIZWRITER_H
#include "DataOutputBase.h"
namespace WikiWalker
{
/*! Writing to a file in dot format
*/
class ToGraphvizWriter : public DataOutputBase
{
public:
/*! output an article with links in dot format to a stream
* \param a reference to article to be output
* \param os out stream to putput to
* YOU are responsible for opening and closing the stream
*/
void output(const Article* a, std::ostream& os) override;
/*! output an article collection in dot format to a stream
* \param ac reference to article collection to be output
* \param os out stream to putput to
* YOU are responsible for opening and closing the stream
*/
void output(const CollectionUtils::ArticleCollection& ac,
std::ostream& os) override;
};
} // namespace WikiWalker
#endif // WIKIWALKER_TOGRAPHVIZWRITER_H
|
[
"github@duering-andreas.de"
] |
github@duering-andreas.de
|
a0cfdbd885ff700f32a744e07d2bab2b63d368a4
|
844969bd953d7300f02172c867725e27b518c08e
|
/SDK/ShantyCategory_functions.cpp
|
4a4a004535e141155449eeed76ec1b6f53ce3138
|
[] |
no_license
|
zanzo420/SoT-Python-Offset-Finder
|
70037c37991a2df53fa671e3c8ce12c45fbf75a5
|
d881877da08b5c5beaaca140f0ab768223b75d4d
|
refs/heads/main
| 2023-07-18T17:25:01.596284
| 2021-09-09T12:31:51
| 2021-09-09T12:31:51
| 380,604,174
| 0
| 0
| null | 2021-06-26T22:07:04
| 2021-06-26T22:07:03
| null |
UTF-8
|
C++
| false
| false
| 544
|
cpp
|
// Name: SoT, Version: 2.2.1.1
#include "../pch.h"
/*!!DEFINE!!*/
/*!!HELPER_DEF!!*/
/*!!HELPER_INC!!*/
#ifdef _MSC_VER
#pragma pack(push, 0x01)
#endif
namespace CG
{
//---------------------------------------------------------------------------
// Functions
//---------------------------------------------------------------------------
void UShantyCategory_C::AfterRead()
{
UShantyCategory::AfterRead();
}
void UShantyCategory_C::BeforeDelete()
{
UShantyCategory::BeforeDelete();
}
}
#ifdef _MSC_VER
#pragma pack(pop)
#endif
|
[
"51171051+DougTheDruid@users.noreply.github.com"
] |
51171051+DougTheDruid@users.noreply.github.com
|
50c99ec7e4f4a8c72c92ed7c397ccfa6669635e9
|
ab1712d65f8510a705a1f28064e4d3fc5a48cf64
|
/SDK/SoT_BP_Island_Bell_classes.hpp
|
efbe33ec53adab37c2798027939c2f061fce1ff8
|
[] |
no_license
|
zk2013/SoT-SDK
|
577f4e26ba969c3fa21a9191a210afc116a11dba
|
04eb22c1c31aaa4d5cf822b0a816786c99e3ea2f
|
refs/heads/master
| 2020-05-29T20:06:57.165354
| 2019-05-29T16:46:51
| 2019-05-29T16:46:51
| null | 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 671
|
hpp
|
#pragma once
// Sea of Thieves (2.0) SDK
#ifdef _MSC_VER
#pragma pack(push, 0x8)
#endif
#include "SoT_BP_Island_Bell_structs.hpp"
namespace SDK
{
//---------------------------------------------------------------------------
//Classes
//---------------------------------------------------------------------------
// BlueprintGeneratedClass BP_Island_Bell.BP_Island_Bell_C
// 0x0000 (0x0640 - 0x0640)
class ABP_Island_Bell_C : public ABell
{
public:
static UClass* StaticClass()
{
static auto ptr = UObject::FindObject<UClass>(_xor_("BlueprintGeneratedClass BP_Island_Bell.BP_Island_Bell_C"));
return ptr;
}
};
}
#ifdef _MSC_VER
#pragma pack(pop)
#endif
|
[
"igromanru@yahoo.de"
] |
igromanru@yahoo.de
|
d59f1fb42f19dbb4fb8538f4db26c4dd227cb718
|
34488d45dbf546ff1e804452c250fc885e7e13fb
|
/practices/cpp/level1/p03_SafeArray/safeArray.cpp
|
48129f3f90a210a7de6defa61e653497ba2309e9
|
[] |
no_license
|
mufengjun260/CCpp2016
|
cc58bb2ff3d25be53ea74e752ef8200d1d7ab10a
|
c23b80e079f95980bc76923f0f2a6b235bd93f59
|
refs/heads/master
| 2020-12-25T16:47:37.350747
| 2016-05-03T15:19:33
| 2016-05-03T15:19:33
| 52,486,087
| 0
| 0
| null | 2016-02-25T01:03:12
| 2016-02-25T01:03:12
| null |
UTF-8
|
C++
| false
| false
| 467
|
cpp
|
#include "safeArray.h"
#include <iostream>
using namespace std;
SafeArray::SafeArray(int cap)
{
data = new int[cap];
size = cap;
}
int SafeArray::get(int location) {
if (location > size) {
std::cout << "outOfSize!!!" << std::endl;
}
else {
return data[location];
}
}
void SafeArray::set(int location, int num) {
if (location > size) {
std::cout << "outOfSize!!!" << std::endl;
return;
}
else {
data[location] = num;
}
}
|
[
"穆逢君"
] |
穆逢君
|
0318c4dc3ed3c79e8e5309b5bd08de17b7560d37
|
be21a6670509b53504a0422e2b781becc0deee83
|
/Applications/DaftEngineApp/src/Widgets/SettingWidgets/SettingWidget.cpp
|
613d88fdc4f9e20d3e02a953c2c24eec57987616
|
[
"MIT"
] |
permissive
|
DaftMat/Daft-Engine
|
ff216723c682a68abe0363059072c830ea003a8c
|
e3d918b4b876d17abd889b9b6b13bd858a079538
|
refs/heads/master
| 2021-07-23T22:33:09.934433
| 2020-12-25T18:00:49
| 2020-12-25T18:00:49
| 277,404,325
| 1
| 0
|
MIT
| 2020-12-25T18:00:50
| 2020-07-06T00:06:12
|
C++
|
UTF-8
|
C++
| false
| false
| 1,924
|
cpp
|
//
// Created by mathis on 12/07/2020.
//
#include "SettingWidget.hpp"
#include <QApplication>
#include <QDesktopWidget>
#include <QtWidgets/QLabel>
namespace daft::app {
SettingWidget::SettingWidget(DrawableSettings *settings, TransformSettings *transforms, std::string name,
float exposure, QWidget *parent)
: QScrollArea(parent), m_settings{settings}, m_transforms{transforms} {
std::string pname;
if (m_settings == nullptr && m_transforms == nullptr) {
pname = "Scene settings";
core::SettingManager sm;
sm.add("Exposure", exposure);
m_settings = std::make_unique<DrawableSettings>(sm);
m_settings->addDoubleSpinBox("Exposure", 0.01, 999.9, 0.1);
} else
pname = std::move(name);
m_title = new QLabel(pname.c_str());
m_title->setObjectName("sectionTitle");
createWidgets();
if (m_settings != nullptr) connect(m_settings.get(), SIGNAL(updateEvent()), this, SLOT(on_updateEvent()));
if (m_transforms != nullptr) connect(m_transforms.get(), SIGNAL(updateEvent()), this, SLOT(on_updateEvent()));
}
void SettingWidget::setTitle(const std::string &name) { m_title->setText(name.c_str()); }
void SettingWidget::on_updateEvent() { createWidgets(); }
void SettingWidget::createWidgets() {
m_layout = std::make_unique<QVBoxLayout>();
m_layout->setMargin(1);
m_layout->addWidget(m_title);
if (m_settings != nullptr) m_layout->addWidget(m_settings.get());
if (m_transforms != nullptr) m_layout->addWidget(m_transforms.get());
auto widget = new QWidget;
widget->setLayout(m_layout.get());
setWidget(widget);
auto screenWidth = float(QApplication::desktop()->screenGeometry().width());
setMinimumWidth(int(screenWidth / 5.5f));
setObjectName("settingWidget");
setSizePolicy(QSizePolicy::Policy::Preferred, QSizePolicy::Policy::Preferred);
}
} // namespace daft::app
|
[
"mathis.margot98@gmail.com"
] |
mathis.margot98@gmail.com
|
5746890ba09a04eb0e49fe2c4a82a909efa018e9
|
5775eb2150996990318bec38c79d59dfa2c562bc
|
/sprout/compost/formats/as_imag.hpp
|
b2b698005ec5b8f0eab392d84e1fc45ef9b02f22
|
[
"BSL-1.0"
] |
permissive
|
horance-liu/Sprout
|
6e1e396db9e27fbc83da41270c96412cced5a767
|
8274f34db498b02bff12277bac5416ea72e018cd
|
refs/heads/master
| 2020-04-05T14:47:12.706952
| 2018-05-29T14:09:43
| 2018-05-29T14:09:43
| null | 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 1,814
|
hpp
|
/*=============================================================================
Copyright (c) 2011-2017 Bolero MURAKAMI
https://github.com/bolero-MURAKAMI/Sprout
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 SPROUT_COMPOST_FORMATS_AS_IMAG_HPP
#define SPROUT_COMPOST_FORMATS_AS_IMAG_HPP
#include <utility>
#include <sprout/config.hpp>
#include <sprout/complex.hpp>
#include <sprout/utility/forward.hpp>
#include <sprout/range/adaptor/transformed.hpp>
namespace sprout {
namespace compost {
//
// to_imag_value
//
struct to_imag_value {
public:
template<typename Complex>
SPROUT_CONSTEXPR decltype(imag(std::declval<Complex const&>())) operator()(Complex const& x) const {
return imag(x);
}
};
namespace formats {
//
// as_imag_forwarder
//
class as_imag_forwarder {};
//
// as_imag
//
namespace {
SPROUT_STATIC_CONSTEXPR sprout::compost::formats::as_imag_forwarder as_imag = {};
} // anonymous-namespace
//
// operator|
//
template<typename Range>
inline SPROUT_CONSTEXPR auto
operator|(Range&& lhs, sprout::compost::formats::as_imag_forwarder const&)
-> decltype(
SPROUT_FORWARD(Range, lhs)
| sprout::adaptors::transformed(sprout::compost::to_imag_value())
)
{
return SPROUT_FORWARD(Range, lhs)
| sprout::adaptors::transformed(sprout::compost::to_imag_value())
;
}
} // namespace formats
using sprout::compost::formats::as_imag;
} // namespace compost
} // namespace sprout
#endif // #ifndef SPROUT_COMPOST_FORMATS_AS_IMAG_HPP
|
[
"bolero.murakami@gmail.com"
] |
bolero.murakami@gmail.com
|
2fa072836a1ca64e67e0cbf4aeca487c507a8c27
|
55de3adb94c4dab6bd9cc6f7dabc34c614841d15
|
/Day1/SocialNetwork(easy).cpp
|
1554fcfaa6a9af5c524f7a7e740b0eb662c2ce27
|
[] |
no_license
|
Jyotishman-Ghatak/Daily-Competitive-Coding
|
ad4f8615b0e8c788ba28a9ef4d60fe8766b2b079
|
5dcbf11d056d0d9975657764ce9066dc50b38dcf
|
refs/heads/master
| 2023-01-19T03:25:02.187543
| 2020-11-27T20:49:40
| 2020-11-27T20:49:40
| 315,717,771
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 460
|
cpp
|
#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;
int main(){
vector <int> a;
long long n,k,p;
cin>>n>>k;
for(long long i=0;i<n;i++){
cin>>p;
if(find(a.begin(),a.end(),p)==a.end()){
if(int(a.size())>=k){
a.pop_back();
}
a.insert(a.begin(),p);
}
}
cout<<a.size()<<endl;
for(long long i=0;i<a.size();i++){
cout<<a[i]<<" ";
}
}
|
[
"jyotish.tubai@gmail.com"
] |
jyotish.tubai@gmail.com
|
ea128e0d54bf1350c1f23988496ab126391bb97e
|
56f431ac8061ddb4c45b32457b0f948d1029d98f
|
/MonoNative.Tests/mscorlib/System/Runtime/CompilerServices/mscorlib_System_Runtime_CompilerServices_CompilerMarshalOverride_Fixture.cpp
|
b169bebf2f7fe7403157c9b6a408afc9b832e0e7
|
[
"BSD-2-Clause"
] |
permissive
|
brunolauze/MonoNative
|
886d2a346a959d86e7e0ff68661be1b6767c5ce6
|
959fb52c2c1ffe87476ab0d6e4fcce0ad9ce1e66
|
refs/heads/master
| 2016-09-15T17:32:26.626998
| 2016-03-01T17:55:27
| 2016-03-01T17:55:27
| 22,582,991
| 12
| 1
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 679
|
cpp
|
// Mono Native Fixture
// Assembly: mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089
// Namespace: System.Runtime.CompilerServices
// Name: CompilerMarshalOverride
// C++ Typed Name: mscorlib::System::Runtime::CompilerServices::CompilerMarshalOverride
#include <gtest/gtest.h>
#include <mscorlib/System/Runtime/CompilerServices/mscorlib_System_Runtime_CompilerServices_CompilerMarshalOverride.h>
#include <mscorlib/System/mscorlib_System_Type.h>
#include <mscorlib/System/mscorlib_System_String.h>
namespace mscorlib
{
namespace System
{
namespace Runtime
{
namespace CompilerServices
{
//Public Methods Tests
}
}
}
}
|
[
"brunolauze@msn.com"
] |
brunolauze@msn.com
|
bc0fb9bbfd516fc6834469853e0a3dffc636198b
|
9f48878caa37ac5f2ccf938fc476efa47c89c644
|
/tests/Unit/PointwiseFunctions/AnalyticData/Test_AnalyticData.cpp
|
e600ed6da48de0ff37875ba9bf6b2c0824e5fdd2
|
[
"MIT"
] |
permissive
|
sxs-collaboration/spectre
|
34f7733ab4c75dbca2f432028145fed110c9ef24
|
96f573cf158201f712da2bfb3378edf497a35a0d
|
refs/heads/develop
| 2023-08-19T11:18:18.465609
| 2023-08-19T04:24:25
| 2023-08-19T04:24:25
| 87,570,510
| 149
| 190
|
NOASSERTION
| 2023-09-14T20:10:35
| 2017-04-07T17:28:20
|
C++
|
UTF-8
|
C++
| false
| false
| 901
|
cpp
|
// Distributed under the MIT License.
// See LICENSE.txt for details.
#include "PointwiseFunctions/AnalyticData/AnalyticData.hpp"
#include "PointwiseFunctions/AnalyticSolutions/AnalyticSolution.hpp"
namespace {
struct AnalyticData : public MarkAsAnalyticData {};
struct Solution : public MarkAsAnalyticSolution {};
struct SolutionDependentAnalyticData : public MarkAsAnalyticData,
private Solution {};
static_assert(is_analytic_data_v<AnalyticData>,
"Failed testing is_analytic_data_v");
static_assert(is_analytic_data_v<SolutionDependentAnalyticData>,
"Failed testing is_analytic_data_v");
static_assert(is_analytic_data<AnalyticData>::value,
"Failed testing is_analytic_data");
static_assert(is_analytic_data<SolutionDependentAnalyticData>::value,
"Failed testing is_analytic_data");
} // namespace
|
[
"nils@nilsdeppe.com"
] |
nils@nilsdeppe.com
|
beeb3f5f2cd104cd4be716de52e61b8398aad435
|
81d1c11616c321a3aeae92b588f0ba59c635080d
|
/walk_hls/hlsinput.h
|
6e190e844658dc192b37bce1674a2a9754708fb5
|
[] |
no_license
|
porjo/libdvbtee
|
818aef46de6b7569f1f02e125466c449367f57c6
|
0e6b6cdda4786f075605567f34e757efe8898410
|
refs/heads/master
| 2021-01-14T08:55:04.075039
| 2014-02-06T04:55:38
| 2014-02-06T04:55:59
| null | 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 1,210
|
h
|
/*****************************************************************************
* Copyright (C) 2013 Michael Krufky
*
* Author: Michael Krufky <mkrufky@linuxtv.org>
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* version 2 as published by the Free Software Foundation.
*
* This library 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, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*
*****************************************************************************/
#ifndef HLSINPUT_H
#define HLSINPUT_H
#include "feed.h"
class hlsinput
{
public:
explicit hlsinput(bool feed_stdout = false);
bool get(const char *url);
private:
bool b_stdout;
feed feeder;
static void write_feed(void *context, void *buffer, size_t size, size_t nmemb);
};
#endif // HLSINPUT_H
|
[
"mkrufky@linuxtv.org"
] |
mkrufky@linuxtv.org
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.