hexsha stringlengths 40 40 | size int64 7 1.05M | ext stringclasses 13 values | lang stringclasses 1 value | max_stars_repo_path stringlengths 4 269 | max_stars_repo_name stringlengths 5 109 | max_stars_repo_head_hexsha stringlengths 40 40 | max_stars_repo_licenses listlengths 1 9 | max_stars_count int64 1 191k ⌀ | max_stars_repo_stars_event_min_datetime stringlengths 24 24 ⌀ | max_stars_repo_stars_event_max_datetime stringlengths 24 24 ⌀ | max_issues_repo_path stringlengths 4 269 | max_issues_repo_name stringlengths 5 116 | max_issues_repo_head_hexsha stringlengths 40 40 | max_issues_repo_licenses listlengths 1 9 | max_issues_count int64 1 48.5k ⌀ | max_issues_repo_issues_event_min_datetime stringlengths 24 24 ⌀ | max_issues_repo_issues_event_max_datetime stringlengths 24 24 ⌀ | max_forks_repo_path stringlengths 4 269 | max_forks_repo_name stringlengths 5 116 | max_forks_repo_head_hexsha stringlengths 40 40 | max_forks_repo_licenses listlengths 1 9 | max_forks_count int64 1 105k ⌀ | max_forks_repo_forks_event_min_datetime stringlengths 24 24 ⌀ | max_forks_repo_forks_event_max_datetime stringlengths 24 24 ⌀ | content stringlengths 7 1.05M | avg_line_length float64 1.21 330k | max_line_length int64 6 990k | alphanum_fraction float64 0.01 0.99 | author_id stringlengths 2 40 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
984743eb1d9401ed2994b7146a29fcb0f743dbfc | 464 | cpp | C++ | Bots/DiversifyBot/DiversifyBot.cpp | Skibisky/InvestorBadness | 44f3a7477e83d5c53be10bc5a8ad537b06a78c81 | [
"MIT"
] | null | null | null | Bots/DiversifyBot/DiversifyBot.cpp | Skibisky/InvestorBadness | 44f3a7477e83d5c53be10bc5a8ad537b06a78c81 | [
"MIT"
] | null | null | null | Bots/DiversifyBot/DiversifyBot.cpp | Skibisky/InvestorBadness | 44f3a7477e83d5c53be10bc5a8ad537b06a78c81 | [
"MIT"
] | null | null | null | #include "DiversifyBot.h"
void DiversifyBot::Turn(std::vector<Contribution*> avail, int pts)
{
// point a point in every project
for each(auto inv in avail)
{
if (pts <= 0)
break;
if (inv->oldContrib == 0)
{
inv->myContrib++;
pts--;
}
}
// dump remaining points in projects we aren't even 5th in
for each(auto inv in avail)
{
if (inv->myRank > 5 && inv->contribs()[4] - inv->oldContrib < 3)
{
inv->myContrib++;
pts--;
}
}
}
| 16.571429 | 66 | 0.601293 | Skibisky |
9847b620b70486452d2670c88c88ef6015eda648 | 681 | hpp | C++ | school/TimeOfDay.hpp | Biyorne/learningcpp | bcf963990800ed939fa4cc1b30fadccaf098155b | [
"MIT"
] | null | null | null | school/TimeOfDay.hpp | Biyorne/learningcpp | bcf963990800ed939fa4cc1b30fadccaf098155b | [
"MIT"
] | null | null | null | school/TimeOfDay.hpp | Biyorne/learningcpp | bcf963990800ed939fa4cc1b30fadccaf098155b | [
"MIT"
] | null | null | null | #ifndef SCHOOL_TIMEOFDAY_HPP_INCLUDED
#define SCHOOL_TIMEOFDAY_HPP_INCLUDED
#include <string>
namespace school
{
class TimeOfDay
{
public:
TimeOfDay(const int HOUR, const int MINUTE, const int SECOND);
int hour() const { return m_hour; }
int minute() const { return m_minute; }
int second() const { return m_second; }
std::string toString() const;
private:
int m_hour;
int m_minute;
int m_second;
};
bool operator==(const TimeOfDay & L, const TimeOfDay & R);
bool operator!=(const TimeOfDay & L, const TimeOfDay & R);
} // namespace school
#endif // SCHOOL_TIMEOFDAY_HPP_INCLUDED
| 21.28125 | 70 | 0.646109 | Biyorne |
984efefea7490c13b4069012e9cc4a8de4e67e0e | 1,611 | cpp | C++ | CPP_US/src/Engine/Camera.cpp | Basher207/Unity-style-Cpp-engine | 812b0be2c61aea828cfd8c6d6f06f2cf6e889661 | [
"MIT"
] | null | null | null | CPP_US/src/Engine/Camera.cpp | Basher207/Unity-style-Cpp-engine | 812b0be2c61aea828cfd8c6d6f06f2cf6e889661 | [
"MIT"
] | null | null | null | CPP_US/src/Engine/Camera.cpp | Basher207/Unity-style-Cpp-engine | 812b0be2c61aea828cfd8c6d6f06f2cf6e889661 | [
"MIT"
] | null | null | null | #include <glm/vec3.hpp>
#include <glm/vec4.hpp>
#include <glm/mat4x4.hpp>
#include <glm/gtc/matrix_transform.hpp>
#include <glm/gtx/transform.hpp>
#include <glm/gtx/rotate_vector.hpp>
#include <glm/gtx/vector_angle.hpp>
#include <glm/gtc/type_ptr.hpp>
#include <stdio.h>
#include "GameObject.hpp"
#include "Transform.hpp"
#include "glad.h"
#include "Camera.hpp"
//Allocating memory for the singleton
Camera* Camera::mainCamera;
Camera* Camera::StartCamera () {
if (!Camera::mainCamera) {//If camera is already started dont create a new one
GameObject* camObject = new GameObject(); //Create a new GameObject to hold the camera
camObject->AddComponent<Camera>(); //Add a camera MonoBehavior to the camObject, and stors it in the mainCamera singlton
}
return mainCamera; //Return the mainCamera
}
void Camera::Awake () {
mainCamera = this; //On camera object Awake, stores itself as the camera singlton
}
void Camera::Render () {
glPushMatrix(); //Pushes the matrix in preperations for rendering
// glMultMatrix takes in a float* to a matrix array
// glm::value_ptr returns such a pointer
glMultMatrixf(glm::value_ptr(this->perspective_mat));
//Turns the quaternion rotation into a matrix for multiplications
glm::mat4x4 rotation = glm::mat4_cast(transform->localRotation);
glMultMatrixf(glm::value_ptr(rotation));
//Translates the camera by it's position
glTranslatef (-this->transform->localPos.x,-this->transform->localPos.y,-this->transform->localPos.z);
//Start rendering all transforms.
Transform::RenderMasterParents();
glPopMatrix();//Pop the matrix
} | 33.5625 | 122 | 0.740534 | Basher207 |
9852d984a8e6a1d79f9c535944a64b9567edef84 | 4,887 | hpp | C++ | include/tudocomp/compressors/lz_pointer_jumping/PointerJumping.hpp | 421408/tudocomp | 9634742393995acdde148b0412f083bfdd0fbe9f | [
"ECL-2.0",
"Apache-2.0"
] | 1 | 2020-09-22T11:29:02.000Z | 2020-09-22T11:29:02.000Z | include/tudocomp/compressors/lz_pointer_jumping/PointerJumping.hpp | 421408/tudocomp | 9634742393995acdde148b0412f083bfdd0fbe9f | [
"ECL-2.0",
"Apache-2.0"
] | null | null | null | include/tudocomp/compressors/lz_pointer_jumping/PointerJumping.hpp | 421408/tudocomp | 9634742393995acdde148b0412f083bfdd0fbe9f | [
"ECL-2.0",
"Apache-2.0"
] | 1 | 2020-09-29T08:57:13.000Z | 2020-09-29T08:57:13.000Z | #pragma once
#include <unordered_map>
#include <array>
#include <tudocomp/compressors/lz_common/factorid_t.hpp>
namespace tdc {namespace lz_pointer_jumping {
static constexpr bool PRINT_DEBUG_TRANSITIONS = false;
template<typename pj_trie_t>
class PointerJumping: public pj_trie_t {
using jump_buffer_handle = typename pj_trie_t::jump_buffer_handle;
public:
using lz_state_t = typename pj_trie_t::lz_state_t;
using traverse_state_t = typename pj_trie_t::traverse_state_t;
using factorid_t = lz_common::factorid_t;
inline PointerJumping(lz_state_t& lz_state, size_t jump_width):
pj_trie_t(jump_width),
m_lz_state(lz_state),
m_jump_width(jump_width),
m_jump_buffer_handle(this->get_working_buffer())
{}
inline uliteral_t& jump_buffer(size_t i) {
DCHECK_LT(i, m_jump_width);
return this->get_buffer(m_jump_buffer_handle)[i];
}
inline uliteral_t const& jump_buffer(size_t i) const {
DCHECK_LT(i, m_jump_width);
return this->get_buffer(m_jump_buffer_handle)[i];
}
inline factorid_t jump_buffer_parent_node() const {
return this->get_parent_node(m_jump_buffer_handle);
}
inline size_t jump_buffer_size() const {
return m_jump_buffer_size;
}
struct action_t {
bool m_was_full;
typename pj_trie_t::result_t m_result;
inline bool buffer_full_and_found() const {
return m_was_full && m_result.found();
}
inline bool buffer_full_and_not_found() const {
return m_was_full && (!m_result.found());
}
inline traverse_state_t traverse_state() const {
DCHECK(buffer_full_and_found());
return m_result.get();
}
};
inline action_t on_insert_char(uliteral_t c) {
DCHECK_LT(m_jump_buffer_size, m_jump_width);
jump_buffer(m_jump_buffer_size) = c;
m_jump_buffer_size++;
if(jump_buffer_full()) {
auto entry = find_jump_buffer();
if (entry.found()) {
debug_transition(std::cout, entry.get(), false);
}
return action_t { true, entry };
} else {
debug_open_transition(std::cout);
return action_t { false, typename pj_trie_t::result_t() };
}
}
inline void shift_buffer(size_t elements) {
factorid_t parent_node = current_lz_node_id();
size_t remaining = m_jump_width - elements;
for(size_t i = 0; i < remaining; i++) {
jump_buffer(i) = jump_buffer(i + elements);
}
m_jump_buffer_size -= elements;
this->set_parent_node(m_jump_buffer_handle, parent_node);
debug_open_transition(std::cout);
}
inline void reset_buffer() {
factorid_t parent_node = current_lz_node_id();
m_jump_buffer_size = 0;
this->set_parent_node(m_jump_buffer_handle, parent_node);
debug_open_transition(std::cout);
}
inline bool jump_buffer_full() const {
return m_jump_width == m_jump_buffer_size;
}
inline auto find_jump_buffer() const {
return this->find(m_jump_buffer_handle);
}
inline void insert_jump_buffer(traverse_state_t const& val) {
debug_transition(std::cout, val, true);
this->insert(m_jump_buffer_handle, val);
}
// DEBUG printing function
inline void debug_print_buffer(std::ostream& out, jump_buffer_handle const& handle, size_t size) const {
if (!PRINT_DEBUG_TRANSITIONS) return;
for(size_t i = 0; i < size; i++) {
out << this->get_buffer(handle)[i];
}
}
inline void debug_print_buffer(std::ostream& out) const {
if (!PRINT_DEBUG_TRANSITIONS) return;
debug_print_buffer(out, m_jump_buffer_handle, m_jump_buffer_size);
}
inline void debug_open_transition(std::ostream& out) const {
if (!PRINT_DEBUG_TRANSITIONS) return;
factorid_t parent_node = jump_buffer_parent_node();
out << "(" << parent_node << ") -[";
debug_print_buffer(out);
out << "..." << std::endl;
}
inline void debug_transition(std::ostream& out, traverse_state_t const& to, bool is_new) const {
if (!PRINT_DEBUG_TRANSITIONS) return;
factorid_t parent_node = jump_buffer_parent_node();
out << "(" << parent_node << ") -[";
debug_print_buffer(out);
out << "]-> (" << m_lz_state.get_node(to).id() << ")" ;
if (is_new) {
out << "*";
}
out << std::endl;
}
private:
lz_state_t& m_lz_state;
size_t m_jump_width;
jump_buffer_handle m_jump_buffer_handle;
size_t m_jump_buffer_size = 0;
inline factorid_t current_lz_node_id() const {
return m_lz_state.get_node(m_lz_state.get_traverse_state()).id();
}
};
}}
| 31.326923 | 108 | 0.638428 | 421408 |
9857071301b5ba8687099d6d851100b9c308db46 | 1,670 | cpp | C++ | src/test/main_tests.cpp | coinkeeper/2015-06-22_19-00_ziftrcoin | 7c37ed9518bf822c51fa4de1c74d8e741e3263f6 | [
"MIT"
] | 10 | 2015-03-01T07:06:10.000Z | 2021-03-18T13:19:35.000Z | src/test/main_tests.cpp | coinkeeper/2015-06-22_19-00_ziftrcoin | 7c37ed9518bf822c51fa4de1c74d8e741e3263f6 | [
"MIT"
] | 11 | 2015-03-01T12:10:13.000Z | 2021-02-25T15:48:44.000Z | src/test/main_tests.cpp | coinkeeper/2015-06-22_19-00_ziftrcoin | 7c37ed9518bf822c51fa4de1c74d8e741e3263f6 | [
"MIT"
] | 14 | 2015-03-02T16:44:39.000Z | 2018-04-20T16:27:22.000Z | // Copyright (c) 2014 The Bitcoin Core developers
// Copyright (c) 2015 The ziftrCOIN developers
// Distributed under the MIT/X11 software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
#include "core.h"
#include "main.h"
#include "chainparams.h"
#include <boost/test/unit_test.hpp>
BOOST_AUTO_TEST_SUITE(main_tests)
BOOST_AUTO_TEST_CASE(subsidy_limit_test)
{
// Takes a little longer, but is more accurate
int64_t nMinSum = 0;
int64_t nMaxSum = 0;
int nTotalDays = 2 * Params().GetMidwayPoint();
for (int nDay = 0; nDay < nTotalDays; nDay++)
{
int nHeight = nDay * 24 * 60;
nMinSum += GetBlockValue(nHeight, 0, false);
nMaxSum += GetBlockValue(nHeight, 0, true);
int64_t nMinSubsidy = GetBlockValue(nHeight + 1, 0, false);
int64_t nMaxSubsidy = GetBlockValue(nHeight + 1, 0, true);
BOOST_CHECK(nMinSubsidy >= MIN_SUBSIDY);
BOOST_CHECK(nMaxSubsidy >= MIN_SUBSIDY);
// Should have the same value through out the day (1440 block period)
BOOST_CHECK(nMinSubsidy == GetBlockValue(nHeight + 24 * 60 - 2, 0, false));
BOOST_CHECK(nMaxSubsidy == GetBlockValue(nHeight + 24 * 60 - 2, 0, true));
nMinSum += nMinSubsidy * (24 * 60 - 1);
nMaxSum += nMaxSubsidy * (24 * 60 - 1);
BOOST_CHECK(MoneyRange(nMinSum));
BOOST_CHECK(MoneyRange(nMaxSum));
}
// printf("min sum : %llu\n", nMinSum);
// printf("max sum : %llu\n", nMaxSum);
BOOST_CHECK(nMinSum == 993742021533401ULL);
BOOST_CHECK(nMaxSum == 1041179115130496ULL);
}
BOOST_AUTO_TEST_SUITE_END()
| 30.363636 | 83 | 0.656287 | coinkeeper |
98576a4bae953234331282ed52e8eabcd5564470 | 2,182 | cpp | C++ | N. Phone Numbers.cpp | Mahboub99/CodeForces_UVA | c5cfad64d573ef21b67d97e17bd4f14fb01de9fa | [
"MIT"
] | 3 | 2020-01-03T11:38:43.000Z | 2021-03-13T13:34:49.000Z | N. Phone Numbers.cpp | Mahboub99/CodeForces_UVA | c5cfad64d573ef21b67d97e17bd4f14fb01de9fa | [
"MIT"
] | null | null | null | N. Phone Numbers.cpp | Mahboub99/CodeForces_UVA | c5cfad64d573ef21b67d97e17bd4f14fb01de9fa | [
"MIT"
] | 2 | 2019-10-16T19:52:15.000Z | 2019-10-28T08:52:38.000Z | #include <iostream>
#include <cmath>
#include <string>
#include <string.h>
#include <stdlib.h>
#include <algorithm>
#include <iomanip>
#include <assert.h>
#include <vector>
#include <cstring>
#include <map>
#include <deque>
#include <queue>
#include <stack>
#include <sstream>
#include <cstdio>
#include <cstdlib>
#include <ctime>
#include <set>
#include <complex>
#include <list>
#include <climits>
#include <cctype>
#include <bitset>
#include <numeric>
#include<array>
#include<tuple>
#include <utility>
#include <functional>
#include <locale>
#define all(v) v.begin(),v.end()
#define mp make_pair
#define pb push_back
typedef long long int ll ;
#define dbg printf("in\n");
#define nl printf("\n");
#define pp pair<int,int>
#define N 21
using namespace std;
inline bool ends_with(std::string const & value, std::string const & ending)
{
if (ending.size() > value.size()) return false;
return std::equal(ending.rbegin(), ending.rend(), value.rbegin());
}
bool cmp(string a,string b)
{
return a.length()<b.length();
}
int main()
{
int i,j,k;
int n,m,x;
string s, t;
map<string,vector<string> > mp;
scanf("%d",&n);
for(i=0;i<n;i++)
{
cin>>s;
scanf("%d",&m);
for(j=0;j<m;j++)
{
cin>>t;
mp[s].push_back(t);
}
}
vector<string> v;
map<string,vector<string> >::iterator p=mp.begin();
printf("%d\n",mp.size());
while(p!=mp.end())
{
v.clear();
v=p->second;
sort(v.begin(),v.end(),cmp);
for(i=0;i<v.size()-1;i++)
{
for(j=i+1;j<v.size();j++)
{
if(ends_with(v[j],v[i]))
{
v[i]="#";break;
}
}
}
s=p->first;x=0;
cout<<s<<" ";
for(i=0;i<v.size();i++)
{
if(v[i]!="#")
x++;
}
cout<<x<<" ";
for(i=0;i<v.size();i++)
{
if(v[i]!="#")
cout<<v[i]<<" ";
}
p++;printf("\n");
}
return 0;
}
| 18.973913 | 76 | 0.482126 | Mahboub99 |
985b8f3ef7e88804f57fd6c3beeec9d92ead404f | 1,287 | cpp | C++ | k-diff_pairs_in_an_array.cpp | shafitek/ArXives | 67170d6bde2093703d9cd3e8efa55b61e7b5ea75 | [
"MIT"
] | null | null | null | k-diff_pairs_in_an_array.cpp | shafitek/ArXives | 67170d6bde2093703d9cd3e8efa55b61e7b5ea75 | [
"MIT"
] | null | null | null | k-diff_pairs_in_an_array.cpp | shafitek/ArXives | 67170d6bde2093703d9cd3e8efa55b61e7b5ea75 | [
"MIT"
] | null | null | null | // https://leetcode.com/problems/k-diff-pairs-in-an-array/
class Solution {
public:
int findPairs(vector<int>& nums, int k) {
int soln = 0;
int len = nums.size();
int nummk = 0;
std::unordered_map<int, int> h_map;
std::unordered_map<int, int> soln_vec;
if (k < 0) {
return 0;
}
if (k == 0) {
for (auto const& num : nums) {
if (soln_vec.count(num) > 0 && soln_vec[num] == 1) {
soln++;
soln_vec[num]++;
continue;
}
soln_vec.insert({num, 1});
}
} else {
for (auto const& num : nums) {
nummk = num - k;
if (h_map.count(nummk) > 0) continue;
h_map.insert({nummk, num});
}
for (auto const& [key, val] : h_map) {
if (h_map.count(val) > 0){
soln++;
// soln_vec.insert({val, h_map[val]});
}
}
}
// for (auto const& [key, val] : soln_vec) {
// cout << "(" << key << ", " << val << ")" << endl;
// }
return soln;
}
}; | 26.265306 | 68 | 0.37296 | shafitek |
98661705d7d57f09be60d53e414ca8dd8293dc06 | 1,069 | cpp | C++ | backup/2/leetcode/c++/find-the-distance-value-between-two-arrays.cpp | yangyanzhan/code-camp | 4272564e916fc230a4a488f92ae32c07d355dee0 | [
"Apache-2.0"
] | 21 | 2019-11-16T19:08:35.000Z | 2021-11-12T12:26:01.000Z | backup/2/leetcode/c++/find-the-distance-value-between-two-arrays.cpp | yangyanzhan/code-camp | 4272564e916fc230a4a488f92ae32c07d355dee0 | [
"Apache-2.0"
] | 1 | 2022-02-04T16:02:53.000Z | 2022-02-04T16:02:53.000Z | backup/2/leetcode/c++/find-the-distance-value-between-two-arrays.cpp | yangyanzhan/code-camp | 4272564e916fc230a4a488f92ae32c07d355dee0 | [
"Apache-2.0"
] | 4 | 2020-05-15T19:39:41.000Z | 2021-10-30T06:40:31.000Z | // Hi, I'm Yanzhan. For more algothmic problems, visit my Youtube Channel (Yanzhan Yang's Youtube Channel) : https://www.youtube.com/channel/UCDkz-__gl3frqLexukpG0DA?view_as=subscriber or my Twitter Account (Yanzhan Yang's Twitter) : https://twitter.com/YangYanzhan or my GitHub HomePage (Yanzhan Yang's GitHub HomePage) : https://yanzhan.site .
// For this specific algothmic problem, visit my Youtube Video : .
// It's fascinating to solve algothmic problems, follow Yanzhan to learn more!
// Blog URL for this problem: https://yanzhan.site/leetcode/find-the-distance-value-between-two-arrays.html .
class Solution {
public:
int findTheDistanceValue(vector<int> &arr1, vector<int> &arr2, int d) {
int res = 0;
for (auto num1 : arr1) {
bool valid = true;
for (auto num2 : arr2) {
if (abs(num1 - num2) <= d) {
valid = false;
break;
}
}
if (valid) {
res++;
}
}
return res;
}
};
| 42.76 | 345 | 0.595884 | yangyanzhan |
9869b535f8a1de758b0c35612dbd4ac2a1701ad9 | 368 | hpp | C++ | mmcv/ops/csrc/pytorch_cuda_helper.hpp | jinliwei1997/mmcv | f8d46df4a9fa32fb44d2e92a4ca5e7b26ee9cb79 | [
"Apache-2.0"
] | 3,748 | 2018-10-12T08:39:46.000Z | 2022-03-31T17:22:55.000Z | mmcv/ops/csrc/pytorch_cuda_helper.hpp | jinliwei1997/mmcv | f8d46df4a9fa32fb44d2e92a4ca5e7b26ee9cb79 | [
"Apache-2.0"
] | 1,637 | 2018-10-12T06:06:18.000Z | 2022-03-31T02:20:53.000Z | mmcv/ops/csrc/pytorch_cuda_helper.hpp | jinliwei1997/mmcv | f8d46df4a9fa32fb44d2e92a4ca5e7b26ee9cb79 | [
"Apache-2.0"
] | 1,234 | 2018-10-12T09:28:20.000Z | 2022-03-31T15:56:24.000Z | #ifndef PYTORCH_CUDA_HELPER
#define PYTORCH_CUDA_HELPER
#include <ATen/ATen.h>
#include <ATen/cuda/CUDAContext.h>
#include <c10/cuda/CUDAGuard.h>
#include <ATen/cuda/CUDAApplyUtils.cuh>
#include <THC/THCAtomics.cuh>
#include "common_cuda_helper.hpp"
using at::Half;
using at::Tensor;
using phalf = at::Half;
#define __PHALF(x) (x)
#endif // PYTORCH_CUDA_HELPER
| 18.4 | 39 | 0.758152 | jinliwei1997 |
9870a9dcd83852a27f22154f595b9a89bafed8dc | 935 | cpp | C++ | source/377.cpp | narikbi/LeetCode | 835215c21d1bd6820b20c253026bcb6f889ed3fc | [
"MIT"
] | 2 | 2017-02-28T11:39:13.000Z | 2019-12-07T17:23:20.000Z | source/377.cpp | narikbi/LeetCode | 835215c21d1bd6820b20c253026bcb6f889ed3fc | [
"MIT"
] | null | null | null | source/377.cpp | narikbi/LeetCode | 835215c21d1bd6820b20c253026bcb6f889ed3fc | [
"MIT"
] | null | null | null | //
// 377.cpp
// LeetCode
//
// Created by Narikbi on 01.03.17.
// Copyright © 2017 app.leetcode.kz. All rights reserved.
//
#include <stdio.h>
#include <iostream>
#include <vector>
#include <string>
#include <algorithm>
#include <deque>
#include <queue>
#include <set>
#include <map>
#include <stack>
#include <cmath>
#include <numeric>
using namespace std;
int combinationSum4(vector<int>& nums, int target) {
sort(nums.begin(), nums.end());
vector <int> res (target + 1, 0);
for (int i = 1; i < res.size(); i++) {
for (int x : nums) {
if (x > i) break;
else if (x == i) {
res[i]++;
} else {
res[i] += res[i-x];
}
}
}
return res[target];
}
//
//int main(int argc, const char * argv[]) {
//
// vector<int> v = {1, 2, 3};
// cout << combinationSum4(v, 4) << endl;
//
// return 0;
//}
//
| 17.980769 | 58 | 0.512299 | narikbi |
987129dde97a7838c3dacb13432153fc32d46972 | 1,261 | hpp | C++ | include/magic.hpp | zborffs/Prometheus | 1ab4f88620dcf45872ec1c9d0e7945ecc651636d | [
"MIT"
] | 1 | 2018-12-29T10:39:56.000Z | 2018-12-29T10:39:56.000Z | include/magic.hpp | zborffs/Prometheus | 1ab4f88620dcf45872ec1c9d0e7945ecc651636d | [
"MIT"
] | 3 | 2021-11-12T06:44:46.000Z | 2021-11-12T06:47:56.000Z | include/magic.hpp | zborffs/Prometheus | 1ab4f88620dcf45872ec1c9d0e7945ecc651636d | [
"MIT"
] | null | null | null | #ifndef PROMETHEUS_MAGIC_HPP
#define PROMETHEUS_MAGIC_HPP
#include "defines.hpp"
#include "extern.hpp"
#include "bitmask.hpp"
#include <x86intrin.h>
#ifdef USE_SSE
#if defined (__GNUC__)
#if defined (__BMI2__)
extern uint16_t* rook_attacks[64];
extern uint16_t* bishop_attacks[64];
extern uint64_t rook_masks[64];
extern uint64_t rook_masks2[64];
extern uint64_t bishop_masks[64];
extern uint64_t bishop_masks2[64];
void init_bmi2_fancy(uint16_t table[], uint16_t* attacks[], uint64_t masks[], uint64_t masks2[], bool is_rook);
inline Bitboard bmi2_index_bishop(Square_t square, Bitboard occupied) {
return (uint16_t)_pext_u64(occupied, bishop_masks[square]);
}
inline Bitboard bmi2_index_rook(Square_t square, Bitboard occupied) {
return (uint16_t)_pext_u64(occupied, rook_masks[square]);
}
inline Bitboard attacks_bishop(Square_t square, Bitboard occupied) {
return _pdep_u64(bishop_attacks[square][bmi2_index_bishop(square, occupied)], bishop_masks2[square]);
}
inline Bitboard attacks_rook(Square_t square, Bitboard occupied) {
return _pdep_u64(rook_attacks[square][bmi2_index_rook(square, occupied)], rook_masks2[square]);
}
void init_sliding_attacks();
#endif // __BMI2__
#endif // __GNUC__
#endif // USE_SSE
#endif // PROMETHEUS_MAGIC_HPP
| 28.022222 | 111 | 0.792228 | zborffs |
9872636f65ca6f797c0c60664af71b95daca9040 | 7,271 | hpp | C++ | src/mbgl/programs/collision_box_program.hpp | dataliz9r/mapbox-gl-native | 7cdc39bee90dbf7658cb280b4fba9e63de18bc31 | [
"BSL-1.0",
"Apache-2.0"
] | null | null | null | src/mbgl/programs/collision_box_program.hpp | dataliz9r/mapbox-gl-native | 7cdc39bee90dbf7658cb280b4fba9e63de18bc31 | [
"BSL-1.0",
"Apache-2.0"
] | null | null | null | src/mbgl/programs/collision_box_program.hpp | dataliz9r/mapbox-gl-native | 7cdc39bee90dbf7658cb280b4fba9e63de18bc31 | [
"BSL-1.0",
"Apache-2.0"
] | null | null | null | #pragma once
#include <mbgl/programs/program.hpp>
#include <mbgl/programs/attributes.hpp>
#include <mbgl/programs/uniforms.hpp>
#include <mbgl/shaders/collision_box.hpp>
#include <mbgl/shaders/collision_circle.hpp>
#include <mbgl/style/properties.hpp>
#include <mbgl/util/geometry.hpp>
#include <cmath>
namespace mbgl {
using CollisionBoxLayoutAttributes = TypeList<
attributes::a_pos,
attributes::a_anchor_pos,
attributes::a_extrude,
attributes::a_shift>;
using CollisionBoxDynamicAttributes = TypeList<attributes::a_placed>;
class CollisionBoxProgram : public Program<
shaders::collision_box,
gfx::Line,
TypeListConcat<CollisionBoxLayoutAttributes, CollisionBoxDynamicAttributes>,
TypeList<
uniforms::u_matrix,
uniforms::u_extrude_scale,
uniforms::u_camera_to_center_distance>,
style::Properties<>>
{
public:
using Program::Program;
static gfx::Vertex<CollisionBoxLayoutAttributes> layoutVertex(Point<float> a, Point<float> anchor, Point<float> o) {
return {
{{
static_cast<int16_t>(a.x),
static_cast<int16_t>(a.y)
}},
{{
static_cast<int16_t>(anchor.x),
static_cast<int16_t>(anchor.y)
}},
{{
static_cast<int16_t>(::round(o.x)),
static_cast<int16_t>(::round(o.y))
}},
{{
0.0f,
0.0f
}}
};
}
static gfx::Vertex<CollisionBoxDynamicAttributes> dynamicVertex(bool placed, bool notUsed) {
return {
{{ static_cast<uint8_t>(placed), static_cast<uint8_t>(notUsed) }}
};
}
template <class DrawMode>
void draw(gl::Context& context,
DrawMode drawMode,
gfx::DepthMode depthMode,
gfx::StencilMode stencilMode,
gfx::ColorMode colorMode,
gfx::CullFaceMode cullFaceMode,
const UniformValues& uniformValues,
const gfx::VertexBuffer<gfx::Vertex<CollisionBoxLayoutAttributes>>& layoutVertexBuffer,
const gfx::VertexBuffer<gfx::Vertex<CollisionBoxDynamicAttributes>>& dynamicVertexBuffer,
const gfx::IndexBuffer& indexBuffer,
const SegmentVector<Attributes>& segments,
const Binders& paintPropertyBinders,
const typename PaintProperties::PossiblyEvaluated& currentProperties,
float currentZoom,
const std::string& layerID) {
typename AllUniforms::Values allUniformValues = uniformValues
.concat(paintPropertyBinders.uniformValues(currentZoom, currentProperties));
typename Attributes::Bindings allAttributeBindings = gl::Attributes<CollisionBoxLayoutAttributes>::bindings(layoutVertexBuffer)
.concat(gl::Attributes<CollisionBoxDynamicAttributes>::bindings(dynamicVertexBuffer))
.concat(paintPropertyBinders.attributeBindings(currentProperties));
assert(layoutVertexBuffer.elements == dynamicVertexBuffer.elements);
for (auto& segment : segments) {
auto vertexArrayIt = segment.vertexArrays.find(layerID);
if (vertexArrayIt == segment.vertexArrays.end()) {
vertexArrayIt = segment.vertexArrays.emplace(layerID, context.createVertexArray()).first;
}
program.draw(
context,
std::move(drawMode),
std::move(depthMode),
std::move(stencilMode),
std::move(colorMode),
std::move(cullFaceMode),
allUniformValues,
vertexArrayIt->second,
Attributes::offsetBindings(allAttributeBindings, segment.vertexOffset),
indexBuffer,
segment.indexOffset,
segment.indexLength);
}
}
};
class CollisionCircleProgram : public Program<
shaders::collision_circle,
gfx::Triangle,
TypeListConcat<CollisionBoxLayoutAttributes, CollisionBoxDynamicAttributes>,
TypeList<
uniforms::u_matrix,
uniforms::u_extrude_scale,
uniforms::u_overscale_factor,
uniforms::u_camera_to_center_distance>,
style::Properties<>>
{
public:
using Program::Program;
static gfx::Vertex<CollisionBoxLayoutAttributes> vertex(Point<float> a, Point<float> anchor, Point<float> o) {
return {
{{
static_cast<int16_t>(a.x),
static_cast<int16_t>(a.y)
}},
{{
static_cast<int16_t>(anchor.x),
static_cast<int16_t>(anchor.y)
}},
{{
static_cast<int16_t>(::round(o.x)),
static_cast<int16_t>(::round(o.y))
}},
{{
0.0f,
0.0f
}}
};
}
template <class DrawMode>
void draw(gl::Context& context,
DrawMode drawMode,
gfx::DepthMode depthMode,
gfx::StencilMode stencilMode,
gfx::ColorMode colorMode,
gfx::CullFaceMode cullFaceMode,
const UniformValues& uniformValues,
const gfx::VertexBuffer<gfx::Vertex<CollisionBoxLayoutAttributes>>& layoutVertexBuffer,
const gfx::VertexBuffer<gfx::Vertex<CollisionBoxDynamicAttributes>>& dynamicVertexBuffer,
const gfx::IndexBuffer& indexBuffer,
const SegmentVector<Attributes>& segments,
const Binders& paintPropertyBinders,
const typename PaintProperties::PossiblyEvaluated& currentProperties,
float currentZoom,
const std::string& layerID) {
typename AllUniforms::Values allUniformValues = uniformValues
.concat(paintPropertyBinders.uniformValues(currentZoom, currentProperties));
typename Attributes::Bindings allAttributeBindings = gl::Attributes<CollisionBoxLayoutAttributes>::bindings(layoutVertexBuffer)
.concat(gl::Attributes<CollisionBoxDynamicAttributes>::bindings(dynamicVertexBuffer))
.concat(paintPropertyBinders.attributeBindings(currentProperties));
for (auto& segment : segments) {
auto vertexArrayIt = segment.vertexArrays.find(layerID);
if (vertexArrayIt == segment.vertexArrays.end()) {
vertexArrayIt = segment.vertexArrays.emplace(layerID, context.createVertexArray()).first;
}
program.draw(
context,
std::move(drawMode),
std::move(depthMode),
std::move(stencilMode),
std::move(colorMode),
std::move(cullFaceMode),
allUniformValues,
vertexArrayIt->second,
Attributes::offsetBindings(allAttributeBindings, segment.vertexOffset),
indexBuffer,
segment.indexOffset,
segment.indexLength);
}
}
};
using CollisionBoxVertex = CollisionBoxProgram::LayoutVertex;
} // namespace mbgl
| 36.722222 | 135 | 0.602256 | dataliz9r |
9876f4e5980aff5a0bebcc1f60e67739ee3c06d5 | 4,308 | cpp | C++ | src/upcore/src/filesystem/posix/operations/absolute_path.cpp | upcaste/upcaste | 8174a2f40e7fde022806f8d1565bb4a415ecb210 | [
"MIT"
] | 1 | 2018-09-17T20:50:14.000Z | 2018-09-17T20:50:14.000Z | src/upcore/src/filesystem/posix/operations/absolute_path.cpp | jwtowner/upcaste | 8174a2f40e7fde022806f8d1565bb4a415ecb210 | [
"MIT"
] | null | null | null | src/upcore/src/filesystem/posix/operations/absolute_path.cpp | jwtowner/upcaste | 8174a2f40e7fde022806f8d1565bb4a415ecb210 | [
"MIT"
] | null | null | null | //
// Upcaste Performance Libraries
// Copyright (C) 2012-2013 Jesse W. Towner
//
// 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 "../filesystem_internal.hpp"
namespace up { namespace filesystem
{
LIBUPCOREAPI
ssize_t absolute_path(char* d, size_t dsz, char const* p, char const* base) noexcept {
char* buffer, * res;
size_t n, buffer_length, buffer_max;
ssize_t retval;
// validate arguments
if ((!d && dsz) || (dsz > (SSIZE_MAX + 1)) || !p) {
errno = EINVAL;
return -1;
}
n = strlen(p);
if (n > SSIZE_MAX) {
errno = EOVERFLOW;
return -1;
}
// if the path is already absolute, just normalize it into the destination buffer
if (*p == '/') {
return normalize_path(d, dsz, p, n);
}
if (!base) {
// copy current directory path into temporary buffer
buffer_max = PATH_MAX + n + 2;
buffer = static_cast<char*>(malloca(buffer_max));
if (!buffer) {
return -1;
}
res = ::getcwd(buffer, PATH_MAX + 1);
if (res != buffer) {
freea(buffer);
return -1;
}
buffer_length = strlen(buffer);
}
else {
// get the absolute path of base and place it into temporary buffer
buffer_max = PATH_MAX + strlen(base) + n + 2;
buffer = static_cast<char*>(malloca(buffer_max));
if (!buffer) {
return -1;
}
retval = absolute_path(buffer, buffer_max, base, nullptr);
if (retval < 0) {
freea(buffer);
return -1;
}
buffer_length = static_cast<size_t>(retval);
}
// join the base path in the buffer with the input path
assert(buffer_length > 0);
if (buffer[buffer_length - 1] != '/') {
buffer[buffer_length] = '/';
++buffer_length;
}
assert((buffer_length + n) < buffer_max);
memcpy(buffer + buffer_length, p, n + 1);
buffer_length += n;
// normalize the joined path to get final result
retval = normalize_path(d, dsz, buffer, buffer_length);
freea(buffer);
return retval;
}
LIBUPCOREAPI UPALLOC UPWARNRESULT
char* absolute_path(char const* p, char const* base) noexcept {
size_t length;
ssize_t slength;
char* retval;
char default_buffer[1024];
slength = absolute_path(default_buffer, sizeof(default_buffer), p, base);
if (slength < 0) {
return nullptr;
}
length = static_cast<size_t>(slength);
if (length < sizeof(default_buffer)) {
return strndup(default_buffer, length);
}
retval = static_cast<char*>(malloc(length + 1));
if (!retval) {
return nullptr;
}
verify(slength == absolute_path(retval, length + 1, p, base));
return retval;
}
}}
| 33.65625 | 91 | 0.56337 | upcaste |
9879d1ceabdae9df2980d94faf0ea7b7c8de3627 | 16,892 | hpp | C++ | src/ui/managers/WindowManager.hpp | inexorgame/entity-system | 230a6f116fb02caeace79bc9b32f17fe08687c36 | [
"MIT"
] | 19 | 2018-10-11T09:19:48.000Z | 2020-04-19T16:36:58.000Z | src/ui/managers/WindowManager.hpp | inexorgame-obsolete/entity-system-inactive | 230a6f116fb02caeace79bc9b32f17fe08687c36 | [
"MIT"
] | 132 | 2018-07-28T12:30:54.000Z | 2020-04-25T23:05:33.000Z | src/ui/managers/WindowManager.hpp | inexorgame-obsolete/entity-system-inactive | 230a6f116fb02caeace79bc9b32f17fe08687c36 | [
"MIT"
] | 3 | 2019-03-02T16:19:23.000Z | 2020-02-18T05:15:29.000Z | #pragma once
#include "base/LifeCycleComponent.hpp"
#include "MonitorManager.hpp"
#include "client/ClientLifecycle.hpp"
#include "entity-system/managers/entities/entity-instance-manager/EntityInstanceManager.hpp"
#include "entity-system/model/data/DataTypes.hpp"
#include "input/managers/KeyboardInputManager.hpp"
#include "input/managers/MouseInputManager.hpp"
#include "logging/managers/LogManager.hpp"
#include "renderer/managers/UserInterfaceRenderer.hpp"
#include "renderer/managers/WorldRenderer.hpp"
#include "ui/factories/WindowFactory.hpp"
#include "ui/model/ManagedWindow.hpp"
#include "visual-scripting/managers/ConnectorManager.hpp"
#include "visual-scripting/model/Connector.hpp"
#include <Magnum/Math/Range.h>
#include <Magnum/Timeline.h>
#include <functional>
#include <list>
struct GLFWwindow;
struct GLFWmonitor;
namespace inexor::ui {
using WindowFactoryPtr = std::shared_ptr<WindowFactory>;
using MonitorManagerPtr = std::shared_ptr<MonitorManager>;
using KeyboardInputManagerPtr = std::shared_ptr<input::KeyboardInputManager>;
using MouseInputManagerPtr = std::shared_ptr<input::MouseInputManager>;
using EntityInstanceManagerPtr = std::shared_ptr<entity_system::EntityInstanceManager>;
using ConnectorManagerPtr = std::shared_ptr<visual_scripting::ConnectorManager>;
using WorldRendererPtr = std::shared_ptr<renderer::WorldRenderer>;
using UserInterfaceRendererPtr = std::shared_ptr<renderer::UserInterfaceRenderer>;
using ClientLifecyclePtr = std::shared_ptr<client::ClientLifecycle>;
using LogManagerPtr = std::shared_ptr<logging::LogManager>;
using EntityInstancePtr = std::shared_ptr<entity_system::EntityInstance>;
using EntityAttributeInstancePtr = std::shared_ptr<entity_system::EntityAttributeInstance>;
using Range2Di = Magnum::Math::Range2D<std::int32_t>;
/// @class WindowManager
/// @brief The WindowManager manages the windows of the application.
class WindowManager : public LifeCycleComponent, public std::enable_shared_from_this<WindowManager>
{
public:
/// @brief Constructor.
/// @note The dependencies of this class will be injected automatically.
/// @param window_factory Factory for creating instances of type 'WINDOW'.
/// @param keyboard_input_manager The keyboard input manager.
/// @param mouse_input_manager The mouse input manager.
/// @param entity_instance_manager The entity instance manager.
/// @param connector_manager The connector manager.
/// @param world_renderer Service, which renders the world on a window.
/// @param user_interface_renderer Service, which renders the user interface on a window.
/// @param log_manager The log manager.
WindowManager(WindowFactoryPtr window_factory, MonitorManagerPtr monitor_manager, KeyboardInputManagerPtr keyboard_input_manager, MouseInputManagerPtr mouse_input_manager, EntityInstanceManagerPtr entity_instance_manager,
ConnectorManagerPtr connector_manager, WorldRendererPtr world_renderer, UserInterfaceRendererPtr user_interface_renderer, ClientLifecyclePtr client_lifecycle, LogManagerPtr log_manager);
/// Destructor.
~WindowManager();
/// Initialize the window manager.
void init() override;
/// Shut down the window manager.
void destroy() override;
/// Returns the name of the component
std::string get_component_name() override;
/// @brief Creates a new window with the given title, position and dimensions.
/// @param window The GLFWwindow instance.
EntityInstancePtr create_window(const std::string& title, int x, int y, int width, int height);
/// @brief Creates a new window with the given title, position and dimensions.
/// @param window The GLFWwindow instance.
EntityInstancePtr create_window(const std::string& title, int x, int y, int width, int height, float opacity, bool visible, bool fullscreen, bool iconified, bool maximized, bool focused, bool vsync, float fps);
/// @brief Creates a new window with the given title, position and dimensions.
/// @param window The GLFWwindow instance.
EntityInstancePtr create_window(const std::string& title, int x, int y, int width, int height, float opacity, bool visible, bool fullscreen, bool iconified, bool maximized, bool focused, bool vsync, float fps,
std::optional<std::function<void(EntityInstancePtr, GLFWwindow *)>> init_function, std::optional<std::function<void(EntityInstancePtr, GLFWwindow *)>> shutdown_function);
/// @brief Destroys the given window.
/// @param window The entity instance of type WINDOW.
void destroy_window(const EntityInstancePtr& window);
/// @brief Destroys the given window.
/// @param window The entity instance of type WINDOW.
void close_window(const EntityInstancePtr& window);
/// @brief Sets the title of the given window.
/// @param window The entity instance of type WINDOW.
/// @param title The new title of the window.
void set_window_title(const EntityInstancePtr& window, std::string title);
/// @brief Sets the position of the given window.
/// @param window The entity instance of type WINDOW.
/// @param x The new x position of the window.
/// @param y The new y position of the window.
void set_window_position(const EntityInstancePtr& window, int x, int y);
/// @brief Sets the size of the given window.
/// @param window The entity instance of type WINDOW.
/// @param width The new width of the window.
/// @param height The new height of the window.
void set_window_size(const EntityInstancePtr& window, int width, int height);
/// @brief Returns the dimensions of the given window.
/// @param window The entity instance of type WINDOW.
Range2Di get_window_dimensions(const EntityInstancePtr& window);
/// @brief Centers the given window on the monitor which contains the window center.
/// @param window The entity instance of type WINDOW.
void center_window_on_current_monitor(const EntityInstancePtr& window);
/// @brief Centers the given window on the primary monitor.
/// @param window The entity instance of type WINDOW.
void center_window_on_primary_monitor(const EntityInstancePtr& window);
/// @brief Centers the given window on the next left monitor.
/// @param window The entity instance of type WINDOW.
void center_window_on_next_left_monitor(const EntityInstancePtr& window);
/// @brief Centers the given window on the next right monitor.
/// @param window The entity instance of type WINDOW.
void center_window_on_next_right_monitor(const EntityInstancePtr& window);
/// @brief Centers the given window to the given monitor.
/// @param window The entity instance of type 'WINDOW'.
/// @param monitor The entity instance of type 'MONITOR'.
void center_window_on_monitor(const EntityInstancePtr& window, const EntityInstancePtr& monitor);
/// @brief Returns true, if the given window is centered on the monitor which contains the window center.
/// @param window The entity instance of type WINDOW.
/// @return True, if the window is centered.
bool is_window_centered(const EntityInstancePtr& window);
/// @brief Returns true, if the given window is centered on the given monitor.
/// @param window The entity instance of type WINDOW.
/// @param monitor The entity instance of type 'MONITOR'.
/// @return True, if the given window is centered on the given monitor.
bool is_window_centered_on_monitor(EntityInstancePtr window, EntityInstancePtr monitor);
/// @brief Makes the given window fullscreen on the monitor which contains the window center.
/// @param window The entity instance of type WINDOW.
void fullscreen_window_on_current_monitor(const EntityInstancePtr& window);
/// @brief Makes the given window fullscreen on the primary monitor.
/// @param window The entity instance of type WINDOW.
void fullscreen_window_on_primary_monitor(const EntityInstancePtr& window);
/// @brief Makes the given window fullscreen on the next left monitor.
/// @param window The entity instance of type WINDOW.
void fullscreen_window_on_next_left_monitor(const EntityInstancePtr& window);
/// @brief Makes the given window fullscreen on the next right monitor.
/// @param window The entity instance of type WINDOW.
void fullscreen_window_on_next_right_monitor(const EntityInstancePtr& window);
/// @brief Makes the given window fullscreen on the given monitor.
/// @param window The entity instance of type 'WINDOW'.
/// @param monitor The entity instance of type 'MONITOR'.
void fullscreen_window_on_monitor(const EntityInstancePtr& window, const EntityInstancePtr& monitor);
/// @brief Returns the monitor which contains the given window.
/// @param window The entity instance of type 'WINDOW'.
std::optional<EntityInstancePtr> get_current_monitor(const EntityInstancePtr& window);
// TODO: document
void make_current(const EntityInstancePtr& window);
/// @brief Registers a function to be called at every frame.
/// @param window The entity instance of type WINDOW.
/// @param render_function The render function to register.
void register_render_function(const EntityInstancePtr& window, std::function<void(EntityInstancePtr, GLFWwindow *, Magnum::Timeline)> render_function);
/// @brief Returns the number of windows.
int get_window_count();
/// @brief Returns the window handle for the entity instance.
/// @param window The entity instance of type 'WINDOW'.
GLFWwindow *get_window_handle(const EntityInstancePtr& window);
/// The logger name of this service.
static constexpr char LOGGER_NAME[] = "inexor.renderer.window";
private:
// State management
/// @brief Starts the window thread.
/// @param window The entity instance of type WINDOW.
void start_window_thread(const EntityInstancePtr& window);
/// @brief Stops the window thread.
/// @param window The entity instance of type 'WINDOW'.
void stop_window_thread(EntityInstancePtr window);
/// @brief Returns true, if the given entity instance of type WINDOW is managed.
/// @param window The entity instance of type 'WINDOW'.
bool is_window_managed(const EntityInstancePtr& window);
/// @brief Returns true, if the given entity instance of type WINDOW is available.
/// @param window The entity instance of type 'WINDOW'.
bool is_window_available(const EntityInstancePtr& window);
/// @brief Returns true, if the thread is managed for the given entity instance of type 'WINDOW'.
/// @param window The entity instance of type 'WINDOW'.
bool is_thread_managed(EntityInstancePtr window);
/// @brief Returns true, if the thread is running for the given entity instance of type 'WINDOW'.
/// @param window The entity instance of type 'WINDOW'.
bool is_thread_running(const EntityInstancePtr& window);
// Internal window API
/// @brief Sets the position of the given window.
/// @param glfw_window The glfw window.
/// @param x The new x position of the window.
/// @param y The new y position of the window.
void set_window_position(GLFWwindow *glfw_window, int x, int y);
/// @brief Sets the size of the given window.
/// @param glfw_window The glfw window.
/// @param width The new width of the window.
/// @param height The new height of the window.
void set_window_size(GLFWwindow *glfw_window, int width, int height);
/// @brief Returns the dimensions of the given window.
/// @param glfw_window The glfw window.
Range2Di get_window_dimensions(GLFWwindow *glfw_window);
// Window initialization
/// @brief Initializes the callbacks on window state changes.
/// @param glfw_window The window handle.
void initialize_window_callbacks(GLFWwindow *glfw_window);
/// @brief Removes the callbacks on window state changes.
/// @param glfw_window The window handle.
void destroy_window_callbacks(GLFWwindow *glfw_window);
/// @brief Initializes observers on the attributes of the entity instance of type WINDOW.
/// @param window The entity instance of type 'WINDOW'.
void initialize_window_observers(const EntityInstancePtr& window, GLFWwindow *glfw_window);
// Event handling
/// This callback is called if a window has been closed.
/// @param glfw_window The window handle.
void window_closed(GLFWwindow *glfw_window);
/// This callback is called if a window has been focused / has lost the focus.
/// @param glfw_window The window handle.
void window_focused(GLFWwindow *glfw_window, bool has_focus);
/// This callback is called if a window has been iconified / restored.
/// @param glfw_window The window handle.
void window_iconified(GLFWwindow *glfw_window, bool is_iconified);
/// This callback is called if a window has been maximized / restored.
/// @param glfw_window The window handle.
void window_maximized(GLFWwindow *glfw_window, bool is_maximized);
/// This callback is called if the position of a window has been changed.
/// @param glfw_window The window handle.
void window_position_changed(GLFWwindow *glfw_window, int x, int y);
/// This callback is called if the size of a window has been changed.
/// @param glfw_window The window handle.
void window_size_changed(GLFWwindow *glfw_window, int width, int height);
/// This callback is called if the state of a key has been changed.
/// @param glfw_window The window handle.
void window_key_changed(GLFWwindow *glfw_window, int key, int scancode, int action, int mods);
/// This callback is called if a character is input.
/// The character callback is intended for Unicode text input. As
/// it deals with characters, it is keyboard layout dependent,
/// whereas the key callback is not. Characters do not map 1:1 to
/// physical keys, as a key may produce zero, one or more
/// characters. If you want to know whether a specific physical
/// key was pressed or released, see the key callback instead.
///
/// The character callback behaves as system text input normally
/// does and will not be called if modifier keys are held down
/// that would prevent normal text input on that platform, for
/// example a Super (Command) key on macOS or Alt key on Windows.
/// @param glfw_window The window handle.
void window_char_input(GLFWwindow *glfw_window, unsigned int codepoint);
/// This callback is called if the mouse position of a window has been changed.
/// @param glfw_window The window handle.
void window_mouse_position_changed(GLFWwindow *glfw_window, double xpos, double ypos);
/// This callback is called if the state of a mouse button has been changed.
/// @param glfw_window The window handle.
void window_mouse_button_changed(GLFWwindow *glfw_window, int button, int action, int mods);
/// This callback is called if the state of a mouse scroll wheel has been changed.
/// @param glfw_window The window handle.
void window_mouse_scroll_changed(GLFWwindow *glfw_window, double xoffset, double yoffset);
/// This callback is called if files are dropped on the window.
/// @param glfw_window The window handle.
void window_path_dropped(GLFWwindow *glfw_window, int count, const char **_paths);
// Services
/// The factory for creating entities of type WINDOW.
WindowFactoryPtr window_factory;
/// The monitor manager.
MonitorManagerPtr monitor_manager;
/// The keyboard input manager.
KeyboardInputManagerPtr keyboard_input_manager;
/// The mouse input manager.
MouseInputManagerPtr mouse_input_manager;
/// The entity instance manager.
EntityInstanceManagerPtr entity_instance_manager;
/// The connector manager.
ConnectorManagerPtr connector_manager;
/// The world renderer.
WorldRendererPtr world_renderer;
/// The user interface renderer.
UserInterfaceRendererPtr user_interface_renderer;
/// The client lifecycle.
ClientLifecyclePtr client_lifecycle;
/// The log manager.
LogManagerPtr log_manager;
// Managed windows and states
/// The mapping between the entity instance and the pointer to the
/// corresponding ManagedWindow.
/// @see ManagedWindow
std::unordered_map<EntityInstancePtr, std::shared_ptr<ManagedWindow>> windows;
/// The mapping between the pointer to the window and the
/// corresponding entity instance.
std::unordered_map<GLFWwindow *, EntityInstancePtr> window_entities;
/// The number of windows managed by the WindowManager.
int window_count;
/// The current window id.
int current_window_id;
};
} // namespace inexor::renderer
| 46.534435 | 225 | 0.738278 | inexorgame |
987d56fd802a7cf2ca78ad87a3d2a866543abc28 | 3,581 | hpp | C++ | src/v2/internal_aparse_grammar.hpp | mohitmv/aparse | 34a6811f9a3d4f1c5dd21ed874b14e59e6725746 | [
"MIT"
] | 2 | 2021-04-15T20:02:37.000Z | 2021-04-17T18:18:50.000Z | src/v2/internal_aparse_grammar.hpp | mohitmv/aparse | 34a6811f9a3d4f1c5dd21ed874b14e59e6725746 | [
"MIT"
] | 1 | 2019-10-07T10:41:52.000Z | 2019-10-07T10:41:52.000Z | src/v2/internal_aparse_grammar.hpp | mohitmv/aparse | 34a6811f9a3d4f1c5dd21ed874b14e59e6725746 | [
"MIT"
] | 1 | 2020-05-05T16:52:20.000Z | 2020-05-05T16:52:20.000Z | // Copyright: 2015 Mohit Saini
// Author: Mohit Saini ([email protected])
#ifndef APARSE_SRC_V2_INTERNAL_APARSE_GRAMMAR_HPP_
#define APARSE_SRC_V2_INTERNAL_APARSE_GRAMMAR_HPP_
#include <utility>
#include <list>
#include <string>
#include <vector>
#include <unordered_map>
#include <unordered_set>
#include <set>
#include "quick/unordered_map.hpp"
#include "quick/debug_stream_decl.hpp"
#include "aparse/common_headers.hpp"
#include "aparse/aparse_grammar.hpp"
namespace aparse {
namespace v2 {
/** InternalAParseGrammar' is a preprocessed version of AparseGrammar. We offer
* a lot of flexibility in AParseGrammar to make it easy to design. However
* these flexibilities can be reduced to non-flexible version of AParseGrammar
* by doing some preprocessing.
* Eg:
* 1). We allow a single non-terminal to be defined in multiple rules. After
* preprocessing step, these non-terminals are combibed into single rule by
* joining the corrosponding expressions with UNION operator.
* 2). In addition to that we attach a label (a unique-id (integer)) on the
* rule-regex so that later we can identify the grammar-rule a regex
* corrosponds to.
* 3). Constructs the enclosed-non-terminals by extraing out the
* sub-expressions wrapped in branching alphabets.
*
* Usage: InternalAParseGrammar igrammar; igrammar.Build(...); */
class InternalAParseGrammar {
public:
InternalAParseGrammar() {}
// Not idempotent.
void Init(const AParseGrammar& grammar);
void DebugStream(qk::DebugStream&) const;
////////////////////// Helpers Functions For Alphabets ////////////////////
//
// Both `IsBAStart` and `IsBAEnd` assumes that `ba_map` and `ba_inverse_map`
// is populated before calling them. Avoiding necessary fatal-assertions here.
//
// Checks if a given regex is a atomic regex and it's alphabet is
// start-branching-alphabet.
bool IsBAStart(const Regex& r) const;
// Checks if a given regex is a atomic regex and it's alphabet is
// end-branching-alphabet.
bool IsBAEnd(const Regex& r) const;
// Checks if a given regex is a atomic regex and it's alphabet is
// end-branching-alphabet and also it's closing end of @start_ba.
bool IsBAEnd(const Regex& r, Alphabet start_ba) const;
//
/////////////////// ----x----x----x----x---- ///////////////////////////////
protected:
// @id_counter: enclosed_non_terminal_id_counter
void ConstructEnclosedNonTerminals(
std::vector<std::pair<int, Regex>>* rules_list,
int* id_counter);
// Regex main_regex;
// Mapping from enclosed-non-terminals to corrosponding Regex.
// std::unordered_map<EnclosedsAlphabet, SubRegex> sub_regex_map;
public:
int alphabet_size;
int main_non_terminal;
std::unordered_map<int, Regex> rules;
// map(enclosed_non_terminal -> (branch_start_alphabet, regex))
std::unordered_map<int, Regex> enclosed_rules;
std::unordered_map<int, Alphabet> enclosed_ba_alphabet;
std::unordered_map<int, int> regex_label_to_original_rule_number_mapping;
// branching-alphabets-map.
std::unordered_map<int, int> ba_map;
// map(value -> key) of `ba_map`.
std::unordered_map<int, int> ba_inverse_map;
// Map(every non-terminal -> list of other non-terminals it's dependent on)
std::unordered_map<int, std::unordered_set<int>> dependency_graph;
std::vector<int> topological_sorted_non_terminals;
std::unordered_set<int> non_terminals;
std::unordered_set<int> enclosed_non_terminals;
};
} // namespace v2
} // namespace aparse
#endif // APARSE_SRC_V2_INTERNAL_APARSE_GRAMMAR_HPP_
| 36.540816 | 80 | 0.724099 | mohitmv |
987dfb4f2323f5c3ee5b7dd51aa36020d7af0c57 | 6,008 | cpp | C++ | mp/src/game/client/fortress/resourcezoneoverlay.cpp | MaartenS11/Team-Fortress-Invasion | f36b96d27f834d94e0db2d2a9470b05b42e9b460 | [
"Unlicense"
] | 1 | 2021-03-20T14:27:45.000Z | 2021-03-20T14:27:45.000Z | mp/src/game/client/fortress/resourcezoneoverlay.cpp | MaartenS11/Team-Fortress-Invasion | f36b96d27f834d94e0db2d2a9470b05b42e9b460 | [
"Unlicense"
] | null | null | null | mp/src/game/client/fortress/resourcezoneoverlay.cpp | MaartenS11/Team-Fortress-Invasion | f36b96d27f834d94e0db2d2a9470b05b42e9b460 | [
"Unlicense"
] | null | null | null | #include "cbase.h"
#include <VGUI_EntityPanel.h>
#include <KeyValues.h>
#include "commanderoverlay.h"
#include "clientmode_tfnormal.h"
#include "tf_shareddefs.h"
#include "shareddefs.h"
#include "c_func_resource.h"
#include "techtree.h"
#include "c_basetfplayer.h"
#include "vgui_HealthBar.h"
#include "vgui_BitmapImage.h"
// memdbgon must be the last include file in a .cpp file!!!
#include "tier0/memdbgon.h"
class CResourceZoneOverlay : public CEntityPanel
{
DECLARE_CLASS( CResourceZoneOverlay, CEntityPanel );
public:
CResourceZoneOverlay( vgui::Panel *parent, const char *panelName );
virtual ~CResourceZoneOverlay( void );
bool Init( KeyValues* pKeyValues, C_BaseEntity* pEntity );
bool InitResourceBitmaps( KeyValues* pKeyValues );
void SetColor( int r, int g, int b, int a );
void SetImage( BitmapImage *pImage );
virtual void OnTick();
virtual void Paint( void );
virtual void PaintBackground( void ) {}
private:
class CResourceBitmaps
{
public:
CResourceBitmaps() : m_pImage(0) {}
BitmapImage *m_pImage;
Color m_Color;
};
struct Rect_t
{
int x, y, w, h;
};
bool ParseSingleResourceBitmap( KeyValues *pKeyValues,
const char *pResourceName, CResourceBitmaps *pResourceBitmap );
bool ParseTeamResourceBitmaps( CResourceBitmaps *pT, KeyValues *pTeam );
int m_r, m_g, m_b, m_a;
CHealthBarPanel m_UsageBar;
Rect_t m_Icon;
C_ResourceZone *m_pResourceZone;
CResourceBitmaps m_pResourceBitmap;
BitmapImage *m_pImage;
};
//-----------------------------------------------------------------------------
// Class factory
//-----------------------------------------------------------------------------
DECLARE_OVERLAY_FACTORY( CResourceZoneOverlay, "resourcezone" );
CResourceZoneOverlay::CResourceZoneOverlay( vgui::Panel *parent, const char *panelName )
: BaseClass( parent, "CResourceZoneOverlay" )
{
m_pImage = 0;
SetPaintBackgroundEnabled( false );
}
CResourceZoneOverlay::~CResourceZoneOverlay( void )
{
if ( m_pResourceBitmap.m_pImage )
{
delete m_pResourceBitmap.m_pImage;
}
}
//-----------------------------------------------------------------------------
// Parse class icons
//-----------------------------------------------------------------------------
bool CResourceZoneOverlay::ParseSingleResourceBitmap( KeyValues *pKeyValues,
const char *pResourceName, CResourceBitmaps *pResourceBitmap )
{
const char *image;
KeyValues *pResource;
pResource = pKeyValues->FindKey( pResourceName );
if ( !pResource )
return false;
image = pResource->GetString( "material" );
if ( image && image[ 0 ] )
{
pResourceBitmap->m_pImage = new BitmapImage( GetVPanel(), image );
}
else
{
return( false );
}
return ParseRGBA( pResource, "color", pResourceBitmap->m_Color );
}
bool CResourceZoneOverlay::ParseTeamResourceBitmaps( CResourceBitmaps *pT, KeyValues *pTeam )
{
if ( !ParseSingleResourceBitmap( pTeam, "Alpha", pT ) )
return false;
return true;
}
//-----------------------------------------------------------------------------
// Initialization
//-----------------------------------------------------------------------------
bool CResourceZoneOverlay::InitResourceBitmaps( KeyValues* pKeyValues )
{
// char teamkey[ 128 ];
// for (int i = 0; i < 3; ++i)
// {
// sprintf( teamkey, "Team%i", i );
// KeyValues *pTeam = pKeyValues->getSection( teamkey );
// if (pTeam)
{
if (!ParseTeamResourceBitmaps( &m_pResourceBitmap, pKeyValues ))
return false;
}
// }
return true;
}
//-----------------------------------------------------------------------------
// Initialization
//-----------------------------------------------------------------------------
bool CResourceZoneOverlay::Init( KeyValues* pKeyValues, C_BaseEntity* pEntity )
{
if (!BaseClass::Init( pKeyValues, pEntity))
return false;
if (!pKeyValues)
return false;
// We gotta be attached to a resource zone
m_pResourceZone = dynamic_cast<C_ResourceZone*>(GetEntity());
if (!m_pResourceZone)
return false;
KeyValues* pUsage = pKeyValues->FindKey("Usage");
if (!m_UsageBar.Init( pUsage ))
return false;
m_UsageBar.SetParent( this );
// get the icon info...
if (!ParseRect( pKeyValues, "iconposition", m_Icon.x, m_Icon.y, m_Icon.w, m_Icon.h ))
return false;
if (!InitResourceBitmaps( pKeyValues ))
return false;
SetImage( 0 );
SetColor( m_pResourceBitmap.m_Color[0], m_pResourceBitmap.m_Color[1], m_pResourceBitmap.m_Color[2], m_pResourceBitmap.m_Color[3] );
// we need updating
return true;
}
//-----------------------------------------------------------------------------
// called when we're ticked...
//-----------------------------------------------------------------------------
void CResourceZoneOverlay::OnTick()
{
// Update position
CEntityPanel::OnTick();
SetImage( m_pResourceBitmap.m_pImage );
int r, g, b, a;
m_pResourceBitmap.m_Color.GetColor( r, g, b, a );
SetColor( r, g, b, a );
m_UsageBar.SetHealth( m_pResourceZone->m_flClientResources );
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : pImage - Class specific image
//-----------------------------------------------------------------------------
void CResourceZoneOverlay::SetImage( BitmapImage *pImage )
{
m_pImage = pImage;
}
//-----------------------------------------------------------------------------
// Sets the draw color
//-----------------------------------------------------------------------------
void CResourceZoneOverlay::SetColor( int r, int g, int b, int a )
{
m_r = r;
m_g = g;
m_b = b;
m_a = a;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CResourceZoneOverlay::Paint( void )
{
if ( !m_pImage )
return;
ComputeAndSetSize();
Color color;
color.SetColor( m_r, m_g, m_b, m_a );
m_pImage->SetPos( m_Icon.x, m_Icon.y );
m_pImage->SetColor( color );
m_pImage->DoPaint( GetVPanel() );
} | 25.896552 | 132 | 0.565413 | MaartenS11 |
987e170d90dfc44b620e47d7fb76537248ef1ea0 | 14,697 | cpp | C++ | src/idatentest/main.cpp | nakdai/aten | f6de0840c1631bafbec3162da6a9af5767300e4d | [
"MIT"
] | 2 | 2017-09-29T02:36:45.000Z | 2017-11-16T03:25:25.000Z | src/idatentest/main.cpp | nakdai/aten | f6de0840c1631bafbec3162da6a9af5767300e4d | [
"MIT"
] | null | null | null | src/idatentest/main.cpp | nakdai/aten | f6de0840c1631bafbec3162da6a9af5767300e4d | [
"MIT"
] | null | null | null | #include "cuda_runtime.h"
#include "device_launch_parameters.h"
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <math.h>
#include <imgui.h>
#include "aten.h"
#include "atenscene.h"
#include "idaten.h"
#include "../common/scenedefs.h"
#define ENABLE_ENVMAP
static int WIDTH = 1280;
static int HEIGHT = 720;
static const char* TITLE = "ReSTIR";
#ifdef ENABLE_OMP
static uint32_t g_threadnum = 8;
#else
static uint32_t g_threadnum = 1;
#endif
static aten::PinholeCamera g_camera;
static bool g_isCameraDirty = false;
static aten::AcceleratedScene<aten::GPUBvh> g_scene;
static aten::context g_ctxt;
static idaten::PathTracing g_tracer;
static aten::visualizer* g_visualizer;
static float g_avgcuda = 0.0f;
static float g_avgupdate = 0.0f;
static bool g_enableUpdate = false;
static aten::TAA g_taa;
static aten::FBO g_fbo;
static aten::RasterizeRenderer g_rasterizer;
static aten::RasterizeRenderer g_rasterizerAABB;
static bool g_willShowGUI = true;
static bool g_willTakeScreenShot = false;
static int g_cntScreenShot = 0;
static int g_maxSamples = 1;
static int g_maxBounce = 5;
static auto g_curMode = idaten::ReSTIRPathTracing::Mode::ReSTIR;
static auto g_curReSTIRMode = idaten::ReSTIRPathTracing::ReSTIRMode::ReSTIR;
static auto g_curAOVMode = idaten::ReSTIRPathTracing::AOVMode::WireFrame;
static auto g_enableProgressive = false;
static bool g_showAABB = false;
static float g_moveMultiply = 1.0f;
static bool g_enableFrameStep = false;
static bool g_frameStep = false;
static bool g_pickPixel = false;
void update()
{
static float y = 0.0f;
static float d = -0.1f;
auto obj = getMovableObj();
if (obj) {
auto t = obj->getTrans();
if (y >= -0.1f) {
d = -0.01f;
}
else if (y <= -1.5f) {
d = 0.01f;
}
y += d;
t.y += d;
obj->setTrans(t);
obj->update();
auto accel = g_scene.getAccel();
accel->update(g_ctxt);
{
std::vector<aten::GeomParameter> shapeparams;
std::vector<aten::PrimitiveParamter> primparams;
std::vector<aten::LightParameter> lightparams;
std::vector<aten::MaterialParameter> mtrlparms;
std::vector<aten::vertex> vtxparams;
aten::DataCollector::collect(
g_ctxt,
g_scene,
shapeparams,
primparams,
lightparams,
mtrlparms,
vtxparams);
const auto& nodes = g_scene.getAccel()->getNodes();
const auto& mtxs = g_scene.getAccel()->getMatrices();
g_tracer.updateBVH(
shapeparams,
nodes,
mtxs);
}
}
}
void onRun(aten::window* window)
{
if (g_enableFrameStep && !g_frameStep) {
return;
}
auto frame = g_tracer.frame();
g_frameStep = false;
float updateTime = 0.0f;
{
aten::timer timer;
timer.begin();
if (g_enableUpdate) {
update();
}
updateTime = timer.end();
g_avgupdate = g_avgupdate * (frame - 1) + updateTime;
g_avgupdate /= (float)frame;
}
if (g_isCameraDirty) {
g_camera.update();
auto camparam = g_camera.param();
camparam.znear = real(0.1);
camparam.zfar = real(10000.0);
g_tracer.updateCamera(camparam);
g_isCameraDirty = false;
g_visualizer->clear();
}
aten::GLProfiler::begin();
g_rasterizer.drawSceneForGBuffer(
g_tracer.frame(),
g_ctxt,
&g_scene,
&g_camera,
&g_fbo);
auto rasterizerTime = aten::GLProfiler::end();
aten::timer timer;
timer.begin();
g_tracer.render(
idaten::TileDomain(0, 0, WIDTH, HEIGHT),
g_maxSamples,
g_maxBounce);
auto cudaelapsed = timer.end();
g_avgcuda = g_avgcuda * (frame - 1) + cudaelapsed;
g_avgcuda /= (float)frame;
aten::GLProfiler::begin();
g_visualizer->render(false);
auto visualizerTime = aten::GLProfiler::end();
if (g_showAABB) {
g_rasterizerAABB.drawAABB(
&g_camera,
g_scene.getAccel());
}
if (g_willTakeScreenShot)
{
static char buffer[1024];
::sprintf(buffer, "sc_%d.png\0", g_cntScreenShot);
g_visualizer->takeScreenshot(buffer);
g_willTakeScreenShot = false;
g_cntScreenShot++;
AT_PRINTF("Take Screenshot[%s]\n", buffer);
}
if (g_willShowGUI)
{
ImGui::Text("[%d] %.3f ms/frame (%.1f FPS)", g_tracer.frame(), 1000.0f / ImGui::GetIO().Framerate, ImGui::GetIO().Framerate);
ImGui::Text("cuda : %.3f ms (avg : %.3f ms)", cudaelapsed, g_avgcuda);
ImGui::Text("update : %.3f ms (avg : %.3f ms)", updateTime, g_avgupdate);
ImGui::Text("%.3f Mrays/sec", (WIDTH * HEIGHT * g_maxSamples) / real(1000 * 1000) * (real(1000) / cudaelapsed));
if (aten::GLProfiler::isEnabled()) {
ImGui::Text("GL : [rasterizer %.3f ms] [visualizer %.3f ms]", rasterizerTime, visualizerTime);
}
auto is_input_samples = ImGui::SliderInt("Samples", &g_maxSamples, 1, 100);
auto is_input_bounce = ImGui::SliderInt("Bounce", &g_maxBounce, 1, 10);
if (is_input_samples || is_input_bounce) {
g_tracer.reset();
}
#if 0
static const char* items[] = { "ReSTIR", "PT", "AOV" };
if (ImGui::Combo("mode", (int*)&g_curMode, items, AT_COUNTOF(items))) {
g_tracer.setMode(g_curMode);
}
if (g_curMode == idaten::ReSTIRPathTracing::Mode::ReSTIR) {
static const char* restir_items[] = { "ReSTIR", "SpatialReuse" };
if (ImGui::Combo("restir mode", (int*)&g_curReSTIRMode, restir_items, AT_COUNTOF(restir_items))) {
g_tracer.setReSTIRMode(g_curReSTIRMode);
}
}
if (g_curMode == idaten::ReSTIRPathTracing::Mode::AOVar) {
static const char* aovitems[] = { "Normal", "TexColor", "Depth", "Wire", "Barycentric", "Motion", "ObjId" };
if (ImGui::Combo("aov", (int*)&g_curAOVMode, aovitems, AT_COUNTOF(aovitems))) {
g_tracer.setAOVMode(g_curAOVMode);
}
}
#endif
if (ImGui::Checkbox("Progressive", &g_enableProgressive)) {
g_tracer.setEnableProgressive(g_enableProgressive);
}
#if 0
bool enableTAA = g_taa.isEnableTAA();
bool canShowTAADiff = g_taa.canShowTAADiff();
if (ImGui::Checkbox("Enable TAA", &enableTAA)) {
g_taa.enableTAA(enableTAA);
}
if (ImGui::Checkbox("Show TAA Diff", &canShowTAADiff)) {
g_taa.showTAADiff(canShowTAADiff);
}
#else
g_taa.enableTAA(false);
#endif
ImGui::Checkbox("Show AABB", &g_showAABB);
#if 0
bool canSSRTHitTest = g_tracer.canSSRTHitTest();
if (ImGui::Checkbox("Can SSRT Hit", &canSSRTHitTest)) {
g_tracer.setCanSSRTHitTest(canSSRTHitTest);
}
#endif
ImGui::SliderFloat("MoveMultiply", &g_moveMultiply, 1.0f, 100.0f);
auto cam = g_camera.param();
ImGui::Text("Pos %f/%f/%f", cam.origin.x, cam.origin.y, cam.origin.z);
ImGui::Text("At %f/%f/%f", cam.center.x, cam.center.y, cam.center.z);
}
}
void onClose()
{
}
bool g_isMouseLBtnDown = false;
bool g_isMouseRBtnDown = false;
int g_prevX = 0;
int g_prevY = 0;
void onMouseBtn(bool left, bool press, int x, int y)
{
g_isMouseLBtnDown = false;
g_isMouseRBtnDown = false;
if (press) {
g_prevX = x;
g_prevY = y;
g_isMouseLBtnDown = left;
g_isMouseRBtnDown = !left;
}
}
void onMouseMove(int x, int y)
{
if (g_isMouseLBtnDown) {
aten::CameraOperator::rotate(
g_camera,
WIDTH, HEIGHT,
g_prevX, g_prevY,
x, y);
g_isCameraDirty = true;
}
else if (g_isMouseRBtnDown) {
aten::CameraOperator::move(
g_camera,
g_prevX, g_prevY,
x, y,
real(0.001));
g_isCameraDirty = true;
}
g_prevX = x;
g_prevY = y;
}
void onMouseWheel(int delta)
{
aten::CameraOperator::dolly(g_camera, delta * real(0.1));
g_isCameraDirty = true;
}
void onKey(bool press, aten::Key key)
{
static const real offset_base = real(0.1);
if (press) {
if (key == aten::Key::Key_F1) {
g_willShowGUI = !g_willShowGUI;
return;
}
else if (key == aten::Key::Key_F2) {
g_willTakeScreenShot = true;
return;
}
else if (key == aten::Key::Key_F3) {
g_enableFrameStep = !g_enableFrameStep;
return;
}
else if (key == aten::Key::Key_F4) {
g_enableUpdate = !g_enableUpdate;
return;
}
else if (key == aten::Key::Key_F5) {
aten::GLProfiler::trigger();
return;
}
else if (key == aten::Key::Key_SPACE) {
if (g_enableFrameStep) {
g_frameStep = true;
return;
}
}
else if (key == aten::Key::Key_CONTROL) {
g_pickPixel = true;
return;
}
}
auto offset = offset_base * g_moveMultiply;
if (press) {
switch (key) {
case aten::Key::Key_W:
case aten::Key::Key_UP:
aten::CameraOperator::moveForward(g_camera, offset);
break;
case aten::Key::Key_S:
case aten::Key::Key_DOWN:
aten::CameraOperator::moveForward(g_camera, -offset);
break;
case aten::Key::Key_D:
case aten::Key::Key_RIGHT:
aten::CameraOperator::moveRight(g_camera, offset);
break;
case aten::Key::Key_A:
case aten::Key::Key_LEFT:
aten::CameraOperator::moveRight(g_camera, -offset);
break;
case aten::Key::Key_Z:
aten::CameraOperator::moveUp(g_camera, offset);
break;
case aten::Key::Key_X:
aten::CameraOperator::moveUp(g_camera, -offset);
break;
case aten::Key::Key_R:
{
aten::vec3 pos, at;
real vfov;
Scene::getCameraPosAndAt(pos, at, vfov);
g_camera.init(
pos,
at,
aten::vec3(0, 1, 0),
vfov,
WIDTH, HEIGHT);
}
break;
default:
break;
}
g_isCameraDirty = true;
}
}
int main()
{
aten::timer::init();
aten::OMPUtil::setThreadNum(g_threadnum);
aten::initSampler(WIDTH, HEIGHT);
aten::window::init(
WIDTH, HEIGHT, TITLE,
onRun,
onClose,
onMouseBtn,
onMouseMove,
onMouseWheel,
onKey);
aten::GLProfiler::start();
g_visualizer = aten::visualizer::init(WIDTH, HEIGHT);
aten::GammaCorrection gamma;
gamma.init(
WIDTH, HEIGHT,
"../shader/fullscreen_vs.glsl",
"../shader/gamma_fs.glsl");
aten::Blitter blitter;
blitter.init(
WIDTH, HEIGHT,
"../shader/fullscreen_vs.glsl",
"../shader/fullscreen_fs.glsl");
g_taa.init(
WIDTH, HEIGHT,
"../shader/fullscreen_vs.glsl", "../shader/taa_fs.glsl",
"../shader/fullscreen_vs.glsl", "../shader/taa_final_fs.glsl");
g_visualizer->addPostProc(&g_taa);
g_visualizer->addPostProc(&gamma);
//aten::visualizer::addPostProc(&blitter);
g_rasterizer.init(
WIDTH, HEIGHT,
"../shader/ssrt_vs.glsl",
"../shader/ssrt_gs.glsl",
"../shader/ssrt_fs.glsl");
g_rasterizerAABB.init(
WIDTH, HEIGHT,
"../shader/simple3d_vs.glsl",
"../shader/simple3d_fs.glsl");
g_fbo.asMulti(2);
g_fbo.init(
WIDTH, HEIGHT,
aten::PixelFormat::rgba32f,
true);
g_taa.setMotionDepthBufferHandle(g_fbo.getTexHandle(1));
aten::vec3 pos, at;
real vfov;
Scene::getCameraPosAndAt(pos, at, vfov);
g_camera.init(
pos,
at,
aten::vec3(0, 1, 0),
vfov,
WIDTH, HEIGHT);
Scene::makeScene(g_ctxt, &g_scene);
g_scene.build(g_ctxt);
#ifdef ENABLE_ENVMAP
auto envmap = aten::ImageLoader::load("../../asset/envmap/studio015.hdr", g_ctxt);
auto bg = std::make_shared<aten::envmap>();
bg->init(envmap);
auto ibl = std::make_shared<aten::ImageBasedLight>(bg);
g_scene.addImageBasedLight(ibl);
#endif
{
auto aabb = g_scene.getAccel()->getBoundingbox();
auto d = aabb.getDiagonalLenght();
g_tracer.setHitDistanceLimit(d * 0.25f);
std::vector<aten::GeomParameter> shapeparams;
std::vector<aten::PrimitiveParamter> primparams;
std::vector<aten::LightParameter> lightparams;
std::vector<aten::MaterialParameter> mtrlparms;
std::vector<aten::vertex> vtxparams;
aten::DataCollector::collect(
g_ctxt,
g_scene,
shapeparams,
primparams,
lightparams,
mtrlparms,
vtxparams);
const auto& nodes = g_scene.getAccel()->getNodes();
const auto& mtxs = g_scene.getAccel()->getMatrices();
std::vector<idaten::TextureResource> tex;
{
auto texNum = g_ctxt.getTextureNum();
for (int i = 0; i < texNum; i++) {
auto t = g_ctxt.getTexture(i);
tex.push_back(
idaten::TextureResource(t->colors(), t->width(), t->height()));
}
}
#ifdef ENABLE_ENVMAP
for (auto& l : lightparams) {
if (l.type == aten::LightType::IBL) {
l.idx = envmap->id();
}
}
#endif
auto camparam = g_camera.param();
camparam.znear = real(0.1);
camparam.zfar = real(10000.0);
g_tracer.update(
aten::visualizer::getTexHandle(),
WIDTH, HEIGHT,
camparam,
shapeparams,
mtrlparms,
lightparams,
nodes,
primparams, 0,
vtxparams, 0,
mtxs,
tex,
#ifdef ENABLE_ENVMAP
idaten::EnvmapResource(envmap->id(), ibl->getAvgIlluminace(), real(1)));
#else
idaten::EnvmapResource());
#endif
}
aten::window::run();
aten::GLProfiler::terminate();
g_rasterizer.release();
g_rasterizerAABB.release();
g_ctxt.release();
aten::window::terminate();
}
| 25.209262 | 133 | 0.564673 | nakdai |
9880985614eeca61f38b16c9ffc4f1f14995c3f3 | 29,850 | cpp | C++ | sparta/src/ConfigParserYAML.cpp | knute-sifive/map | fb25626830a56ad68ab896bcd01929023ff31c48 | [
"MIT"
] | null | null | null | sparta/src/ConfigParserYAML.cpp | knute-sifive/map | fb25626830a56ad68ab896bcd01929023ff31c48 | [
"MIT"
] | null | null | null | sparta/src/ConfigParserYAML.cpp | knute-sifive/map | fb25626830a56ad68ab896bcd01929023ff31c48 | [
"MIT"
] | null | null | null | // <ConfigParserYAML> -*- C++ -*-
#include <cassert>
#include <yaml-cpp/node/impl.h>
#include <yaml-cpp/node/node.h>
#include <boost/filesystem/operations.hpp>
#include <boost/filesystem/path.hpp>
#include <cstddef>
#include <yaml-cpp/anchor.h>
#include <yaml-cpp/emitterstyle.h>
#include <yaml-cpp/mark.h>
#include <yaml-cpp/node/type.h>
#include <algorithm>
#include <cstdint>
#include <functional>
#include <iostream>
#include <stack>
#include <string>
#include <vector>
#include "sparta/parsers/ConfigParserYAML.hpp"
#include "sparta/simulation/TreeNode.hpp"
#include "sparta/simulation/TreeNodePrivateAttorney.hpp"
#include "sparta/utils/Printing.hpp"
#include "sparta/parsers/ConfigParser.hpp"
#include "sparta/simulation/Parameter.hpp"
#include "sparta/simulation/ParameterTree.hpp"
#include "sparta/utils/SpartaAssert.hpp"
#include "sparta/utils/SpartaException.hpp"
namespace YP = YAML; // Prevent collision with YAML class in ConfigParser namespace.
namespace sparta
{
namespace ConfigParser
{
//! Handle Scalar (key or value) YAML node from parser
void YAML::EventHandler::OnScalar(const YP::Mark& mark, const std::string& tag, YP::anchor_t anchor, const std::string& value)
{
(void) anchor;
(void) tag;
if(subtree_.size() > 0){
verbose() << indent_() << "(" << subtree_.size() << ") vptn:" << (pt_node_ ? pt_node_->getPath() : "<null>") << " + Scalar " << value << " @" << mark.line << std::endl;
}else{
verbose() << indent_() << "(commented)" << " vptn:" << (pt_node_ ? pt_node_->getPath() : "<null>") << " + Scalar " << value << " @" << mark.line << std::endl;
}
//if(subtree_.size() == 0){
// //! \todo Check to see if this is legal
// return;
//}
// New scalar within a sequence
if(seq_params_.size() > 0){
last_val_ = "";
cur_ = YP::NodeType::Scalar;
assert(sequence_pos_.size() > 0);
// Save sequence to parameter @ subtree
std::vector<ParameterBase*>& seq_ps = seq_params_.top();
for(ParameterBase* pb : seq_ps){
verbose() << "Storing " << value << " at " << sequence_pos_
<< " to parameter:" << *pb << std::endl;
if(filter_predicate_(pb)){ // Can apply?
if(write_to_default_){
pb->overrideDefaultItemValueFromString(sequence_pos_, value);
}else{
pb->setItemValueFromString(sequence_pos_, value);
}
}
verbose() << "Result = " << pb << std::endl;
}
seq_params_.addValue(value);
//std::cerr << "seq scalar assigned @\"" << pt_node_->getPath() << "\" \"" << sequence_pos_ << "\" <- " << value << std::endl;
//ptree_.recursPrint(std::cerr);
sequence_pos_.back() += 1;
return; // Done
} else if(last_val_ != ""){
// Value in a compact map
verbose() << indent_() << "COMPACT MAPPING {" << last_val_ << " : " << value << "}" << std::endl;
static const std::vector<std::string> include_keys(INCLUDE_KEYS);
if(std::find(include_keys.begin(), include_keys.end(), last_val_) != include_keys.end()){
verbose() << indent_() << " handling include directive" << std::endl;
handleIncludeDirective(value, subtree_, pt_node_);
}else if(last_val_.find(COMMENT_KEY_START) == 0){
verbose() << indent_() << " commented compact mapping. doing nothing" << std::endl;
}else{
// Assign this value to each parameter that matches pattern
if(subtree_.size() > 0){
bool found = false;
std::vector<TreeNode*> nodes;
for(TreeNode* tn : subtree_){
TreeNodePrivateAttorney::findChildren(tn, last_val_, nodes);
for(TreeNode* n : nodes){
ParameterBase* pb = dynamic_cast<ParameterBase*>(n);
if(pb){
if(filter_predicate_(pb)){ // Can apply?
if(write_to_default_){
pb->overrideDefaultFromString(value);
}else{
pb->setValueFromString(value);
}
found = true;
}
}
}
}
if(!found && !allow_missing_nodes_){
std::stringstream ss;
ss << "Could not find at least 1 parameter node matching pattern \""
<< last_val_ << "\" from tree nodes \"" << sparta::utils::stringize_value(subtree_)
<< "\". Maybe the typical 'params' node was omitted from the input file "
<< "between a node name and the actual parameter name (e.g. 'core.params.paramX')";
ss << markToString_(mark);
errors_.push_back(ss.str());
}
}
if(pt_node_){ // Because ptree does not handle parent references yet.
if(value == OPTIONAL_PARAMETER_KEYWORD){
const bool required = false; // Not required
auto n = pt_node_->create(last_val_, required);
n->unrequire();
}else{
const bool required = true; // Temporary value. Parameters created this way are always required
if(!pt_node_->set(last_val_, value, required, markToString_(mark, false))){ // Assign value
std::cerr << "WARNING: Encountered parameter path with parent reference: \"" << pt_node_->getPath()
<< "\" + \"" << last_val_ << "\". This node will not be available in the unbound parameter tree."
<< markToString_(mark) << std::endl;
}
}
//std::cerr << "set " << pt_node_->getPath() << " \"" << last_val_ << "\" <- " << value << std::endl;
//ptree_.recursPrint(std::cerr);
}
}
last_val_ = ""; // End of mapping pair. Clear
cur_ = YP::NodeType::Null;
return;
}else if(cur_ == YP::NodeType::Null && nesting_ == 1){
// Value in a compact map
verbose() << indent_() << "SINGULAR SCALAR : \"" << value << "\"" << std::endl;
if(value.find(COMMENT_KEY_START) == 0){
verbose() << indent_() << " commented singular scalar. doing nothing" << std::endl;
}else{
if(subtree_.size() > 0){
// Assign this value to each parameter that matches pattern
bool found = false;
for(TreeNode* tn : subtree_){
ParameterBase* pb = dynamic_cast<ParameterBase*>(tn);
if(pb){
if(filter_predicate_(pb)){ // Can apply?
if(write_to_default_){
pb->overrideDefaultFromString(value);
}else{
pb->setValueFromString(value);
}
found = true;
}
}
}
if(!found && !allow_missing_nodes_){
std::stringstream ss;
ss << "Could not find at least 1 parameter node in the current context \""
<< sparta::utils::stringize_value(subtree_)
<< "\". Maybe this YAML was parsed starting at the wrong context.";
ss << markToString_(mark);
errors_.push_back(ss.str());
}
}
}
if(pt_node_){ // Because ptree does not handle parent references yet.
if(value == OPTIONAL_PARAMETER_KEYWORD){
const bool required = false; // Not required
auto n = pt_node_->create(last_val_, required);
n->unrequire(); // In case it was already created
}else{
const bool required = true; // Temporary value. Parameters created this way are always required
pt_node_->setValue(value, required, markToString_(mark, false));
//std::cerr << "setValue " << pt_node_->getPath() << " \"" << last_val_ << "\" <- " << value << std::endl;
//ptree_.recursPrint(std::cerr);
}
}
cur_ = YP::NodeType::Null;
return;
}else{
// This is legitimate. In inline-maps with comma-separated k-v pairs, this
// case is encountered
verbose() << indent_() << "next scalar : " << value << std::endl;
}
if(cur_ == YP::NodeType::Map){
verbose() << indent_() << "<within map>" << std::endl;
}else if(cur_ == YP::NodeType::Sequence){
verbose() << indent_() << "<within seq>" << std::endl;
// Append value
}else{
verbose() << indent_() << "<new key?>" << std::endl;
}
last_val_ = value;
cur_ = YP::NodeType::Scalar;
}
//! Handle SequenceStart YAML node from parser
void YAML::EventHandler::OnSequenceStart(const YP::Mark& mark, const std::string& tag,
YP::anchor_t anchor, YP::EmitterStyle::value style)
{
(void) anchor;
(void) tag;
(void) style;
if(subtree_.size() > 0){
verbose() << indent_() << "(" << subtree_.size() << ") vptn:" << (pt_node_ ? pt_node_->getPath() : "<null>") << " + SeqStart (" << last_val_ << ") @" << mark.line << std::endl;
}else{
verbose() << indent_() << "(commented)" << " vptn:" << (pt_node_ ? pt_node_->getPath() : "<null>") << " + SeqStart (" << last_val_ << ") @" << mark.line << std::endl;
}
//if(subtree_.size() == 0){
// return;
//}
seq_vec_.push({}); // Add a new level of values to the stack
if(seq_params_.size() == 0){
// Handle entry into first level of the sequence
sequence_pos_.push_back(0);
seq_params_.push({});
std::vector<ParameterBase*>& seq_ps = seq_params_.top();
if(subtree_.size() > 0){
// Find next generation based on pattern of scalar (key) last_val_
NodeVector nodes;
findNextGeneration_(subtree_, last_val_, nodes, mark);
bool found = false;
for(TreeNode* tn : nodes){
ParameterBase* pb = dynamic_cast<ParameterBase*>(tn);
if(pb){
if(filter_predicate_(pb)){ // Can apply?
seq_ps.push_back(pb);
found = true;
// Clear the parameter value before setting it (in case it is larger than the new content)
if (write_to_default_) {
pb->overrideDefaultClearVectorValue();
} else {
pb->clearVectorValue();
}
}
}
}
//! \todo Implement filtering with a lambda functor such as:
//! [] (TreeNode* in) -> bool {return dynamic_cast<ParameterBase*>(in)));
if(!found && !allow_missing_nodes_){
std::stringstream ss;
ss << "Could not find at least 1 parameter node matching pattern \""
<< last_val_ << "\" from tree node \"" << sparta::utils::stringize_value(subtree_)
<< "\". Maybe the 'params' level was omitted from the input file's tree before the parameter";
ss << markToString_(mark);
errors_.push_back(ss.str());
}
}
pt_stack_.push(pt_node_); // Push on first entry
if(pt_node_){
const bool required = true; // Temporary value. Parameters created this way are always required
auto npt_node = pt_node_->create(last_val_, required); // Fails if it contains a parent reference
//std::cerr << "OnSequenceStart Create \"" << pt_node_->getPath() << "\" \"" << last_val_ << "\"" << std::endl;
//ptree_.recursPrint(std::cerr);
if(!npt_node){
std::cerr << "WARNING: Encountered parameter path with parent reference: \"" << pt_node_->getPath()
<< "\" + \"" << last_val_ << "\". This node will not be available in the unbound parameter tree."
<< markToString_(mark) << std::endl;
}
pt_node_ = npt_node;
}
}else{
// Enlarge the parameter at current indices before moving into the next level
for(auto pb : seq_params_.top()){
if(filter_predicate_(pb)){ // Can apply?
if (write_to_default_){
pb->overrideDefaultResizeVectorsFromString(sequence_pos_);
} else {
pb->resizeVectorsFromString(sequence_pos_);
}
}
}
sequence_pos_.push_back(0);
// Handle entry into nested sequence in YAML file
seq_params_.push(seq_params_.top()); // Copy previous level
}
last_val_ = "";
nesting_++;
}
//! Handle SequenceEnd YAML node from parser
void YAML::EventHandler::OnSequenceEnd()
{
sparta_assert(seq_vec_.size() > 0,
"Reached end of a YAML sequence in " << filename_
<< " without any sets of sequence values tracked");
auto& seq_vals = seq_vec_.top();
verbose() << indent_() << "Storing sequence to param: " << sparta::utils::stringize_value(seq_vals) << std::endl;
if(subtree_.size() > 0){
verbose() << indent_() << "(" << subtree_.size() << ") vptn:" << (pt_node_ ? pt_node_->getPath() : "<null>") << " + SeqEnd" << std::endl;
}else{
verbose() << indent_() << "(commented)" << " vptn:" << (pt_node_ ? pt_node_->getPath() : "<null>") << " + SeqEnd" << std::endl;
}
nesting_--;
//if(subtree_.size() == 0){
// return; // seq_params_ should be NULL and seq_vec_ empty
//}
sparta_assert(seq_params_.size() > 0,
"Reached end of YAML sequence in " << filename_
<< " without any sets of sequence parameters tracked");
seq_params_.pop();
// Assign popped sequence to parameter tree node once the nessted sequence has ended
if(seq_params_.size() == 0){
if(pt_node_){
// NOTE: cannot unrequire this parameter here because we're assigning a
// sequence to it. Only when assigning the OPTIONAL_PARAMETER_KEYWORD
// string can it be ignored.
// Just ensure a node with last_val_ exists, but do not assign to it yet.
const bool required = true; // Temporary value. Parameters created this way are always required
pt_node_->setValue(seq_params_.getValue(), required);
//std::cerr << "OnSequenceEnd setValue @\"" << pt_node_->getPath() << " \"" << seq_params_.getValue() << "\"" << std::endl;
//ptree_.recursPrint(std::cerr);
}
// Reached end of nested sequence, pop pt_stack_ tos to get node before sequences started
pt_node_ = pt_stack_.top();
pt_stack_.pop();
}
seq_vec_.pop();
sequence_pos_.pop_back();
if(!sequence_pos_.empty()){
sequence_pos_.back() += 1;
}
last_val_ = "";
}
//! Handle MapStart YAML node from parser
void YAML::EventHandler::OnMapStart(const YP::Mark& mark, const std::string& tag,
YP::anchor_t anchor, YP::EmitterStyle::value style)
{
(void) anchor;
(void) tag;
(void) style;
if(subtree_.size() > 0){
verbose() << indent_() << "(" << subtree_.size() << ") vptn:" << (pt_node_ ? pt_node_->getPath() : "<null>") << " + MapStart (" << last_val_ << ") @" << mark.line << std::endl;
}else{
verbose() << indent_() << "(commented)" << " vptn:" << (pt_node_ ? pt_node_->getPath() : "<null>") << " + MapStart (" << last_val_ << ") @" << mark.line << std::endl;
}
nesting_++;
sparta_assert(seq_params_.size() == 0,
"Cannot start a YAML map if already within a sequence " << markToString_(mark));
tree_stack_.push(subtree_); // Add to stack regardless of comment-state
pt_stack_.push(pt_node_);
//if(subtree_.size() == 0){
// return; // subtree_ remains NULL
//}
static const std::vector<std::string> include_keys(INCLUDE_KEYS);
if(std::find(include_keys.begin(), include_keys.end(), last_val_) != include_keys.end()){
verbose() << indent_() << " INCLUDE MAPPING" << std::endl;
SpartaException ex("Include directive contains a map. This is not allowed. ");
ex << "Includes must map directly to a filename scalar";
addMarkInfo_(ex, mark);
throw ex;
}else if(last_val_.find(COMMENT_KEY_START) == 0){
// comment
verbose() << indent_() << " COMMENTED MAPPING" << std::endl;
///subtree_
subtree_.clear(); // Clear current nodes
}else{
// current subtree_ already pushed to stack
// Move onto next generation of children
///subtree_ = subtree_->getChild(last_val_);
subtree_.clear(); // Clear this level to be reset
NodeVector& v = tree_stack_.top();
findNextGeneration_(v, last_val_, subtree_, mark); // Assures found num nodes in range [1, MAX_MATCHES_PER_LEVEL].
if(pt_node_){ // Because ptree cannot handle parent references yet
const bool required = true; // Temporary value. Parameters created this way are always required
auto npt_node = pt_node_->create(last_val_, required); // create child if not already existing
if(!npt_node){
std::cerr << "WARNING: Encountered parameter path with parent reference: \"" << pt_node_->getPath()
<< "\" + \"" << last_val_ << "\". This node will not be available in the unbound parameter tree."
<< markToString_(mark) << std::endl;
}
pt_node_ = npt_node;
}
}
last_val_ = "";
}
//! Handle MapEnd YAML node from parser
void YAML::EventHandler::OnMapEnd()
{
if(subtree_.size() > 0){
verbose() << indent_() << "(" << subtree_.size() << ") vptn:" << (pt_node_ ? pt_node_->getPath() : "<null>") << " + MapEnd" << std::endl;
}else{
verbose() << indent_() << "(commented)" << " vptn:" << (pt_node_ ? pt_node_->getPath() : "<null>") << " + MapEnd" << std::endl;
}
nesting_--;
subtree_ = tree_stack_.top();
tree_stack_.pop();
pt_node_ = pt_stack_.top();
pt_stack_.pop();
last_val_ = "";
}
void YAML::EventHandler::findNextGeneration_(NodeVector& current, const std::string& pattern,
NodeVector& next, const YP::Mark& mark){
sparta_assert(next.size() == 0);
if(current.size() == 0){
// Breaks sparta TreeNode test
//sparta_assert(allow_missing_nodes_);
return;
}
for(TreeNode* tn : current){
TreeNodePrivateAttorney::findChildren(tn, pattern, next);
}
if(next.size() == 0 && !allow_missing_nodes_){
SpartaException ex("Could not find any nodes matching the pattern \"");
ex << pattern << "\" from nodes " << sparta::utils::stringize_value(current) << ".";
addMarkInfo_(ex, mark);
throw ex;
}
if(next.size() > MAX_MATCHES_PER_LEVEL){
SpartaException ex("Found more than ");
ex << (size_t)MAX_MATCHES_PER_LEVEL << " nodes matching the pattern \""
<< pattern << "\" from " << subtree_.size() << " nodes. "
<< "This is likely a very deep and dangerous search pattern (or possibly a bug). "
<< "If there really should be this many matches, increase MAX_MATCHES_PER_LEVEL.";
addMarkInfo_(ex, mark);
throw ex;
}
}
/*!
* \brief Sets the given sequence YAML node <node> as the value
* of the parameter described by <param_path> relative to the
* current node <subtree>.
* \param subtree Current node.
* \param param_path Path (pattern) relative to <subtree> to a
* node which is a sparta::Parameter.
* \param node The value to assign to the parameter decribed by
* <subtree> and <param_path>.
*/
void YAML::EventHandler::applyArrayParameter(TreeNode* subtree,
const std::string& param_path,
const YP::Node& node)
{
sparta_assert(node.Type() == YP::NodeType::Sequence);
sparta_assert(subtree || allow_missing_nodes_);
std::vector<TreeNode*> nodes;
findNextGeneration_(subtree_, param_path, nodes, node.Mark());
const bool required = true; // Temporary value. Parameters created this way are always required
ParameterTree::Node* ptn = pt_node_ ? pt_node_->create(param_path, required) : nullptr; // create child if not already existing
std::vector<std::string> values;
verbose() << indent_() << " [" << std::endl;
// Extract each value into values vector
for(size_t i=0; i<node.size(); ++i) {
std::string scalar;
scalar = node[i].Scalar();
verbose() << indent_() << " " << scalar << " " << std::endl;
values.push_back(scalar);
}
verbose() << indent_() << " ]" << std::endl;
// Assign this array of values to each node
bool found = false;
for(TreeNode* n : nodes){
ParameterBase* pb = dynamic_cast<ParameterBase*>(n);
if(pb){
if(filter_predicate_(pb)){ // Can apply?
if(write_to_default_){
pb->overrideDefaultFromStringVector(values);
}else{
pb->setValueFromStringVector(values);
}
found = true;
}
}
}
if(!found && !allow_missing_nodes_){
std::stringstream ss;
ss << "Could not find at least 1 parameter node matching pattern \""
<< param_path << "\" from tree nodes \"" << sparta::utils::stringize_value(subtree_)
<< "\". Maybe the typical 'params' node was omitted from the input file "
<< "between a node name and the actual parameter name (e.g. 'core.params.paramX')";
ss << markToString_(node.Mark());
errors_.push_back(ss.str());
}
if(ptn){ // Because ptree cannot handle parent references yet
std::stringstream ss;
ss << values;
ptn->setValue(ss.str(), required, markToString_(node.Mark()));
//std::cerr << "setValue " << pt_node_->getPath() << " \"" << ss.str() << "\"" << std::endl;
//ptree_.recursPrint(std::cerr);
}else if(pt_node_){
std::cerr << "WARNING: Encountered parameter path with parent reference: \"" << pt_node_->getPath()
<< "\" + \"" << param_path << "\". This node will not be available in the unbound parameter tree."
<< markToString_(node.Mark()) << std::endl;
}
}
/*!
* \brief Consumes a file based on an include directives destination.
* \param pfilename YAML file to read
* \param device_trees Vector of TreeNodes to act as roots of
* the filename being read. This allows includes to be scoped to specific
* nodes. The file will be parsed once an applied to all roots in
* device_trees.
*/
void YAML::EventHandler::handleIncludeDirective(const std::string& filename, NodeVector& device_trees, ParameterTree::Node* ptn)
{
//! \todo Be smarter about checking for indirect recursion by keeping a set
// files or limiting the depth of this include stack
// Prevent direct reursion by filename
if(filename == filename_){
throw SpartaException("Direct recursion detected in configuration file. File ")
<< filename_ << " includes " << filename;
//! \todo Include line number in this error
}
std::string filename_used = filename;
// Check to see if we can point to the relative filepath to include based on the
// filepath of the current yaml file in the case that the file does not exist.
boost::filesystem::path fp(filename);
bool found = false;
// Try to find the incldue in the include paths list
for(const auto & incl_path : include_paths_)
{
boost::filesystem::path curr_inc(incl_path);
const auto combined_path = curr_inc / filename;
if (boost::filesystem::exists(combined_path))
{
std::cout << " [PARAMETER INCLUDE NOTE] : Including " << combined_path << std::endl;
filename_used = combined_path.string();
found = true;
break;
}
}
if(!found) {
SpartaException e("Could not resolve location of included file: '");
e << filename << "' in source file: " << filename_ << "\nSearch paths: \n";
for(const auto & incl_path : include_paths_) {
e << "\t" << incl_path << '\n';
}
e << '\n';
throw e;
}
YAML incl(filename_used, include_paths_);
incl.allowMissingNodes(doesAllowMissingNodes()); // Allow missing nodes if parent does
incl.setParameterApplyFilter(filter_predicate_); // How to filter nodes that are about to be assigned
TreeNode dummy("dummy", "dummy");
NodeVector dummy_tree{&dummy};
incl.consumeParameters(device_trees.size() > 0 ? device_trees : dummy_tree, verbose_); // Throws on error
if(ptn){ // Because ptree cannot handle parent references yet
ptn->appendTree(incl.getParameterTree().getRoot()); // Bring over tree
}
}
}; // namespace ConfigParser
}; // namespace sparta
| 48.22294 | 192 | 0.479799 | knute-sifive |
98815a520bf31d25aeac0f04e309df6294cfa41f | 19,577 | cpp | C++ | tc 160+/FoxSearchingRuins.cpp | ibudiselic/contest-problem-solutions | 88082981b4d87da843472e3ca9ed5f4c42b3f0aa | [
"BSD-2-Clause"
] | 3 | 2015-05-25T06:24:37.000Z | 2016-09-10T07:58:00.000Z | tc 160+/FoxSearchingRuins.cpp | ibudiselic/contest-problem-solutions | 88082981b4d87da843472e3ca9ed5f4c42b3f0aa | [
"BSD-2-Clause"
] | null | null | null | tc 160+/FoxSearchingRuins.cpp | ibudiselic/contest-problem-solutions | 88082981b4d87da843472e3ca9ed5f4c42b3f0aa | [
"BSD-2-Clause"
] | 5 | 2015-05-25T06:24:40.000Z | 2021-08-19T19:22:29.000Z | #include <algorithm>
#include <cassert>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <sstream>
#include <string>
#include <vector>
using namespace std;
int bestval[1001][1001];
int bestval2[1001][1001];
struct jewel {
int x, y, v;
jewel(int x_, int y_, int v_): x(x_), y(y_), v(v_) {}
};
bool operator<(const jewel &a, const jewel &b) {
if (a.y != b.y) {
return a.y < b.y;
} else if (a.x != b.x) {
return a.x < b.x;
} else {
return a.v < b.v;
}
}
class RunningMaxes {
// this structure uses an upper fenwick tree to support
// O(logn) set_value for insering a value at a position and
// get_max(from) that returns the maximal value from the interval [from, MAXVAL]
// using only O(n) space
public:
RunningMaxes(int MAXVAL_): MAXVAL(MAXVAL_), M(MAXVAL+1, 0) {} // change 0 with -INF if necessary
void set_value(int at, int x) {
M[0] = max(M[0], x);
while (at > 0) {
M[at] = max(M[at], x);
at -= at&-at;
}
}
int get_max(int from) { // get_max(from, MAXVAL)
if (from == 0) return M[0];
int ret = 0; // replace with -INF if necessary
while (from <= MAXVAL) {
ret = max(ret, M[from]);
from += from&-from;
}
return ret;
}
private:
const int MAXVAL;
vector<int> M;
};
class RunningMaxes2 {
// this structure uses a lower fenwick tree to support
// O(logn) set_value for insering a value at a position and
// get_max(to) that returns the maximal value from the interval [0, to]
// using only O(n) space
public:
RunningMaxes2(int MAXVAL_): MAXVAL(MAXVAL_), M(MAXVAL+1, 0) {} // change 0 with -INF if necessary
void set_value(int at, int x) {
while (at <= MAXVAL) {
M[at] = max(M[at], x);
at |= at+1;
}
}
int get_max(int to) { // get_max(0, to)
int ret = 0; // replace with -INF if necessary
while (to >= 0) {
ret = max(ret, M[to]);
to = (to & (to+1)) - 1;
}
return ret;
}
private:
const int MAXVAL;
vector<int> M;
};
class SegmentTree {
// only works for positive values!
public:
SegmentTree(int MAXVAL_): MAXVAL(MAXVAL_), M(2*(MAXVAL+1), 0) { init(0, 0, MAXVAL); }
void set_value(int at, int x) { set_value(0, 0, MAXVAL, at, x); }
int get_max(int a, int b) { return get_max(0, 0, MAXVAL, a, b); }
private:
int init(int node, int l, int r) {
while (node >= (int)M.size()) {
M.push_back(0);
}
if (l == r) {
return (M[node] = 0); // change with -INF if necessary or some A[l] for an array with inital values
} else {
int mid = l + (r-l)/2;
return (M[node] = max(init(2*node + 1, l, mid), init(2*node + 2, mid+1, r)));
}
}
int set_value(int node, int l, int r, int at, int x) {
if (at<l || r<at) {
return M[node];
}
if (l == r) {
assert(l == at);
return (M[node] = max(M[node], x));
} else {
int mid = l + (r-l)/2;
// don't need to check the old value since set_value will
// properly recalculate the max for the whole interval
return (M[node] = max(set_value(2*node + 1, l, mid, at, x),
set_value(2*node + 2, mid+1, r, at, x)));
}
}
int get_max(int node, int l, int r, int a, int b) {
if (a>r || b<l) {
return -1;
}
a = max(a, l);
b = min(b, r);
if (a==l && b==r) {
return M[node];
} else {
int mid = l + (r-l)/2;
return max(get_max(2*node + 1, l, mid, a, b),
get_max(2*node + 2, mid+1, r, a, b));
}
}
const int MAXVAL;
vector<int> M;
};
class FoxSearchingRuins {
public:
long long theMinTime(int W, int H, int n, int LR, int goalValue, int timeX, int timeY, vector <int> seeds) {
vector<jewel> J;
J.reserve(n);
J.push_back(jewel(((long long)seeds[1]*seeds[0] + seeds[2]) % W,
((long long)seeds[4]*seeds[3] + seeds[5]) % H,
((long long)seeds[7]*seeds[6] + seeds[8]) % seeds[9]));
for (int i=1; i<n; ++i) {
J.push_back(jewel(((long long)seeds[1]*J.back().x + seeds[2]) % W,
((long long)seeds[4]*J.back().y + seeds[5]) % H,
((long long)seeds[7]*J.back().v + seeds[8]) % seeds[9]));
}
sort(J.begin(), J.end());
for (int i=0; i<n-1; ++i) {
int j = i+1;
while (j<n && J[i].x==J[j].x && J[i].y==J[j].y) {
J[i].v += J[j].v;
J[j].y = H;
++j;
}
i = j - 1;
}
sort(J.begin(), J.end());
while (J.back().y == H) {
--n;
J.pop_back();
}
vector<int> ys;
for (int i=0; i<n; ++i) {
if (ys.size()==0 || J[i].y!=ys.back()) {
ys.push_back(J[i].y);
}
}
/* uncomment this for RuningMaxes with an upper fenwick tree
vector<RunningMaxes> left(W+LR, RunningMaxes(W-1));
vector<RunningMaxes> right(W+LR, RunningMaxes(W-1));
*/
/* uncomment this for RunningMaxes2 with a lower fenwick tree
vector<RunningMaxes2> left(W+LR, RunningMaxes2(W-1));
vector<RunningMaxes2> right(W+LR, RunningMaxes2(W-1));
*/
vector<SegmentTree> left(W+LR, SegmentTree(W-1));
vector<SegmentTree> right(W+LR, SegmentTree(W-1));
long long sol = -1;
for (int i=0; i<(int)ys.size(); ++i) {
const int Y = ys[i];
vector<int> xs, vals;
for (int j=0; j<n; ++j) {
if (J[j].y == Y) {
while (j<n && J[j].y==Y) {
if (xs.size() > 0) {
assert(xs.back() < J[j].x);
}
xs.push_back(J[j].x);
vals.push_back(J[j].v);
++j;
}
break;
}
}
/* this uses RunningMaxes with an upper fenwick tree
for (int j=0; j<(int)xs.size(); ++j) {
for (int lr=0; lr<=LR; ++lr) { // -> amount of LR moves used thus far
bestval[j][lr] = bestval2[j][lr] = vals[j] // -> this is the "entry" value to this row (motion within the row is handled later)
+ max(left[xs[j]+LR-lr].get_max(W-1-xs[j]), // -> the columns further left must have spent less lr so the difference x-lr is constant
// however, since that could be negative, we add LR to it to make it nonegative
// -> also, since we are using an upper fenwick tree for a segment tree, only get_max(from, MAXVAL)
// queries are supported (MAXVAL is W-1) - therefore, the values are reversed because we need
// queries get_max(0, to)... note also that a lower fenwick tree would work nicely for this, but
// requires a separate implementation
right[xs[j]+lr].get_max(xs[j])); // -> the columns further right must have spent less lr so the sum x+lr is constant
// -> also, when using an upper fenwick tree for a segment tree, only get_max(from, MAXVAL)
// queries are supported (MAXVAL here is W-1)
}
}
// now try moving left/right... it is always optimal to do a single sweep left or right
// this is because we can alwasy not take jewels moving right and then sweep to the left, or vice versa...
for (int j=1; j<(int)xs.size(); ++j) { // sweep right
for (int lr=xs[j]-xs[j-1]; lr<=LR; ++lr) {
bestval[j][lr] = max(bestval[j][lr], vals[j] + bestval[j-1][lr-(xs[j]-xs[j-1])]);
}
}
for (int j=(int)xs.size()-2; j>=0; --j) { // sweep left
for (int lr=xs[j+1]-xs[j]; lr<=LR; ++lr) {
bestval2[j][lr] = max(bestval2[j][lr], vals[j] + bestval2[j+1][lr-(xs[j+1]-xs[j])]);
}
}
for (int j=0; j<(int)xs.size(); ++j) {
for (int lr=0; lr<=LR; ++lr) {
int best = max(bestval[j][lr], bestval2[j][lr]);
if (best >= goalValue) {
long long t = (long long)Y*timeY + (long long)lr*timeX;
if (sol==-1 || t<sol) {
sol = t;
}
}
left[xs[j]+LR-lr].set_value(W-1-xs[j], best);
right[xs[j]+lr].set_value(xs[j], best);
}
} */
/* this uses running maxes with a lower fenwick tree.
for (int j=0; j<(int)xs.size(); ++j) {
for (int lr=0; lr<=LR; ++lr) {
bestval[j][lr] = bestval2[j][lr] = vals[j]
+ max(left[xs[j]+LR-lr].get_max(xs[j]), // since this uses a lower fenwick tree, it supports get_max(0, to) queries
// and that is exactly what is needed for the left hand side
right[xs[j]+lr].get_max(W-1-xs[j])); // similarly to the previous solution using RunningMaxes with an upper fenwick tree,
// we will reverse the values in 'right' trees so that we can use the get_max call
// to simulate (from, MAXVAL) queries
}
}
// this part is the same
for (int j=1; j<(int)xs.size(); ++j) {
for (int lr=xs[j]-xs[j-1]; lr<=LR; ++lr) {
bestval[j][lr] = max(bestval[j][lr], vals[j] + bestval[j-1][lr-(xs[j]-xs[j-1])]);
}
}
for (int j=(int)xs.size()-2; j>=0; --j) {
for (int lr=xs[j+1]-xs[j]; lr<=LR; ++lr) {
bestval2[j][lr] = max(bestval2[j][lr], vals[j] + bestval2[j+1][lr-(xs[j+1]-xs[j])]);
}
}
for (int j=0; j<(int)xs.size(); ++j) {
for (int lr=0; lr<=LR; ++lr) {
int best = max(bestval[j][lr], bestval2[j][lr]);
if (best >= goalValue) {
long long t = (long long)Y*timeY + (long long)lr*timeX;
if (sol==-1 || t<sol) {
sol = t;
}
}
// this is reversed from the previous case... here we are reversing the 'right' trees since we are using a lower fenwick tree
left[xs[j]+LR-lr].set_value(xs[j], best);
right[xs[j]+lr].set_value(W-1-xs[j], best);
}
} */
// this is by far the slowest solution... worst case is about 1.99 secs (or above)
for (int j=0; j<(int)xs.size(); ++j) {
for (int lr=0; lr<=LR; ++lr) {
bestval[j][lr] = bestval2[j][lr] = vals[j] + max(left[xs[j]+LR-lr].get_max(0, xs[j]), right[xs[j]+lr].get_max(xs[j], W-1));
}
}
for (int j=1; j<(int)xs.size(); ++j) {
for (int lr=xs[j]-xs[j-1]; lr<=LR; ++lr) {
bestval[j][lr] = max(bestval[j][lr], vals[j] + bestval[j-1][lr-(xs[j]-xs[j-1])]);
}
}
for (int j=(int)xs.size()-2; j>=0; --j) {
for (int lr=xs[j+1]-xs[j]; lr<=LR; ++lr) {
bestval2[j][lr] = max(bestval2[j][lr], vals[j] + bestval2[j+1][lr-(xs[j+1]-xs[j])]);
}
}
for (int j=0; j<(int)xs.size(); ++j) {
for (int lr=0; lr<=LR; ++lr) {
int best = max(bestval[j][lr], bestval2[j][lr]);
if (best >= goalValue) {
long long t = (long long)Y*timeY + (long long)lr*timeX;
if (sol==-1 || t<sol) {
sol = t;
}
}
left[xs[j]+LR-lr].set_value(xs[j], best);
right[xs[j]+lr].set_value(xs[j], best);
}
}
}
return sol;
}
/*
int L[1000], R[1000];
O(n^5) ili tako nesto... jako sporo, ali tocno
memset(L, 0xff, sizeof L);
memset(R, 0xff, sizeof R);
for (int i=0; i<n; ++i) {
if (i>0 && J[i-1].y==J[i].y) {
L[i] = i-1;
}
if (i<n-1 && J[i].y==J[i+1].y) {
R[i] = i+1;
}
}
long long sol = -1LL;
memset(bestval, 0xff, sizeof bestval);
for (int i=0; i<n; ++i) {
bestval[i][LR] = J[i].v;
for (int j=0; J[j].y<J[i].y; ++j) {
const int dlr = abs(J[j].x - J[i].x);
for (int lr=dlr; lr<=LR; ++lr) {
if (bestval[j][lr] == -1) {
continue;
}
int l = i;
int val_l = 0;
do {
val_l += J[l].v;
int r = i;
int val_r = 0;
do {
if (r != i) {
val_r += J[r].v;
}
int lr_cost;
lr_cost = abs(J[j].x - J[l].x) + abs(J[r].x - J[l].x) + abs(J[r].x - J[i].x);
if (lr_cost <= lr) {
bestval[i][lr-lr_cost] = max(bestval[i][lr-lr_cost], bestval[j][lr] + val_l + val_r);
}
lr_cost = abs(J[j].x - J[r].x) + abs(J[r].x - J[l].x) + abs(J[l].x - J[i].x);
if (lr_cost <= lr) {
bestval[i][lr-lr_cost] = max(bestval[i][lr-lr_cost], bestval[j][lr] + val_l + val_r);
}
r = R[r];
} while (r != -1);
l = L[l];
} while (l != -1);
}
}
for (int lr=0; lr<=LR; ++lr) {
long long t = (long long)J[i].y*timeY + (long long)(LR-lr)*timeX;
if (bestval[i][lr] >= goalValue) {
if (sol==-1 || sol>t) {
sol = t;
}
}
}
}*/
// BEGIN CUT HERE
public:
void run_test(int Case) { if ((Case == -1) || (Case == 0)) test_case_0(); if ((Case == -1) || (Case == 1)) test_case_1(); if ((Case == -1) || (Case == 2)) test_case_2(); if ((Case == -1) || (Case == 3)) test_case_3(); if ((Case == -1) || (Case == 4)) test_case_4(); if ((Case == -1) || (Case == 5)) test_case_5(); }
private:
template <typename T> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
void verify_case(int Case, const long long &Expected, const long long &Received) { cerr << "Test Case #" << Case << "..."; if (Expected == Received) cerr << "PASSED" << endl; else { cerr << "FAILED" << endl; cerr << "\tExpected: \"" << Expected << '\"' << endl; cerr << "\tReceived: \"" << Received << '\"' << endl; } }
void test_case_0() { int Arg0 = 5; int Arg1 = 8; int Arg2 = 5; int Arg3 = 7; int Arg4 = 10; int Arg5 = 3; int Arg6 = 1; int Arr7[] = {979, 777, 878, 646, 441, 545, 789, 896, 987, 10}; vector <int> Arg7(Arr7, Arr7 + (sizeof(Arr7) / sizeof(Arr7[0]))); long long Arg8 = 5LL; verify_case(0, Arg8, theMinTime(Arg0, Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7)); }
void test_case_1() { int Arg0 = 7; int Arg1 = 8; int Arg2 = 10; int Arg3 = 3; int Arg4 = 10; int Arg5 = 3; int Arg6 = 10; int Arr7[] = {0, 1, 1, 0, 1, 3, 1011, 3033, 2022, 10}; vector <int> Arg7(Arr7, Arr7 + (sizeof(Arr7) / sizeof(Arr7[0]))); long long Arg8 = 29LL; verify_case(1, Arg8, theMinTime(Arg0, Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7)); }
void test_case_2() { int Arg0 = 7; int Arg1 = 8; int Arg2 = 10; int Arg3 = 3; int Arg4 = 14; int Arg5 = 3; int Arg6 = 10; int Arr7[] = {0, 1, 1, 0, 1, 3, 1011, 3033, 2022, 10}; vector <int> Arg7(Arr7, Arr7 + (sizeof(Arr7) / sizeof(Arr7[0]))); long long Arg8 = 59LL; verify_case(2, Arg8, theMinTime(Arg0, Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7)); }
void test_case_3() { int Arg0 = 7; int Arg1 = 8; int Arg2 = 10; int Arg3 = 4; int Arg4 = 14; int Arg5 = 3; int Arg6 = 10; int Arr7[] = {0, 1, 1, 0, 1, 3, 1011, 3033, 2022, 10}; vector <int> Arg7(Arr7, Arr7 + (sizeof(Arr7) / sizeof(Arr7[0]))); long long Arg8 = 42LL; verify_case(3, Arg8, theMinTime(Arg0, Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7)); }
void test_case_4() { int Arg0 = 497; int Arg1 = 503; int Arg2 = 989; int Arg3 = 647; int Arg4 = 100000; int Arg5 = 13; int Arg6 = 14; int Arr7[] = {7613497, 5316789, 1334537, 2217889, 6349551, 978463, 1234567, 2345678, 3456789, 1000}; vector <int> Arg7(Arr7, Arr7 + (sizeof(Arr7) / sizeof(Arr7[0]))); long long Arg8 = -1LL; verify_case(4, Arg8, theMinTime(Arg0, Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7)); }
void test_case_5() { int Arg0 = 1000; int Arg1 = 749613275; int Arg2 = 1000; int Arg3 = 1000; int Arg4 = 7500000; int Arg5 = 97; int Arg6 = 6; int Arr7[] = {224284427, 617001937, 294074399, 606566321, 202762619, 419798101, 200613401, 640663967, 417565817, 170000}; vector <int> Arg7(Arr7, Arr7 + (sizeof(Arr7) / sizeof(Arr7[0]))); long long Arg8 = 3780225876LL; verify_case(5, Arg8, theMinTime(Arg0, Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7)); }
// END CUT HERE
};
// BEGIN CUT HERE
int main()
{
FoxSearchingRuins ___test;
___test.run_test(-1);
}
// END CUT HERE
| 47.982843 | 447 | 0.427543 | ibudiselic |
9882f664ec54e7d3e5a94a7eff8ed960a2dcf1f8 | 6,215 | cpp | C++ | unit_tests/test_classes/const_functions.cpp | SoapyMan/oolua | 9d25a865b05bbb6aaff56726b46e5b746572e490 | [
"MIT"
] | 4 | 2018-12-19T09:30:24.000Z | 2021-06-26T05:38:11.000Z | unit_tests/test_classes/const_functions.cpp | SoapyMan/oolua | 9d25a865b05bbb6aaff56726b46e5b746572e490 | [
"MIT"
] | null | null | null | unit_tests/test_classes/const_functions.cpp | SoapyMan/oolua | 9d25a865b05bbb6aaff56726b46e5b746572e490 | [
"MIT"
] | 2 | 2017-03-28T18:38:30.000Z | 2018-10-17T19:01:05.000Z |
# include "oolua_tests_pch.h"
# include "oolua.h"
# include "common_cppunit_headers.h"
# include "gmock/gmock.h"
# include "expose_const_func.h"
namespace
{
struct ConstantMockHelper
{
ConstantMockHelper()
: mock()
, ptr_to_const(&mock)
, ptr_to(&mock)
{}
ConstantMock mock;
Constant const* ptr_to_const;
Constant * ptr_to;
};
} // namespace
/*
Tests that the object, on which are calls are requested, handles the following correctly :
call none constant function on a none constant object
call a constant function on a none constant object
call a constant function on a constant object
error:
call a none constant function on a constant object
Tested for C++ proxied functions either called directly in Lua or indirectly via functions
added to the type in Lua, which in turn will call the C++ functions.
*/
class Constant_functions : public CPPUNIT_NS::TestFixture
{
CPPUNIT_TEST_SUITE(Constant_functions);
CPPUNIT_TEST(callConstantFunction_passedConstantInstance_calledOnce);
CPPUNIT_TEST(callConstantFunction_passedNoneConstantInstance_calledOnce);
CPPUNIT_TEST(callNoneConstantFunction_passedNoneConstantInstance_calledOnce);
CPPUNIT_TEST(callLuaAddedFunctionWhichCallsConstMember_passedConstantInstance_calledOnce);
CPPUNIT_TEST(callLuaAddedFunctionWhichCallsConstMember_passedNoneConstantInstance_calledOnce);
CPPUNIT_TEST(callLuaAddedFunctionWhichCallsNoneConstMember_passedNoneConstantInstance_calledOnce);
#if OOLUA_STORE_LAST_ERROR == 1
CPPUNIT_TEST(callNoneConstantFunction_passedConstantInstance_callReturnsFalse);
CPPUNIT_TEST(callLuaAddedFunctionWhichCallsNoneConstMember_passedConstantInstance_callReturnsFalse);
CPPUNIT_TEST(callConstantMethodInBaseClass_usesConstantInstance_callReturnsTrue);
#endif
#if OOLUA_USE_EXCEPTIONS == 1
CPPUNIT_TEST(callNoneConstantFunction_passedConstantInstance_throwsRuntimeError);
CPPUNIT_TEST(callLuaAddedFunctionWhichCallsNoneConstMember_passedConstantInstance_callThrowsRuntimeError);
CPPUNIT_TEST(callConstantMethodInBaseClass_usesConstantInstance_noException);
#endif
CPPUNIT_TEST_SUITE_END();
OOLUA::Script * m_lua;
public:
Constant_functions()
: m_lua(0)
{}
LVD_NOCOPY(Constant_functions)
void setUp()
{
m_lua = new OOLUA::Script;
m_lua->register_class<Constant>();
}
void tearDown()
{
delete m_lua;
}
void callConstantFunction_passedConstantInstance_calledOnce()
{
ConstantMockHelper helper;
EXPECT_CALL(helper.mock, cpp_func_const()).Times(1);
m_lua->run_chunk("return function(obj) obj:cpp_func_const() end");
m_lua->call(1, helper.ptr_to_const);
}
void callConstantFunction_passedNoneConstantInstance_calledOnce()
{
ConstantMockHelper helper;
EXPECT_CALL(helper.mock, cpp_func_const()).Times(1);
m_lua->run_chunk("return function(obj) obj:cpp_func_const() end");
m_lua->call(1, helper.ptr_to);
}
void callNoneConstantFunction_passedNoneConstantInstance_calledOnce()
{
ConstantMockHelper helper;
EXPECT_CALL(helper.mock, cpp_func()).Times(1);
m_lua->run_chunk("return function(obj) obj:cpp_func() end");
m_lua->call(1, helper.ptr_to);
}
void callLuaAddedFunctionWhichCallsConstMember_passedConstantInstance_calledOnce()
{
ConstantMockHelper helper;
EXPECT_CALL(helper.mock, cpp_func_const()).Times(1);
m_lua->run_chunk("function Constant:lua_const_func() self:cpp_func_const() end "
"return function(object) object:lua_const_func() end ");
m_lua->call(1, helper.ptr_to_const);
}
void callLuaAddedFunctionWhichCallsConstMember_passedNoneConstantInstance_calledOnce()
{
ConstantMockHelper helper;
EXPECT_CALL(helper.mock, cpp_func_const()).Times(1);
m_lua->run_chunk("function Constant:lua_const_func() self:cpp_func_const() end "
"return function(object) object:lua_const_func() end ");
m_lua->call(1, helper.ptr_to_const);
}
void callLuaAddedFunctionWhichCallsNoneConstMember_passedNoneConstantInstance_calledOnce()
{
ConstantMockHelper helper;
EXPECT_CALL(helper.mock, cpp_func()).Times(1);
m_lua->run_chunk("function Constant:lua_func() self:cpp_func() end "
"return function(object) object:lua_func() end ");
m_lua->call(1, helper.ptr_to);
}
#if OOLUA_STORE_LAST_ERROR == 1
void callNoneConstantFunction_passedConstantInstance_callReturnsFalse()
{
ConstantMockHelper helper;
m_lua->run_chunk("return function(obj) obj:cpp_func() end");
CPPUNIT_ASSERT_EQUAL(false, m_lua->call(1, helper.ptr_to_const));
}
void callLuaAddedFunctionWhichCallsNoneConstMember_passedConstantInstance_callReturnsFalse()
{
ConstantMockHelper helper;
m_lua->run_chunk("function Constant:lua_func() self:cpp_func() end "
"return function(object) object:lua_func() end ");
CPPUNIT_ASSERT_EQUAL(false, m_lua->call(1, helper.ptr_to_const));
}
void callConstantMethodInBaseClass_usesConstantInstance_callReturnsTrue()
{
DerivesToUseConstMethod instance;
DerivesToUseConstMethod const* const_instance = &instance;
OOLUA::register_class<DerivesToUseConstMethod>(*m_lua);
m_lua->run_chunk("return function(obj) obj:cpp_func_const() end");
CPPUNIT_ASSERT_EQUAL(true, m_lua->call(1, const_instance));
}
#endif
#if OOLUA_USE_EXCEPTIONS == 1
void callNoneConstantFunction_passedConstantInstance_throwsRuntimeError()
{
ConstantMockHelper helper;
m_lua->run_chunk("return function(obj) obj:cpp_func() end");
CPPUNIT_ASSERT_THROW((m_lua->call(1, helper.ptr_to_const)), OOLUA::Runtime_error);
}
void callLuaAddedFunctionWhichCallsNoneConstMember_passedConstantInstance_callThrowsRuntimeError()
{
ConstantMockHelper helper;
m_lua->run_chunk("function Constant:lua_func() self:cpp_func() end "
"return function(object) object:lua_func() end ");
CPPUNIT_ASSERT_THROW((m_lua->call(1, helper.ptr_to_const)), OOLUA::Runtime_error);
}
void callConstantMethodInBaseClass_usesConstantInstance_noException()
{
DerivesToUseConstMethod instance;
DerivesToUseConstMethod const* const_instance = &instance;
OOLUA::register_class<DerivesToUseConstMethod>(*m_lua);
m_lua->run_chunk("return function(obj) obj:cpp_func_const() end");
CPPUNIT_ASSERT_NO_THROW(m_lua->call(1, const_instance));
}
#endif
};
CPPUNIT_TEST_SUITE_REGISTRATION(Constant_functions);
| 34.72067 | 108 | 0.799678 | SoapyMan |
98854f72a0dae86d558a5c2a641d0428297072bb | 2,715 | cpp | C++ | tests/test_for_Status.cpp | PGZXB/PGBigNumber | a0f128a0b415bd1a63929c55c2f952205c1a59df | [
"MIT"
] | 2 | 2021-10-25T23:56:54.000Z | 2022-01-02T06:35:49.000Z | tests/test_for_Status.cpp | PGZXB/PGBigNumber | a0f128a0b415bd1a63929c55c2f952205c1a59df | [
"MIT"
] | 1 | 2021-11-12T09:03:39.000Z | 2021-12-27T02:03:41.000Z | tests/test_for_Status.cpp | PGZXB/PGBigNumber | a0f128a0b415bd1a63929c55c2f952205c1a59df | [
"MIT"
] | null | null | null | #include "Status.h"
#include <iostream>
#define STATUS (*pgbn::Status::getInstance())
std::int8_t a = 0, b = 0;
std::int8_t c = 0;
enum class CALCU_STATUS : pgbn::Enum {
SUCCESS,
DIV_ZERO_ERR,
ADD_OVERFLOW_ERR,
SUB_OVERFLOW_ERR,
ADD_GLOB_A_AND_B_ERROR,
};
#define TO_ENUM(val) static_cast<pgbn::Enum>(val)
std::int8_t add(std::int8_t a, std::int8_t b) {
std::int8_t res = a + b;
if (
(a > 0 && b > 0 && res <= 0) ||
(a < 0 && b < 0 && res >= 0)
) STATUS = TO_ENUM(CALCU_STATUS::ADD_OVERFLOW_ERR);
else {
STATUS = TO_ENUM(CALCU_STATUS::SUCCESS);
}
return res;
}
void add(std::int8_t a, std::int8_t b, std::int8_t & res) {
res = a + b;
if (
(a > 0 && b > 0 && res <= 0) ||
(a < 0 && b < 0 && res >= 0)
) STATUS = TO_ENUM(CALCU_STATUS::ADD_GLOB_A_AND_B_ERROR);
else {
STATUS = TO_ENUM(CALCU_STATUS::SUCCESS);
}
}
std::int8_t sub(std::int8_t a, std::int8_t b) {
std::int8_t res = a - b;
if (
(a > 0 && b < 0 && res <= 0) ||
(a < 0 && b > 0 && res >= 0)
) STATUS = TO_ENUM(CALCU_STATUS::SUB_OVERFLOW_ERR);
else {
STATUS = TO_ENUM(CALCU_STATUS::SUCCESS);
}
return res;
}
std::int8_t divide(std::int8_t a, std::int8_t b) {
if (b == 0) STATUS = TO_ENUM(CALCU_STATUS::DIV_ZERO_ERR);
else STATUS = TO_ENUM(CALCU_STATUS::SUCCESS);
return a / b;
}
void err_output(pgbn::Enum err_no) {
std::cerr << err_no << " : " << pgbn::Status::getInfo(err_no) << '\n';
}
void add_err(std::int8_t & a, std::int8_t & b, std::int8_t & c) {
std::cerr << "Calcu " << (int)a << " + " << (int)b << " = " << (int)c << " Error\n";
err_output(
static_cast<pgbn::Enum>(CALCU_STATUS::ADD_GLOB_A_AND_B_ERROR)
);
}
void err_exit(pgbn::Enum err_no) {
err_output(err_no);
std::cerr << "Exiting---\n";
exit(-1);
}
void test() {
std::cerr << "TEST\n";
}
#define REG pgbn::Status::registe
int main () {
// // 注册错误码
REG(CALCU_STATUS::SUCCESS, "SUCCESS");
REG(CALCU_STATUS::ADD_OVERFLOW_ERR, "Add Overflow\n", err_output, TO_ENUM(CALCU_STATUS::ADD_OVERFLOW_ERR));
REG(CALCU_STATUS::SUB_OVERFLOW_ERR, "Sub Overflow\n", err_output, TO_ENUM(CALCU_STATUS::SUB_OVERFLOW_ERR));
REG(CALCU_STATUS::ADD_GLOB_A_AND_B_ERROR, "Add a And b Error\n", add_err, std::ref<int8_t>(a), std::ref<int8_t>(b), std::ref<int8_t>(c));
REG(CALCU_STATUS::DIV_ZERO_ERR, "DIV 0 Error", err_exit, TO_ENUM(CALCU_STATUS::DIV_ZERO_ERR));
add(1, 2); // success
add(100, 100); // overflow
sub(2, 4); // success
sub(100, -100); // overflow
a = b = 100;
add(a, b, c); // error
divide(1, 0);
return 0;
}
| 24.241071 | 141 | 0.580479 | PGZXB |
98877f9748bf6d391328816228d16d81cad82645 | 741 | hpp | C++ | libraries/CMakeServerConnector/include/Messages/HandshakeRequest.hpp | Megaxela/HGEngineReloadedEditor | be79b6089985da1bf811be8a6d06ce25f71236b1 | [
"MIT"
] | null | null | null | libraries/CMakeServerConnector/include/Messages/HandshakeRequest.hpp | Megaxela/HGEngineReloadedEditor | be79b6089985da1bf811be8a6d06ce25f71236b1 | [
"MIT"
] | null | null | null | libraries/CMakeServerConnector/include/Messages/HandshakeRequest.hpp | Megaxela/HGEngineReloadedEditor | be79b6089985da1bf811be8a6d06ce25f71236b1 | [
"MIT"
] | 1 | 2020-03-12T04:39:14.000Z | 2020-03-12T04:39:14.000Z | #pragma once
#include <Messages/BasicMessage.hpp>
#include <Version.hpp>
#include <Messages/Register.hpp>
struct HandshakeRequest : public BasicMessage
{
HandshakeRequest() :
sourceDirectory(),
buildDirectory(),
generator(),
protocolVersion()
{
type = Messages::Type::HandshakeRequest;
}
static nlohmann::json serialize(const BasicMessage &msg);
std::string sourceDirectory;
std::string buildDirectory;
std::string generator;
Version protocolVersion;
};
namespace
{
Messages::Registrator<HandshakeRequest> HandshakeRequestRegistrator(
"handshake",
Messages::Type::HandshakeRequest,
&HandshakeRequest::serialize,
nullptr
);
} | 21.794118 | 72 | 0.672065 | Megaxela |
988fb19474526c03629437f7759cd979b03d7665 | 10,133 | cpp | C++ | code/src/engine/application/window_user32.cpp | shossjer/fimbulwinter | d894e4bddb5d2e6dc31a8112d245c6a1828604e3 | [
"0BSD"
] | 3 | 2020-04-29T14:55:58.000Z | 2020-08-20T08:43:24.000Z | code/src/engine/application/window_user32.cpp | shossjer/fimbulwinter | d894e4bddb5d2e6dc31a8112d245c6a1828604e3 | [
"0BSD"
] | 1 | 2022-03-12T11:37:46.000Z | 2022-03-12T20:17:38.000Z | code/src/engine/application/window_user32.cpp | shossjer/fimbulwinter | d894e4bddb5d2e6dc31a8112d245c6a1828604e3 | [
"0BSD"
] | null | null | null | #include "config.h"
#if WINDOW_USE_USER32
#include "window.hpp"
#include "engine/application/config.hpp"
#include "engine/debug.hpp"
#if TEXT_USE_USER32
# include "utility/unicode/string_view.hpp"
#endif
#include <windowsx.h>
#include <windows.h>
#if HAVE_VERSIONHELPERS_H
# include <versionhelpers.h>
#endif
namespace engine
{
namespace graphics
{
extern void notify_resize(viewer & viewer, int width, int height);
}
namespace hid
{
#if INPUT_HAS_USER32_RAWINPUT
extern void add_device(devices & devices, HANDLE device);
extern void remove_device(devices & devices, HANDLE device);
extern void process_input(devices & devices, HRAWINPUT input);
#endif
extern void key_character(devices & devices, int scancode, const char16_t * character);
extern void key_down(devices & devices, WPARAM wParam, LPARAM lParam, LONG time);
extern void key_up(devices & devices, WPARAM wParam, LPARAM lParam, LONG time);
extern void syskey_down(devices & devices, WPARAM wParam, LPARAM lParam, LONG time);
extern void syskey_up(devices & devices, WPARAM wParam, LPARAM lParam, LONG time);
extern void lbutton_down(devices & devices, LONG time);
extern void lbutton_up(devices & devices, LONG time);
extern void mbutton_down(devices & devices, LONG time);
extern void mbutton_up(devices & devices, LONG time);
extern void rbutton_down(devices & devices, LONG time);
extern void rbutton_up(devices & devices, LONG time);
extern void mouse_move(devices & devices, int_fast16_t x, int_fast16_t y, LONG time);
extern void mouse_wheel(devices & devices, int_fast16_t delta, LONG time);
extern void notify_resize(ui & ui, const int width, const int height);
}
}
namespace
{
engine::graphics::viewer * viewer = nullptr;
engine::hid::devices * devices = nullptr;
engine::hid::ui * ui = nullptr;
/**
*/
HWND hWnd;
/**
*/
HDC hDC;
/**
*/
HGLRC hGLRC;
/**
*/
LRESULT CALLBACK WinProc(HWND hWnd_, UINT msg, WPARAM wParam, LPARAM lParam)
{
switch (msg)
{
#if INPUT_HAS_USER32_RAWINPUT
case WM_INPUT:
if (GET_RAWINPUT_CODE_WPARAM(wParam) == RIM_INPUT)
{
process_input(*::devices, reinterpret_cast<HRAWINPUT>(lParam));
}
return DefWindowProcW(hWnd_, msg, wParam, lParam);
case WM_INPUT_DEVICE_CHANGE:
switch (wParam)
{
case GIDC_ARRIVAL: add_device(*::devices, reinterpret_cast<HANDLE>(lParam)); break;
case GIDC_REMOVAL: remove_device(*::devices, reinterpret_cast<HANDLE>(lParam)); break;
default: debug_unreachable();
}
break;
#endif
case WM_CHAR:
key_character(*::devices, uint32_t(lParam & 0xff0000) >> 16, reinterpret_cast<const char16_t *>(&wParam));
break;
case WM_KEYDOWN:
key_down(*::devices, wParam, lParam, GetMessageTime());
break;
case WM_KEYUP:
key_up(*::devices, wParam, lParam, GetMessageTime());
break;
case WM_SYSKEYDOWN:
syskey_down(*::devices, wParam, lParam, GetMessageTime());
break;
case WM_SYSKEYUP:
syskey_up(*::devices, wParam, lParam, GetMessageTime());
break;
case WM_MOUSEMOVE:
mouse_move(*::devices, (int_fast16_t)GET_X_LPARAM(lParam), (int_fast16_t)GET_Y_LPARAM(lParam), GetMessageTime());
break;
case WM_LBUTTONDOWN:
lbutton_down(*::devices, GetMessageTime());
break;
case WM_LBUTTONUP:
lbutton_up(*::devices, GetMessageTime());
break;
case WM_RBUTTONDOWN:
rbutton_down(*::devices, GetMessageTime());
break;
case WM_RBUTTONUP:
rbutton_up(*::devices, GetMessageTime());
break;
case WM_MBUTTONDOWN:
mbutton_down(*::devices, GetMessageTime());
break;
case WM_MBUTTONUP:
mbutton_up(*::devices, GetMessageTime());
break;
case WM_MOUSEWHEEL:
mouse_wheel(*::devices, (int_fast16_t)HIWORD(wParam), GetMessageTime());
break;
case WM_CLOSE:
PostQuitMessage(0);
break;
case WM_SIZE:
notify_resize(*::viewer, (int_fast16_t)LOWORD(lParam), (int_fast16_t)HIWORD(lParam));
notify_resize(*::ui, (int_fast16_t)LOWORD(lParam), (int_fast16_t)HIWORD(lParam));
break;
default:
return DefWindowProcW(hWnd_, msg, wParam, lParam);
}
return 0;
}
/**
*/
inline int messageLoop()
{
MSG msg;
while (GetMessageW(&msg, nullptr, 0, 0)) // while the message isn't 'WM_QUIT'
{
TranslateMessage(&msg);
DispatchMessageW(&msg);
}
return (int)msg.wParam;
}
void RegisterRawInputDevicesWithFlags(const uint32_t * collections, int count, DWORD dwFlags, HWND hWnd_)
{
RAWINPUTDEVICE rids[10]; // arbitrary
debug_assert(std::size_t(count) < sizeof rids / sizeof rids[0]);
for (int i = 0; i < count; i++)
{
rids[i].usUsagePage = collections[i] >> 16;
rids[i].usUsage = collections[i] & 0x0000ffff;
rids[i].dwFlags = dwFlags;
rids[i].hwndTarget = hWnd_;
}
if (RegisterRawInputDevices(rids, count, sizeof rids[0]) == FALSE)
{
const auto err = GetLastError();
debug_fail("RegisterRawInputDevices failed: ", err);
}
}
HINSTANCE cast(void * hInstance)
{
return static_cast<HINSTANCE>(hInstance);
}
}
namespace engine
{
namespace application
{
window::~window()
{
wglDeleteContext(hGLRC);
ReleaseDC(hWnd, hDC);
DestroyWindow(hWnd);
UnregisterClassW(L"Tribunal Window Class Name", cast(hInstance_));
::ui = nullptr;
::devices = nullptr;
::viewer = nullptr;
}
// TODO: proper error handling
window::window(HINSTANCE hInstance, int nCmdShow, const config_t & config)
: hInstance_(hInstance)
{
OSVERSIONINFO osvi;
{
ZeroMemory(&osvi, sizeof(OSVERSIONINFO));
osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
}
//GetVersionEx(&osvi);
//debug_printline(engine::application_channel, "GetVersionEx: ", osvi.dwMajorVersion, " ", osvi.dwMinorVersion);
// register window class
const WNDCLASSEX WndClass = {sizeof(WNDCLASSEX),
0,
WinProc,
0,
0,
cast(hInstance),
LoadIconW(0, IDI_APPLICATION),
LoadCursorW(nullptr, IDC_ARROW),
(HBRUSH)COLOR_WINDOW,
0,
L"Tribunal Window Class Name",
LoadIconW(cast(hInstance), IDI_APPLICATION)};
RegisterClassExW(&WndClass);
// create window
::hWnd = CreateWindowExW(WS_EX_CLIENTEDGE,
L"Tribunal Window Class Name",
L"Tribunal \U00010348 \u2603",
WS_OVERLAPPEDWINDOW,
CW_USEDEFAULT,
CW_USEDEFAULT,
config.window_width,
config.window_height,
0,
0,
cast(hInstance),
0);
// create window graphics
::hDC = GetDC(::hWnd);
const PIXELFORMATDESCRIPTOR pfd = {sizeof(PIXELFORMATDESCRIPTOR),
0,
PFD_DOUBLEBUFFER | PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL,
PFD_TYPE_RGBA,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
32,
0,
0,
0,
0,
0,
0,
0};
const int pf = ChoosePixelFormat(::hDC, &pfd);
SetPixelFormat(::hDC, pf, &pfd);
::hGLRC = wglCreateContext(::hDC);
ShowWindow(::hWnd, nCmdShow);
}
void window::set_dependencies(engine::graphics::viewer & viewer_, engine::hid::devices & devices_, engine::hid::ui & ui_)
{
::viewer = &viewer_;
::devices = &devices_;
::ui = &ui_;
}
void make_current(window & /*window*/)
{
wglMakeCurrent(hDC, hGLRC);
}
void swap_buffers(window & /*window*/)
{
SwapBuffers(hDC);
}
#if INPUT_HAS_USER32_RAWINPUT
void RegisterRawInputDevices(window & /*window*/, const uint32_t * collections, int count)
{
RegisterRawInputDevicesWithFlags(collections, count, RIDEV_DEVNOTIFY, hWnd);
}
void UnregisterRawInputDevices(window & /*window*/, const uint32_t * collections, int count)
{
RegisterRawInputDevicesWithFlags(collections, count, RIDEV_REMOVE, nullptr);
}
#endif
#if TEXT_USE_USER32
void buildFont(window & /*window*/, HFONT hFont, DWORD count, DWORD listBase)
{
HGDIOBJ hPrevious = SelectObject(hDC, hFont);
wglUseFontBitmaps(hDC, 0, count, listBase);
SelectObject(hDC, hPrevious);
}
void freeFont(window & /*window*/, HFONT hFont)
{
DeleteObject(hFont);
}
HFONT loadFont(window & /*window*/, utility::string_units_utf8 name, int height)
{
return CreateFontW(height,
0,
0,
0,
FW_DONTCARE,
FALSE,
FALSE,
FALSE,
DEFAULT_CHARSET,
OUT_OUTLINE_PRECIS,
CLIP_DEFAULT_PRECIS,
5, // CLEARTYPE_QUALITY,
VARIABLE_PITCH,
utility::heap_widen(name).data());
}
#endif
int execute(window & /*window*/)
{
return messageLoop();
}
void close()
{
PostMessageW(hWnd, WM_CLOSE, 0, 0);
}
}
}
#endif /* WINDOW_USE_USER32 */
| 28.147222 | 123 | 0.571992 | shossjer |
989213e950580ce23b78398ef53a8e6a90dce76e | 15,564 | cpp | C++ | src/planner.cpp | zgh551/ros_rrt_bias | fd0596603d11acd19dc05d263f6eb3e3354297ae | [
"Apache-2.0"
] | 1 | 2021-12-06T07:39:22.000Z | 2021-12-06T07:39:22.000Z | src/planner.cpp | zgh551/ros_rrt_bias | fd0596603d11acd19dc05d263f6eb3e3354297ae | [
"Apache-2.0"
] | null | null | null | src/planner.cpp | zgh551/ros_rrt_bias | fd0596603d11acd19dc05d263f6eb3e3354297ae | [
"Apache-2.0"
] | 1 | 2021-12-28T02:10:08.000Z | 2021-12-28T02:10:08.000Z | /*
* @brief The planner
*/
#include "../include/planner.h"
#include "../include/rrt_bias.h"
#include "../include/obstacle_checker.h"
#include "../include/convolution.h"
// the tf
#include <algorithm>
#include <fftw3.h>
#include <geometry_msgs/PoseArray.h>
#include <geometry_msgs/PoseStamped.h>
#include <nav_msgs/OccupancyGrid.h>
#include <nav_msgs/Path.h>
#include <ompl/base/ScopedState.h>
#include <ompl/geometric/PathGeometric.h>
#include <ompl/geometric/planners/rrt/RRTstar.h>
#include <ros/time.h>
#include <tf/transform_datatypes.h>
/*
* @brief OMPL lib
*/
#include <ompl/base/PlannerStatus.h>
#include <ompl/base/SpaceInformation.h>
#include <ompl/base/StateSampler.h>
#include <ompl/base/spaces/RealVectorBounds.h>
#include <ompl/base/spaces/SE2StateSpace.h>
#include <ompl/geometric/planners/rrt/BiTRRT.h>
#include <ompl/geometric/planners/rrt/RRTConnect.h>
#include <ompl/geometric/planners/rrt/InformedRRTstar.h>
#include <ompl/geometric/planners/informedtrees/AITstar.h>
/*
* @brief System lib
*/
#include <valarray>
#include <memory>
#include <vector>
#include <visualization_msgs/Marker.h>
using namespace Common;
RRT_planner::Planner::Planner(void)
{
_start_valid = false;
_goal_valid = false;
_is_map_update = false;
_disk_map_width = 7;
_disk_map_height = 7;
_disk_map_size = _disk_map_width * _disk_map_height;
_disk_origin_x = static_cast<int16_t>(-(_disk_map_width - 1) * 0.5);
_disk_origin_y = static_cast<int16_t>(-(_disk_map_height - 1) * 0.5);
_obstacle_map_width = BOUNDARY_SIZE_X;
_obstacle_map_height = BOUNDARY_SIZE_Y;
_obstacle_map_size = _obstacle_map_width * _obstacle_map_height;
_obstacle_origin_x = static_cast<int16_t>(-_obstacle_map_width * 0.5);
_obstacle_origin_y = static_cast<int16_t>(-_obstacle_map_height * 0.5);
/*
* @brief malloc the memory space for grid map
*/
_disk_grid_map = (int8_t*)fftw_malloc(sizeof(int8_t) * _disk_map_size);
/*
* @brief base on the radius of circle produce the grid map
*/
DrawCircle(2);
// the line strip init
_start_pose_line_strip.header.frame_id =
_goal_pose_line_strip.header.frame_id =
_sample_point.header.frame_id =
_plan_path.header.frame_id =
_disk_occ_map.header.frame_id =
_convolution_occ_map.header.frame_id =
_diatance_occ_map.header.frame_id =
"map";
_start_pose_line_strip.header.stamp =
_goal_pose_line_strip.header.stamp =
_sample_point.header.stamp =
_plan_path.header.stamp =
_disk_occ_map.header.stamp =
_convolution_occ_map.header.stamp =
_diatance_occ_map.header.stamp =
ros::Time::now();
_start_pose_line_strip.ns = "start_pose_line_strip";
_goal_pose_line_strip.ns = "goal_pose_line_strip";
_start_pose_line_strip.action =
_goal_pose_line_strip.action =
visualization_msgs::Marker::MODIFY;
_start_pose_line_strip.id = 0;
_goal_pose_line_strip.id = 1;
_start_pose_line_strip.type =
_goal_pose_line_strip.type =
visualization_msgs::Marker::ARROW;
// the line strip scale
_start_pose_line_strip.scale.x = _goal_pose_line_strip.scale.x = 1;
_start_pose_line_strip.scale.y = _goal_pose_line_strip.scale.y = 0.1;
_start_pose_line_strip.scale.z = _goal_pose_line_strip.scale.z = 0.1;
_start_pose_line_strip.color.b = 1.0;
_start_pose_line_strip.color.a = 1.0;
_goal_pose_line_strip.color.g = 1.0;
_goal_pose_line_strip.color.a = 1.0;
/*
* @brief The disk map configure
*/
_disk_occ_map.info.height = _disk_map_height;
_disk_occ_map.info.width = _disk_map_width;
_disk_occ_map.info.origin.position.x = _disk_origin_x;
_disk_occ_map.info.origin.position.y = _disk_origin_y;
_disk_occ_map.info.resolution = 1;
_convolution_occ_map.info.resolution = 1;
_diatance_occ_map.info.resolution = 1;
/*
* @brief The publisher
*/
line_marker_pub = n.advertise<visualization_msgs::Marker>("visualization_marker", 100);
pose_array_pub = n.advertise<geometry_msgs::PoseArray>("sampling_points", 100);
path_state_pub = n.advertise<nav_msgs::Path>("plan_path", 100);
disk_grid_map_pub = n.advertise<nav_msgs::OccupancyGrid>("disk_grid", 100);
sum_grid_map_pub = n.advertise<nav_msgs::OccupancyGrid>("sum_grid", 100);
distance_map_pub = n.advertise<nav_msgs::OccupancyGrid>("distance_map", 100);
/*
* @brief The subscribe
*/
map_sub = n.subscribe("map", 1, &RRT_planner::Planner::MapCallback, this);
start_pose_sub = n.subscribe("initialpose", 1, &RRT_planner::Planner::StartPoseCallback, this);
goal_pose_sub = n.subscribe("move_base_simple/goal", 1, &RRT_planner::Planner::GoalPoseCallback, this);
}
RRT_planner::Planner::~Planner(void)
{
// TODO free memory
}
/*
* @brief The initial function
*/
void RRT_planner::Planner::Init(void)
{
ob::RealVectorBounds obstacle_boundary = ob::RealVectorBounds(2);
obstacle_boundary.setLow(0, _obstacle_origin_x);
obstacle_boundary.setLow(1, _obstacle_origin_y);
obstacle_boundary.setHigh(0, _obstacle_map_width + _obstacle_origin_x);
obstacle_boundary.setHigh(1, _obstacle_map_height + _obstacle_origin_y);
_state_space = std::make_shared<ob::ReedsSheppStateSpace>(5.0);
//_state_space = std::make_shared<ob::SE2StateSpace>();
_state_space->as<ob::SE2StateSpace>()->setBounds(obstacle_boundary);
_si = std::make_shared<ob::SpaceInformation>(_state_space);
_si->setStateValidityChecker(std::make_shared<RRT_planner::ObstacleChecker>(_si));
_si->setStateValidityCheckingResolution(0.03);
_si->setup();
_ss = std::make_shared<og::SimpleSetup>(_si);
_ss->setPlanner(std::make_shared<og::RRT_Bias>(_si));
}
void RRT_planner::Planner::Init(int8_t *map, uint16_t map_width, uint16_t map_height)
{
ob::RealVectorBounds obstacle_boundary = ob::RealVectorBounds(2);
obstacle_boundary.setLow(0, -map_width / 2);
obstacle_boundary.setLow(1, -map_height / 2);
obstacle_boundary.setHigh(0, map_width / 2);
obstacle_boundary.setHigh(1, map_height / 2);
_state_space = std::make_shared<ob::ReedsSheppStateSpace>(5.0);
//_state_space = std::make_shared<ob::SE2StateSpace>();
_state_space->as<ob::SE2StateSpace>()->setBounds(obstacle_boundary);
_si = std::make_shared<ob::SpaceInformation>(_state_space);
_si->setStateValidityChecker(std::make_shared<RRT_planner::ObstacleChecker>(_si, map, map_width, map_height));
_si->setStateValidityCheckingResolution(0.03);
_si->setup();
_ss = std::make_shared<og::SimpleSetup>(_si);
//_ss->setPlanner(std::make_shared<og::RRT_Bias>(_si));
//_ss->setPlanner(std::make_shared<og::BiTRRT>(_si));
_ss->setPlanner(std::make_shared<og::RRTstar>(_si));
}
/*
* @brief The solve function
*/
void RRT_planner::Planner::solve(const double time)
{
if (_start_valid && _goal_valid && _is_map_update)
{
ob::ScopedState<> start_state(_state_space);
ob::ScopedState<> goal_state(_state_space);
start_state->as<ob::SE2StateSpace::StateType>()->setX(_start_position.x);
start_state->as<ob::SE2StateSpace::StateType>()->setY(_start_position.y);
start_state->as<ob::SE2StateSpace::StateType>()->setYaw(_start_position.yaw);
goal_state->as<ob::SE2StateSpace::StateType>()->setX(_goal_position.x);
goal_state->as<ob::SE2StateSpace::StateType>()->setY(_goal_position.y);
goal_state->as<ob::SE2StateSpace::StateType>()->setYaw(_goal_position.yaw);
_ss->setStartAndGoalStates(start_state, goal_state);
_ss->setup();
_ss->print();
ob::PlannerStatus solved = _ss->solve(time);
if (solved)
{
/*
* @brief Step1: the solution path state points
*/
_sample_point.poses.clear();
geometry_msgs::Pose pose_temp;
for (auto &state : _ss->getSolutionPath().getStates())
{
const auto *SE2_state = state->as<ob::SE2StateSpace::StateType>();
pose_temp.position.x = SE2_state->getX();
pose_temp.position.y = SE2_state->getY();
pose_temp.orientation = tf::createQuaternionMsgFromYaw(SE2_state->getYaw());
_sample_point.poses.push_back(pose_temp);
}
pose_array_pub.publish(_sample_point);
/*
* @brief Step2: base on the solution path points,interpolate the
* full path with small step lenght
*/
og::PathGeometric path_state = _ss->getSolutionPath();
// using the solution path to interpolate the state
path_state.interpolate(1000);
geometry_msgs::PoseStamped pose_stamp;
_plan_path.poses.clear();
for (auto &state : path_state.getStates())
{
auto *SE2_state = state->as<ob::SE2StateSpace::StateType>();
pose_stamp.pose.position.x = SE2_state->getX();
pose_stamp.pose.position.y = SE2_state->getY();
_plan_path.poses.push_back(pose_stamp);
}
path_state_pub.publish(_plan_path);
}
else
{
ROS_INFO("plan faile!");
}
_ss->clear();
_goal_valid = false;
}
else
{
//ROS_INFO("map no update or without start or goal point!");
}
}
void RRT_planner::Planner::DrawCircle(double r)
{
for (uint16_t i = 0; i < _disk_map_size; i++)
{
_disk_grid_map[i] = 0;
}
int16_t F = 1 - r;
int16_t x = r;
int16_t y = 0;
int16_t delta_up_left = -2 * r;
int16_t delta_up = 1;
while (y < x)
{
if (F >= 0)
{
for(uint16_t i = -x - _disk_origin_x; i < (x - _disk_origin_x + 1); i++)
{
for (uint16_t j = -y -_disk_origin_y; j < (y - _disk_origin_y + 1); j++)
{
_disk_grid_map[j + _disk_map_width * i] = 100;
}
}
for(uint16_t i = -y - _disk_origin_y; i < (y - _disk_origin_y + 1); i++)
{
for (uint16_t j = -x - _disk_origin_x; j < (x - _disk_origin_x + 1); j++)
{
_disk_grid_map[j + _disk_map_width * i] = 100;
}
}
x -= 1;
delta_up_left += 2;
F += delta_up_left;
}
y += 1;
delta_up += 2;
F += delta_up;
}
}
/*
* @brief the callback function for
*/
void RRT_planner::Planner::MapCallback(const nav_msgs::OccupancyGrid::Ptr map)
{
/*
* @brief obstacle map size update
*/
_obstacle_map_height = map->info.height;
_obstacle_map_width = map->info.width;
_obstacle_map_size = _obstacle_map_width * _obstacle_map_height;
_obstacle_origin_x = static_cast<int16_t>(-_obstacle_map_width * 0.5);
_obstacle_origin_y = static_cast<int16_t>(-_obstacle_map_height * 0.5);
if (_is_map_update)
{
fftw_free(_obstacle_grid_map);
fftw_free(_convolution_grid_map);
}
else
{
_is_map_update = true;
}
_obstacle_grid_map = (int8_t*)fftw_malloc(sizeof(int8_t) * _obstacle_map_size);
_convolution_grid_map = (int8_t*)fftw_malloc(sizeof(int8_t) * _obstacle_map_size);
_convolution_occ_map.info.height = _obstacle_map_height;
_convolution_occ_map.info.width = _obstacle_map_width;
_convolution_occ_map.info.origin.position.x = _obstacle_origin_x;
_convolution_occ_map.info.origin.position.y = _obstacle_origin_y;
_diatance_occ_map.info.height = _obstacle_map_height;
_diatance_occ_map.info.width = _obstacle_map_width;
_diatance_occ_map.info.origin.position.x = _obstacle_origin_x;
_diatance_occ_map.info.origin.position.y = _obstacle_origin_y;
// obstacle map update
for (uint16_t i = 0; i < _obstacle_map_height; i++)
{
for (uint16_t j = 0; j < _obstacle_map_width; j++)
{
_obstacle_grid_map[i * _obstacle_map_width + j] = map->data[i * _obstacle_map_width + j] > 0 ? 100 : 0;
}
}
ROS_INFO("grid map update width:%d,height:%d", _obstacle_map_width, _obstacle_map_height);
double *output_test_grid_map = (double*)fftw_malloc(sizeof(double) * _obstacle_map_size);
int8_t *distance_grid_map = (int8_t*)fftw_malloc(sizeof(int8_t) * _obstacle_map_size);
// calculate the time begin
ros::Time begin = ros::Time::now();
// map convolution
// convolution_2d(_disk_grid_map, _obstacle_grid_map, _convolution_grid_map);
Common::Convolution::convolution_2d( _disk_grid_map, _disk_map_width, _disk_map_height,
_obstacle_grid_map,_obstacle_map_width, _obstacle_map_height,
_convolution_grid_map);
// the end of calculate time
double pro_time = (ros::Time::now() - begin).toSec();
ROS_INFO("convolution time %f", pro_time);
// distance map update
_distance_map.DistanceMapUpdate(_obstacle_map_width, _obstacle_map_height, _obstacle_grid_map, output_test_grid_map);
for (uint16_t i = 0; i < _obstacle_map_size; i++)
{
distance_grid_map[i] = static_cast<int8_t>(output_test_grid_map[i] * 10);
}
/*
* @brief the convolution result map show
*/
std::vector<int8_t> convolution_map_temp(_convolution_grid_map , _convolution_grid_map + _obstacle_map_size);
_convolution_occ_map.data = convolution_map_temp;
sum_grid_map_pub.publish(_convolution_occ_map);
// the distance map show
std::vector<int8_t> distance_temp(distance_grid_map , distance_grid_map + _obstacle_map_size);
_diatance_occ_map.data = distance_temp;
distance_map_pub.publish(_diatance_occ_map);
// the disk map show
std::vector<int8_t> disk_map_temp(_disk_grid_map, _disk_grid_map + _disk_map_size );
_disk_occ_map.data = disk_map_temp;
disk_grid_map_pub.publish(_disk_occ_map);
// init the planner space and obstacle map
Init(_convolution_grid_map, _obstacle_map_width, _obstacle_map_height);
}
/*
* @brief The callback function of start position
*/
void RRT_planner::Planner::StartPoseCallback(const geometry_msgs::PoseWithCovarianceStamped &pose)
{
_start_position.x = pose.pose.pose.position.x;
_start_position.y = pose.pose.pose.position.y;
_start_position.yaw = tf::getYaw(pose.pose.pose.orientation);
_start_valid = true;
_start_pose_line_strip.pose = pose.pose.pose;
line_marker_pub.publish(_start_pose_line_strip);
ROS_INFO("start position x:%f, y:%f, yaw:%f", _start_position.x,
_start_position.y,
_start_position.yaw);
}
/*
* @brief The callback function of goal position
*/
void RRT_planner::Planner::GoalPoseCallback(const geometry_msgs::PoseStamped &pose)
{
_goal_position.x = pose.pose.position.x;
_goal_position.y = pose.pose.position.y;
_goal_position.yaw = tf::getYaw(pose.pose.orientation);
_goal_valid = true;
_goal_pose_line_strip.pose = pose.pose;
line_marker_pub.publish(_goal_pose_line_strip);
ROS_INFO("goal position x:%f, y:%f, yaw:%f", _goal_position.x,
_goal_position.y,
_goal_position.yaw);
}
| 33.982533 | 121 | 0.663133 | zgh551 |
9892ef902a25ceaccf9a96230a579e8f3533dd08 | 620 | hpp | C++ | src/main/cpp/pdf_tin/DocumentCreationError.hpp | tomault/pdf_tin | 5d33d87a622327fd5cb50e895435b454c02ecf06 | [
"Apache-2.0"
] | null | null | null | src/main/cpp/pdf_tin/DocumentCreationError.hpp | tomault/pdf_tin | 5d33d87a622327fd5cb50e895435b454c02ecf06 | [
"Apache-2.0"
] | null | null | null | src/main/cpp/pdf_tin/DocumentCreationError.hpp | tomault/pdf_tin | 5d33d87a622327fd5cb50e895435b454c02ecf06 | [
"Apache-2.0"
] | null | null | null | #ifndef __PDF_TIN__DOCUMENTCREATIONERROR_HPP__
#define __PDF_TIN__DOCUMENTCREATIONERROR_HPP__
#include <exception>
#include <string>
namespace pdf_tin {
class DocumentCreationError : public std::exception {
public:
DocumentCreationError(const std::string& source,
const std::string& details);
DocumentCreationError(const std::string& details);
virtual ~DocumentCreationError() noexcept;
const std::string& details() const { return details_; }
virtual const char* what() const noexcept { return msg_.c_str(); }
private:
std::string details_;
std::string msg_;
};
}
#endif
| 23.846154 | 70 | 0.730645 | tomault |
98934539dc932761deef2fe8b71535036ff89ed6 | 500 | cpp | C++ | Common/BackupFileName.cpp | BartoszMilewski/CodeCoop | 7d29f53ccf65b0d29ea7d6781a74507b52c08d0d | [
"MIT"
] | 67 | 2018-03-02T10:50:02.000Z | 2022-03-23T18:20:29.000Z | Common/BackupFileName.cpp | BartoszMilewski/CodeCoop | 7d29f53ccf65b0d29ea7d6781a74507b52c08d0d | [
"MIT"
] | null | null | null | Common/BackupFileName.cpp | BartoszMilewski/CodeCoop | 7d29f53ccf65b0d29ea7d6781a74507b52c08d0d | [
"MIT"
] | 9 | 2018-03-01T16:38:28.000Z | 2021-03-02T16:17:09.000Z | //----------------------------------
// (c) Reliable Software, 2008
//----------------------------------
#include "precompiled.h"
#include "BackupFileName.h"
#include "RegFunc.h"
#include <TimeStamp.h>
#include <File/File.h>
BackupFileName::BackupFileName ()
{
_fileName = "Code Co-op Backup for ";
_fileName += Registry::GetComputerName ();
StrDate timeStamp (CurrentTime ());
_fileName += " ";
_fileName += timeStamp.GetString ();
_fileName += ".cab";
File::LegalizeName (_fileName);
}
| 22.727273 | 43 | 0.592 | BartoszMilewski |
9894888fd6231d04f5f4963037c49d634dc9c50c | 609 | cpp | C++ | Ex2/Ex2.cpp | SAE-Geneve/debug-exam-past-Okyriio | c5687df1522b800006d8e6414b18d96af1f1c46a | [
"MIT"
] | null | null | null | Ex2/Ex2.cpp | SAE-Geneve/debug-exam-past-Okyriio | c5687df1522b800006d8e6414b18d96af1f1c46a | [
"MIT"
] | null | null | null | Ex2/Ex2.cpp | SAE-Geneve/debug-exam-past-Okyriio | c5687df1522b800006d8e6414b18d96af1f1c46a | [
"MIT"
] | null | null | null | #include <iostream>
void swaps(int* a, int* b)
{
//This function swaps the values contained in the two pointers
int c = *a ;
a = b;
b = &c;
}
void print_values(int* a, int* b)
{
//This function shows the values and their pointer
std::cout << "The value of a is: "<< *a << " and is contained in address: "<<a<<"\n";
std::cout << "The value of b is: "<< *b << " and is contained in address: "<<b<<"\n";
}
int main(const char* argv, int argc)
{
int a = 4;
int b = 3;
swaps( &a, &b);
print_values(&a,&b);
//Windows specific
system("pause");
return 0;
}
| 17.4 | 89 | 0.558292 | SAE-Geneve |
989523041e2f023d91c8dd15cd89d3ff33cd2af9 | 2,012 | cpp | C++ | ww-example/Example.cpp | koalefant/yasli | 2096ed8a59ae9c7da467d8de8f1eb811a989dc39 | [
"MIT"
] | 8 | 2021-07-08T18:06:33.000Z | 2022-01-17T18:29:57.000Z | ww-example/Example.cpp | koalefant/yasli | 2096ed8a59ae9c7da467d8de8f1eb811a989dc39 | [
"MIT"
] | null | null | null | ww-example/Example.cpp | koalefant/yasli | 2096ed8a59ae9c7da467d8de8f1eb811a989dc39 | [
"MIT"
] | 1 | 2021-12-31T15:52:56.000Z | 2021-12-31T15:52:56.000Z | #include "ww/Win32/Types.h"
#include "ww/Application.h"
#include "ww/Window.h"
#include "ww/VBox.h"
#include "ww/HBox.h"
#include "ww/VSplitter.h"
#include "ww/HSplitter.h"
#include "ww/ScrolledWindow.h"
#include "ww/Tabs.h"
#include "ww/PropertyTree.h"
#include "ww/Frame.h"
#include "ww/Serialization.h"
#include "ww/Win32/Window32.h"
#include "yasli/TextOArchive.h"
#include "yasli/TextIArchive.h"
#include "TestData.h"
#include <string>
#include <windows.h>
class MainWindow : public ww::Window{
public:
MainWindow(ww::Application& app);
~MainWindow();
protected:
ww::Application* app_;
};
TestData testData;
TestData testData1;
MainWindow::MainWindow(ww::Application& app)
: app_(&app)
{
setTitle("wWidgets: PropertyTree Example");
setBorder(0);
setMinimizeable(true);
setResizeable(true);
setDefaultSize(800, 600);
setDefaultPosition(ww::POSITION_CENTER);
signalClose().connect(&app, &ww::Application::quit);
ww::TabPages* pages = new ww::TabPages();
ww::Widget* createPolymorphicTree();
pages->add("Polymorphic Tree", createPolymorphicTree());
ww::Widget* createCustomRows();
pages->add("Custom Rows & Decorators", createCustomRows());
ww::Widget* createDigestSample();
pages->add("Digests", createDigestSample());
ww::Widget* createTableSample();
pages->add("Table", createTableSample());
ww::Widget* createTwoTrees();
pages->add("Two Trees", createTwoTrees());
add(pages);
TextIArchive sa;
sa.setFilter(ww::SERIALIZE_STATE);
if(sa.load("example.state"))
sa(*this, "window", "Window");
}
MainWindow::~MainWindow()
{
TextOArchive oa;
oa.setFilter(ww::SERIALIZE_STATE);
oa(*this, "window", "Window");
oa.save("example.state");
}
int APIENTRY WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow)
{
ww::Application app(hInstance);
SharedPtr<MainWindow> window = new MainWindow(app);
window->showAll();
app.run();
return 0;
}
| 21.634409 | 98 | 0.686382 | koalefant |
989e38a565b2462e4f35217dbda08e6be37e6825 | 11,774 | cpp | C++ | NOLF/ClientShellDLL/PolyDebrisFX.cpp | rastrup/no-one-lives-forever | dfbe22fb4cc01bf7e5f54a79174fa8f108dd2f54 | [
"Unlicense"
] | 65 | 2015-02-28T03:35:14.000Z | 2021-09-23T05:43:33.000Z | NOLF/ClientShellDLL/PolyDebrisFX.cpp | rastrup/no-one-lives-forever | dfbe22fb4cc01bf7e5f54a79174fa8f108dd2f54 | [
"Unlicense"
] | null | null | null | NOLF/ClientShellDLL/PolyDebrisFX.cpp | rastrup/no-one-lives-forever | dfbe22fb4cc01bf7e5f54a79174fa8f108dd2f54 | [
"Unlicense"
] | 27 | 2015-02-28T07:42:01.000Z | 2022-02-11T01:35:20.000Z | // ----------------------------------------------------------------------- //
//
// MODULE : PolyDebrisFX.cpp
//
// PURPOSE : Polygon Debris - Implementation
//
// CREATED : 7/16/99
//
// (c) 1999 Monolith Productions, Inc. All Rights Reserved
//
// ----------------------------------------------------------------------- //
#include "stdafx.h"
#include "PolyDebrisFX.h"
#include "GameClientShell.h"
#include "VarTrack.h"
extern CGameClientShell* g_pGameClientShell;
VarTrack g_cvarPolyDebrisTrailTime;
VarTrack g_cvarPolyDebrisScaleDist;
VarTrack g_cvarPolyDebrisMinDistScale;
VarTrack g_cvarPolyDebrisMaxDistScale;
CPolygonDebrisFX::~CPolygonDebrisFX()
{
// Clear out the PolyFX list
for (uint32 nClearLoop = 0; nClearLoop < MAX_DEBRIS; ++nClearLoop)
{
if (m_Polies[nClearLoop])
{
GetPolyLineFXBank()->Delete(m_Polies[nClearLoop]);
m_Polies[nClearLoop] = LTNULL;
}
}
}
CBankedList<CPolyLineFX> *CPolygonDebrisFX::GetPolyLineFXBank()
{
static CBankedList<CPolyLineFX> theBank;
return &theBank;
}
// ----------------------------------------------------------------------- //
//
// ROUTINE: CPolygonDebrisFX::Init
//
// PURPOSE: Init the polygon debris
//
// ----------------------------------------------------------------------- //
LTBOOL CPolygonDebrisFX::Init(SFXCREATESTRUCT* psfxCreateStruct)
{
if (!psfxCreateStruct) return LTFALSE;
m_cs = *(POLYDEBRISCREATESTRUCT*)psfxCreateStruct;
DEBRISCREATESTRUCT debris;
g_pLTClient->AlignRotation(&(debris.rRot), &m_cs.vNormal, LTNULL);
debris.vPos = m_cs.vPos + (m_cs.vDir * m_cs.PolyDebrisFX.fDirOffset);
debris.vMinVel = m_cs.PolyDebrisFX.vMinVel;
debris.vMaxVel = m_cs.PolyDebrisFX.vMaxVel;
debris.fMinLifeTime = m_cs.PolyDebrisFX.fMinDuration;
debris.fMaxLifeTime = m_cs.PolyDebrisFX.fMaxDuration;
debris.nNumDebris = GetRandom(m_cs.PolyDebrisFX.nMinDebris, m_cs.PolyDebrisFX.nMaxDebris);
debris.nMinBounce = m_cs.PolyDebrisFX.nMinBounce;
debris.nMaxBounce = m_cs.PolyDebrisFX.nMaxBounce;
debris.fGravityScale = m_cs.PolyDebrisFX.fGravityScale;
debris.vMinDOffset = m_cs.PolyDebrisFX.vMinDOffset;
debris.vMaxDOffset = m_cs.PolyDebrisFX.vMaxDOffset;
debris.bDirOffsetOnly = m_cs.PolyDebrisFX.bDirOffsetOnly;
if (!CDebrisFX::Init(&debris)) return LTFALSE;
// Too expensive to have poly debris bouncing...
m_ds.bBounce = LTFALSE;
if (!g_cvarPolyDebrisTrailTime.IsInitted())
{
g_cvarPolyDebrisTrailTime.Init(g_pLTClient, "PolyDebrisTrailTime", LTNULL, 0.25f);
}
if (!g_cvarPolyDebrisScaleDist.IsInitted())
{
g_cvarPolyDebrisScaleDist.Init(g_pLTClient, "PolyDebrisScaleDist", LTNULL, 150.0f);
}
if (!g_cvarPolyDebrisMinDistScale.IsInitted())
{
g_cvarPolyDebrisMinDistScale.Init(g_pLTClient, "PolyDebrisMinDistScale", LTNULL, 1.0f);
}
if (!g_cvarPolyDebrisMaxDistScale.IsInitted())
{
g_cvarPolyDebrisMaxDistScale.Init(g_pLTClient, "PolyDebrisMaxDistScale", LTNULL, 1.0f);
}
return LTTRUE;
}
// ----------------------------------------------------------------------- //
//
// ROUTINE: CPolygonDebrisFX::IsValidDebris
//
// PURPOSE: Is this debris object valid
//
// ----------------------------------------------------------------------- //
LTBOOL CPolygonDebrisFX::IsValidDebris(int i)
{
if (i < 0 || i >= m_ds.nNumDebris) return LTFALSE;
return (i < m_nNumPolies && (m_Polies[i] != LTNULL));
}
// ----------------------------------------------------------------------- //
//
// ROUTINE: CPolygonDebrisFX::CreateDebris
//
// PURPOSE: Create a debris poly
//
// ----------------------------------------------------------------------- //
void CPolygonDebrisFX::CreateDebris(int i, LTVector vPos)
{
if (i < 0 || i >= m_ds.nNumDebris || i != m_nNumPolies || (m_Polies[i] != LTNULL)) return;
// Create a poly debris object...
PLFXCREATESTRUCT pls;
LTVector vLength = (m_cs.vDir * GetRandom(m_cs.PolyDebrisFX.fMinLength, m_cs.PolyDebrisFX.fMaxLength)) / 2.0f;
LTVector vMinC1 = m_cs.PolyDebrisFX.vMinColor1;
LTVector vMaxC1 = m_cs.PolyDebrisFX.vMaxColor1;
LTVector vMinC2 = m_cs.PolyDebrisFX.vMinColor2;
LTVector vMaxC2 = m_cs.PolyDebrisFX.vMaxColor2;
pls.pTexture = m_cs.PolyDebrisFX.szTexture[0] ? m_cs.PolyDebrisFX.szTexture : LTNULL;
pls.vStartPos = vPos - vLength;
pls.vEndPos = vPos + vLength;
pls.vInnerColorStart = LTVector(GetRandom(vMinC1.x, vMaxC1.x), GetRandom(vMinC1.y, vMaxC1.y), GetRandom(vMinC1.z, vMaxC1.z));
pls.vInnerColorEnd = LTVector(GetRandom(vMinC2.x, vMaxC2.x), GetRandom(vMinC2.y, vMaxC2.y), GetRandom(vMinC2.z, vMaxC2.z));
pls.vOuterColorStart = pls.vInnerColorStart;
pls.vOuterColorEnd = pls.vInnerColorEnd;
pls.fAlphaStart = m_cs.PolyDebrisFX.fInitialAlpha;
pls.fAlphaEnd = m_cs.PolyDebrisFX.fFinalAlpha;
pls.fMinWidth = 0.0f;
pls.fMaxWidth = GetRandom(m_cs.PolyDebrisFX.fMinWidth, m_cs.PolyDebrisFX.fMaxWidth);
pls.fLifeTime = GetDebrisLife(i);
pls.fAlphaLifeTime = GetDebrisLife(i);
pls.bAdditive = m_cs.PolyDebrisFX.bAdditive;
pls.bMultiply = m_cs.PolyDebrisFX.bMultiply;
pls.bDontFadeAlphaAtEdge= !m_cs.PolyDebrisFX.bAdditive;
pls.nWidthStyle = m_cs.PolyDebrisFX.nStyle > PLWS_CONSTANT ? GetRandom(PLWS_BIG_TO_SMALL, PLWS_CONSTANT) : m_cs.PolyDebrisFX.nStyle;
pls.bUseObjectRotation = !m_cs.PolyDebrisFX.bShowTrail;
pls.bNoZ = m_cs.PolyDebrisFX.bShowTrail;
pls.nNumSegments = 1;
pls.fMinDistMult = 1.0f;
pls.fMaxDistMult = 1.0f;
pls.fPerturb = 0.0f;
// Scale the width based on the distance the camera is away from the
// origin of the debris...
HLOCALOBJ hCamera = g_pGameClientShell->GetCamera();
if (hCamera)
{
LTVector vCamPos;
g_pLTClient->GetObjectPos(hCamera, &vCamPos);
vCamPos -= vPos;
LTFLOAT fScaleVal = vCamPos.Mag() / g_cvarPolyDebrisScaleDist.GetFloat();
fScaleVal = (fScaleVal < g_cvarPolyDebrisMinDistScale.GetFloat() ? g_cvarPolyDebrisMinDistScale.GetFloat()
: (fScaleVal > g_cvarPolyDebrisMaxDistScale.GetFloat() ? g_cvarPolyDebrisMaxDistScale.GetFloat() : fScaleVal));
pls.fMaxWidth *= fScaleVal;
}
CPolyLineFX *pNewPoly = GetPolyLineFXBank()->New();
if (!pNewPoly->Init(&pls) ||
!pNewPoly->CreateObject(m_pClientDE))
{
GetPolyLineFXBank()->Delete(pNewPoly);
return;
}
else
{
m_Polies[m_nNumPolies] = pNewPoly;
}
m_nNumPolies++;
}
// ----------------------------------------------------------------------- //
//
// ROUTINE: CPolygonDebrisFX::OkToRemoveDebris
//
// PURPOSE: See if this particular debris can be removed.
//
// ----------------------------------------------------------------------- //
LTBOOL CPolygonDebrisFX::OkToRemoveDebris(int i)
{
return LTTRUE;
}
// ----------------------------------------------------------------------- //
//
// ROUTINE: CPolygonDebrisFX::RemoveDebris
//
// PURPOSE: Remove the specified debris object
//
// ----------------------------------------------------------------------- //
void CPolygonDebrisFX::RemoveDebris(int i)
{
if (i < 0 || i >= m_ds.nNumDebris) return;
if (i >= m_nNumPolies) return;
if (m_Polies[i] == LTNULL) return;
GetPolyLineFXBank()->Delete(m_Polies[i]);
m_Polies[i] = LTNULL;
CDebrisFX::RemoveDebris(i);
}
// ----------------------------------------------------------------------- //
//
// ROUTINE: CPolygonDebrisFX::RotateDebrisToRest
//
// PURPOSE: Rotate the debris to the rest position
//
// ----------------------------------------------------------------------- //
void CPolygonDebrisFX::RotateDebrisToRest(int i)
{
if (i < 0 || i >= m_ds.nNumDebris) return;
if (i >= m_nNumPolies) return;
}
// ----------------------------------------------------------------------- //
//
// ROUTINE: CPolygonDebrisFX::SetDebrisPos
//
// PURPOSE: Set the debris position
//
// ----------------------------------------------------------------------- //
void CPolygonDebrisFX::SetDebrisPos(int i, LTVector vPos)
{
if (i < 0 || i >= m_ds.nNumDebris) return;
if (i >= m_nNumPolies) return;
if (m_Polies[i] == LTNULL) return;
// Instead of moving the current poly, add another one at the
// new position if we're showing a trail..
if (m_cs.PolyDebrisFX.bShowTrail)
{
PLFXLINESTRUCT ls;
LTVector vLength = (m_cs.vDir * GetRandom(m_cs.PolyDebrisFX.fMinLength, m_cs.PolyDebrisFX.fMaxLength)) / 2.0f;
ls.vStartPos = vPos - vLength;
// Get the last vert position...
PolyLineList* pLines = m_Polies[i]->GetLines();
if (pLines->GetLength() > 0)
{
PolyLine** pLine = pLines->GetItem(TLIT_LAST);
if (pLine && *pLine)
{
PolyVertStruct** pVert = (*pLine)->list.GetItem(TLIT_LAST);
if (pVert && *pVert)
{
ls.vStartPos = m_Polies[i]->GetVertPos((*pVert));
}
}
}
LTVector vMinC1 = m_cs.PolyDebrisFX.vMinColor1;
LTVector vMaxC1 = m_cs.PolyDebrisFX.vMaxColor1;
LTVector vMinC2 = m_cs.PolyDebrisFX.vMinColor2;
LTVector vMaxC2 = m_cs.PolyDebrisFX.vMaxColor2;
ls.vEndPos = vPos;
ls.vInnerColorStart = LTVector(GetRandom(vMinC1.x, vMaxC1.x), GetRandom(vMinC1.y, vMaxC1.y), GetRandom(vMinC1.z, vMaxC1.z));
ls.vInnerColorEnd = LTVector(GetRandom(vMinC2.x, vMaxC2.x), GetRandom(vMinC2.y, vMaxC2.y), GetRandom(vMinC2.z, vMaxC2.z));
ls.fAlphaStart = m_cs.PolyDebrisFX.fInitialAlpha;
ls.fAlphaEnd = m_cs.PolyDebrisFX.fFinalAlpha;
//ls.fLifeTime = m_fDebrisLife[i] - (g_pLTClient->GetTime() - m_fStartTime);
ls.fLifeTime = g_cvarPolyDebrisTrailTime.GetFloat();
ls.fLifeTime = ls.fLifeTime < 0.0f ? 0.0f : ls.fLifeTime;
ls.fAlphaLifeTime = ls.fLifeTime;
m_Polies[i]->AddLine(ls);
}
else
{
m_Polies[i]->SetPos(vPos);
}
}
// ----------------------------------------------------------------------- //
//
// ROUTINE: CPolygonDebrisFX::GetDebrisPos
//
// PURPOSE: Get the debris position
//
// ----------------------------------------------------------------------- //
LTBOOL CPolygonDebrisFX::GetDebrisPos(int i, LTVector & vPos)
{
if (i < 0 || i >= m_ds.nNumDebris) return LTFALSE;
if (i >= m_nNumPolies) return LTFALSE;
if (m_Polies[i] == LTNULL) return LTFALSE;
vPos = m_Polies[i]->GetPos();
return LTTRUE;
}
// ----------------------------------------------------------------------- //
//
// ROUTINE: CPolygonDebrisFX::SetDebrisRot
//
// PURPOSE: Set the debris rotation
//
// ----------------------------------------------------------------------- //
void CPolygonDebrisFX::SetDebrisRot(int i, LTRotation rRot)
{
if (i < 0 || i >= m_ds.nNumDebris) return;
if (i >= m_nNumPolies) return;
if (m_Polies[i] == LTNULL) return;
if (!m_cs.PolyDebrisFX.bShowTrail)
{
m_Polies[i]->SetRot(rRot);
}
}
// ----------------------------------------------------------------------- //
//
// ROUTINE: CPolygonDebrisFX::Update
//
// PURPOSE: Update the debris
//
// ----------------------------------------------------------------------- //
LTBOOL CPolygonDebrisFX::Update()
{
if (!CDebrisFX::Update())
return LTFALSE;
for (int i=0; i < m_nNumPolies; i++)
{
if (m_Polies[i] == LTNULL) continue;
// Align poly forward vector to movement direction...
if (!m_cs.PolyDebrisFX.bShowTrail)
{
LTVector vDir = GetEmitter(i)->m_vLastPos - GetEmitter(i)->m_vPos;
LTRotation rRot;
rRot = m_Polies[i]->GetRot();
g_pLTClient->AlignRotation(&rRot, &vDir, LTNULL);
m_Polies[i]->SetRot(rRot);
}
m_Polies[i]->Update();
}
return LTTRUE;
} | 30.423773 | 137 | 0.585612 | rastrup |
98a0574de5a4f3f68a4dfff7fd588030514b7b20 | 1,480 | cpp | C++ | LookupVerb/src/main/LookupVerb.cpp | 3bananas4/Spanish | af8ca51a746ef4f14773200ddd7edee7f64253b3 | [
"MIT"
] | null | null | null | LookupVerb/src/main/LookupVerb.cpp | 3bananas4/Spanish | af8ca51a746ef4f14773200ddd7edee7f64253b3 | [
"MIT"
] | null | null | null | LookupVerb/src/main/LookupVerb.cpp | 3bananas4/Spanish | af8ca51a746ef4f14773200ddd7edee7f64253b3 | [
"MIT"
] | null | null | null | //============================================================================
// Name : LookupVerb.cpp
// Author :
// Version :
// Copyright : Your copyright notice
// Description : Reads in a file, supplied on command line
// builds a dictionary of english-> spanish verb infinitives
// receives input from the user to define an English verb and a conjugation
// then sends the spanish verb to std::out
// which can then be picked up by a piped app downstream
//============================================================================
#include <iostream>
#include <array>
#include "FileReader.h"
//#include "InfContent.h"
#include <cstdlib>
#include <cstring>
#include <sstream>
#include <functional>
#include "Parser.h"
#include "Feeder.h"
using namespace std;
STRVEC collectArgs(int argc,char* argv[])
{
STRVEC a;
for(int i=0;i<argc;++i){
a.emplace_back(argv[i]);
}
return a;
}
int main(int argc,char* argv[]) {
STRVEC args = collectArgs(argc,argv);
unsigned index=args[1][0]=='-'?3u:1u;
Feeder feeder(args);
FileReader f(args[index],[&feeder](const string & entry){
auto parser = [](const string& s)->STRVEC{return LookupParser::Process(s);};
feeder.addEntry(entry,parser);
});
if(args[1].compare("-i")==0){
// interactive mode
feeder.interactive(true,[](const string& s,char ch)->STRVEC{
return Parser::Process(s,ch);});
}
else if(argc>3){
// feed the pipe
cout << feeder.feedPipe() << endl;
}
}
| 25.964912 | 79 | 0.595946 | 3bananas4 |
98a07395436b7ba2cd3f06bd7e8afe71db663603 | 1,325 | hpp | C++ | include/paal/utils/less_pointees.hpp | Kommeren/AA | e537b58d50e93d4a72709821b9ea413008970c6b | [
"BSL-1.0"
] | null | null | null | include/paal/utils/less_pointees.hpp | Kommeren/AA | e537b58d50e93d4a72709821b9ea413008970c6b | [
"BSL-1.0"
] | null | null | null | include/paal/utils/less_pointees.hpp | Kommeren/AA | e537b58d50e93d4a72709821b9ea413008970c6b | [
"BSL-1.0"
] | 1 | 2021-02-24T06:23:56.000Z | 2021-02-24T06:23:56.000Z | //=======================================================================
// Copyright (c) 2013 Piotr Wygocki
//
// 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)
//=======================================================================
/**
* @file less_pointees.hpp
* @brief
* @author Piotr Wygocki
* @version 1.0
* @date 2013-09-29
*/
#ifndef PAAL_LESS_POINTEES_HPP
#define PAAL_LESS_POINTEES_HPP
namespace paal {
// TODO add to boost
/**
* @brief compare pointee using comparator
*
* @tparam Comparator
*/
template <class Comparator> struct less_pointees_t {
/// constructor
less_pointees_t(Comparator compare) : m_compare(compare) {}
/// compare operator()
template <typename OptionalPointee>
bool operator()(OptionalPointee const &x, OptionalPointee const &y) const {
return !y ? false : (!x ? true : m_compare(*x, *y));
}
private:
Comparator m_compare;
};
/**
* @brief make function for less_pointees_t
*
* @tparam Comparator
* @param compare
*
* @return
*/
template <class Comparator>
less_pointees_t<Comparator> make_less_pointees_t(Comparator compare) {
return less_pointees_t<Comparator>(compare);
}
} //! paal
#endif // PAAL_LESS_POINTEES_HPP
| 24.537037 | 79 | 0.623396 | Kommeren |
98a19b4c0b10faa4440a3adf641b0a98e0da9710 | 663 | cpp | C++ | mainProject/SrcUI/AboutGui.cpp | WelinLee/qt_cmake_project | b69621a82c5a68ca23c5a216d74ddfea5051bae7 | [
"MIT"
] | 1 | 2019-02-27T07:31:24.000Z | 2019-02-27T07:31:24.000Z | mainProject/SrcUI/AboutGui.cpp | WelinLee/qt_cmake_project | b69621a82c5a68ca23c5a216d74ddfea5051bae7 | [
"MIT"
] | null | null | null | mainProject/SrcUI/AboutGui.cpp | WelinLee/qt_cmake_project | b69621a82c5a68ca23c5a216d74ddfea5051bae7 | [
"MIT"
] | null | null | null | #include "AboutGui.h"
#include "ui_AboutGui.h"
#include <QPushButton>
#define qAppDir QCoreApplication::applicationDirPath()
AboutGUI::AboutGUI(QWidget *parent)
: QWidget(parent),
ui(new Ui::AboutGUI)
{
ui->setupUi(this);
this->setWindowTitle(QStringLiteral("About Us"));
this->setWindowModality(Qt::ApplicationModal);
this->setWindowFlags(Qt::SubWindow);
this->setFixedSize(364,253);
QPixmap px(QString(qAppDir.append("/Skins/logo.png")));
ui->label->setPixmap(px);
connect(ui->pushButton, &QPushButton::clicked, this, &AboutGUI::BtnOnClose);
}
AboutGUI::~AboutGUI()
{
}
void AboutGUI::BtnOnClose()
{
this->close();
}
| 20.71875 | 80 | 0.699849 | WelinLee |
98a200027baf0798e03d961d389bae66abdafacb | 43,087 | hh | C++ | dune/ax1/acme2_cyl/common/acme2_cyl_simulation.hh | pederpansen/dune-ax1 | 152153824d95755a55bdd4fba80686863e928196 | [
"BSD-3-Clause"
] | null | null | null | dune/ax1/acme2_cyl/common/acme2_cyl_simulation.hh | pederpansen/dune-ax1 | 152153824d95755a55bdd4fba80686863e928196 | [
"BSD-3-Clause"
] | null | null | null | dune/ax1/acme2_cyl/common/acme2_cyl_simulation.hh | pederpansen/dune-ax1 | 152153824d95755a55bdd4fba80686863e928196 | [
"BSD-3-Clause"
] | null | null | null | /*
* acme2_cyl_fully_coupled.hh
*
* Created on: Dec 15, 2011
* Author: jpods
*/
#ifndef DUNE_AX1_ACME2CYL_SIMULATION_HH
#define DUNE_AX1_ACME2CYL_SIMULATION_HH
#include <dune/ax1/common/tools.hh>
#include <dune/ax1/common/ax1_boundaryfunction_membranefunction_adapter.hh>
template<typename Traits,typename ACME2CYL_OUTPUT>
class Acme2CylSimulation
{
public:
typedef typename Traits::Real Real;
template<typename SOLVER, typename ELEC_SUBPROBLEM>
static void run(Real& time, Real& dt, Real& dtstart, Real& tend, const Real& tEquilibrium,
typename Traits::Physics& physics,
const typename Traits::GridView& gv, const typename Traits::SubGridView& membGV,
SOLVER& solver,
typename Traits::PARAMETERS_POT& parametersPot,
typename Traits::PARAMETERS_CON& parametersCon,
typename Traits::MultiGFS& multigfs,
typename Traits::U& uold, typename Traits::U& unew,
typename Traits::MultiGFS::template ConstraintsContainer<Real>::Type& cc,
typename Traits::MultiGFS::template ConstraintsContainer<Real>::Type& ccWithoutOverlap,
typename Traits::GF_MEMB_FLUX& gfMembFlux,
typename Traits::GF_MORI_FLUX& gfMoriFlux,
typename Traits::DGF_CON& dgfCon,
typename Traits::DGF_POT& dgfPot, typename Traits::DGF_POT_GRAD& dgfGradPot,
ACME2CYL_OUTPUT& acme2_cylOutput,
Acme2CylSolutionVectors<Traits>& solutionVectors,
typename Traits::INITIAL_ELEC& initialElec, ELEC_SUBPROBLEM& elecSubProblem)
{
const Acme2CylParameters& params = physics.getParams();
const Real timeScale = physics.getTimeScale();
const Real lengthScale = physics.getLengthScale();
const bool fullyImplicit = params.boundary.get("fullyImplicitMembraneFlux",false);
const bool doConcentrationPostprocessing = params.general.get("doConcentrationPostprocessing",false);
const int intorderPot = acme2_cylOutput.getIntOrderPot();
const int intorderCon = acme2_cylOutput.getIntOrderCon();
const int intorderadd = 2;
// Create vector of DGFs, one for each concentration
std::vector<typename ACME2CYL_OUTPUT::Traits::DGF_SINGLE_CON_MD> dgfSingleConVec;
typedef MoriChargeGridFunction<typename Traits::GF_MORI_FLUX, typename Traits::DGF_POT, typename Traits::Physics>
GF_MORI_CHARGE;
GF_MORI_CHARGE gfMoriCharge(gfMoriFlux, dgfPot, physics);
std::vector<typename ACME2CYL_OUTPUT::Traits::DGF_SINGLE_CON_MD::Traits::RangeType> initConcIntegralBulk;
std::vector<typename ACME2CYL_OUTPUT::Traits::DGF_SINGLE_CON_MD::Traits::RangeType> initConcIntegralChargeLayer;
for(int j=0; j<NUMBER_OF_SPECIES; ++j)
{
typename ACME2CYL_OUTPUT::Traits::DGF_SINGLE_CON_MD dgfSingleCon(dgfCon, j);
dgfSingleConVec.push_back(dgfSingleCon);
}
std::vector<typename ACME2CYL_OUTPUT::Traits::DGF_SINGLE_CON_MD::Traits::RangeType>
concIntegralBulk(NUMBER_OF_SPECIES, -1);
std::vector<typename ACME2CYL_OUTPUT::Traits::DGF_SINGLE_CON_MD::Traits::RangeType>
concIntegralChargeLayer(NUMBER_OF_SPECIES, -1);
const std::vector<int> subDomains = {CYTOSOL, ES};
// scalingFactorBulk misses the valence 'z_i', which will be added in-place below
const Real scalingFactorBulk = con_e * con_mol * lengthScale * lengthScale * lengthScale;
const Real scalingFactorChargeLayer = lengthScale * lengthScale;
typename ACME2CYL_OUTPUT::DiagnosticInfo& diagInfo = acme2_cylOutput.getDiagInfo();
typename ACME2CYL_OUTPUT::DiagnosticInfo lastDiagInfo(diagInfo); // copy of diagInfo
Real time0 = time;
if(dt <= 0.0)
dt = 1.0;
Real dpot(0.0);
Real old_dt = dt;
Real last_dt = dt;
Real last_dpot(0.0);
diagInfo.tEquilibrium = tEquilibrium;
diagInfo.registerDebugData(std::string("newton_restarts"), 0.0);
diagInfo.registerDebugData(std::string("avg_lin_it"), 0.0,
ACME2CYL_OUTPUT::DiagnosticInfo::ReductionFunction::Function_Mean);
diagInfo.registerDebugData(std::string("old_dt"), old_dt);
diagInfo.registerDebugData(std::string("last_dt"), last_dt);
// Only initialize (i.e., delete) diagnostics file if simulation is not continued
if(not (physics.getParams().doLoadState() && physics.getParams().doContinueSimulation()))
{
// This creates the file with all the header information from the
// debug data dynamically added via 'registerDebugData()'
acme2_cylOutput.initDiagInfoFile();
}
typedef Ax1GoldmanEquationGridFunction<typename Traits::DGF_CON,
typename Traits::Physics> GoldmanGF;
GoldmanGF goldmanGF(dgfCon,physics);
// Initialize membrane flux classes once and for all
if(! gfMembFlux.isCompletelyInitialized())
{
debug_jochen << "[init] # gfMembFlux.updateState" << std::endl;
gfMembFlux.updateState(time, dt);
debug_jochen << "# gfMembFlux.acceptTimeStep" << std::endl;
gfMembFlux.acceptTimeStep();
}
if(! gfMoriFlux.isCompletelyInitialized())
{
debug_jochen << "[init] # gfMoriFlux.updateState" << std::endl;
gfMoriFlux.updateState(time, dt);
debug_jochen << "# gfMoriFlux.acceptTimeStep" << std::endl;
gfMoriFlux.acceptTimeStep();
}
// Don't do initial output when a previous simulation is continued
if(not (physics.getParams().doLoadState() && physics.getParams().doContinueSimulation()))
{
acme2_cylOutput.writeStep(time);
Tools::pecletNumber(gv, parametersCon, dgfGradPot);
Real minMembPot = std::numeric_limits<Real>::max();
Real maxMembPot = std::numeric_limits<Real>::lowest();
for(typename Traits::Physics::MIterator mit = physics.mInteriorBegin(); mit != physics.mInteriorEnd(); ++mit)
{
typename Traits::DGF_POT::Traits::RangeType membPot;
physics.getMembranePotential(*mit, dgfPot, membPot);
if(membPot < minMembPot) minMembPot = membPot;
if(membPot > maxMembPot) maxMembPot = membPot;
}
minMembPot = gv.comm().min(minMembPot);
maxMembPot = gv.comm().max(maxMembPot);
debug_info << "MAX membrane potential = " << physics.convertTo_mV(maxMembPot) << " mV" << std::endl;
debug_info << "MIN membrane potential = " << physics.convertTo_mV(minMembPot) << " mV" << std::endl;
debug_info << std::endl << "########## initial output done" << std::endl << std::endl;
}
// ==============================================================================================
Real outputTimeInterval = physics.getParams().getOutputTimeInterval();
int outputCounter = 1;
bool printEveryTimeStep = (dt > outputTimeInterval && !physics.getParams().useAdaptiveTimeStep());
double tInj_start = physics.getParams().tInj_start();
double tInj_end = physics.getParams().tInj_end();
if(params.doStimulation())
{
debug_jochen << "tInj_start = " << tInj_start << ", tInj_end = " << tInj_end << std::endl;
}
// These variables are needed when reading in timesteps from an external file
std::ifstream timestepFile(physics.getParams().getTimeStepFile());
double next_time_last = 0.0;
double next_time = 0.0;
if(physics.getParams().getTimeStepFile() != "")
{
debug_info << "Using fixed time points from file '" << physics.getParams().getTimeStepFile()
<< "'!" << std::endl;
assert(timestepFile.good());
double next_time = -1;
if(physics.getParams().doContinueSimulation() || physics.getParams().general.get("startTime", 0.0) > 0.0)
{
// Try to find time value in order to resume simulation
std::string prefix("");
if(not physics.getParams().doContinueSimulation())
{
time = physics.getParams().general.get("startTime", 0.0);
}
next_time = time;
// Find value in 2nd column of file
int nLine = Tools::findValue(timestepFile, next_time, 2, prefix, true);
debug_info << "Found start time=" << next_time << " in line " << nLine << " in '"
<< physics.getParams().getTimeStepFile() << "', resuming from there..." << std::endl;
if(nLine < 0)
DUNE_THROW(Dune::Exception, "Could not find the requested time " << time
<< " to continue simulation from in timestep file '"
<< physics.getParams().getTimeStepFile() << "!");
} else {
// Simply read first timestep value in file; make sure it is equal to our start time!
std::string line;
std::getline(timestepFile, line);
std::stringstream line_str(line);
double dummy = -1;
next_time = 0.0;
// Extract first (unused) timestep
line_str >> dummy >> next_time;
}
assert(std::abs(time-next_time) < 1e-4);
}
if(physics.getParams().doStimulation() && physics.getParams().doEquilibration())
{
assert(tInj_start > tEquilibrium);
}
// Check if time-dependent Dirichlet constraints shall be interpolated in each time step
std::string loadBoundaryLocation = params.boundary.get("loadBoundary","bottom");
// Loading time-dependent Dirichlet values only implemented for potential for now!
bool isLoadedBoundaryDirichletPot = params.isBoundaryDirichlet_Potential(loadBoundaryLocation);
typename Traits::U uChange = unew;
//typename Traits::U_CON uConChange(unewCon);
//typename Traits::U_POT uPotChange(unewPot);
//typename Traits::U_CON uConChange_Rel(unewCon);
//typename Traits::U_POT uPotChange_Rel(unewPot);
// Total number of time steps
int totalTimeSteps = 0;
// Number of iterations/time steps since last output
int iterations = 0;
int timeSteps = 0;
// This flag only becomes true once when the equilibration is over, so that the time step can be resetted
bool equilibrationOver = false;
// ========= time loop ==========================================================================
while (time<tend-1e-8)
{
debug_verb << "TIME = " << time << std::endl;
debug_verb << "Last dt = " << dt << std::endl;
// Check if this is the first time point after completing the equilibration
if(physics.getParams().doEquilibration()
&& (time > tEquilibrium || std::abs(time-tEquilibrium) < 1e-6) //time >= tEquilibrium
&& not equilibrationOver)
{
equilibrationOver = true;
}
// ======================= Choose an appropriate time step dt ====================================
last_dt = old_dt;
old_dt = dt;
bool acceptTimeStep = not physics.getParams().useAdaptiveTimeStep() // Fixed time step
|| (physics.getParams().doEquilibration() && time < tEquilibrium); // Fixed time step during equilibration
// Reset to default time step when equilibration was completed
if(equilibrationOver)
{
debug_info << "== Equilibration over, resetting dt to start value " << dtstart << std::endl;
dt = dtstart;
acceptTimeStep = true;
bool printEveryTimeStep = (dt > outputTimeInterval && !physics.getParams().useAdaptiveTimeStep());
}
// Use default time step when injection starts
if(params.doStimulation() && (time+dt > tInj_start && time < tInj_start))
{
debug_info << "== Injection starts, resetting dt to start value " << dtstart << std::endl;
acceptTimeStep = true;
dt = dtstart;
}
// When loading and continuing an old simulation, take the last used time step as the first dt!
if(params.doLoadState() && params.doContinueSimulation()
&& std::abs(time-time0) < 1e-6)
{
debug_info << "== Continuing old simulation with from loaded time " << time << " with dt=" << dt << std::endl;
acceptTimeStep = true;
}
// Use fixed time step to match next time value from timestep file
if(not physics.getParams().useAdaptiveTimeStep() && physics.getParams().getTimeStepFile() != "")
{
// Read next line in timestep file
double dummy = -1;
double next_time = 0.0;
std::string line;
std::getline(timestepFile, line);
std::stringstream line_str(line);
line_str >> dummy >> next_time;
// Set dt such that the next prescribed timestep is hit
dt = next_time - time;
debug_jochen << "Next time: " << next_time << " => dt = " << dt << std::endl;
acceptTimeStep = true;
}
while(not acceptTimeStep)
{
//Real dpot_dt = uPotChange.base().infinity_norm() / dt;
//Real last_dpot_dt = last_dpot / last_dt;
debug_jochen << "==========================================" << std::endl;
debug_jochen << "dt = " << dt << std::endl;
// Update channels; this in only used when the timestep is chosen according to some
// flux measure. As this is currently not used, membrane flux updates are commented out as well!
// gfMembFlux.updateChannels(membGV, time, dt);
// gfMembFlux.updateFlux(membGV, time, dt);
// typename Traits::GF_MEMB_FLUX::Traits::RangeType maxFlux = gfMembFlux.getMaxFlux();
// typename Traits::GF_MEMB_FLUX::Traits::RangeFieldType oldMaxTotalFlux(0.0);
// typename Traits::GF_MEMB_FLUX::Traits::RangeFieldType maxTotalFlux(0.0);
// for(int j=0; j<NUMBER_OF_SPECIES; j++)
// {
// //debug_jochen << "Last time step / this time step (flux*dt) = "
// // << (oldMaxFlux[j] * dt) << " / " << (maxFlux[j] * dt) << std::endl;
// oldMaxTotalFlux += oldMaxFlux[j];
// maxTotalFlux += maxFlux[j];
// }
// // Factor representing the ratio of the current flux with respect to the one from the last time step
// typename Traits::GF_MEMB_FLUX::Traits::RangeFieldType fluxFactor = maxFlux.one_norm() / oldMaxFlux.one_norm();
//
// //debug_jochen << std::endl << "Old / this (max flux * dt) = "
// // << (oldMaxTotalFlux * dt) << " / " << (maxTotalFlux * dt)
// // << " [factor " << fluxFactor << "]" << std::endl;
//
// diagInfo.addDebugData(std::string("flux_factor"), fluxFactor);
// (1) 'Soft' criterion: Try to adjust time step according to number Newton iterations
const int lowerLimit = params.getTimeStepLowerLimitNewtonIt(); // default 3
const int upperLimit = params.getTimeStepUpperLimitNewtonIt(); // default 5
if(diagInfo.iterations < lowerLimit && diagInfo.iterations <= lastDiagInfo.iterations)
{
dt *= 1.1; // Carefully increase time step
}
if(diagInfo.iterations >= upperLimit)
{
dt /= 1.2; // Use smaller time step when we need too many Newton iterations
}
// (2) 'Harder' criterion: Bound time step according to change in potential
//Real rel_dpot_dt = std::abs((dpot_dt-last_dpot_dt)/(std::max(dpot_dt,last_dpot_dt)));
//diagInfo.addDebugData(std::string("rel_dpot_dt"), rel_dpot_dt);
// if(time+dt > tInj_start && time+dt < tInj_end)
// {
// if(rel_dpot_dt > 0.05)
// {
// dt /= 2;
// }
// if(rel_dpot_dt < 0.001)
// {
// dt *= 1.2;
// }
// }
// (3) 'Hardest' criterion: Bound maximum/minimum time step
dt = std::min(dt, params.getMaxTimeStep() / physics.getTimeScale()); // maximum timestep (default 0.05 ms)
dt = std::max(dt, params.getMinTimeStep() / physics.getTimeScale()); // minimum timestep (default 0.05 µs)
Real minMembPot = std::numeric_limits<Real>::max();
Real maxMembPot = std::numeric_limits<Real>::lowest();
for(typename Traits::Physics::MIterator mit = physics.mInteriorBegin(); mit != physics.mInteriorEnd(); ++mit)
{
typename Traits::DGF_POT::Traits::RangeType membPot;
physics.getMembranePotential(*mit, dgfPot, membPot);
if(membPot < minMembPot) minMembPot = membPot;
if(membPot > maxMembPot) maxMembPot = membPot;
}
minMembPot = gv.comm().min(minMembPot);
maxMembPot = gv.comm().max(maxMembPot);
// (4) Additionally limit time step during AP
if((params.doStimulation() && time+dt > tInj_start && time+dt < tInj_end)
//|| (time+dt > 15e3+tInj_start && time+dt < 15e3+tInj_end)
|| physics.convertTo_mV(maxMembPot) > -50.) // Check if membrane potential is _anywhere_ above -50mV
{
dt = std::min(dt, params.getMaxTimeStepAP() / physics.getTimeScale()); // maximum timestep (default: 0.01ms) during AP
}
debug_jochen << "Last time step #iterations = " << diagInfo.iterations
<< " => new time step dt = " << dt << std::endl;
debug_jochen << "==========================================" << std::endl;
// Find best matching timestep from timestep file and adjust dt such that time value
// is matched exactly!
if(physics.getParams().getTimeStepFile() != "")
{
// Read next line in timestep file
double dummy = -1;
double desired_time = time+dt;
debug_info << "Desired next time value: " << desired_time << std::endl;
assert(timestepFile.good());
while(next_time < desired_time && timestepFile.good())
{
// Save last found value
next_time_last = next_time;
std::string line;
std::getline(timestepFile, line);
std::stringstream line_str(line);
line_str >> dummy >> next_time;
debug_jochen << "Found time value " << next_time << std::endl;
}
// Found value next_time should now be the first occurring value >= desired_time,
// so next_time_last should be the last value < desired_time
if(next_time < desired_time || next_time_last >= desired_time)
{
// Handle case when desired_time is > tend (last time step)
if(desired_time >= tend)
{
debug_jochen << "Last time step detected!" << std::endl;
} else {
DUNE_THROW(Dune::Exception, "Something went wrong when trying to find a matching time step from '"
<< physics.getParams().getTimeStepFile() << "', desired time: " << desired_time
<< ", best match: " << next_time_last);
}
}
// Choose new time value to be the one with the smallest difference to the desired time value;
// set dt such that the next prescribed timestep is hit
if(std::abs(next_time_last-desired_time) < std::abs(next_time-desired_time))
{
dt = next_time_last - time;
} else {
dt = next_time - time;
}
debug_info << "Next time: " << (time+dt) << " => dt = " << dt << std::endl;
}
acceptTimeStep = true;
}
debug_info << "Calculated timestep: " << dt << " -> new time: " << (time+dt) << std::endl;
Real dt_max = gv.comm().max(dt);
Real dt_min = gv.comm().min(dt);
if(std::abs(dt - dt_max)>1e-6 || std::abs(dt - dt_min)>1e-6)
{
DUNE_THROW(Dune::Exception, "Calculated time steps on processors don't match! min_dt = "
<< dt_min << ", dt_max = " << dt_max << "!");
}
// ==================================================================================================
// TODO Check if this condition is necessary; it should be safe to update here!
// if(time > time0)
// {
// Update channels
debug_jochen << "# gfMembFlux.updateState" << std::endl;
gfMembFlux.updateState(time, dt);
if(! fullyImplicit)
{
debug_jochen << "# gfMembFlux.updateFlux" << std::endl;
gfMembFlux.updateFlux(time, dt);
debug_jochen << "# gfMembFlux.acceptTimeStep" << std::endl;
gfMembFlux.acceptTimeStep();
}
// Update Mori charge layer
debug_jochen << "# gfMoriFlux.updateState" << std::endl;
gfMoriFlux.updateState(time, dt);
if(! fullyImplicit)
{
debug_jochen << "# gfMoriFlux.updateFlux" << std::endl;
gfMoriFlux.updateFlux(time, dt);
debug_jochen << "# gfMoriFlux.acceptTimeStep" << std::endl;
gfMoriFlux.acceptTimeStep();
}
// }
// Update boundary values
debug_info << "# Calling prepareNextTimeStep(" << (time+dt) << ") on parameter classes" << std::endl;
parametersPot.prepareNextTimeStep(time+dt);
for(int j=0; j<parametersCon.size(); ++j)
{
parametersCon[j]->prepareNextTimeStep(time+dt);
}
// Calculate initial concentration integrals; we have to do this here in order to make sure that
// both membrane and Mori flux GFs have been initialized to steady-state with respect to initial conditions
// TODO: Add possibility to load initial concentration integrals from config file; this would be
// mandatory when continuing a previous simulation!
if(initConcIntegralBulk.size() == 0)
{
// Calculate initial concentration integral (charge layer)
typename GF_MORI_CHARGE::Traits::RangeType concIntegralChargeLayer_temp;
Acme2CylGeometryTools::integrateIntersectionGridFunctionOverCylinderSubdomain(gfMoriCharge, physics,
subDomains, concIntegralChargeLayer_temp, intorderCon + intorderadd, false);
debug_jochen << "^^^ Initial concentration integrals (bulk / charge layer)" << std::endl;
Real sumBulk = 0;
Real sumChargeLayer = 0;
for(int j=0; j<NUMBER_OF_SPECIES; ++j)
{
// Calculate initial concentration integral (bulk)
typename ACME2CYL_OUTPUT::Traits::DGF_SINGLE_CON_MD::Traits::RangeType concIntegralBulk_temp;
Acme2CylGeometryTools::integrateGridFunctionOverCylinderSubdomain(dgfSingleConVec[j], physics,
subDomains, concIntegralBulk_temp, intorderCon + intorderadd);
// Bring to units of [C]
concIntegralBulk_temp *= scalingFactorBulk * physics.getValence(j);
initConcIntegralBulk.push_back(concIntegralBulk_temp);
sumBulk += concIntegralBulk_temp;
// Bring to units of [C]
concIntegralChargeLayer_temp[j] *= scalingFactorChargeLayer;
initConcIntegralChargeLayer.push_back(concIntegralChargeLayer_temp[j]);
sumChargeLayer += concIntegralChargeLayer_temp[j];
debug_jochen << "^^^ [" << ION_NAMES[j] << "] " << initConcIntegralBulk[j] << " / "
<< initConcIntegralChargeLayer[j] << std::endl;
}
sumBulk = gv.comm().sum(sumBulk);
sumChargeLayer = gv.comm().sum(sumChargeLayer);
debug_jochen << "^^^ [TOTAL] " << sumBulk << " / " << sumChargeLayer << std::endl;
}
// Update values representing last iteration
//last_dpot = dpot;
lastDiagInfo = diagInfo; // save diagnostic information for usage in next time step
diagInfo.clear();
bool converged = false;
const int numberRestarts = 3;
int countNumberRestarts = 0;
// Restart mechanism
while(not converged)
{
// Hack to let PDE solver be able to get the current time
diagInfo.time = (time+dt);
// !! Time-dependent boundary condition TYPES are currently not implemented in PDELab !!
// evaluate constraints for current time step
// bctypePot.setTime(time+dt);
// bctypeCon.setTime(time+dt);
// ccCon.clear();
// Dune::PDELab::constraints( bctypeCon, gfsCon, ccCon );
// ccPot.clear();
// Dune::PDELab::constraints( bctypePot, gfsPot, ccPot );
physics.setTimeStep(dt);
diagInfo.dt = dt;
// Set time also in initialGF (and implicitly also in parameter class!)
initialElec.setTime(time+dt);
try{
// ========= DO ONE TIME STEP ==============
//debug_verb << "================= Solving fully implicit system..." << std::endl;
// Time-dependent Dirichlet values (supported for potential only);
if(params.boundary.get("useTimeDependentBoundaryValuesPot",false) && isLoadedBoundaryDirichletPot)
{
debug_info << "== Applying time-dependent Dirichlet values..." << std::endl;
// Save unew: It might have been modified in a failed Newton iteration, so unew != uold might
// hold at this point. Use the modified unew rather than uold, as it might already contain
// better starting values!
typename Traits::U unew_save(unew);
//std::vector<typename Traits::U> uu;
//std::vector<std::string> uu_names(3);
//uu.push_back(unew_save);
//uu_names[0] = "unew_save";
Dune::PDELab::MultiDomain::interpolateOnTrialSpace(multigfs,unew,initialElec,elecSubProblem);
//uu.push_back(unew);
//uu_names[1] = "unew after interpolation";
//Dune::PDELab::copy_nonconstrained_dofs(cc, unew_save, unew);
// IMPORTANT: Use the modified contraints container ccWithoutOverlap to make this work in parallel!
// This will also copy overlap DOFs, even though they are considered as constrained in the original cc
Dune::PDELab::copy_nonconstrained_dofs(ccWithoutOverlap, unew_save, unew);
//uu.push_back(unew);
//uu_names[2] = "unew after copy_nonconstrained_dofs";
//Output::printRawCoefficientVector(uu, uu_names);
//Output::printRawCoefficientVector(unew, "unew");
}
solver.apply(time,dt,uold,unew);
//debug_verb << "================= Solved fully implicit system" << std::endl;
} catch(Dune::PDELab::NewtonError& e)
{
countNumberRestarts++;
if(countNumberRestarts <= params.maxNumberNewtonRestarts())
{
debug_warn << "====================================================" << std::endl;
debug_warn << e << std::endl;
debug_warn << "====================================================" << std::endl;
debug_warn << "Newton did not converge for dt = " << dt;
dt *= 0.5;
debug_warn << ", trying new time step dt = " << dt << "!" << std::endl;
// Recalculate membrane flux
debug_jochen << "# gfMembFlux.updateState" << std::endl;
gfMembFlux.updateState(time, dt);
if(! fullyImplicit)
{
debug_jochen << "# gfMembFlux.updateFlux" << std::endl;
gfMembFlux.updateFlux(time, dt);
debug_jochen << "# gfMembFlux.acceptTimeStep" << std::endl;
gfMembFlux.acceptTimeStep();
}
// Update Mori charge layer
debug_jochen << "# gfMoriFlux.updateState" << std::endl;
gfMoriFlux.updateState(time, dt);
if(! fullyImplicit)
{
debug_jochen << "# gfMoriFlux.updateFlux" << std::endl;
gfMoriFlux.updateFlux(time, dt);
debug_jochen << "# gfMoriFlux.acceptTimeStep" << std::endl;
gfMoriFlux.acceptTimeStep();
}
// Update boundary values
debug_info << "# Calling prepareNextTimeStep(" << (time+dt) << ") on parameter classes" << std::endl;
parametersPot.prepareNextTimeStep(time+dt);
for(int j=0; j<parametersCon.size(); ++j)
{
parametersCon[j]->prepareNextTimeStep(time+dt);
}
continue;
}
else
{
debug_warn << "====================================================" << std::endl;
debug_warn << e << std::endl;
debug_warn << "====================================================" << std::endl;
debug_warn << "Newton did not converge for dt = " << dt
<< " maximum number of Newton restarts (" << params.maxNumberNewtonRestarts()
<< ") exceeded!" << std::endl;
debug_warn << " first defect: " << solver.getPDESolver().result().first_defect << std::endl;
debug_warn << " defect: " << solver.getPDESolver().result().defect << std::endl;
// Write out non-converged solution
time += dt;
acme2_cylOutput.writeStep(time);
Tools::pecletNumber(gv, parametersCon, dgfGradPot);
throw e;
}
} catch(Dune::Exception& e)
{
debug_warn << "====================================================" << std::endl;
debug_warn << "DUNE Exception caught: " << e.what() << std::endl;
debug_warn << "====================================================" << std::endl;
// Write out non-converged solution
time += dt;
acme2_cylOutput.writeStep(time);
Tools::pecletNumber(gv, parametersCon, dgfGradPot);
throw e;
} catch(std::exception& e)
{
debug_warn << "====================================================" << std::endl;
debug_warn << "Exception caught: " << e.what() << std::endl;
debug_warn << "====================================================" << std::endl;
// Write out non-converged solution
time += dt;
acme2_cylOutput.writeStep(time);
Tools::pecletNumber(gv, parametersCon, dgfGradPot);
throw e;
} catch(...)
{
debug_warn << "====================================================" << std::endl;
debug_warn << "Unknown exception!" << std::endl;
debug_warn << "====================================================" << std::endl;
// Write out non-converged solution
time += dt;
acme2_cylOutput.writeStep(time);
Tools::pecletNumber(gv, parametersCon, dgfGradPot);
throw;
}
// Fill diagnosticInfo
diagInfo.iterations = solver.getPDESolver().result().iterations;
diagInfo.dt = dt;
diagInfo.setDebugData(std::string("newton_restarts"), countNumberRestarts);
converged = true;
}
uChange = 0.0;
uChange -= uold;
if(doConcentrationPostprocessing)
{
// Save non-postprocessed solution vector
typename Traits::U unew_orig = unew;
// Initial state will be wrong when resuming simulation
if(params.doLoadState() && params.doContinueSimulation())
DUNE_THROW(Dune::NotImplemented, "Resuming simulation with concentration postprocessing not implemented!");
debug_info << "=================================================================================" << std::endl;
debug_info << " Postprocessing ion concentrations to avoid global charge accumulation..." << std::endl;
debug_info << "=================================================================================" << std::endl;
std::vector<Real> corrections(3, 1.0);
debug_info << "^^^ Concentration integrals (bulk / charge layer)" << std::endl;
// Calculate concentration integral (charge layer)
typename GF_MORI_CHARGE::Traits::RangeType concIntegralChargeLayer_temp;
Acme2CylGeometryTools::integrateIntersectionGridFunctionOverCylinderSubdomain(gfMoriCharge, physics,
subDomains, concIntegralChargeLayer_temp, intorderCon + intorderadd, false);
Real sumBulk = 0;
Real sumChargeLayer = 0;
for(int j=0; j<NUMBER_OF_SPECIES; ++j)
{
// Calculate concentration integral (bulk)
Acme2CylGeometryTools::integrateGridFunctionOverCylinderSubdomain(dgfSingleConVec[j], physics,
subDomains, concIntegralBulk[j], intorderCon + intorderadd);
// Bring to units of [C]
concIntegralBulk[j] *= scalingFactorBulk * physics.getValence(j);
sumBulk += concIntegralBulk[j];
// Bring to units of [C]
concIntegralChargeLayer_temp[j] *= scalingFactorChargeLayer;
concIntegralChargeLayer[j] = concIntegralChargeLayer_temp[j];
sumChargeLayer += concIntegralChargeLayer[j];
// Ion concentration correction to avoid global charge accumulation when using Neumann-0 boundary condition
// (MoriPeskin 2008)
corrections[j] = (initConcIntegralBulk[j] + initConcIntegralChargeLayer[j] - concIntegralChargeLayer[j])
/ concIntegralBulk[j];
debug_info << "^^^ [" << ION_NAMES[j] << "] initial: " << initConcIntegralBulk[j] << " / "
<< initConcIntegralChargeLayer[j] << std::endl;
debug_info << "^^^ [" << ION_NAMES[j] << "] current: " << concIntegralBulk[j] << " / "
<< concIntegralChargeLayer[j] << std::endl;
debug_info << "^^^ => corrections[" << ION_NAMES[j] << "] = " << corrections[j] << std::endl;
}
sumBulk = gv.comm().sum(sumBulk);
sumChargeLayer = gv.comm().sum(sumChargeLayer);
debug_jochen << "^^^ [TOTAL] " << sumBulk << " / " << sumChargeLayer << std::endl;
// Here comes the ugly hack: As we don't have a global mapping to extract a single GFS component from
// a composite GFS coefficient vector, we need to assume we know the ordering of DOFs in the container
// and do it manually!
assert(params.nMembraneElements() <= 1);
const int blockSize = AX1_BLOCKSIZE;
assert(unew.flatsize() % blockSize == 0);
//std::size_t size = unew.flatsize() / blockSize;
std::size_t i = 0;
for (typename Traits::U::iterator it = unew.begin(); it != unew.end(); ++it)
{
// Component is out of the interval [0 NUMBER_OF_SPECIES], the last value represents the potential
// (which we don't need here)
std::size_t component = i % blockSize;
// Apply correction for the respective ion species
if(component < NUMBER_OF_SPECIES)
{
*it *= corrections[component];
}
++i;
}
debug_info << "=================================================================================" << std::endl;
// Debug output (remove this later)
std::vector<typename Traits::U> uu;
uu.push_back(unew_orig);
uu.push_back(unew);
std::vector<std::string> uu_str;
uu_str.push_back("unew before postprocessing");
uu_str.push_back("unew after postprocessing ");
Output::printRawCoefficientVector(uu, uu_str);
}
uChange += unew;
// TODO Re-implement calculation of equation-specific changes!
//uConChange = unewCon;
//uConChange -= uoldCon;
//uPotChange = unewPot;
//uPotChange -= uoldPot;
// dpot = uPotChange.base().infinity_norm();
// uPotChange_Rel = unewPot;
// int n = unewPot.flatsize();
// for(int i=0; i<n; ++i)
// {
// Traits::VBE::access(uPotChange_Rel, i) /= Traits::VBE::access(uoldPot, i);
// Traits::VBE::access(uPotChange_Rel, i) -= 1;
//
// //debug_jochen << uoldPot[i] << " --> " << unewPot[i] << " (" << uPotChange_Rel[i] << std::endl;
// }
// uConChange_Rel = unewCon;
// for(int i=0; i<uConChange_Rel.flatsize(); i++)
// {
// Traits::VBE::access(uConChange_Rel,i) /= Traits::VBE::access(uoldCon, i);
// Traits::VBE::access(uConChange_Rel, i) -= 1;
// }
// Open new scope so that Dune::ios_base_all_saver's destructor can restore stream setting after output
{
Dune::ios_base_all_saver hackbraten(std::cout);
debug_info << std::scientific << std::setprecision(16);
debug_info << "L2 solution change: " << uChange.base().two_norm() << std::endl;
debug_info << "MAX solution change: " << uChange.base().infinity_norm() << std::endl;
diagInfo.setDebugData(std::string("old_dt"), old_dt);
diagInfo.setDebugData(std::string("last_dt"), last_dt);
}
time += dt;
iterations += diagInfo.iterations;
timeSteps++;
totalTimeSteps++;
double diffToNextTimeStep = time - outputCounter * outputTimeInterval;
if (printEveryTimeStep || std::abs(diffToNextTimeStep) < 1e-8 || diffToNextTimeStep > 0)
{
++outputCounter;
//Output::printSingleCoefficientVectorDG(uPot, "pot");
//Output::printMultipleComponentCoefficientVectorDG(unewCon, NUMBER_OF_SPECIES);
acme2_cylOutput.writeStep(time);
Tools::pecletNumber(gv, parametersCon, dgfGradPot);
Real minMembPot = std::numeric_limits<Real>::max();
Real maxMembPot = std::numeric_limits<Real>::lowest();
typename Traits::DGF_CON::Traits::RangeType minConCytosol(std::numeric_limits<Real>::max());
typename Traits::DGF_CON::Traits::RangeType maxConCytosol(std::numeric_limits<Real>::lowest());
typename Traits::DGF_CON::Traits::RangeType minConExtra(std::numeric_limits<Real>::max());
typename Traits::DGF_CON::Traits::RangeType maxConExtra(std::numeric_limits<Real>::lowest());
for(typename Traits::Physics::MIterator mit = physics.mInteriorBegin(); mit != physics.mInteriorEnd(); ++mit)
{
typename Traits::DGF_POT::Traits::RangeType membPot;
physics.getMembranePotential(*mit, dgfPot, membPot);
typename Traits::DGF_CON::Traits::RangeType conCytosol, conExtra;
physics.getMembraneConcentrationJump(*mit, dgfCon, conCytosol, conExtra);
if(membPot < minMembPot) minMembPot = membPot;
if(membPot > maxMembPot) maxMembPot = membPot;
for(int j=0; j<conCytosol.size(); j++)
{
if(conCytosol[j] < minConCytosol[j]) minConCytosol[j] = conCytosol[j];
if(conCytosol[j] > maxConCytosol[j]) maxConCytosol[j] = conCytosol[j];
if(conExtra[j] < minConExtra[j]) minConExtra[j] = conExtra[j];
if(conExtra[j] > maxConExtra[j]) maxConExtra[j] = conExtra[j];
}
if(std::abs(time-physics.getParams().tEquilibrium()) < 1e-6)
{
typename GoldmanGF::Traits::RangeType goldmanPotential;
// Evaluate at cell center
typename GoldmanGF::Traits::DomainType x(0.5);
//Dune::PDELab::IntersectionGeometry<typename Traits::Physics::ElementIntersection> ig(*mit,-1);
goldmanGF.evaluate(*mit, x, goldmanPotential);
debug_verb << mit->geometry().global(x) << std::endl;
debug_verb << " Membrane potential: " << physics.convertTo_mV(membPot) << std::endl;
debug_verb << " Goldman potential: " << goldmanPotential << std::endl;
}
}
minMembPot = gv.comm().min(minMembPot);
maxMembPot = gv.comm().max(maxMembPot);
debug_info << "MAX membrane potential = " << physics.convertTo_mV(maxMembPot) << " mV" << std::endl;
debug_info << "MIN membrane potential = " << physics.convertTo_mV(minMembPot) << " mV" << std::endl;
debug_info << "MIN/MAX membrane concentrations (CY) = " << minConCytosol << " / "
<< maxConCytosol << std::endl;
debug_info << "MIN/MAX membrane concentrations (ES) = " << minConExtra << " / "
<< maxConExtra << std::endl;
debug_info << std::endl << "########## timestep #" << acme2_cylOutput.getNTimeSteps()
<< ": output done, time: " << time
<< " [" << timeSteps << " steps, average #iterations: " << (iterations/timeSteps) << "] ###########"
<< std::endl << std::endl;
// debug_jochen << "-------------------------------------------------------------" << std::endl;
// debug_jochen << "CHANNEL STATES: " << std::endl;
//
// Dune::ios_base_all_saver hack(std::cout);
// std::cout << std::setprecision(32);
// Output::printVector(physics.getMembrane().getChannelSet().serializeChannelStates());
// debug_jochen << "-------------------------------------------------------------" << std::endl;
iterations = 0;
timeSteps = 0;
}
// Check if a checkpoint output will be created. A checkpoint is created for the very first
// time steps and then every k time steps [with k == params.checkpointInterval()]
if(params.doCheckpointing() &&
(totalTimeSteps % params.checkpointInterval() == 0 || totalTimeSteps == 1))
{
std::string checkpointFilename("");
acme2_cylOutput.saveState(time,dt,checkpointFilename);
}
// Do not overwrite uold before output, otherwise Mori flux will be calculated wrongly.
// So we update the vector as the very last instruction in the time loop
uold = unew;
// Same goes for the membrane flux states: The old values are needed (at least for Mori flux)
// during output in order to correctly calculated fluxes. Do not overwrite old values before
// output has completed!
if(fullyImplicit)
{
debug_jochen << "# gfMembFlux.acceptTimeStep" << std::endl;
gfMembFlux.acceptTimeStep();
debug_jochen << "# gfMoriFlux.acceptTimeStep" << std::endl;
gfMoriFlux.acceptTimeStep();
}
}
// ==============================================================================================
debug_info << "Total number of time steps: " << totalTimeSteps << std::endl;
}
};
#endif /* DUNE_AX1_ACME2CYL_FULLY_COUPLED_HH */
| 45.886049 | 130 | 0.575905 | pederpansen |
98a22b41d985c8ab13bb12fed4efe0b406a71953 | 524 | hpp | C++ | PlanetLab/src/engine/Skybox.hpp | Thomas-Zorroche/Procedural-Planets | 44f8a9fa3120d11d137e4f499142333e81ed68ce | [
"MIT"
] | null | null | null | PlanetLab/src/engine/Skybox.hpp | Thomas-Zorroche/Procedural-Planets | 44f8a9fa3120d11d137e4f499142333e81ed68ce | [
"MIT"
] | null | null | null | PlanetLab/src/engine/Skybox.hpp | Thomas-Zorroche/Procedural-Planets | 44f8a9fa3120d11d137e4f499142333e81ed68ce | [
"MIT"
] | null | null | null | #pragma once
#include "engine/ResourceManager.hpp"
#include "opengl/Mesh.hpp"
#include "common.hpp"
#include "engine/Material.hpp"
#include "opengl/Shader.h"
#include "engine/Renderer.hpp"
namespace PlanetLab
{
class Skybox
{
public:
Skybox(const std::vector<std::string>& faces);
void GenerateMesh();
void Draw();
private:
void SendUniforms();
std::vector<std::string> _faces;
unsigned int _id;
std::shared_ptr<Shader> _shader;
std::shared_ptr<Mesh> _mesh;
static const float _SkyboxVertices[];
};
} | 14.162162 | 47 | 0.721374 | Thomas-Zorroche |
98a4b254ef4011043ec5f3eb6c2eca314ac5bd4a | 26,063 | cpp | C++ | src/xml_parse.cpp | incoder1/libio | fbfd83fe31ca59a69670e5269f5847b2b4c6c553 | [
"BSL-1.0"
] | 14 | 2018-06-12T15:42:43.000Z | 2022-02-28T16:19:20.000Z | src/xml_parse.cpp | incoder1/libio | fbfd83fe31ca59a69670e5269f5847b2b4c6c553 | [
"BSL-1.0"
] | null | null | null | src/xml_parse.cpp | incoder1/libio | fbfd83fe31ca59a69670e5269f5847b2b4c6c553 | [
"BSL-1.0"
] | null | null | null | /*
*
* Copyright (c) 2016-2019
* Viktor Gubin
*
* Use, modification and distribution are subject to 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)
*
*/
#include "stdafx.hpp"
#include "xml_parse.hpp"
#include "strings.hpp"
namespace io {
namespace xml {
static constexpr const char* PROLOGUE = "xml";
static const char* COMMENT = "<!--";
static const char* CDATA = "<![CDATA[";
static const char* DOCTYPE = "<!DOCTYPE";
static constexpr const std::size_t MEDIUM_BUFF_SIZE = 128;
static constexpr const std::size_t HUGE_BUFF_SIZE = 256;
// unicode constants in digit forms, to handle endians
static constexpr const int ENDL = 0;
static constexpr const int LEFTB = 60; // '<';
static constexpr const int RIGHTB = 62; // '>';
static constexpr const int SRIGHTB = 93; // ']'
static constexpr const int QNM = 34; // '"'
static constexpr const int APH = 39; // '\''
static constexpr const int SPACE = 32;//' ';
static constexpr const int EM = 33;//'!';
static constexpr const int SOLIDUS = 47;// '/'
static constexpr const int HYPHEN = 45;// '-'
static constexpr const int COLON = 58; // ':'
static constexpr const int ES = 61 ; // '='
static constexpr const int QM = 63; // '?'
static inline bool is_prologue(const char *s) noexcept
{
return start_with(s, PROLOGUE, 3) && is_space( s[3] );
}
static inline bool is_comment(const char *s) noexcept
{
return start_with(s, COMMENT, 4);
}
static inline bool is_cdata(const char* s) noexcept
{
return start_with(s, CDATA, 9);
}
static inline bool is_doc_type(const char *s) noexcept
{
return start_with(s, DOCTYPE, 9);
}
static std::size_t prefix_delimit(const char* src) noexcept
{
static const char* DELIMS = "\t\n\v\f\r :/>";
return io_strcspn(src, DELIMS);
}
static size_t xmlname_strspn(const char *s) noexcept
{
constexpr const char* sym = "\t\n\v\f\r />";
return io_strcspn(s, sym);
}
static std::size_t extract_prefix(std::size_t &start, const char* str) noexcept
{
const char *s = str;
if( cheq(LEFTB,*s) ) {
const std::size_t shift = cheq( SOLIDUS, *(s+1) ) ? 2 : 1;
s += shift;
start += shift;
}
s += prefix_delimit(s);
if( chnoteq(COLON, *s) ) {
start = 0;
return 0;
}
return str_size( (str + start), s );
}
static std::size_t extract_local_name(std::size_t& start,const char* str) noexcept
{
char *s = const_cast<char*>(str);
start = 0;
if( is_one_of(*s, LEFTB,COLON,QM) ) {
++start;
++s;
}
if( cheq(*s, SOLIDUS) ) {
++start;
++s;
}
s += xmlname_strspn(s);
std::size_t ret = 0;
if( io_unlikely( cheq(ENDL, *s) ) )
start = 0;
else
ret = memory_traits::distance(str,s-1) - (start-1);
return ret;
}
#if defined(__GNUG__) || defined(__ICL) || defined(__clang__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wpedantic"
static bool is_xml_name_char(uint32_t ch) noexcept
{
switch( ch ) {
case 0x5F:
case 0x3A:
case 0x2D:
case 0x2E:
case 0xB7:
case 0x30 ... 0x39:
case 0x41 ... 0x5A:
case 0x61 ... 0x7A:
case 0xC0 ... 0xD6:
case 0xD8 ... 0xF6:
case 0xF8 ... 0x2FF:
case 0x370 ... 0x37D:
case 0x37F ... 0x1FFF:
case 0x200C ... 0x200D:
case 0x203F ... 0x2040:
case 0x2070 ... 0x218F:
case 0x2C00 ... 0x2FEF:
case 0x0300 ... 0x036F:
case 0x3001 ... 0xD7FF:
case 0xF900 ... 0xFDCF:
case 0xFDF0 ... 0xFFFD:
case 0x10000 ... 0xEFFFF:
return true;
default:
return false;
}
}
#pragma GCC diagnostic pop
#else
static constexpr bool is_xml_name_start_char_lo(char32_t ch) noexcept
{
// _ | :
return is_one_of(ch, U'_', U':') || is_alpha( ch );
}
template<unsigned int S, unsigned int E, unsigned int D = ((E - S) + 1) >
static constexpr bool between(char32_t ch) noexcept {
return (static_cast<unsigned int>(ch)-S) < D;
}
static constexpr bool is_xml_name_start_char(char32_t ch) noexcept
{
// Compiler optimize it better then search array
return is_xml_name_start_char_lo(ch) ||
between<0xC0,0xD6>(ch) ||
between<0xD8,0xF6>(ch) ||
between<0xF8,0x2FF>(ch) ||
between<0x370,0x37D>(ch) ||
between<0x37F,0x1FFF>(ch) ||
between<0x200C,0x200D>(ch) ||
between<0x2070,0x218F>(ch) ||
between<0x2C00,0x2FEF>(ch) ||
between<0x3001,0xD7FF>(ch) ||
between<0xF900,0xFDCF>(ch) ||
between<0xFDF0,0xFFFD>(ch) ||
between<0x10000,0xEFFFF>(ch);
}
static constexpr bool is_xml_name_char(char32_t ch) noexcept
{
return is_digit(ch) ||
// - | . | U+00B7
is_one_of(ch,0x2D,0x2E,0xB7) ||
is_xml_name_start_char(ch) ||
between<0x0300,0x036F>(ch) ||
between<0x203F,0x2040>(ch);
}
#endif // __GNUG__
// Check XML name is correct according XML syntax
static error check_xml_name(const char* tn) noexcept
{
// name can not start from digit
if( io_unlikely( is_endl(*tn) || io_isdigit(*tn) ) )
return error::illegal_name;
uint32_t utf32c;
do {
// decode UTF-8 symbol to UTF-32 to check name
switch( utf8::mblen(tn) ) {
case io_likely(1):
utf32c = static_cast<uint32_t>( *tn );
++tn;
break;
case 2:
utf32c = utf8::decode2( tn );
tn += 2;
break;
case 3:
utf32c = utf8::decode3( tn );
tn += 3;
break;
case 4:
utf32c = utf8::decode4( tn );
tn += 4;
break;
default:
return error::illegal_name;
}
if( !is_xml_name_char(utf32c) )
return error::illegal_name;
} while( not_endl(*tn) );
return error::ok;
}
static error validate_tag_name(const char* name) noexcept
{
// check XML,xMl,xml etc
char first[3];
for(std::size_t i=0; i < 3; i++)
first[i] = latin1_to_lower(name[i]);
if( start_with(first, PROLOGUE, 3) )
return error::illegal_name;
return check_xml_name(name);
}
static error validate_attribute_name(const char* name) noexcept
{
return check_xml_name(name);
}
// event_stream_parser
s_event_stream_parser event_stream_parser::open(std::error_code& ec,s_source&& src) noexcept
{
if(!src) {
ec = std::make_error_code( std::errc::bad_address );
return s_event_stream_parser();
}
s_string_pool pool = string_pool::create(ec);
if(!pool)
return s_event_stream_parser();
return s_event_stream_parser( nobadalloc<event_stream_parser>::construct( ec, std::move(src), std::move(pool) ) );
}
s_event_stream_parser event_stream_parser::open(std::error_code& ec,s_read_channel&& src) noexcept
{
s_source xmlsrc = source::create(ec, std::forward<s_read_channel>(src) );
return !ec ? open(ec, std::move(xmlsrc) ) : s_event_stream_parser();
}
event_stream_parser::event_stream_parser(s_source&& src, s_string_pool&& pool) noexcept:
object(),
src_( std::forward<s_source>(src) ),
state_(),
current_(event_type::start_document),
pool_(std::forward<s_string_pool>(pool)),
validated_(),
nesting_(0)
{
constexpr std::size_t VD_INITIAL = 64;
validated_.reserve( VD_INITIAL );
// skip any leading spaces if any
char c;
do {
c = next();
}
while( is_space(c) && error_state_ok() );
if( io_unlikely( chnoteq(c,LEFTB) ) ) {
assign_error(error::illegal_markup);
}
else {
sb_clear();
scan_buf_[0] = '<';
}
}
event_stream_parser::~event_stream_parser() noexcept
{}
inline void event_stream_parser::assign_error(error ec) noexcept
{
state_.current = state_type::eod;
if(error::ok == state_.ec)
state_.ec = ec;
}
inline void event_stream_parser::putch(byte_buffer& buf, char ch) noexcept
{
if( io_unlikely( !buf.put(ch) && ( !buf.ln_grow() || !buf.put(ch) ) ) )
assign_error(error::out_of_memory);
}
cached_string event_stream_parser::precache(const char* str) noexcept
{
return pool_->get(str);
}
// extract name and namespace prefix if any
qname event_stream_parser::extract_qname(const char* from, std::size_t& len) noexcept
{
cached_string prefix;
cached_string local_name;
len = 0;
std::size_t start = 0;
std::size_t count = extract_prefix( start, from );
if( count > 0 )
prefix = pool_->get( (from+start), count);
len += start+count;
const char* name = from+len;
count = extract_local_name(start,name);
if(count > 0) {
local_name = pool_->get( (name+start), count);
}
else {
assign_error(error::illegal_name);
return qname();
}
len += start+count;
const char* left = from + len;
if( cheq(SOLIDUS,*left) ) {
++len;
++left;
}
if(cheq(RIGHTB,*left))
++len;
return qname( std::move(prefix), std::move(local_name) );
}
state_type event_stream_parser::scan_next() noexcept
{
if(state_type::eod != state_.current)
scan();
return state_.current;
}
byte_buffer event_stream_parser::read_entity() noexcept
{
byte_buffer ret;
ret.extend(MEDIUM_BUFF_SIZE);
if( !ret ) {
assign_error(error::out_of_memory);
return byte_buffer();
}
ret.put( scan_buf_ );
sb_clear();
src_->read_until_char( ret, static_cast<char>(RIGHTB), static_cast<char>(LEFTB) );
if( src_->eof() ) {
assign_error( src_->last_error() );
return byte_buffer();
}
ret.flip();
return ret;
}
#define check_state( _STATE_TYPE, _EMPTY_RET_TYPE)\
if( state_.current != _STATE_TYPE ) {\
assign_error(error::invalid_state);\
return _EMPTY_RET_TYPE();\
}
#define check_event_parser_state( _EVENT_TYPE, _EMPTY_RET_TYPE )\
if(state_type::event != state_.current || current_ != _EVENT_TYPE ) { \
assign_error(error::invalid_state); \
return _EMPTY_RET_TYPE(); \
}
document_event event_stream_parser::parse_start_doc() noexcept
{
static constexpr const char* VERSION = "version=";
static constexpr const char* ENCODING = "encoding=";
static constexpr const char* STANDALONE = "standalone=";
static constexpr const char* YES = "yes";
static constexpr const char* NO = "no";
static constexpr const char* END_PROLOGUE = "?>";
check_event_parser_state(event_type::start_document, document_event )
byte_buffer buff( read_entity() );
if( is_error() )
return document_event();
buff.shift(5);
const_string version, encoding;
bool standalone = false;
const char* prologue = buff.position().cdata();
// extract version
char* i = io_strstr( const_cast<char*>(prologue), VERSION );
if(nullptr == i) {
assign_error(error::illegal_prologue);
return document_event();
}
i += 8; // i + strlen(VERSION)
int sep = std::char_traits<char>::to_int_type( *i );
if( !is_one_of(sep,QNM,APH) ) {
assign_error(error::illegal_prologue);
return document_event();
}
else
++i;
char *stop = io_strchr(i, sep);
if(nullptr == stop ) {
assign_error(error::illegal_prologue);
return document_event();
}
version = const_string( i, stop);
if( version.empty() ) {
assign_error(error::out_of_memory);
return document_event();
}
// extract optional
i = const_cast<char*>( stop + 1 );
// extract encoding if exist
const char* j = io_strstr(i, ENCODING);
if(nullptr != j) {
i = const_cast<char*>( j + 9 );
sep = std::char_traits<char>::to_int_type( *i );
if( !is_one_of(sep,QNM,APH) ) {
assign_error(error::illegal_prologue);
return document_event();
}
else
++i;
stop = io_strchr( i, sep );
if(nullptr == stop ) {
assign_error(error::illegal_prologue);
return document_event();
}
encoding = const_string(i,stop);
if( encoding.empty() ) {
assign_error(error::out_of_memory);
return document_event();
}
i = const_cast<char*> ( stop + 1 );
}
// extract standalone if exist
j = io_strstr(i, STANDALONE);
if(nullptr != j) {
// j + strlen(STANDALONE)
i = const_cast<char*> ( j + 11 );
sep = std::char_traits<char>::to_int_type( *i );
if( !is_one_of(sep,QNM,APH) ) {
assign_error(error::illegal_prologue);
return document_event();
}
else
++i;
stop = io_strchr( i, sep );
if(nullptr == stop || (str_size(i,stop) > 3) ) {
assign_error(error::illegal_prologue);
return document_event();
}
standalone = ( 0 == io_memcmp( i, YES, 3) );
if( !standalone && ( 0 != io_memcmp(i, NO, 2) ) ) {
assign_error(error::illegal_prologue);
return document_event();
}
i = const_cast<char*> ( stop + 1 );
}
// check error in this point
if( 0 != io_memcmp( find_first_symbol(i), END_PROLOGUE, 2) ) {
assign_error(error::illegal_prologue);
return document_event();
}
return document_event( std::move(version), std::move(encoding), standalone);
}
instruction_event event_stream_parser::parse_processing_instruction() noexcept
{
check_event_parser_state(event_type::processing_instruction, instruction_event)
byte_buffer buff = read_entity();
if( is_error() )
return instruction_event();
buff.move(1);
char *i = const_cast<char*>( buff.position().cdata() );
std::size_t start = 0;
std::size_t len = extract_local_name(start,i);
i += start;
const_string target(i,len);
if( target.empty() ) {
assign_error(error::out_of_memory);
return instruction_event();
}
i += len;
len = io_strlen(i);
const_string data( i, len-2);
if( target.empty() ) {
assign_error(error::out_of_memory);
return instruction_event();
}
return instruction_event( std::move(target), std::move(data) );
}
void event_stream_parser::skip_dtd() noexcept
{
if(state_type::dtd != state_.current) {
assign_error(error::invalid_state);
return;
}
std::size_t brackets = 1;
do {
switch( std::char_traits<char>::to_int_type( next() ) ) {
case EOF:
assign_error(error::illegal_dtd);
break;
case LEFTB:
++brackets;
break;
case RIGHTB:
--brackets;
break;
default:
break;
}
}
while( brackets > 0);
}
const_string event_stream_parser::read_dtd() noexcept
{
check_state(state_type::dtd, const_string)
std::error_code ec;
byte_buffer dtd = byte_buffer::allocate(ec, MEDIUM_BUFF_SIZE);
if( ec ) {
assign_error(error::out_of_memory);
return const_string();
}
dtd.put(scan_buf_);
sb_clear();
std::size_t brackets = 1;
char i;
do {
i = next();
switch( std::char_traits<char>::to_int_type(i) ) {
case EOF:
assign_error(error::illegal_dtd);
return const_string();
case LEFTB:
++brackets;
break;
case RIGHTB:
--brackets;
break;
default:
break;
}
putch(dtd, i );
}
while( brackets > 0 && error_state_ok() );
dtd.flip();
return const_string( dtd.position().cdata(), dtd.last().cdata() );
}
void event_stream_parser::skip_comment() noexcept
{
if(state_type::comment != state_.current) {
assign_error(error::invalid_state);
return;
} else if( scan_failed() ) {
assign_error(error::illegal_commentary);
return;
}
sb_clear();
constexpr const uint16_t double_hyphen = pack_word( static_cast<uint16_t>('-'), '-');
uint16_t hw = 0;
char c;
do {
c = next();
hw = pack_word(hw, c);
}
while( double_hyphen != hw && io_likely( !is_eof(c) && error_state_ok() ) );
if( chnoteq(RIGHTB, next() ) )
assign_error(error::illegal_commentary);
}
byte_buffer event_stream_parser::read_until_double_separator(const char separator,const error ec) noexcept
{
if( scan_failed() ) {
assign_error(ec);
return byte_buffer();
}
byte_buffer ret;
ret.extend( HUGE_BUFF_SIZE );
if( !ret ) {
assign_error(error::out_of_memory);
return ret;
}
sb_clear();
src_->read_until_double_char( ret, separator );
if( ret.empty() || chnoteq(RIGHTB, next() ) ) {
if( error::out_of_memory == src_->last_error() )
assign_error(error::out_of_memory);
else
assign_error( ec );
return byte_buffer();
}
ret.flip();
return ret;
}
const_string event_stream_parser::read_comment() noexcept
{
check_state(state_type::comment, const_string)
constexpr std::size_t END_LEXEM_LEN = 3; // --> len
byte_buffer tmp( read_until_double_separator(HYPHEN, error::illegal_commentary) );
if( tmp.empty() || 0 == io_strcmp("--", tmp.position().cdata() ) )
return const_string();
else
return const_string( tmp.position().cdata(), tmp.last().cdata()-END_LEXEM_LEN );
}
const_string event_stream_parser::read_chars() noexcept
{
check_state(state_type::characters, const_string)
byte_buffer ret;
ret.extend( HUGE_BUFF_SIZE );
if( !ret ) {
assign_error(error::out_of_memory);
return const_string();
}
// just "\s<" in scan stack
//const char *i = io_strchr(scan_buf_+1, RIGHTB);
if( is_space(scan_buf_[0]) && cheq(scan_buf_[1],RIGHTB) ) {
io_memmove(scan_buf_, "<", 2);
return const_string(scan_buf_, 1);
}
// check for <tag></tag>
char c = next();
if( cheq(c,LEFTB) ) {
io_memmove(scan_buf_, "<", 2);
return const_string();
}
else
ret.put( c );
src_->read_until_char(ret, '<', '>');
error errc = src_->last_error();
if( io_unlikely( error::ok != errc ) ) {
if(error::illegal_markup == errc)
assign_error(error::root_element_is_unbalanced);
else
assign_error( errc );
}
else if( !ret.empty() ) {
io_memmove(scan_buf_, "<", 2);
ret.flip();
// don't add last <
return const_string( ret.position().cdata(), ret.length()-1 );
}
return const_string();
}
void event_stream_parser::skip_chars() noexcept
{
if(state_type::characters != state_.current) {
assign_error(error::invalid_state);
return;
}
for(int i = std::char_traits<char>::to_int_type( next() ); error_state_ok() ; i = std::char_traits<char>::to_int_type( next() ) ) {
switch(i) {
case LEFTB:
sb_clear();
sb_append( static_cast<char>(LEFTB) );
return;
case RIGHTB:
sb_clear();
assign_error(error::illegal_chars);
return;
case io_unlikely(EOF):
sb_clear();
assign_error(error::root_element_is_unbalanced);
return;
}
}
}
const_string event_stream_parser::read_cdata() noexcept
{
check_state(state_type::cdata, const_string)
byte_buffer tmp( read_until_double_separator(SRIGHTB, error::illegal_cdata_section) );
tmp.flip();
return const_string( tmp.position().cdata(), tmp.last().cdata()-3 );
}
attribute event_stream_parser::extract_attribute(const char* from, std::size_t& len) noexcept
{
len = 0;
// skip lead spaces, don't copy them into name
const char *i = find_first_symbol(from);
if( nullptr == i || is_one_of(*i, SOLIDUS,RIGHTB,0) )
return attribute();
const char* start = i;
i = io_strchr(start, ES);
if( nullptr == i || !is_one_of( i[1], QNM, APH) ) {
assign_error(error::illegal_markup);
return attribute();
}
const char val_sep = *(++i);
cached_string np;
cached_string ln;
// find prefix if any, ans split onto qualified name
char *tmp = strchrn( start, COLON, str_size(start,i) );
if(nullptr != tmp) {
np = pool_->get( start, str_size(start, tmp) );
start = tmp + 1;
}
ln = pool_->get(start, str_size(start, i-1) );
// extract attribute value
++i; // skip ( "|' )
start = i;
// find closing value separator
i = io_strchr(i, val_sep );
if(nullptr == i) {
assign_error(error::illegal_attribute);
return attribute();
}
// check for empty attribute value
// not valid according W3C, but can be present
// in sort of generated xmls
const std::size_t val_size = str_size(start,i);
// empty value attribute, return
if( io_unlikely( val_size < 1 ) ) {
len = str_size(from, i+1);
return attribute( qname( std::move(np), std::move(ln) ), io::const_string() );
}
const_string value(start, val_size);
if( io_unlikely( value.empty() ) ) {
assign_error(error::out_of_memory);
return attribute();
}
// normalize attribute value
// replace any white space characters to space character
// according to W3C XML spec
char *v = const_cast<char*>( value.data() );
constexpr const char* NOT_SPACE_WS = "\t\n\v\f\r";
do {
v += io_strcspn(v,NOT_SPACE_WS);
if( not_endl(*v) )
*v = ' ';
} while( not_endl(*v) );
len = str_size(from, ++i);
return attribute( qname( std::move(np), std::move(ln) ), std::move(value) );
}
bool event_stream_parser::validate_xml_name(const cached_string& str, bool attr) noexcept
{
std::size_t str_hash = str.hash();
if( validated_.end() == validated_.find( str_hash ) ) {
const char *s = str.data();
error err;
if(attr)
err = validate_attribute_name( s );
else
err = validate_tag_name( s );
if(error::ok != err ) {
assign_error( err );
return false;
}
validated_.insert( str_hash );
return true;
}
return true;
}
inline char event_stream_parser::next() noexcept
{
return src_->next();
}
bool event_stream_parser::validate_attr_name(const qname& name) noexcept
{
bool ret = validate_xml_name( name.local_name(), true );
if( ret && name.has_prefix() )
ret = validate_xml_name(name.prefix(), true);
return ret;
}
bool event_stream_parser::validate_element_name(const qname& name) noexcept
{
bool ret = validate_xml_name( name.local_name(), false );
if( ret && name.has_prefix() )
ret = validate_xml_name(name.prefix(), false);
return ret;
}
start_element_event event_stream_parser::parse_start_element() noexcept
{
check_event_parser_state(event_type::start_element, start_element_event);
byte_buffer buff = read_entity();
if( is_error() )
return start_element_event();
constexpr std::size_t SELF_CLOSE_LEN = 3; // len of </ from last
bool empty_element = cheq(SOLIDUS, *(buff.last().cdata()-SELF_CLOSE_LEN) );
// nesting level for nodes balance
if( !empty_element )
++nesting_;
std::size_t len = 0;
qname name = extract_qname( buff.position().cdata(), len );
// check name validity
if(is_error() || !validate_element_name(name) )
return start_element_event();
start_element_event result( std::move(name), empty_element );
// extract attributes if any
const char *left = buff.position().cdata() + len;
if( is_space(*left) && error_state_ok() ) {
std::size_t offset;
attribute attr = extract_attribute(left,offset);
while( (0 < offset) && error_state_ok() ) {
// validate attribute name and check for
// double attributes with the same name check
// according to W3C XML spec
if( !validate_attr_name( attr.name() ) || !result.add_attribute( std::move(attr) ) ) {
assign_error( error::illegal_attribute );
} else {
// extract next attribute if there were any
attr = extract_attribute( (left += offset) ,offset);
}
}
}
return error_state_ok() ? std::move(result) : start_element_event();
}
end_element_event event_stream_parser::parse_end_element() noexcept
{
check_event_parser_state(event_type::end_element, end_element_event )
qname name;
if( io_likely(nesting_ > 0) ) {
if(0 == (--nesting_) )
state_.current = state_type::eod;
byte_buffer buff = read_entity();
if( error_state_ok() ) {
std::size_t len = 0;
name = extract_qname( buff.position().cdata(), len );
}
} else {
assign_error(error::root_element_is_unbalanced);
}
return end_element_event( std::move(name) );
}
void event_stream_parser::s_instruction_or_prologue() noexcept
{
if( 0 != nesting_ ) {
assign_error(error::illegal_markup);
return;
}
constexpr std::size_t SCAN_START = 2;
constexpr std::size_t MAX_SCAN = 7;
for(std::size_t i=SCAN_START; i < MAX_SCAN; i++) {
scan_buf_[i] = next();
}
if( scan_failed() ) {
assign_error(error::illegal_markup);
}
else if( is_prologue(scan_buf_+SCAN_START) ) {
if( state_type::initial == state_.current ) {
current_ = event_type::start_document;
state_.current = state_type::event;
}
else {
assign_error(error::illegal_prologue);
}
}
else {
current_ = event_type::processing_instruction;
state_.current = state_type::event;
}
}
void event_stream_parser::s_comment_cdata_or_dtd() noexcept
{
scan_buf_[2] = next();
scan_buf_[3] = next();
if( scan_failed() ) {
assign_error(error::root_element_is_unbalanced);
}
else if( is_comment(scan_buf_) ) {
state_.current = state_type::comment;
}
else {
constexpr std::size_t SCAN_START = 4;
constexpr std::size_t MAX_SCAN = 9;
for(std::size_t i = SCAN_START; i < MAX_SCAN; i++) {
scan_buf_[i] = next();
}
// check for the EOF in the scan buffer
if( scan_failed() )
assign_error(error::root_element_is_unbalanced);
else if( is_cdata(scan_buf_) )
state_.current = state_type::cdata;
else if( is_doc_type(scan_buf_) )
state_.current = state_type::dtd;
else
assign_error(error::illegal_markup);
}
}
void event_stream_parser::s_entity() noexcept
{
scan_buf_[1] = next();
const int second = std::char_traits<char>::to_int_type( scan_buf_[1] );
// scan on exact entity type
switch( second ) {
case SOLIDUS:
// </foo
state_.current = state_type::event;
current_ = event_type::end_element;
break;
case EM:
// <!
s_comment_cdata_or_dtd();
break;
case QM:
// <?
s_instruction_or_prologue();
break;
default:
// <foo
if( io_likely( !is_space(second) ) ) {
state_.current = state_type::event;
current_ = event_type::start_element;
}
else {
assign_error( error::illegal_markup );
}
}
}
void event_stream_parser::scan() noexcept
{
switch( std::char_traits<char>::to_int_type(*scan_buf_) ) {
// this is entity (tag or instruction) begin
case LEFTB:
// jump to scan for exact entity type
s_entity();
break;
// this is end of document, no more data from source
case EOF:
state_.current = state_type::eod;
// no root tag in this xml
// i.e. something like <?xml version="1.0"?> <!-- <root>...</root> -->
if( 0 != nesting_)
assign_error(error::root_element_is_unbalanced);
break;
default:
// this is characters state, i.e. tag value or between tags spaces
state_.current = state_type::characters;
}
}
} // namesapce xml
} // namesapce io
| 26.352882 | 133 | 0.654146 | incoder1 |
f0fa72f58c4b7b8ccb451322ec10619757e48b47 | 1,529 | hpp | C++ | src/core/sinuscontroller.hpp | Yorokobii/SpLiCE | 4e016b04c04a14154be5c60ca3843300b69d22fa | [
"Apache-2.0"
] | null | null | null | src/core/sinuscontroller.hpp | Yorokobii/SpLiCE | 4e016b04c04a14154be5c60ca3843300b69d22fa | [
"Apache-2.0"
] | null | null | null | src/core/sinuscontroller.hpp | Yorokobii/SpLiCE | 4e016b04c04a14154be5c60ca3843300b69d22fa | [
"Apache-2.0"
] | null | null | null | #ifndef SINCELL_CONTROLLER_HPP
#define SINCELL_CONTROLLER_HPP
#include <mecacell/mecacell.h>
#include <random>
#include <string>
struct SinController {
public:
SinController() {}
static SinController random() {
return SinController();
}
double getInput(const std::string &input, const int& verb = 1) const {
return 0.0;
}
void setInput(const std::string &input, double val) {
MecaCell::logger<MecaCell::DBG>("input: ", input, " ", val);
}
double getOutput(const std::string &output, const int& verb = 1, const int& step = 0) const {
double r = 0.0;
if ((sin((step/50)) > 0.5 && output == "contract")
/*|| (sin(step/100) <= 0 && output == "extension")*/)
r = 1.0;
if(verb >= 3) MecaCell::logger<MecaCell::DBG>("output: ", output, " ", r);
return r;
}
double getDelta(const std::string &o1, const std::string &o2) {
double plus = getOutput(o1);
double minus = getOutput(o2);
double div = plus + minus;
if (div > 0.0) {
return (plus - minus) / div;
}
return 0.0;
}
SinController(const SinController &c) {
// MecaCell::logger<MecaCell::DBG>("cloning");
}
SinController(const string& s) {} // unserialize
std::string serialize() const { return ""; }
void reset() {}
void update() {}
void mutate() {}
SinController crossover(const SinController& other) {
return SinController();
}
inline static double getDistance(const SinController& a, const SinController& b) {
return 0.0;
}
};
#endif
| 23.166667 | 95 | 0.621321 | Yorokobii |
f0ff98642109064c50dc6c93381de368e9918ce3 | 4,648 | cc | C++ | libspindle/adt/Forest/EliminationForest.cc | Kumfert/Spindle | d5f2cab92c86c547efbf09fb30be9d478da04332 | [
"BSD-4-Clause",
"FSFAP"
] | null | null | null | libspindle/adt/Forest/EliminationForest.cc | Kumfert/Spindle | d5f2cab92c86c547efbf09fb30be9d478da04332 | [
"BSD-4-Clause",
"FSFAP"
] | null | null | null | libspindle/adt/Forest/EliminationForest.cc | Kumfert/Spindle | d5f2cab92c86c547efbf09fb30be9d478da04332 | [
"BSD-4-Clause",
"FSFAP"
] | 1 | 2021-01-19T16:36:28.000Z | 2021-01-19T16:36:28.000Z | //
// EliminationForest.cc
//
// $Id: EliminationForest.cc,v 1.2 2000/02/18 01:31:44 kumfert Exp $
//
// Gary Kumfert, Old Dominion University
// Copyright(c) 1997, Old Dominion University. All rights reserved.
//
// Permission to use, copy, modify, distribute and sell this software and
// its documentation for any purpose is hereby granted without fee,
// provided that the above copyright notice appear in all copies and
// that both that copyright notice and this permission notice appear
// in supporting documentation. Old Dominion University makes no
// representations about the suitability of this software for any
// purpose. It is provided "as is" without express or implied warranty.
//
///////////////////////////////////////////////////////////////////////
//
//
//
#include "spindle/EliminationForest.h"
#ifndef SPINDLE_PERMUTATION_H_
#include "spindle/PermutationMap.h"
#endif
#ifdef HAVE_NAMESPACES
using namespace SPINDLE_NAMESPACE;
#endif
SPINDLE_IMPLEMENT_PERSISTANT( EliminationForest, GenericForest )
EliminationForest::EliminationForest() {
g = 0;
currentState = EMPTY;
}
EliminationForest::EliminationForest( const Graph* graph ) {
incrementInstanceCount( EliminationForest::MetaData );
g = graph;
// set a null parent and ancestor
const int n = g->size();
SharedArray<int> ancestor( n );
ancestor.init(-1);
parent.resize(0);
GenericForest::resize(n);
parent.resize(n);
parent.init(-1);
for( int i=0; i<n; ++i) {
for( const int* jj=g->begin_adj(i), *stop_jj = g->end_adj(i);
jj < stop_jj; ++jj ) {
int j = *jj;
if ( j < i ) { // ii is an ancestor of jj
// find the root of the tree containing the node `jj'
while( (ancestor[j]!=-1) & (ancestor[j]!=i) ) {
int temp = ancestor[j];
ancestor[j] = i;
j = temp;
}
// make node `ii' the root of this subtree, if not already true
if ( ancestor[j] == -1 ) {
ancestor[j] = i;
parent[j] = i;
}
} // end if `ii' is ancestor of `jj'
} // end for all jj adj to ii
} // end for all ii
currentState = UNKNOWN;
createChildSibling();
createDoubleLink();
}
EliminationForest::EliminationForest( const Graph* graph, const SharedPtr<PermutationMap>& perm ) {
incrementInstanceCount( EliminationForest::MetaData );
g = graph;
// set a null parent and ancestor
const int n = g->size();
SharedArray<int> ancestor( n );
ancestor.init(-1);
GenericForest::resize(n);
parent.resize(n);
parent.init(-1);
const int* old2new = perm->getOld2New().lend();
const int* new2old = perm->getNew2Old().lend();
// programmer's note: `ii' & `jj' refer to the vertices in the new ordering
// `i' & `j' refer to the same vertices in the old ordering
for( int ii=0; ii<n; ++ii) {
int i = new2old[ii];
for( const int* jp=g->begin_adj(i), *stop_jp = g->end_adj(i);
jp < stop_jp; ++jp ) {
int j = *jp;
int jj = old2new[ j ];
if ( jj < ii ) { // ii is an ancestor of jj
/* old code. put the tree in terms of new indices, not old
// find the root of the tree containing the node `jj'
while( (ancestor[jj]!=-1) & (ancestor[jj]!=ii) ) {
int temp = ancestor[jj];
ancestor[jj] = ii;
jj = temp;
}
// make node `ii' the root of this subtree, if not already true
if ( ancestor[jj] == -1 ) {
ancestor[jj] = ii;
parent[jj] = ii;
}
*/
// find the root of the tree containing the node `j'
while( (ancestor[j]!=-1) & (ancestor[j]!=i) ) {
int temp = ancestor[j];
ancestor[j] = i;
j = temp;
}
// make node `i' the root of this subtree, if not already true
if ( ancestor[j] == -1 ) {
ancestor[j] = i;
parent[j] = i;
}
} // end if `ii' is ancestor of `jj'
} // end for all jj adj to ii
} // end for all ii
currentState = UNKNOWN;
createChildSibling();
createDoubleLink();
}// end
EliminationForest::EliminationForest( const Graph* graph, const int n, const int* Parent )
: GenericForest( n, Parent ) {
incrementInstanceCount( EliminationForest::MetaData );
g = graph;
}
EliminationForest::~EliminationForest() {
decrementInstanceCount( EliminationForest::MetaData );
}
#define __FUNC__ "void EliminationForest::loadObject( SpindleArchive & ar )"
void
EliminationForest::loadObject( SpindleArchive & ar ) {
ERROR( SPINDLE_ERROR_UNIMP_FUNC , "Method not yet implemented.");
if ( &ar );
}
#undef __FUNC__
#define __FUNC__ "void EliminationForest::loadObject( SpindleArchive & ar )"
void
EliminationForest::storeObject( SpindleArchive& ar ) const {
ERROR( SPINDLE_ERROR_UNIMP_FUNC , "Method not yet implemented.");
if( &ar ) ;
}
#undef __FUNC__
| 28.869565 | 99 | 0.648021 | Kumfert |
0b00c5049488bb7b165b54a0384c4986b522aab0 | 18,651 | cpp | C++ | ndn-cxx/net/impl/netlink-socket.cpp | KITE-2018/kite-ndn-cxx | 2a674e2bab42a39d0731b0a30c4d49369b084c1c | [
"OpenSSL"
] | 4 | 2021-04-21T02:48:49.000Z | 2021-06-25T06:08:58.000Z | ndn-cxx/net/impl/netlink-socket.cpp | KITE-2018/kite-ndn-cxx | 2a674e2bab42a39d0731b0a30c4d49369b084c1c | [
"OpenSSL"
] | 11 | 2020-12-27T23:02:56.000Z | 2021-10-18T08:00:50.000Z | ndn-cxx/net/impl/netlink-socket.cpp | KITE-2018/kite-ndn-cxx | 2a674e2bab42a39d0731b0a30c4d49369b084c1c | [
"OpenSSL"
] | 3 | 2021-02-28T10:04:09.000Z | 2021-09-23T05:01:00.000Z | /* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
* Copyright (c) 2013-2019 Regents of the University of California.
*
* This file is part of ndn-cxx library (NDN C++ library with eXperimental eXtensions).
*
* ndn-cxx library is free software: you can redistribute it and/or modify it under the
* terms of the GNU Lesser General Public License as published by the Free Software
* Foundation, either version 3 of the License, or (at your option) any later version.
*
* ndn-cxx 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 Lesser General Public License for more details.
*
* You should have received copies of the GNU General Public License and GNU Lesser
* General Public License along with ndn-cxx, e.g., in COPYING.md file. If not, see
* <http://www.gnu.org/licenses/>.
*
* See AUTHORS.md for complete list of ndn-cxx authors and contributors.
*
* @author Davide Pesavento <[email protected]>
*/
#include "ndn-cxx/net/impl/netlink-socket.hpp"
#include "ndn-cxx/net/impl/netlink-message.hpp"
#include "ndn-cxx/util/logger.hpp"
#include "ndn-cxx/util/time.hpp"
#include <linux/genetlink.h>
#include <sys/socket.h>
#ifndef SOL_NETLINK
#define SOL_NETLINK 270
#endif
#ifndef NETLINK_CAP_ACK
#define NETLINK_CAP_ACK 10
#endif
#ifndef NETLINK_GET_STRICT_CHK
#define NETLINK_GET_STRICT_CHK 12
#endif
NDN_LOG_INIT(ndn.NetworkMonitor);
namespace ndn {
namespace net {
// satisfies Asio's SettableSocketOption type requirements
template<int OptName>
class NetlinkSocketOption
{
public:
explicit
NetlinkSocketOption(int val)
: m_value(val)
{
}
template<typename Protocol>
int
level(const Protocol&) const
{
return SOL_NETLINK;
}
template<typename Protocol>
int
name(const Protocol&) const
{
return OptName;
}
template<typename Protocol>
const int*
data(const Protocol&) const
{
return &m_value;
}
template<typename Protocol>
std::size_t
size(const Protocol&) const
{
return sizeof(m_value);
}
private:
int m_value;
};
NetlinkSocket::NetlinkSocket(boost::asio::io_service& io)
: m_sock(make_shared<boost::asio::generic::raw_protocol::socket>(io))
, m_pid(0)
, m_seqNum(static_cast<uint32_t>(time::system_clock::now().time_since_epoch().count()))
, m_buffer(16 * 1024) // 16 KiB
{
}
NetlinkSocket::~NetlinkSocket()
{
boost::system::error_code ec;
m_sock->close(ec);
}
void
NetlinkSocket::open(int protocol)
{
boost::asio::generic::raw_protocol proto(AF_NETLINK, protocol);
// open socket manually to set the close-on-exec flag atomically on creation
int fd = ::socket(proto.family(), proto.type() | SOCK_CLOEXEC, proto.protocol());
if (fd < 0) {
NDN_THROW_ERRNO(Error("Cannot create netlink socket"));
}
boost::system::error_code ec;
m_sock->assign(proto, fd, ec);
if (ec) {
NDN_THROW(Error("Cannot assign descriptor: " + ec.message()));
}
// increase socket receive buffer to 1MB to avoid losing messages
m_sock->set_option(boost::asio::socket_base::receive_buffer_size(1 * 1024 * 1024), ec);
if (ec) {
// not a fatal error
NDN_LOG_DEBUG("setting receive buffer size failed: " << ec.message());
}
// enable control messages for received packets to get the destination group
m_sock->set_option(NetlinkSocketOption<NETLINK_PKTINFO>(true), ec);
if (ec) {
NDN_THROW(Error("Cannot enable NETLINK_PKTINFO: " + ec.message()));
}
sockaddr_nl addr{};
addr.nl_family = AF_NETLINK;
if (::bind(m_sock->native_handle(), reinterpret_cast<sockaddr*>(&addr), sizeof(addr)) < 0) {
NDN_THROW_ERRNO(Error("Cannot bind netlink socket"));
}
// find out what pid has been assigned to us
socklen_t len = sizeof(addr);
if (::getsockname(m_sock->native_handle(), reinterpret_cast<sockaddr*>(&addr), &len) < 0) {
NDN_THROW_ERRNO(Error("Cannot obtain netlink socket address"));
}
if (len != sizeof(addr)) {
NDN_THROW(Error("Wrong address length (" + to_string(len) + ")"));
}
if (addr.nl_family != AF_NETLINK) {
NDN_THROW(Error("Wrong address family (" + to_string(addr.nl_family) + ")"));
}
m_pid = addr.nl_pid;
NDN_LOG_TRACE("our pid is " << m_pid);
// tell the kernel it doesn't need to include the original payload in ACK messages
m_sock->set_option(NetlinkSocketOption<NETLINK_CAP_ACK>(true), ec);
if (ec) {
// not a fatal error
NDN_LOG_DEBUG("setting NETLINK_CAP_ACK failed: " << ec.message());
}
#ifdef NDN_CXX_HAVE_NETLINK_EXT_ACK
// enable extended ACK reporting
m_sock->set_option(NetlinkSocketOption<NETLINK_EXT_ACK>(true), ec);
if (ec) {
// not a fatal error
NDN_LOG_DEBUG("setting NETLINK_EXT_ACK failed: " << ec.message());
}
#endif // NDN_CXX_HAVE_NETLINK_EXT_ACK
// enable strict checking of get/dump requests
m_sock->set_option(NetlinkSocketOption<NETLINK_GET_STRICT_CHK>(true), ec);
if (ec) {
// not a fatal error
NDN_LOG_DEBUG("setting NETLINK_GET_STRICT_CHK failed: " << ec.message());
}
}
void
NetlinkSocket::joinGroup(int group)
{
boost::system::error_code ec;
m_sock->set_option(NetlinkSocketOption<NETLINK_ADD_MEMBERSHIP>(group), ec);
if (ec) {
NDN_THROW(Error("Cannot join netlink group " + to_string(group) + ": " + ec.message()));
}
}
void
NetlinkSocket::registerNotificationCallback(MessageCallback cb)
{
registerRequestCallback(0, std::move(cb));
}
void
NetlinkSocket::registerRequestCallback(uint32_t seq, MessageCallback cb)
{
if (cb == nullptr) {
m_pendingRequests.erase(seq);
}
else {
bool wasEmpty = m_pendingRequests.empty();
m_pendingRequests.emplace(seq, std::move(cb));
if (wasEmpty)
asyncWait();
}
}
std::string
NetlinkSocket::nlmsgTypeToString(uint16_t type) const
{
#define NLMSG_STRINGIFY(x) case NLMSG_##x: return to_string(type) + "<" #x ">"
switch (type) {
NLMSG_STRINGIFY(NOOP);
NLMSG_STRINGIFY(ERROR);
NLMSG_STRINGIFY(DONE);
NLMSG_STRINGIFY(OVERRUN);
default:
return to_string(type);
}
#undef NLMSG_STRINGIFY
}
void
NetlinkSocket::asyncWait()
{
// capture a copy of 'm_sock' to prevent its deallocation while the handler is still pending
auto handler = [this, sock = m_sock] (const boost::system::error_code& ec) {
if (!sock->is_open() || ec == boost::asio::error::operation_aborted) {
// socket was closed, ignore the error
NDN_LOG_DEBUG("netlink socket closed or operation aborted");
}
else if (ec) {
NDN_LOG_ERROR("read failed: " << ec.message());
NDN_THROW(Error("Netlink socket read error (" + ec.message() + ")"));
}
else {
receiveAndValidate();
if (!m_pendingRequests.empty())
asyncWait();
}
};
#if BOOST_VERSION >= 106600
m_sock->async_wait(boost::asio::socket_base::wait_read, std::move(handler));
#else
m_sock->async_receive(boost::asio::null_buffers(),
[h = std::move(handler)] (const boost::system::error_code& ec, size_t) { h(ec); });
#endif
}
void
NetlinkSocket::receiveAndValidate()
{
sockaddr_nl sender{};
iovec iov{};
iov.iov_base = m_buffer.data();
iov.iov_len = m_buffer.size();
uint8_t cmsgBuffer[CMSG_SPACE(sizeof(nl_pktinfo))];
msghdr msg{};
msg.msg_name = &sender;
msg.msg_namelen = sizeof(sender);
msg.msg_iov = &iov;
msg.msg_iovlen = 1;
msg.msg_control = cmsgBuffer;
msg.msg_controllen = sizeof(cmsgBuffer);
ssize_t nBytesRead = ::recvmsg(m_sock->native_handle(), &msg, 0);
if (nBytesRead < 0) {
if (errno == EAGAIN || errno == EINTR || errno == EWOULDBLOCK) {
// not a fatal error
NDN_LOG_DEBUG("recvmsg failed: " << std::strerror(errno));
return;
}
NDN_LOG_ERROR("recvmsg failed: " << std::strerror(errno));
NDN_THROW_ERRNO(Error("Netlink socket receive error"));
}
NDN_LOG_TRACE("read " << nBytesRead << " bytes from netlink socket");
if (msg.msg_flags & MSG_TRUNC) {
NDN_LOG_ERROR("truncated message");
NDN_THROW(Error("Received truncated netlink message"));
// TODO: grow the buffer and start over
}
if (msg.msg_namelen >= sizeof(sender) && sender.nl_pid != 0) {
NDN_LOG_TRACE("ignoring message from pid=" << sender.nl_pid);
return;
}
uint32_t nlGroup = 0;
for (cmsghdr* cmsg = CMSG_FIRSTHDR(&msg); cmsg != nullptr; cmsg = CMSG_NXTHDR(&msg, cmsg)) {
if (cmsg->cmsg_level == SOL_NETLINK &&
cmsg->cmsg_type == NETLINK_PKTINFO &&
cmsg->cmsg_len == CMSG_LEN(sizeof(nl_pktinfo))) {
const nl_pktinfo* pktinfo = reinterpret_cast<nl_pktinfo*>(CMSG_DATA(cmsg));
nlGroup = pktinfo->group;
}
}
NetlinkMessage nlmsg(m_buffer.data(), static_cast<size_t>(nBytesRead));
for (; nlmsg.isValid(); nlmsg = nlmsg.getNext()) {
NDN_LOG_TRACE("parsing " << (nlmsg->nlmsg_flags & NLM_F_MULTI ? "multi-part " : "") <<
"message type=" << nlmsgTypeToString(nlmsg->nlmsg_type) <<
" len=" << nlmsg->nlmsg_len <<
" seq=" << nlmsg->nlmsg_seq <<
" pid=" << nlmsg->nlmsg_pid <<
" group=" << nlGroup);
auto cbIt = m_pendingRequests.end();
if (nlGroup != 0) {
// it's a multicast notification
cbIt = m_pendingRequests.find(0);
}
else if (nlmsg->nlmsg_pid == m_pid) {
// it's for us
cbIt = m_pendingRequests.find(nlmsg->nlmsg_seq);
}
else {
NDN_LOG_TRACE(" pid mismatch, ignoring");
continue;
}
if (cbIt == m_pendingRequests.end()) {
NDN_LOG_TRACE(" no handler registered, ignoring");
continue;
}
else if (nlmsg->nlmsg_flags & NLM_F_DUMP_INTR) {
NDN_LOG_ERROR("dump is inconsistent");
NDN_THROW(Error("Inconsistency detected in netlink dump"));
// TODO: discard the rest of the message and retry the dump
}
else {
// invoke the callback
BOOST_ASSERT(cbIt->second);
cbIt->second(nlmsg);
}
// garbage collect the handler if we don't need it anymore:
// do it only if this is a reply message (i.e. not a notification) and either
// (1) it's not a multi-part message, in which case this is the only fragment, or
// (2) it's the last fragment of a multi-part message
if (nlGroup == 0 && (!(nlmsg->nlmsg_flags & NLM_F_MULTI) || nlmsg->nlmsg_type == NLMSG_DONE)) {
NDN_LOG_TRACE("removing handler for seq=" << nlmsg->nlmsg_seq);
BOOST_ASSERT(cbIt != m_pendingRequests.end());
m_pendingRequests.erase(cbIt);
}
}
}
RtnlSocket::RtnlSocket(boost::asio::io_service& io)
: NetlinkSocket(io)
{
}
void
RtnlSocket::open()
{
NDN_LOG_TRACE("opening rtnetlink socket");
NetlinkSocket::open(NETLINK_ROUTE);
}
void
RtnlSocket::sendDumpRequest(uint16_t nlmsgType, const void* payload, size_t payloadLen,
MessageCallback cb)
{
struct RtnlMessageHeader
{
alignas(NLMSG_ALIGNTO) nlmsghdr nlh;
};
static_assert(sizeof(RtnlMessageHeader) == NLMSG_HDRLEN, "");
auto hdr = make_shared<RtnlMessageHeader>();
hdr->nlh.nlmsg_len = sizeof(RtnlMessageHeader) + payloadLen;
hdr->nlh.nlmsg_type = nlmsgType;
hdr->nlh.nlmsg_flags = NLM_F_REQUEST | NLM_F_DUMP;
hdr->nlh.nlmsg_seq = ++m_seqNum;
hdr->nlh.nlmsg_pid = m_pid;
registerRequestCallback(hdr->nlh.nlmsg_seq, std::move(cb));
std::array<boost::asio::const_buffer, 2> bufs = {
boost::asio::buffer(hdr.get(), sizeof(RtnlMessageHeader)),
boost::asio::buffer(payload, payloadLen)
};
m_sock->async_send(bufs,
// capture 'hdr' to prevent its premature deallocation
[this, hdr] (const boost::system::error_code& ec, size_t) {
if (!ec) {
NDN_LOG_TRACE("sent dump request type=" << nlmsgTypeToString(hdr->nlh.nlmsg_type)
<< " seq=" << hdr->nlh.nlmsg_seq);
}
else if (ec != boost::asio::error::operation_aborted) {
NDN_LOG_ERROR("send failed: " << ec.message());
NDN_THROW(Error("Failed to send netlink request (" + ec.message() + ")"));
}
});
}
std::string
RtnlSocket::nlmsgTypeToString(uint16_t type) const
{
#define RTM_STRINGIFY(x) case RTM_##x: return to_string(type) + "<" #x ">"
switch (type) {
RTM_STRINGIFY(NEWLINK);
RTM_STRINGIFY(DELLINK);
RTM_STRINGIFY(GETLINK);
RTM_STRINGIFY(NEWADDR);
RTM_STRINGIFY(DELADDR);
RTM_STRINGIFY(GETADDR);
RTM_STRINGIFY(NEWROUTE);
RTM_STRINGIFY(DELROUTE);
RTM_STRINGIFY(GETROUTE);
default:
return NetlinkSocket::nlmsgTypeToString(type);
}
#undef RTM_STRINGIFY
}
GenlSocket::GenlSocket(boost::asio::io_service& io)
: NetlinkSocket(io)
{
m_cachedFamilyIds["nlctrl"] = GENL_ID_CTRL;
}
void
GenlSocket::open()
{
NDN_LOG_TRACE("opening genetlink socket");
NetlinkSocket::open(NETLINK_GENERIC);
}
void
GenlSocket::sendRequest(const std::string& familyName, uint8_t command,
const void* payload, size_t payloadLen,
MessageCallback messageCb, std::function<void()> errorCb)
{
auto it = m_cachedFamilyIds.find(familyName);
if (it != m_cachedFamilyIds.end()) {
if (it->second >= GENL_MIN_ID) {
sendRequest(it->second, command, payload, payloadLen, std::move(messageCb));
}
else if (errorCb) {
errorCb();
}
return;
}
auto ret = m_familyResolvers.emplace(std::piecewise_construct,
std::forward_as_tuple(familyName),
std::forward_as_tuple(familyName, *this));
auto& resolver = ret.first->second;
if (ret.second) {
// cache the result
resolver.onResolved.connectSingleShot([=] (uint16_t familyId) {
m_cachedFamilyIds[familyName] = familyId;
});
resolver.onError.connectSingleShot([=] {
m_cachedFamilyIds[familyName] = 0;
});
}
resolver.onResolved.connectSingleShot([=, cb = std::move(messageCb)] (uint16_t familyId) {
sendRequest(familyId, command, payload, payloadLen, std::move(cb));
});
if (errorCb) {
resolver.onError.connectSingleShot(std::move(errorCb));
}
}
void
GenlSocket::sendRequest(uint16_t familyId, uint8_t command,
const void* payload, size_t payloadLen, MessageCallback cb)
{
struct GenlMessageHeader
{
alignas(NLMSG_ALIGNTO) nlmsghdr nlh;
alignas(NLMSG_ALIGNTO) genlmsghdr genlh;
};
static_assert(sizeof(GenlMessageHeader) == NLMSG_SPACE(GENL_HDRLEN), "");
auto hdr = make_shared<GenlMessageHeader>();
hdr->nlh.nlmsg_len = sizeof(GenlMessageHeader) + payloadLen;
hdr->nlh.nlmsg_type = familyId;
hdr->nlh.nlmsg_flags = NLM_F_REQUEST;
hdr->nlh.nlmsg_seq = ++m_seqNum;
hdr->nlh.nlmsg_pid = m_pid;
hdr->genlh.cmd = command;
hdr->genlh.version = 1;
registerRequestCallback(hdr->nlh.nlmsg_seq, std::move(cb));
std::array<boost::asio::const_buffer, 2> bufs = {
boost::asio::buffer(hdr.get(), sizeof(GenlMessageHeader)),
boost::asio::buffer(payload, payloadLen)
};
m_sock->async_send(bufs,
// capture 'hdr' to prevent its premature deallocation
[this, hdr] (const boost::system::error_code& ec, size_t) {
if (!ec) {
NDN_LOG_TRACE("sent genl request type=" << nlmsgTypeToString(hdr->nlh.nlmsg_type) <<
" cmd=" << static_cast<unsigned>(hdr->genlh.cmd) <<
" seq=" << hdr->nlh.nlmsg_seq);
}
else if (ec != boost::asio::error::operation_aborted) {
NDN_LOG_ERROR("send failed: " << ec.message());
NDN_THROW(Error("Failed to send netlink request (" + ec.message() + ")"));
}
});
}
GenlFamilyResolver::GenlFamilyResolver(std::string familyName, GenlSocket& socket)
: m_sock(socket)
, m_family(std::move(familyName))
{
if (m_family.size() >= GENL_NAMSIZ) {
NDN_THROW(std::invalid_argument("netlink family name '" + m_family + "' too long"));
}
NDN_LOG_TRACE("resolving netlink family " << m_family);
asyncResolve();
}
void
GenlFamilyResolver::asyncResolve()
{
struct FamilyNameAttribute
{
alignas(NLA_ALIGNTO) nlattr nla;
alignas(NLA_ALIGNTO) char name[GENL_NAMSIZ];
};
auto attr = make_shared<FamilyNameAttribute>();
attr->nla.nla_type = CTRL_ATTR_FAMILY_NAME;
attr->nla.nla_len = NLA_HDRLEN + m_family.size() + 1;
::strncpy(attr->name, m_family.data(), GENL_NAMSIZ);
m_sock.sendRequest(GENL_ID_CTRL, CTRL_CMD_GETFAMILY, attr.get(), attr->nla.nla_len,
// capture 'attr' to prevent its premature deallocation
[this, attr] (const auto& msg) { this->handleResolve(msg); });
}
void
GenlFamilyResolver::handleResolve(const NetlinkMessage& nlmsg)
{
switch (nlmsg->nlmsg_type) {
case NLMSG_ERROR: {
const nlmsgerr* err = nlmsg.getPayload<nlmsgerr>();
if (err == nullptr) {
NDN_LOG_WARN("malformed nlmsgerr");
}
else if (err->error != 0) {
NDN_LOG_DEBUG(" failed to resolve netlink family " << m_family
<< ": " << std::strerror(std::abs(err->error)));
}
onError();
break;
}
case GENL_ID_CTRL: {
const genlmsghdr* genlh = nlmsg.getPayload<genlmsghdr>();
if (genlh == nullptr) {
NDN_LOG_WARN("malformed genlmsghdr");
return onError();
}
if (genlh->cmd != CTRL_CMD_NEWFAMILY) {
NDN_LOG_WARN("unexpected genl cmd=" << static_cast<unsigned>(genlh->cmd));
return onError();
}
auto attrs = nlmsg.getAttributes<nlattr>(genlh);
auto familyName = attrs.getAttributeByType<std::string>(CTRL_ATTR_FAMILY_NAME);
if (familyName && *familyName != m_family) {
NDN_LOG_WARN("CTRL_ATTR_FAMILY_NAME mismatch: " << *familyName << " != " << m_family);
return onError();
}
auto familyId = attrs.getAttributeByType<uint16_t>(CTRL_ATTR_FAMILY_ID);
if (!familyId) {
NDN_LOG_WARN("missing CTRL_ATTR_FAMILY_ID");
return onError();
}
if (*familyId < GENL_MIN_ID) {
NDN_LOG_WARN("invalid CTRL_ATTR_FAMILY_ID=" << *familyId);
return onError();
}
NDN_LOG_TRACE(" resolved netlink family name=" << m_family << " id=" << *familyId);
onResolved(*familyId);
break;
}
default: {
NDN_LOG_WARN("unexpected message type");
onError();
break;
}
}
}
std::string
GenlSocket::nlmsgTypeToString(uint16_t type) const
{
if (type >= GENL_MIN_ID) {
for (const auto& p : m_cachedFamilyIds) {
if (p.second == type) {
return to_string(type) + "<" + p.first + ">";
}
}
}
return NetlinkSocket::nlmsgTypeToString(type);
}
} // namespace net
} // namespace ndn
| 30.376221 | 107 | 0.660501 | KITE-2018 |
0b0272c6b9579238df9db13a04f5fcb677c92529 | 690 | cpp | C++ | src/fw/CrtThumbprint.cpp | jnmeurisse/FortiRDP | 53f48413c8a292304de27468b271847534353c61 | [
"Apache-2.0"
] | null | null | null | src/fw/CrtThumbprint.cpp | jnmeurisse/FortiRDP | 53f48413c8a292304de27468b271847534353c61 | [
"Apache-2.0"
] | null | null | null | src/fw/CrtThumbprint.cpp | jnmeurisse/FortiRDP | 53f48413c8a292304de27468b271847534353c61 | [
"Apache-2.0"
] | 1 | 2022-02-19T19:47:43.000Z | 2022-02-19T19:47:43.000Z | /*!
* This file is part of FortiRDP
*
* Copyright (C) 2022 Jean-Noel Meurisse
* SPDX-License-Identifier: Apache-2.0
*
*/
#include <string>
#include "CrtThumbprint.h"
#include "mbedtls\sha256.h"
namespace fw {
CrtThumbprint::CrtThumbprint()
{
std::memset(_thumbprint, 0, sizeof(_thumbprint));
}
CrtThumbprint::CrtThumbprint(const mbedtls_x509_crt& crt)
{
mbedtls_sha256_ret(crt.raw.p, crt.raw.len, _thumbprint, 0);
}
bool CrtThumbprint::operator== (const CrtThumbprint& other) const
{
return std::memcmp(_thumbprint, other._thumbprint, sizeof(_thumbprint)) == 0;
}
bool CrtThumbprint::operator!= (const CrtThumbprint& other) const
{
return !(*this == other);
}
} | 18.648649 | 79 | 0.710145 | jnmeurisse |
0b02ac2b81b5ad8bafbfbfa91c437882338184c7 | 11,669 | cpp | C++ | bt_editor/models/BehaviorTreeNodeModel.cpp | ipa-foj/Groot | 133b67c6f0a1fa677b25a4d5c19b7623512be9c1 | [
"Unlicense"
] | null | null | null | bt_editor/models/BehaviorTreeNodeModel.cpp | ipa-foj/Groot | 133b67c6f0a1fa677b25a4d5c19b7623512be9c1 | [
"Unlicense"
] | null | null | null | bt_editor/models/BehaviorTreeNodeModel.cpp | ipa-foj/Groot | 133b67c6f0a1fa677b25a4d5c19b7623512be9c1 | [
"Unlicense"
] | null | null | null | #include "BehaviorTreeNodeModel.hpp"
#include <QBoxLayout>
#include <QFormLayout>
#include <QSizePolicy>
#include <QLineEdit>
#include <QComboBox>
#include <QDebug>
#include <QFile>
#include <QFont>
#include <QApplication>
const int MARGIN = 10;
const int DEFAULT_LINE_WIDTH = 100;
const int DEFAULT_FIELD_WIDTH = 50;
const int DEFAULT_LABEL_WIDTH = 50;
BehaviorTreeDataModel::BehaviorTreeDataModel(const TreeNodeModel &model):
_params_widget(nullptr),
_uid( GetUID() ),
_registration_name(model.registration_ID),
_instance_name(model.registration_ID),
_icon_renderer(nullptr)
{
_main_widget = new QFrame();
_line_edit_name = new QLineEdit(_main_widget);
_params_widget = new QFrame();
_main_layout = new QVBoxLayout(_main_widget);
_main_widget->setLayout( _main_layout );
auto capt_layout = new QHBoxLayout();
_caption_label = new QLabel();
_caption_logo_left = new QFrame();
_caption_logo_right = new QFrame();
_caption_logo_left->setFixedSize( QSize(0,20) );
_caption_logo_right->setFixedSize( QSize(0,20) );
_caption_label->setFixedHeight(20);
_caption_logo_left->installEventFilter(this);
QFont capt_font = _caption_label->font();
capt_font.setPointSize(12);
_caption_label->setFont(capt_font);
capt_layout->addWidget(_caption_logo_left, 0, Qt::AlignRight);
capt_layout->addWidget(_caption_label, 0, Qt::AlignHCenter );
capt_layout->addWidget(_caption_logo_right, 0, Qt::AlignLeft);
_main_layout->addLayout( capt_layout );
_main_layout->addWidget( _line_edit_name );
_main_layout->setMargin(0);
_main_layout->setSpacing(2);
//----------------------------
_line_edit_name->setAlignment( Qt::AlignCenter );
_line_edit_name->setText( _instance_name );
_line_edit_name->setFixedWidth( DEFAULT_LINE_WIDTH );
_main_widget->setAttribute(Qt::WA_NoSystemBackground);
_line_edit_name->setStyleSheet("color: white; "
"background-color: transparent;"
"border: 0px;");
//--------------------------------------
_form_layout = new QFormLayout( _params_widget );
_form_layout->setFieldGrowthPolicy(QFormLayout::ExpandingFieldsGrow);
_main_layout->addWidget(_params_widget);
_params_widget->setStyleSheet("color: white;");
_form_layout->setHorizontalSpacing(4);
_form_layout->setVerticalSpacing(2);
_form_layout->setContentsMargins(0, 0, 0, 0);
for(const auto& param: model.params )
{
auto param_creator = buildWidgetCreator(param);
const QString label = param_creator.label;
QLabel* form_label = new QLabel( label, _params_widget );
QWidget* form_field = param_creator.instance_factory();
form_field->setMinimumWidth(DEFAULT_FIELD_WIDTH);
_params_map.insert( std::make_pair( label, form_field) );
form_field->setStyleSheet(" color: rgb(30,30,30); "
"background-color: rgb(180,180,180); "
"border: 0px; "
"padding: 0px 0px 0px 0px;");
_form_layout->addRow( form_label, form_field );
auto paramUpdated = [this,label,form_field]()
{
this->parameterUpdated(label,form_field);
};
if(auto lineedit = dynamic_cast<QLineEdit*>( form_field ) )
{
connect( lineedit, &QLineEdit::editingFinished, this, paramUpdated );
connect( lineedit, &QLineEdit::editingFinished,
this, &BehaviorTreeDataModel::updateNodeSize);
}
else if( auto combo = dynamic_cast<QComboBox*>( form_field ) )
{
connect( combo, &QComboBox::currentTextChanged, this, paramUpdated);
}
}
_params_widget->adjustSize();
capt_layout->setSizeConstraint(QLayout::SizeConstraint::SetMaximumSize);
_main_layout->setSizeConstraint(QLayout::SizeConstraint::SetMaximumSize);
_form_layout->setSizeConstraint(QLayout::SizeConstraint::SetMaximumSize);
//--------------------------------------
connect( _line_edit_name, &QLineEdit::editingFinished,
this, [this]()
{
setInstanceName( _line_edit_name->text() );
});
}
BehaviorTreeDataModel::~BehaviorTreeDataModel()
{
}
void BehaviorTreeDataModel::initWidget()
{
const auto resource_file = captionIicon();
if( resource_file.isEmpty() == false )
{
_caption_logo_left->setFixedWidth( 20);
_caption_logo_right->setFixedWidth( 1 );
QFile file(resource_file);
if(!file.open(QIODevice::ReadOnly))
{
qDebug()<<"file not opened: "<< resource_file;
file.close();
}
else {
QByteArray ba = file.readAll();
QByteArray new_color_fill = QString("fill:%1;").arg(caption().second.name()).toUtf8();
ba.replace("fill:#ffffff;", new_color_fill);
_icon_renderer = new QSvgRenderer(ba, this);
}
}
auto label_text = caption().first;
auto color = caption().second;
_caption_label->setText( label_text );
QPalette capt_palette = _caption_label->palette();
capt_palette.setColor(_caption_label->backgroundRole(), Qt::transparent);
capt_palette.setColor(_caption_label->foregroundRole(), color);
_caption_label->setPalette(capt_palette);
_caption_logo_left->adjustSize();
_caption_logo_right->adjustSize();
_caption_label->adjustSize();
updateNodeSize();
}
void BehaviorTreeDataModel::updateNodeSize()
{
int caption_width = _caption_label->width();
caption_width += _caption_logo_left->width() + _caption_logo_right->width();
int line_edit_width = caption_width;
if( _line_edit_name->isHidden() == false)
{
QFontMetrics fm = _line_edit_name->fontMetrics();
const QString& txt = _line_edit_name->text();
int text_width = fm.boundingRect(txt).width();
line_edit_width = std::max( line_edit_width, text_width + MARGIN);
}
//----------------------------
int field_colum_width = DEFAULT_LABEL_WIDTH;
int label_colum_width = 0;
for(int row = 0; row< _form_layout->rowCount(); row++)
{
auto label_widget = _form_layout->itemAt(row, QFormLayout::LabelRole)->widget();
auto field_widget = _form_layout->itemAt(row, QFormLayout::FieldRole)->widget();
if(auto field_line_edit = dynamic_cast<QLineEdit*>(field_widget))
{
QFontMetrics fontMetrics = field_line_edit->fontMetrics();
QString text = field_line_edit->text();
int text_width = fontMetrics.boundingRect(text).width();
field_colum_width = std::max( field_colum_width, text_width + MARGIN);
}
label_colum_width = std::max(label_colum_width, label_widget->width());
}
field_colum_width = std::max( field_colum_width,
line_edit_width - label_colum_width - _form_layout->spacing());
for(int row = 0; row< _form_layout->rowCount(); row++)
{
auto field_widget = _form_layout->itemAt(row, QFormLayout::FieldRole)->widget();
if(auto field_line_edit = dynamic_cast<QLineEdit*>(field_widget))
{
field_line_edit->setFixedWidth( field_colum_width );
}
}
line_edit_width = std::max( line_edit_width, label_colum_width + field_colum_width );
_line_edit_name->setFixedWidth( line_edit_width);
_params_widget->setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Preferred);
_params_widget->adjustSize();
_main_widget->setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Preferred);
_main_widget->adjustSize();
//----------------------------
emit embeddedWidgetSizeUpdated();
}
QtNodes::NodeDataType BehaviorTreeDataModel::dataType(QtNodes::PortType, QtNodes::PortIndex) const
{
return NodeDataType {"", ""};
}
std::shared_ptr<QtNodes::NodeData> BehaviorTreeDataModel::outData(QtNodes::PortIndex)
{
return nullptr;
}
std::pair<QString, QColor> BehaviorTreeDataModel::caption() const {
return {_registration_name, QtNodes::NodeStyle().FontColor };
}
const QString &BehaviorTreeDataModel::registrationName() const
{
return _registration_name;
}
const QString &BehaviorTreeDataModel::instanceName() const
{
return _instance_name;
}
std::vector<TreeNodeModel::Param> BehaviorTreeDataModel::getCurrentParameters() const
{
std::vector<TreeNodeModel::Param> out;
for(const auto& it: _params_map)
{
const auto& label = it.first;
const auto& value = it.second;
if(auto linedit = dynamic_cast<QLineEdit*>( value ) )
{
out.push_back( { label, linedit->text() } );
}
else if( auto combo = dynamic_cast<QComboBox*>( value ) )
{
out.push_back( { label, combo->currentText() } );
}
}
return out;
}
QJsonObject BehaviorTreeDataModel::save() const
{
QJsonObject modelJson;
modelJson["name"] = registrationName();
modelJson["alias"] = instanceName();
for (const auto& it: _params_map)
{
if( auto linedit = dynamic_cast<QLineEdit*>(it.second)){
modelJson[it.first] = linedit->text();
}
else if( auto combo = dynamic_cast<QComboBox*>(it.second)){
modelJson[it.first] = combo->currentText();
}
}
return modelJson;
}
void BehaviorTreeDataModel::restore(const QJsonObject &modelJson)
{
if( _registration_name != modelJson["name"].toString() )
{
throw std::runtime_error(" error restoring: different registration_name");
}
QString alias = modelJson["alias"].toString();
setInstanceName( alias );
for(auto it = modelJson.begin(); it != modelJson.end(); it++ )
{
if( it.key() != "alias" && it.key() != "name")
{
setParameterValue( it.key(), it.value().toString() );
}
}
}
void BehaviorTreeDataModel::lock(bool locked)
{
_line_edit_name->setEnabled( !locked );
for(const auto& it: _params_map)
{
const auto& field_widget = it.second;
if(auto lineedit = dynamic_cast<QLineEdit*>( field_widget ))
{
lineedit->setReadOnly( locked );
}
else if(auto combo = dynamic_cast<QComboBox*>( field_widget ))
{
combo->setEnabled( !locked );
}
}
}
void BehaviorTreeDataModel::setParameterValue(const QString &label, const QString &value)
{
auto it = _params_map.find(label);
if( it != _params_map.end() )
{
if( auto lineedit = dynamic_cast<QLineEdit*>(it->second) )
{
lineedit->setText(value);
}
else if( auto combo = dynamic_cast<QComboBox*>(it->second) )
{
int index = combo->findText(value);
if( index == -1 ){
qDebug() << "error, combo value "<< value << " not found";
}
else{
combo->setCurrentIndex(index);
}
}
}
else{
qDebug() << "error, label "<< label << " not found in the model";
}
}
bool BehaviorTreeDataModel::eventFilter(QObject *obj, QEvent *event)
{
if (event->type() == QEvent::Paint && obj == _caption_logo_left && _icon_renderer)
{
QPainter paint(_caption_logo_left);
_icon_renderer->render(&paint);
}
return NodeDataModel::eventFilter(obj, event);
}
void BehaviorTreeDataModel::setInstanceName(const QString &name)
{
_instance_name = name;
_line_edit_name->setText( name );
updateNodeSize();
emit instanceNameChanged();
}
| 31.117333 | 98 | 0.63673 | ipa-foj |
0b0344b09fe7c831f999838b421ef9a6952e0ddf | 352 | hpp | C++ | include/GOL/cell.hpp | jonathanabrahams/cpp-game-of-life | 046b985e6e12c68005b0c4788e5a8db828d17474 | [
"MIT"
] | null | null | null | include/GOL/cell.hpp | jonathanabrahams/cpp-game-of-life | 046b985e6e12c68005b0c4788e5a8db828d17474 | [
"MIT"
] | null | null | null | include/GOL/cell.hpp | jonathanabrahams/cpp-game-of-life | 046b985e6e12c68005b0c4788e5a8db828d17474 | [
"MIT"
] | null | null | null | #ifndef __GOL_CELL_HPP__
#define __GOL_CELL_HPP__
namespace GOL
{
enum CellState
{
Alive,
Dead,
Unknown
};
class Cell
{
public:
explicit Cell(CellState);
bool alive() const;
bool dead() const;
bool unknown() const;
private:
CellState _state;
};
};
#endif | 14.666667 | 33 | 0.542614 | jonathanabrahams |
0b08667a3134cf4b3e082f23927e298facbc9223 | 3,621 | hpp | C++ | src/Renderer.hpp | sakhnik/neovim-sdl2 | eb4e8375a5d756fee3fe619cc273b68362f8989e | [
"MIT"
] | 21 | 2021-05-02T00:03:14.000Z | 2022-03-28T23:25:40.000Z | src/Renderer.hpp | sakhnik/nvim-ui | 3c51f22d875de1f9127294ef8e0f838e766f66ea | [
"MIT"
] | 18 | 2021-04-22T04:03:34.000Z | 2022-02-05T21:17:25.000Z | src/Renderer.hpp | sakhnik/neovim-sdl2 | eb4e8375a5d756fee3fe619cc273b68362f8989e | [
"MIT"
] | null | null | null | #pragma once
#include "HlAttr.hpp"
#include "GridLine.hpp"
#include "AsyncExec.hpp"
#include "Timer.hpp"
#include <vector>
#include <unordered_map>
#include <string_view>
#include <string>
#include <mutex>
#include <chrono>
class MsgPackRpc;
struct IWindow;
class Renderer
{
public:
Renderer(uv_loop_t *, MsgPackRpc *);
~Renderer();
void SetWindow(IWindow *);
// Get current grid cell dimensions
int GetHeight() const { return _lines.size(); }
int GetWidth() const { return _lines[0].hl_id.size(); }
void Flush();
// Window was resized
void OnResized(int rows, int cols);
void GridLine(int row, int col, std::string_view chunk, unsigned hl_id, int repeat);
void GridCursorGoto(int row, int col);
void GridScroll(int top, int bot, int left, int right, int rows);
void GridResize(int width, int height);
void GridClear();
void HlAttrDefine(unsigned hl_id, HlAttr attr);
void DefaultColorSet(unsigned fg, unsigned bg);
void ModeChange(std::string_view mode);
void SetBusy(bool is_busy);
// The snapshot of last consistent grid state
using GridChunkT = GridLine::ChunkWrapper<&BaseTexture::SetVisible>;
using GridLineT = std::vector<GridChunkT>;
using GridLinesT = std::vector<GridLineT>;
const GridLinesT& GetGridLines() const { return _grid_lines; }
std::lock_guard<std::mutex> Lock()
{
return std::lock_guard<std::mutex>{_mutex};
}
using AttrMapT = std::unordered_map<unsigned, HlAttr>;
const AttrMapT& GetAttrMap() const { return _hl_attr; }
bool IsAttrMapModified() const { return _hl_attr_modified; }
void MarkAttrMapProcessed() { _hl_attr_modified = false; }
unsigned GetBg() const { return _def_attr.bg.value(); }
unsigned GetFg() const { return _def_attr.fg.value(); }
const HlAttr& GetDefAttr() const { return _def_attr; }
bool IsBusy() const { return _is_busy; }
int GetCursorRow() const { return _cursor_row; }
int GetCursorCol() const { return _cursor_col; }
const std::string& GetMode() const { return _mode; }
private:
MsgPackRpc *_rpc;
Timer _timer;
AsyncExec _async_exec;
IWindow *_window = nullptr;
AttrMapT _hl_attr;
bool _hl_attr_modified = false;
HlAttr _def_attr;
int _cursor_row = 0;
int _cursor_col = 0;
std::string _mode;
bool _is_busy = false;
struct _Line
{
std::vector<std::string> text;
std::vector<unsigned> hl_id;
// Remember the previously rendered chunks, high chance they're reusable.
class GridLine grid_line;
// Is it necessary to redraw this line carefully or can just draw from the texture cache?
bool dirty = true;
};
// The volatile state of the grid, the changes are collected here first
// before going to _grid_lines;
std::vector<_Line> _lines;
GridLinesT _grid_lines;
std::mutex _mutex;
static std::vector<size_t> _SplitChunks(const _Line &);
// Make sure flush requests are executed not too frequently,
// but cleanly.
using ClockT = std::chrono::high_resolution_clock;
ClockT::time_point _last_flush_time;
// Rendering is done asyncrhonously and concurrently, make sure only clean
// state after Flush() is displayed.
bool _is_clean = true;
// The textures may be updated asynchronously and concurrently to the Flush.
// For example, when lines are scrolled. We'd like to make sure the textures
// are redrawn when the respective Flush is received.
uint32_t _redraw_token = 0;
void _DoFlush();
void _AnticipateFlush();
};
| 30.948718 | 97 | 0.685998 | sakhnik |
0b13e070b7705329fb1d3d2a32a8209d0d4b1165 | 2,110 | cpp | C++ | Eudora71/MAPI/filedesc.cpp | dusong7/eudora-win | 850a6619e6b0d5abc770bca8eb5f3b9001b7ccd2 | [
"BSD-3-Clause-Clear"
] | 10 | 2018-05-23T10:43:48.000Z | 2021-12-02T17:59:48.000Z | Eudora71/MAPI/filedesc.cpp | ivanagui2/hermesmail-code | 34387722d5364163c71b577fc508b567de56c5f6 | [
"BSD-3-Clause-Clear"
] | 1 | 2019-03-19T03:56:36.000Z | 2021-05-26T18:36:03.000Z | Eudora71/MAPI/filedesc.cpp | ivanagui2/hermesmail-code | 34387722d5364163c71b577fc508b567de56c5f6 | [
"BSD-3-Clause-Clear"
] | 11 | 2018-05-23T10:43:53.000Z | 2021-12-27T15:42:58.000Z | ////////////////////////////////////////////////////////////////////////
//
// CMapiFileDesc
//
// Intelligent C++ object wrapper for dumb C-based MapiFileDesc structure.
//
////////////////////////////////////////////////////////////////////////
#include "stdafx.h"
//#include <afxwin.h> // FORNOW, should probably be precompiled header
#include "filedesc.h"
////////////////////////////////////////////////////////////////////////
// CMapiFileDesc [private, constructor]
//
////////////////////////////////////////////////////////////////////////
CMapiFileDesc::CMapiFileDesc(void)
{
ulReserved = 0;
flFlags = 0;
nPosition = ULONG(-1);
lpszPathName = NULL;
lpszFileName = NULL;
lpFileType = NULL;
}
////////////////////////////////////////////////////////////////////////
// ~CMapiFileDesc [public, destructor]
//
////////////////////////////////////////////////////////////////////////
CMapiFileDesc::~CMapiFileDesc(void)
{
delete lpszPathName;
delete lpszFileName;
delete lpFileType;
}
////////////////////////////////////////////////////////////////////////
// SetFileName [public]
//
// Allocates and initializes a new string for the 'lpszFileName' field.
//
////////////////////////////////////////////////////////////////////////
BOOL CMapiFileDesc::SetFileName(const CString& fileName)
{
ASSERT(NULL == lpszFileName);
ASSERT(fileName.GetLength() > 0);
lpszFileName = new char [fileName.GetLength() + 1];
if (NULL == lpszFileName)
return FALSE;
strcpy(lpszFileName, fileName);
return TRUE;
}
////////////////////////////////////////////////////////////////////////
// SetPathName [public]
//
// Allocates and initializes a new string for the 'lpszPathName' field.
//
////////////////////////////////////////////////////////////////////////
BOOL CMapiFileDesc::SetPathName(const CString& pathName)
{
ASSERT(NULL == lpszPathName);
ASSERT(pathName.GetLength() > 0);
lpszPathName = new char [pathName.GetLength() + 1];
if (NULL == lpszPathName)
return FALSE;
strcpy(lpszPathName, pathName);
return TRUE;
}
| 26.375 | 74 | 0.447867 | dusong7 |
0b13f66f9e949667995774aec6f15b3c1356f4d4 | 501 | cpp | C++ | VehicleManagement/VehicleManage/inputtaxdialog.cpp | maanjun/IVM | fe7f58c0e45b2471357fafcc63328d903f08ea76 | [
"Apache-2.0"
] | null | null | null | VehicleManagement/VehicleManage/inputtaxdialog.cpp | maanjun/IVM | fe7f58c0e45b2471357fafcc63328d903f08ea76 | [
"Apache-2.0"
] | null | null | null | VehicleManagement/VehicleManage/inputtaxdialog.cpp | maanjun/IVM | fe7f58c0e45b2471357fafcc63328d903f08ea76 | [
"Apache-2.0"
] | null | null | null | #include "inputtaxdialog.h"
#include "ui_inputtaxdialog.h"
InputTaxDialog::InputTaxDialog(QWidget *parent) :
BaseDialog(parent),
ui(new Ui::InputTaxDialog)
{
ui->setupUi(this);
}
InputTaxDialog::~InputTaxDialog()
{
delete ui;
}
void InputTaxDialog::on_pBtnHomepage_clicked()
{
m_pCountdownTimer->stop();
m_pTimer->stop();
emit goHomeSignal();
}
void InputTaxDialog::on_pBtnDone_clicked()
{
m_pCountdownTimer->stop();
m_pTimer->stop();
emit inputTaxDoneSignal(m_qstrOwnerId);
}
| 17.275862 | 49 | 0.736527 | maanjun |
0b16196aec35de9d41319b5e9ee6bf4d07f7c08a | 3,436 | hpp | C++ | Libs/GuiSys/CompListBox.hpp | dns/Cafu | 77b34014cc7493d6015db7d674439fe8c23f6493 | [
"MIT"
] | 3 | 2020-04-11T13:00:31.000Z | 2020-12-07T03:19:10.000Z | Libs/GuiSys/CompListBox.hpp | DNS/Cafu | 77b34014cc7493d6015db7d674439fe8c23f6493 | [
"MIT"
] | null | null | null | Libs/GuiSys/CompListBox.hpp | DNS/Cafu | 77b34014cc7493d6015db7d674439fe8c23f6493 | [
"MIT"
] | 1 | 2020-04-11T13:00:04.000Z | 2020-04-11T13:00:04.000Z | /*
Cafu Engine, http://www.cafu.de/
Copyright (c) Carsten Fuchs and other contributors.
This project is licensed under the terms of the MIT license.
*/
#ifndef CAFU_GUISYS_COMPONENT_LISTBOX_HPP_INCLUDED
#define CAFU_GUISYS_COMPONENT_LISTBOX_HPP_INCLUDED
#include "CompBase.hpp"
namespace cf
{
namespace GuiSys
{
class ComponentTextT;
/// This components turns its window into a list-box control.
/// It requires that in the same window a text component is available where the aspects of text rendering are
/// configured (but that normally has empty text contents itself).
class ComponentListBoxT : public ComponentBaseT
{
public:
/// The constructor.
ComponentListBoxT();
/// The copy constructor.
/// @param Comp The component to create a copy of.
ComponentListBoxT(const ComponentListBoxT& Comp);
// Base class overrides.
ComponentListBoxT* Clone() const;
const char* GetName() const { return "ListBox"; }
void UpdateDependencies(WindowT* Window);
void Render() const;
bool OnInputEvent(const CaKeyboardEventT& KE);
bool OnInputEvent(const CaMouseEventT& ME, float PosX, float PosY);
// The TypeSys related declarations for this class.
const cf::TypeSys::TypeInfoT* GetType() const { return &TypeInfo; }
static void* CreateInstance(const cf::TypeSys::CreateParamsT& Params);
static const cf::TypeSys::TypeInfoT TypeInfo;
protected:
// The Lua API methods of this class.
static int GetSelItem(lua_State* LuaState);
static int toString(lua_State* LuaState);
static const luaL_Reg MethodsList[]; ///< The list of Lua methods for this class.
static const char* DocClass;
static const cf::TypeSys::MethsDocT DocMethods[];
static const cf::TypeSys::MethsDocT DocCallbacks[];
static const cf::TypeSys::VarsDocT DocVars[];
private:
IntrusivePtrT<ComponentTextT> m_TextComp; ///< The sibling text component from which we take the text settings.
TypeSys::VarArrayT<std::string> m_Items; ///< The list of available items.
TypeSys::VarT<unsigned int> m_Selection; ///< The index number of the currently selected item, where 1 corresponds to the first item (as per Lua convention). Use 0 for "no selection".
TypeSys::VarT<Vector3fT> m_BgColorOdd; ///< The background color for odd rows.
TypeSys::VarT<float> m_BgAlphaOdd; ///< The background alpha for odd rows.
TypeSys::VarT<Vector3fT> m_BgColorEven; ///< The background color for even rows.
TypeSys::VarT<float> m_BgAlphaEven; ///< The background alpha for even rows.
TypeSys::VarT<Vector3fT> m_BgColorSel; ///< The background color for selected rows.
TypeSys::VarT<float> m_BgAlphaSel; ///< The background alpha for selected rows.
TypeSys::VarT<Vector3fT> m_TextColorSel; ///< The foreground color for selected rows.
TypeSys::VarT<float> m_TextAlphaSel; ///< The foreground alpha for selected rows.
};
}
}
#endif
| 42.95 | 202 | 0.621071 | dns |
0b1b5057431c8106ee0c3c1e1bfa32be4f54044a | 2,437 | cpp | C++ | src/BudgetManager.cpp | MichalWilczek/your-budget | fb0ace51a1e4ea9013398fef945798d2695659cf | [
"MIT"
] | null | null | null | src/BudgetManager.cpp | MichalWilczek/your-budget | fb0ace51a1e4ea9013398fef945798d2695659cf | [
"MIT"
] | null | null | null | src/BudgetManager.cpp | MichalWilczek/your-budget | fb0ace51a1e4ea9013398fef945798d2695659cf | [
"MIT"
] | null | null | null | #include "BudgetManager.h"
void BudgetManager::showBalance(string startDate, string endDate) {
double totalIncome = 0;
double totalExpenses = 0;
system("cls");
if (incomeManager.areTransactionsAvailable()) {
cout << " >>> INCOME <<<" << endl << endl;
incomeManager.showTransactions(startDate, endDate);
totalIncome = incomeManager.getTransactionsSummedValue(startDate, endDate);
}
if (expensesManager.areTransactionsAvailable()) {
cout << endl << " >>> EXPENSES <<<" << endl << endl;
expensesManager.showTransactions(startDate, endDate);
totalExpenses = expensesManager.getTransactionsSummedValue(startDate, endDate);
}
cout << endl << "---------------------" << endl;
cout << "Total income = " << totalIncome << endl;
cout << "Total expenses = " << totalExpenses << endl;
cout << "---------------------" << endl;
cout << "Total balance = " << totalIncome - totalExpenses << endl << endl;
system("pause");
}
void BudgetManager::addIncome() {
system("cls");
cout << " >>> ADDING INCOME <<<" << endl << endl;
incomeManager.addTransaction();
system("pause");
}
void BudgetManager::addExpense() {
system("cls");
cout << " >>> ADDING EXPENSE <<<" << endl << endl;
expensesManager.addTransaction();
system("pause");
}
void BudgetManager::showBalanceFromCurrentMonth() {
DateEditor dateEditor;
string currentDate = dateEditor.getDateString();
string firstDayOfMonthDate = dateEditor.getDateStringFirstDayOfMonth();
showBalance(firstDayOfMonthDate, currentDate);
}
void BudgetManager::showBalanceFromPreviousMonth() {
DateEditor dateEditorCurrentDate;
string firstDayOfPreviousMonthDate = dateEditorCurrentDate.getDateStringFirstDayOfPreviousMonth();
DateEditor lastMonthDate(firstDayOfPreviousMonthDate);
string lastDayOfPreviousMonthDate = lastMonthDate.getDateStringLastDayOfMonth();
showBalance(firstDayOfPreviousMonthDate, lastDayOfPreviousMonthDate);
}
void BudgetManager::showBalanceFromChosenPeriod() {
system("cls");
cout << ">>> START DATE <<<" << endl;
DateEditor dateEditorStartDate(false);
string startDate = dateEditorStartDate.getDateString();
cout << endl << ">>> END DATE <<<" << endl;
DateEditor dateEditorEndDate(false);
string endDate = dateEditorEndDate.getDateString();
showBalance(startDate, endDate);
}
| 32.065789 | 102 | 0.675831 | MichalWilczek |
0b1c30f2b142a6ed009b852174d40113e91ba96c | 5,231 | cpp | C++ | src/Interpreters/ExternalUserDefinedExecutableFunctionsLoader.cpp | ivoleg/ClickHouse | 16e173f0c024e36cd253388abac2ecc513686d87 | [
"Apache-2.0"
] | 1 | 2021-12-12T10:33:27.000Z | 2021-12-12T10:33:27.000Z | src/Interpreters/ExternalUserDefinedExecutableFunctionsLoader.cpp | ivoleg/ClickHouse | 16e173f0c024e36cd253388abac2ecc513686d87 | [
"Apache-2.0"
] | null | null | null | src/Interpreters/ExternalUserDefinedExecutableFunctionsLoader.cpp | ivoleg/ClickHouse | 16e173f0c024e36cd253388abac2ecc513686d87 | [
"Apache-2.0"
] | null | null | null | #include "ExternalUserDefinedExecutableFunctionsLoader.h"
#include <DataTypes/DataTypeFactory.h>
#include <Interpreters/UserDefinedExecutableFunction.h>
#include <Interpreters/UserDefinedExecutableFunctionFactory.h>
#include <Functions/FunctionFactory.h>
#include <AggregateFunctions/AggregateFunctionFactory.h>
namespace DB
{
namespace ErrorCodes
{
extern const int BAD_ARGUMENTS;
extern const int FUNCTION_ALREADY_EXISTS;
}
ExternalUserDefinedExecutableFunctionsLoader::ExternalUserDefinedExecutableFunctionsLoader(ContextPtr global_context_)
: ExternalLoader("external user defined function", &Poco::Logger::get("ExternalUserDefinedExecutableFunctionsLoader"))
, WithContext(global_context_)
{
setConfigSettings({"function", "name", "database", "uuid"});
enableAsyncLoading(false);
enablePeriodicUpdates(true);
}
ExternalUserDefinedExecutableFunctionsLoader::UserDefinedExecutableFunctionPtr ExternalUserDefinedExecutableFunctionsLoader::getUserDefinedFunction(const std::string & user_defined_function_name) const
{
return std::static_pointer_cast<const UserDefinedExecutableFunction>(load(user_defined_function_name));
}
ExternalUserDefinedExecutableFunctionsLoader::UserDefinedExecutableFunctionPtr ExternalUserDefinedExecutableFunctionsLoader::tryGetUserDefinedFunction(const std::string & user_defined_function_name) const
{
return std::static_pointer_cast<const UserDefinedExecutableFunction>(tryLoad(user_defined_function_name));
}
void ExternalUserDefinedExecutableFunctionsLoader::reloadFunction(const std::string & user_defined_function_name) const
{
loadOrReload(user_defined_function_name);
}
ExternalLoader::LoadablePtr ExternalUserDefinedExecutableFunctionsLoader::create(const std::string & name,
const Poco::Util::AbstractConfiguration & config,
const std::string & key_in_config,
const std::string &) const
{
if (FunctionFactory::instance().hasNameOrAlias(name))
throw Exception(ErrorCodes::FUNCTION_ALREADY_EXISTS, "The function '{}' already exists", name);
if (AggregateFunctionFactory::instance().hasNameOrAlias(name))
throw Exception(ErrorCodes::FUNCTION_ALREADY_EXISTS, "The aggregate function '{}' already exists", name);
String type = config.getString(key_in_config + ".type");
UserDefinedExecutableFunctionType function_type;
if (type == "executable")
function_type = UserDefinedExecutableFunctionType::executable;
else if (type == "executable_pool")
function_type = UserDefinedExecutableFunctionType::executable_pool;
else
throw Exception(ErrorCodes::BAD_ARGUMENTS,
"Wrong user defined function type expected 'executable' or 'executable_pool' actual {}",
function_type);
String command = config.getString(key_in_config + ".command");
String format = config.getString(key_in_config + ".format");
DataTypePtr result_type = DataTypeFactory::instance().get(config.getString(key_in_config + ".return_type"));
bool send_chunk_header = config.getBool(key_in_config + ".send_chunk_header", false);
size_t pool_size = 0;
size_t command_termination_timeout = 0;
size_t max_command_execution_time = 0;
if (function_type == UserDefinedExecutableFunctionType::executable_pool)
{
pool_size = config.getUInt64(key_in_config + ".pool_size", 16);
command_termination_timeout = config.getUInt64(key_in_config + ".command_termination_timeout", 10);
max_command_execution_time = config.getUInt64(key_in_config + ".max_command_execution_time", 10);
size_t max_execution_time_seconds = static_cast<size_t>(getContext()->getSettings().max_execution_time.totalSeconds());
if (max_execution_time_seconds != 0 && max_command_execution_time > max_execution_time_seconds)
max_command_execution_time = max_execution_time_seconds;
}
ExternalLoadableLifetime lifetime;
if (config.has(key_in_config + ".lifetime"))
lifetime = ExternalLoadableLifetime(config, key_in_config + ".lifetime");
std::vector<DataTypePtr> argument_types;
Poco::Util::AbstractConfiguration::Keys config_elems;
config.keys(key_in_config, config_elems);
for (const auto & config_elem : config_elems)
{
if (!startsWith(config_elem, "argument"))
continue;
const auto argument_prefix = key_in_config + '.' + config_elem + '.';
auto argument_type = DataTypeFactory::instance().get(config.getString(argument_prefix + "type"));
argument_types.emplace_back(std::move(argument_type));
}
UserDefinedExecutableFunctionConfiguration function_configuration
{
.type = function_type,
.name = std::move(name),
.script_path = std::move(command),
.format = std::move(format),
.argument_types = std::move(argument_types),
.result_type = std::move(result_type),
.pool_size = pool_size,
.command_termination_timeout = command_termination_timeout,
.max_command_execution_time = max_command_execution_time,
.send_chunk_header = send_chunk_header
};
return std::make_shared<UserDefinedExecutableFunction>(function_configuration, lifetime);
}
}
| 42.185484 | 204 | 0.758555 | ivoleg |
0b1d1aaa7547010c73d8162e55c32904dd4efb0d | 2,522 | cpp | C++ | third_party/subzero/crosstest/test_icmp.cpp | sunnycase/swiftshader | 592bce0dc7daaa8d2c7ee4b94bec98e0e7beeacc | [
"Apache-2.0"
] | 2,151 | 2020-04-18T07:31:17.000Z | 2022-03-31T08:39:18.000Z | third_party/subzero/crosstest/test_icmp.cpp | sunnycase/swiftshader | 592bce0dc7daaa8d2c7ee4b94bec98e0e7beeacc | [
"Apache-2.0"
] | 395 | 2020-04-18T08:22:18.000Z | 2021-12-08T13:04:49.000Z | third_party/subzero/crosstest/test_icmp.cpp | sunnycase/swiftshader | 592bce0dc7daaa8d2c7ee4b94bec98e0e7beeacc | [
"Apache-2.0"
] | 338 | 2020-04-18T08:03:10.000Z | 2022-03-29T12:33:22.000Z | //===- subzero/crosstest/test_icmp.cpp - Implementation for tests ---------===//
//
// The Subzero Code Generator
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This aims to test the icmp bitcode instruction across all PNaCl primitive
// and SIMD integer types.
//
//===----------------------------------------------------------------------===//
#include <stdint.h>
#include "test_icmp.h"
#include "xdefs.h"
#define X(cmp, op) \
bool icmp##cmp(uint8_t a, uint8_t b) { return a op b; } \
bool icmp##cmp(uint16_t a, uint16_t b) { return a op b; } \
bool icmp##cmp(uint32_t a, uint32_t b) { return a op b; } \
bool icmp##cmp(uint64 a, uint64 b) { return a op b; } \
v4ui32 icmp##cmp(v4ui32 a, v4ui32 b) { return a op b; } \
v8ui16 icmp##cmp(v8ui16 a, v8ui16 b) { return a op b; } \
v16ui8 icmp##cmp(v16ui8 a, v16ui8 b) { return a op b; } \
bool icmp_zero##cmp(uint8_t a) { return a op 0; } \
bool icmp_zero##cmp(uint16_t a) { return a op 0; } \
bool icmp_zero##cmp(uint32_t a) { return a op 0; } \
bool icmp_zero##cmp(uint64 a) { return a op 0; }
ICMP_U_TABLE
#undef X
#define X(cmp, op) \
bool icmp##cmp(myint8_t a, myint8_t b) { return a op b; } \
bool icmp##cmp(int16_t a, int16_t b) { return a op b; } \
bool icmp##cmp(int32_t a, int32_t b) { return a op b; } \
bool icmp##cmp(int64 a, int64 b) { return a op b; } \
v4si32 icmp##cmp(v4si32 a, v4si32 b) { return a op b; } \
v8si16 icmp##cmp(v8si16 a, v8si16 b) { return a op b; } \
v16si8 icmp##cmp(v16si8 a, v16si8 b) { return a op b; } \
bool icmp_zero##cmp(myint8_t a) { return a op 0; } \
bool icmp_zero##cmp(int16_t a) { return a op 0; } \
bool icmp_zero##cmp(int32_t a) { return a op 0; } \
bool icmp_zero##cmp(int64 a) { return a op 0; }
ICMP_S_TABLE
#undef X
| 51.469388 | 80 | 0.450833 | sunnycase |
0b1ffcf08c9a1ffbc7b56d18c8745c75793bfc3e | 422 | cpp | C++ | Minigin/ThreadComponent.cpp | Zakatos/Component-Game-Engine | c52f49ada5c23cdee502f4d3a8ce09392d6bcae9 | [
"MIT"
] | null | null | null | Minigin/ThreadComponent.cpp | Zakatos/Component-Game-Engine | c52f49ada5c23cdee502f4d3a8ce09392d6bcae9 | [
"MIT"
] | null | null | null | Minigin/ThreadComponent.cpp | Zakatos/Component-Game-Engine | c52f49ada5c23cdee502f4d3a8ce09392d6bcae9 | [
"MIT"
] | null | null | null | #include "MiniginPCH.h"
#include "ThreadComponent.h"
#include "ThreadManager.h"
ThreadComponent::ThreadComponent()
{
}
ThreadComponent::~ThreadComponent()
{
}
void ThreadComponent::init()
{
std::shared_ptr<std::thread> threadObj = std::make_shared<std::thread>(&ThreadComponent::update, this);
ThreadManager::GetInstance().AddThread(std::make_shared<ThreadRaii>(threadObj));
}
void ThreadComponent::update()
{
}
| 16.88 | 104 | 0.746445 | Zakatos |
0b231e24d58e032f02073f7d28166bf58ae015b7 | 3,163 | cc | C++ | sparselets/tile_sparselet_resps.cc | rksltnl/sparselet-release1 | bf7977c2b886961c35506184796b04021206b62b | [
"BSD-2-Clause"
] | 4 | 2015-03-23T05:55:23.000Z | 2019-03-05T02:18:39.000Z | sparselets/tile_sparselet_resps.cc | rksltnl/sparselet-release1 | bf7977c2b886961c35506184796b04021206b62b | [
"BSD-2-Clause"
] | null | null | null | sparselets/tile_sparselet_resps.cc | rksltnl/sparselet-release1 | bf7977c2b886961c35506184796b04021206b62b | [
"BSD-2-Clause"
] | 10 | 2015-03-23T05:55:24.000Z | 2019-03-05T02:18:51.000Z | #include <sys/types.h>
#include "mex.h"
const int S = 3;
const int NUM_SUB_FILTERS = 4;
/*
* Hyun Oh Song ([email protected])
* Part filter tiling
*/
void tile_sparselets(double* Q_ptr, double* P_ptr, int s_dimy, int s_dimx, int out_dimy, int out_dimx, int i){
// Q_ptr points to head of ith filter response
// P_ptr points to head of temp array for tiled filter response
// 0 | 1
// --+--
// 2 | 3
int col=0, row=0, P_idx=0;
int stop_idx = out_dimx * out_dimy;
// Copy P0
while (P_idx < stop_idx){
if (row == out_dimy){
row = 0;
col += s_dimy;
}
P_ptr[P_idx++] = Q_ptr[col+row];
row++;
}
Q_ptr += (s_dimy * s_dimx); // Point Q_ptr to next sub-filter
// Copy P1
col=S*s_dimy; row=0; P_idx=0;
while (P_idx < stop_idx){
if (row == out_dimy){
row = 0;
col += s_dimy;
}
P_ptr[P_idx++] += Q_ptr[col+row];
row++;
}
Q_ptr += (s_dimy * s_dimx);
// Copy P2
col=0; row=S; P_idx=0;
while (P_idx < stop_idx){
if (row == (S + out_dimy)){
row = S;
col += s_dimy;
}
P_ptr[P_idx++] += Q_ptr[col+row];
row++;
}
Q_ptr += (s_dimy * s_dimx);
// Copy P3
col=S*s_dimy; row=S; P_idx=0;
while (P_idx < stop_idx){
if (row == (S + out_dimy)){
row = S;
col += s_dimy;
}
P_ptr[P_idx++] += Q_ptr[col+row];
row++;
}
}
void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[]) {
if (nrhs != 6)
mexErrMsgTxt("Wrong number of inputs");
if (nlhs != 1)
mexErrMsgTxt("Wrong number of outputs");
if (mxGetClassID(prhs[0]) != mxDOUBLE_CLASS)
mexErrMsgTxt("Invalid input");
const int* Q_dims = mxGetDimensions( prhs[0]);
double* Q_ptr = (double*)mxGetPr(prhs[0]);
int s_dimy = mxGetScalar(prhs[1]);
int s_dimx = mxGetScalar(prhs[2]);
int out_dimy = mxGetScalar(prhs[3]);
int out_dimx = mxGetScalar(prhs[4]);
int num_sub_filters_roots = mxGetScalar(prhs[5]);
// Temp array to hold tiled filter response
int P_dims[2] = {out_dimy, out_dimx};
mxArray* mxP = mxCreateNumericArray(2, P_dims, mxDOUBLE_CLASS, mxREAL);
// Cell array of tiled filter response
const int num_filters = (Q_dims[1] - num_sub_filters_roots) / NUM_SUB_FILTERS;
mxArray *cell_array_ptr = mxCreateCellArray(1, &num_filters);
int numel_ith_filter = Q_dims[0] * NUM_SUB_FILTERS;
double* P_ptr_init = (double*)mxGetPr(mxP);
double* P_ptr = P_ptr_init;
// Offset the Q pointer to where part filter begins (after roots)
Q_ptr += Q_dims[0] * num_sub_filters_roots;
for (int i=0; i < num_filters; i++){
tile_sparselets(Q_ptr, P_ptr, s_dimy, s_dimx, out_dimy, out_dimx, i);
P_ptr = P_ptr_init; // point back to origin
mxSetCell(cell_array_ptr, i, mxDuplicateArray(mxP));
if (i != (num_filters-1))
Q_ptr += numel_ith_filter;
}
plhs[0] = cell_array_ptr;
}
| 29.018349 | 110 | 0.566235 | rksltnl |
0b23d3eda0f184c0181cd96ba03744d32b50cc60 | 342 | cpp | C++ | OpenKattis/dicecup.cpp | MFathirIrhas/ProgrammingChallenges | 8c67bd71212a1941e5bcc0463095285859afa04d | [
"MIT"
] | 3 | 2020-10-19T10:03:20.000Z | 2021-12-18T20:39:31.000Z | OpenKattis/dicecup.cpp | MFathirIrhas/ProgrammingChallenges | 8c67bd71212a1941e5bcc0463095285859afa04d | [
"MIT"
] | null | null | null | OpenKattis/dicecup.cpp | MFathirIrhas/ProgrammingChallenges | 8c67bd71212a1941e5bcc0463095285859afa04d | [
"MIT"
] | null | null | null | #include <iostream>
using namespace std;
void PrintResult(int *n, int *m){
if(*n == *m){
cout<< *n + 1;
}else if(*n < *m){
for(int i=*n + 1; i<= *m+1; i++){
cout<<i<<endl;
}
}else{
for(int i=*m + 1; i<= *n+1; i++){
cout<<i<<endl;
}
}
}
int main(){
int n,m;
cin>>n>>m;
PrintResult(&n,&m);
cout<<endl;
return 0;
} | 13.153846 | 35 | 0.48538 | MFathirIrhas |
0b2e451f57935f73601fedadf1b8c26e03989a86 | 343 | cpp | C++ | usaco/madscientist.cpp | datpq/competitive-programming | ed5733cc55fa4167c4a2e828894b044ea600dcac | [
"MIT"
] | 1 | 2022-02-24T21:35:18.000Z | 2022-02-24T21:35:18.000Z | usaco/madscientist.cpp | datpq/competitive-programming | ed5733cc55fa4167c4a2e828894b044ea600dcac | [
"MIT"
] | null | null | null | usaco/madscientist.cpp | datpq/competitive-programming | ed5733cc55fa4167c4a2e828894b044ea600dcac | [
"MIT"
] | 1 | 2022-02-12T14:40:21.000Z | 2022-02-12T14:40:21.000Z | #include <fstream>
#include <string>
using namespace std;
int main() {
ifstream ifs("breedflip.in");
ofstream ofs("breedflip.out");
int n; string a, b; ifs >> n >> a >> b;
int ans = 0;
for (int i = 0; i < n; i++) {
if (a[i] != b[i]) {
ans++;
while (i < n-1 && a[i + 1] != b[i + 1]) i++;
}
}
ofs << ans << endl;
return 0;
}
| 17.15 | 47 | 0.504373 | datpq |
0b31e9c46850c30e6cbe2dc6d22a360fef03ddb2 | 1,326 | cc | C++ | critic/test/art/Throwing_service.cc | art-framework-suite/critic | bf9289facca1adc110e1bfa5d788f9f2354b2d40 | [
"BSD-3-Clause"
] | null | null | null | critic/test/art/Throwing_service.cc | art-framework-suite/critic | bf9289facca1adc110e1bfa5d788f9f2354b2d40 | [
"BSD-3-Clause"
] | null | null | null | critic/test/art/Throwing_service.cc | art-framework-suite/critic | bf9289facca1adc110e1bfa5d788f9f2354b2d40 | [
"BSD-3-Clause"
] | null | null | null | // ======================================================================
// Throwing is a service that throws an exception when the
// postProcessEvent signal is emitted.
// ======================================================================
#include "art/Framework/Principal/fwd.h"
#include "art/Framework/Services/Registry/ActivityRegistry.h"
#include "art/Framework/Services/Registry/ServiceDeclarationMacros.h"
#include "art/Framework/Services/Registry/ServiceDefinitionMacros.h"
#include "messagefacility/MessageLogger/MessageLogger.h"
using namespace art;
namespace arttest {
class Throwing {
public:
struct Config {};
using Parameters = ServiceTable<Config>;
Throwing(Parameters const& cfg, ActivityRegistry& ar);
private:
void throwError(art::Event const& e, ScheduleContext);
};
}
arttest::Throwing::Throwing(Parameters const&, ActivityRegistry& r)
{
r.sPostProcessEvent.watch(this, &Throwing::throwError);
mf::LogInfo("testing") << "Throwing service created";
}
void
arttest::Throwing::throwError(Event const&, ScheduleContext)
{
mf::LogInfo("testing") << "Throwing service about to throw";
throw Exception(errors::ProductNotFound)
<< "Intentional exception from Throwing service";
}
DECLARE_ART_SERVICE(arttest::Throwing, LEGACY)
DEFINE_ART_SERVICE(arttest::Throwing)
| 31.571429 | 73 | 0.680241 | art-framework-suite |
0b3474bcc6ff1d547ae668a3e2e8e620687081e0 | 1,723 | hpp | C++ | src/common/optimization/include/optimization/line_search/fixed_line_search.hpp | ruvus/auto | 25ae62d6e575cae40212356eed43ec3e76e9a13e | [
"Apache-2.0"
] | 19 | 2021-05-28T06:14:21.000Z | 2022-03-10T10:03:08.000Z | src/common/optimization/include/optimization/line_search/fixed_line_search.hpp | ruvus/auto | 25ae62d6e575cae40212356eed43ec3e76e9a13e | [
"Apache-2.0"
] | 222 | 2021-10-29T22:00:27.000Z | 2022-03-29T20:56:34.000Z | src/common/optimization/include/optimization/line_search/fixed_line_search.hpp | ruvus/auto | 25ae62d6e575cae40212356eed43ec3e76e9a13e | [
"Apache-2.0"
] | 14 | 2021-05-29T14:59:17.000Z | 2022-03-10T10:03:09.000Z | // Copyright 2020 the Autoware Foundation
//
// 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.
//
// Co-developed by Tier IV, Inc. and Apex.AI, Inc.
#ifndef OPTIMIZATION__LINE_SEARCH__FIXED_LINE_SEARCH_HPP_
#define OPTIMIZATION__LINE_SEARCH__FIXED_LINE_SEARCH_HPP_
#include <optimization/line_search/line_search.hpp>
#include <limits>
namespace autoware
{
namespace common
{
namespace optimization
{
/// Class to use a fixed step length during optimization.
class OPTIMIZATION_PUBLIC FixedLineSearch : public LineSearch<FixedLineSearch>
{
public:
/// Constructor.
/// \param step Fixed step to be used.
explicit FixedLineSearch(const StepT step = std::numeric_limits<StepT>::min())
: LineSearch{step} {}
/// Returns directly the pre-set (maximum) step length
/// \return The fixed step length.
template<typename DomainValueT, typename OptimizationProblemT>
DomainValueT compute_next_step(
const DomainValueT &, DomainValueT & step_direction,
OptimizationProblemT &) const noexcept
{
return get_step_max() * step_direction.normalized();
}
};
} // namespace optimization
} // namespace common
} // namespace autoware
#endif // OPTIMIZATION__LINE_SEARCH__FIXED_LINE_SEARCH_HPP_
| 31.327273 | 80 | 0.761463 | ruvus |
0b351c095f964ef97052abe98ea9233127b51ad8 | 2,227 | cpp | C++ | kthlis.cpp | qbbd/Algorithm_List | b3c9d97e20c7a10eaa908f8d98654319ac95f302 | [
"MIT"
] | null | null | null | kthlis.cpp | qbbd/Algorithm_List | b3c9d97e20c7a10eaa908f8d98654319ac95f302 | [
"MIT"
] | 7 | 2018-04-08T01:47:01.000Z | 2018-06-07T23:33:15.000Z | kthlis.cpp | qbbd/Algorithm_List | b3c9d97e20c7a10eaa908f8d98654319ac95f302 | [
"MIT"
] | null | null | null | #include<algorithm>
#include<cstring>
#include<iostream>
#include<string>
#include<vector>
using namespace std;
const int MAX = 2000000000+10;
int n;
int cacheLen[501], cacheCnt[501], S[500];
// S[start] 에서 시작하는 증가 부분 수열 중 최대 길이를 반환한다
int lis(int start) {
// 메모이제이션
int& ret = cacheLen[start+1];
if(ret != -1) return ret;
// 항상 S[start] 는 있기 때문에 길이는 최하 1
ret = 1;
for(int next = start+1; next < n; ++next)
if(start == -1 || S[start] < S[next])
ret = max(ret, lis(next) + 1);
return ret;
}
// S[start] 에서 시작하는 최대 증가 부분 수열의 수를 반환한다
int count(int start) {
// 기저 사례: LIS 의 길이가 1 인 경우
if(lis(start) == 1) return 1;
// 메모이제이션
int& ret = cacheCnt[start+1];
if(ret != -1) return ret;
ret = 0;
for(int next = start+1; next < n; ++next) {
if((start == -1 || S[start] < S[next]) &&
lis(start) == lis(next) + 1)
ret = min<long long>(MAX, (long long)ret + count(next));
}
return ret;
}
// S[start] 에서 시작하는 LIS 중 사전 순으로 skip 개 건너뛴 수열을
// lis 에 저장한다
void reconstruct(int start, int skip, vector<int>& lis) {
// S[start] 는 항상 LIS 에 포함된다
if(start != -1) lis.push_back(S[start]);
// 뒤에 올 수 있는 숫자들과 위치의 목록을 만든다
// (숫자, 숫자의 위치) 의 목록이 된다
vector<pair<int,int> > followers;
for(int next = start; next < n; next++)
if((start == -1 || S[start] < S[next]) &&
lis(start) == lis(next) + 1)
followers.push_back(make_pair(S[next], next));
// 숫자 크기별로 정렬한다
sort(followers.begin(), followers.end());
for(int i = 0; i < followers.size(); ++i) {
// 이 숫자를 뒤에 이어서 만들 수 있는 LIS 의 개수를 본다
int idx = followers[i].second;
int cnt = count(idx);
if(cnt <= skip)
skip -= cnt;
else {
// 다음 숫자는 S[idx] 임을 알았다
reconstruct(idx, skip, lis);
break;
}
}
}
int main() {
int cases;
cin >> cases;
for(int cc = 0; cc < cases; ++cc) {
int k;
cin >> n >> k;
for(int i = 0; i < n; i++) {
cin >> S[i];
}
memset(cacheLen, -1, sizeof(cacheLen));
memset(cacheCnt, -1, sizeof(cacheCnt));
//cout << lis(-1)-1 << endl;
//cout << count(-1) << endl;
vector<int> kth;
reconstruct(-1, k-1, kth);
cout << kth.size() << endl;
for(int i = 0; i < kth.size(); i++) {
if(i) cout << ' ';
cout << kth[i];
}
cout << endl;
}
}
| 23.946237 | 59 | 0.557701 | qbbd |
0b3d11b78909203dbb470210f29ba998ace59b5b | 1,237 | cpp | C++ | test/bwe/FakeCrossTraffic.cpp | danielgronberg/SymphonyMediaBridge | 2cdd2ecd45c534545c9d3f3c36d8e86771330057 | [
"Apache-2.0"
] | null | null | null | test/bwe/FakeCrossTraffic.cpp | danielgronberg/SymphonyMediaBridge | 2cdd2ecd45c534545c9d3f3c36d8e86771330057 | [
"Apache-2.0"
] | null | null | null | test/bwe/FakeCrossTraffic.cpp | danielgronberg/SymphonyMediaBridge | 2cdd2ecd45c534545c9d3f3c36d8e86771330057 | [
"Apache-2.0"
] | null | null | null | #include "FakeCrossTraffic.h"
#include "FakeMedia.h"
#include "utils/Time.h"
namespace fakenet
{
FakeCrossTraffic::FakeCrossTraffic(memory::PacketPoolAllocator& allocator, uint32_t mtu, uint32_t bandwidthKbps)
: _allocator(allocator),
_releaseTime(0),
_bandwidthKbps(bandwidthKbps),
_mtu(mtu)
{
}
memory::Packet* FakeCrossTraffic::getPacket(uint64_t timestamp)
{
if (_bandwidthKbps == 0)
{
return nullptr;
}
if (_releaseTime == 0)
{
_releaseTime = timestamp;
}
if (utils::Time::diff(_releaseTime, timestamp) >= 0)
{
auto* packet = memory::makePacket(_allocator);
packet->get()[0] = CROSS_TRAFFIC_PROTOCOL;
packet->setLength(randomPacketSize());
const auto deltaTime = utils::Time::sec * _mtu / (_bandwidthKbps * int64_t(125));
_releaseTime += deltaTime;
return packet;
}
return nullptr;
}
int64_t FakeCrossTraffic::timeToRelease(uint64_t timestamp) const
{
return std::max(int64_t(0), utils::Time::diff(timestamp, _releaseTime));
}
void FakeCrossTraffic::setBandwidth(uint32_t kbps)
{
_bandwidthKbps = kbps;
}
size_t FakeCrossTraffic::randomPacketSize()
{
return _mtu;
}
} // namespace fakenet | 23.788462 | 112 | 0.675829 | danielgronberg |
0b447c70f4ca25e193eee7917343ec7348cb5b92 | 962 | hpp | C++ | rest_rpc/iguana/third_party/msgpack/include/msgpack/version.hpp | emogua/CGAssistant | f3ded85a8336bcc03fd1a3d370880cdeedaa570f | [
"MIT"
] | 1,316 | 2016-07-03T10:01:37.000Z | 2022-03-31T18:40:35.000Z | rest_rpc/iguana/third_party/msgpack/include/msgpack/version.hpp | emogua/CGAssistant | f3ded85a8336bcc03fd1a3d370880cdeedaa570f | [
"MIT"
] | 3,393 | 2019-05-07T08:33:32.000Z | 2022-03-31T14:57:14.000Z | rest_rpc/iguana/third_party/msgpack/include/msgpack/version.hpp | emogua/CGAssistant | f3ded85a8336bcc03fd1a3d370880cdeedaa570f | [
"MIT"
] | 315 | 2016-08-24T13:08:20.000Z | 2022-03-29T10:59:08.000Z | /*
* MessagePack for C++ version information
*
* Copyright (C) 2008-2013 FURUHASHI Sadayuki and Takatoshi Kondo
*
* 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 MSGPACK_VERSION_HPP
#define MSGPACK_VERSION_HPP
#include "version_master.h"
#define MSGPACK_STR(v) #v
#define MSGPACK_VERSION_I(maj, min, rev) MSGPACK_STR(maj) "." MSGPACK_STR(min) "." MSGPACK_STR(rev)
#define MSGPACK_VERSION MSGPACK_VERSION_I(MSGPACK_VERSION_MAJOR, MSGPACK_VERSION_MINOR, MSGPACK_VERSION_REVISION)
inline const char* msgpack_version(void) {
return MSGPACK_VERSION;
}
inline int msgpack_version_major(void) {
return MSGPACK_VERSION_MAJOR;
}
inline int msgpack_version_minor(void) {
return MSGPACK_VERSION_MINOR;
}
inline int msgpack_version_revision(void) {
return MSGPACK_VERSION_REVISION;
}
#endif /* msgpack/version.hpp */
| 26 | 113 | 0.767152 | emogua |
0b46bd09868904b1e05132cfeeb040492c040c5f | 513 | cpp | C++ | Gpx_2/Gpx/Implementation/TextureViewer.cpp | DexterDreeeam/DxtSdk2021 | 2dd8807b4ebe1d65221095191eaa7938bc5e9e78 | [
"MIT"
] | 1 | 2021-11-18T03:57:54.000Z | 2021-11-18T03:57:54.000Z | Gpx_2/Gpx/Implementation/TextureViewer.cpp | DexterDreeeam/P9 | 2dd8807b4ebe1d65221095191eaa7938bc5e9e78 | [
"MIT"
] | null | null | null | Gpx_2/Gpx/Implementation/TextureViewer.cpp | DexterDreeeam/P9 | 2dd8807b4ebe1d65221095191eaa7938bc5e9e78 | [
"MIT"
] | null | null | null |
#include "../_Interface.hpp"
namespace gpx
{
texture_viewer::texture_viewer() :
_state((s64)texture_viewer_state::Offline)
{
}
texture_viewer_state texture_viewer::state() const
{
return (texture_viewer_state)_state.get();
}
boole texture_viewer::transfer_state(texture_viewer_state from, texture_viewer_state to)
{
s64 f = (s64)from;
s64 t = (s64)to;
if (_state.compare_exchange(f, t) == f)
{
return boole::True;
}
else
{
return boole::False;
}
}
}
| 15.545455 | 88 | 0.654971 | DexterDreeeam |
0b46f4981f3a745130e02b4dae0f7ebad67a7063 | 342,762 | cpp | C++ | tsc/tsc-new-parser/parser.cpp | SamuraiCrow/TypeScriptCompiler | 11a5379f3ffe145e61611c463e43d39ec7ea8522 | [
"MIT"
] | null | null | null | tsc/tsc-new-parser/parser.cpp | SamuraiCrow/TypeScriptCompiler | 11a5379f3ffe145e61611c463e43d39ec7ea8522 | [
"MIT"
] | null | null | null | tsc/tsc-new-parser/parser.cpp | SamuraiCrow/TypeScriptCompiler | 11a5379f3ffe145e61611c463e43d39ec7ea8522 | [
"MIT"
] | null | null | null | #include "parser.h"
#include "node_factory.h"
#include "node_test.h"
#include "utilities.h"
namespace ts
{
namespace Impl
{
// Implement the parser.as<a>() singleton module. We do this for perf reasons because creating
// parser instances can actually be expensive enough to impact us on projects with many source
// files.
struct Parser
{
// Share a single scanner across all calls to parse a source file. This helps speed things
// up by avoiding the cost of creating/compiling scanners over and over again.
ts::Scanner scanner;
NodeFlags disallowInAndDecoratorContext = NodeFlags::DisallowInContext | NodeFlags::DecoratorContext;
NodeCreateFunc nodeCreateCallback;
string fileName;
NodeFlags sourceFlags;
string sourceText;
ScriptTarget languageVersion;
ScriptKind scriptKind;
LanguageVariant languageVariant;
std::vector<DiagnosticWithDetachedLocation> parseDiagnostics;
std::vector<DiagnosticWithDetachedLocation> jsDocDiagnostics;
IncrementalParser::SyntaxCursor syntaxCursor;
SyntaxKind currentToken;
number nodeCount;
std::map<string, string> identifiers;
std::map<string, string> privateIdentifiers;
number identifierCount;
ParsingContext parsingContext;
std::vector<number> notParenthesizedArrow;
// Flags that dictate what parsing context we're in. For example:
// Whether or not we are in strict parsing mode. All that changes in strict parsing mode is
// that some tokens that would be considered identifiers may be considered keywords.
//
// When adding more parser context flags, consider which is the more common case that the
// flag will be in. This should be the 'false' state for that flag. The reason for this is
// that we don't store data in our nodes unless the value is in the *non-default* state. So,
// for example, more often than code 'allows-in' (or doesn't 'disallow-in'). We opt for
// 'disallow-in' set to 'false'. Otherwise, if we had 'allowsIn' set to 'true', then almost
// all nodes would need extra state on them to store this info.
//
// Note: 'allowIn' and 'allowYield' track 1:1 with the [in] and [yield] concepts in the ES6
// grammar specification.
//
// An important thing about these context concepts. By default they are effectively inherited
// while parsing through every grammar production. i.e. if you don't change them, then when
// you parse a sub-production, it will have the same context values.as<the>() parent production.
// This is great most of the time. After all, consider all the 'expression' grammar productions
// and how nearly all of them pass along the 'in' and 'yield' context values:
//
// EqualityExpression[In, Yield] :
// RelationalExpression[?In, ?Yield]
// EqualityExpression[?In, ?Yield] == RelationalExpression[?In, ?Yield]
// EqualityExpression[?In, ?Yield] != RelationalExpression[?In, ?Yield]
// EqualityExpression[?In, ?Yield] == RelationalExpression[?In, ?Yield]
// EqualityExpression[?In, ?Yield] != RelationalExpression[?In, ?Yield]
//
// Where you have to be careful is then understanding what the points are in the grammar
// where the values are *not* passed along. For example:
//
// SingleNameBinding[Yield,GeneratorParameter]
// [+GeneratorParameter]BindingIdentifier[Yield] Initializer[In]opt
// [~GeneratorParameter]BindingIdentifier[?Yield]Initializer[In, ?Yield]opt
//
// Here this is saying that if the GeneratorParameter context flag is set, that we should
// explicitly set the 'yield' context flag to false before calling into the BindingIdentifier
// and we should explicitly unset the 'yield' context flag before calling into the Initializer.
// production. Conversely, if the GeneratorParameter context flag is not set, then we
// should leave the 'yield' context flag alone.
//
// Getting this all correct is tricky and requires careful reading of the grammar to
// understand when these values should be changed versus when they should be inherited.
//
// it Note should not be necessary to save/restore these flags during speculative/lookahead
// parsing. These context flags are naturally stored and restored through normal recursive
// descent parsing and unwinding.
NodeFlags contextFlags;
// Indicates whether we are currently parsing top-level statements.
boolean topLevel = true;
// Whether or not we've had a parse error since creating the last AST node-> If we have
// encountered an error, it will be stored on the next AST node we create. Parse errors
// can be broken down into three categories:
//
// 1) An error that occurred during scanning. For example, an unterminated literal, or a
// character that was completely not understood.
//
// 2) A token was expected, but was not present. This type of error is commonly produced
// by the 'parseExpected' function.
//
// 3) A token was present that no parsing auto was able to consume. This type of error
// only occurs in the 'abortParsingListOrMoveToNextToken' auto when the parser
// decides to skip the token.
//
// In all of these cases, we want to mark the next node.as<having>() had an error before it.
// With this mark, we can know in incremental settings if this node can be reused, or if
// we have to reparse it. If we don't keep this information around, we may just reuse the
// node-> in that event we would then not produce the same errors.as<we>() did before, causing
// significant confusion problems.
//
// it Note is necessary that this value be saved/restored during speculative/lookahead
// parsing. During lookahead parsing, we will often create a node-> That node will have
// this value attached, and then this value will be set back to 'false'. If we decide to
// rewind, we must get back to the same value we had prior to the lookahead.
//
// any Note errors at the end of the file that do not precede a regular node, should get
// attached to the EOF token.
boolean parseErrorBeforeNextFinishedNode = false;
// Rather than using `createBaseNodeFactory` here, we establish a `BaseNodeFactory` that closes over the
// constructors above, which are reset each time `initializeState` is called.
NodeFactory factory;
// Share a single scanner across all calls to parse a source file. This helps speed things
// up by avoiding the cost of creating/compiling scanners over and over again.
Parser()
: scanner(ScriptTarget::Latest, /*skipTrivia*/ true),
factory(&scanner,
NodeFactoryFlags::NoParenthesizerRules | NodeFactoryFlags::NoNodeConverters |
NodeFactoryFlags::NoOriginalNode,
[&](Node node) -> void { countNode(node); })
{
}
auto countNode(Node node) -> Node
{
nodeCount++;
return node;
}
auto parseSourceFile(string fileName, string sourceText, ScriptTarget languageVersion,
IncrementalParser::SyntaxCursor syntaxCursor, boolean setParentNodes = false,
ScriptKind scriptKind = ScriptKind::Unknown) -> SourceFile
{
scriptKind = ensureScriptKind(fileName, scriptKind);
if (scriptKind == ScriptKind::JSON)
{
auto result = parseJsonText(fileName, sourceText, languageVersion, syntaxCursor, setParentNodes);
// TODO: review if we need it
// convertToObjectWorker(result, result.statements[0].expression, result.parseDiagnostics, /*returnValue*/
// false,
// /*knownRootOptions*/ undefined, /*jsonConversionNotifier*/ undefined);
result->referencedFiles.clear();
result->typeReferenceDirectives.clear();
result->libReferenceDirectives.clear();
result->amdDependencies.clear();
result->hasNoDefaultLib = false;
result->pragmas.clear();
return result;
}
initializeState(fileName, sourceText, languageVersion, syntaxCursor, scriptKind);
auto result = parseSourceFileWorker(languageVersion, setParentNodes, scriptKind);
clearState();
return result;
}
auto parseIsolatedEntityName(string content, ScriptTarget languageVersion) -> EntityName
{
// Choice of `isDeclarationFile` should be arbitrary
initializeState(string(), content, languageVersion, undefined, ScriptKind::JS);
// Prime the scanner.
nextToken();
auto entityName = parseEntityName(/*allowReservedWords*/ true);
auto isInvalid = token() == SyntaxKind::EndOfFileToken && !parseDiagnostics.size();
clearState();
return isInvalid ? entityName : undefined;
}
auto fixupParentReferences(Node rootNode) -> void
{
// normally parent references are set during binding. However, for clients that only need
// a syntax tree, and no semantic features, then the binding process is an unnecessary
// overhead. This functions allows us to set all the parents, without all the expense of
// binding.
setParentRecursive<boolean>(rootNode, /*incremental*/ true);
}
/**
* Parse json text into SyntaxTree and return node and parse errors if any
* @param fileName
* @param sourceText
*/
auto parseJsonText(string fileName, string sourceText, ScriptTarget languageVersion = ScriptTarget::ES2015,
IncrementalParser::SyntaxCursor syntaxCursor = undefined, boolean setParentNodes = false)
-> JsonSourceFile
{
initializeState(fileName, sourceText, languageVersion, syntaxCursor, ScriptKind::JSON);
sourceFlags = contextFlags;
// Prime the scanner.
nextToken();
auto pos = getNodePos();
NodeArray<Statement> statements;
Node endOfFileToken;
if (token() == SyntaxKind::EndOfFileToken)
{
statements = createNodeArray(NodeArray<Statement>(), pos, pos);
endOfFileToken = parseTokenNode<EndOfFileToken>();
}
else
{
// Loop and synthesize an ArrayLiteralExpression if there are more than
// one top-level expressions to ensure all input text is consumed.
NodeArray<Expression> expressions;
while (token() != SyntaxKind::EndOfFileToken)
{
Node expression;
switch (token())
{
case SyntaxKind::OpenBracketToken:
expression = parseArrayLiteralExpression();
break;
case SyntaxKind::TrueKeyword:
case SyntaxKind::FalseKeyword:
expression = parseTokenNode<BooleanLiteral>();
break;
case SyntaxKind::NullKeyword:
expression = parseTokenNode<NullLiteral>();
break;
case SyntaxKind::MinusToken:
if (lookAhead<boolean>([&]() {
return nextToken() == SyntaxKind::NumericLiteral && nextToken() != SyntaxKind::ColonToken;
}))
{
expression = parsePrefixUnaryExpression();
}
else
{
expression = parseObjectLiteralExpression();
}
break;
case SyntaxKind::NumericLiteral:
case SyntaxKind::StringLiteral:
if (lookAhead<boolean>([&]() { return nextToken() != SyntaxKind::ColonToken; }))
{
expression = parseLiteralNode();
break;
}
// falls through
default:
expression = parseObjectLiteralExpression();
break;
}
// Error collect recovery multiple top-level expressions
expressions.push_back(expression);
if (token() != SyntaxKind::EndOfFileToken)
{
parseErrorAtCurrentToken(
ts::DiagnosticMessage(data::DiagnosticMessage(Diagnostics::Unexpected_token)));
}
}
auto expression = expressions.size() > 1
? finishNode(factory.createArrayLiteralExpression(expressions), pos).as<Expression>()
: Debug::checkDefined(expressions[0]);
auto statement = factory.createExpressionStatement(expression).as<Statement>();
finishNode(statement, pos);
statements = createNodeArray(NodeArray<Statement>(statement), pos);
endOfFileToken =
parseExpectedToken(SyntaxKind::EndOfFileToken, data::DiagnosticMessage(Diagnostics::Unexpected_token));
}
// Set source file so that errors will be reported with this file name
auto sourceFile = createSourceFile(fileName, ScriptTarget::ES2015, ScriptKind::JSON, /*isDeclaration*/ false,
statements, endOfFileToken, sourceFlags);
if (setParentNodes)
{
fixupParentReferences(sourceFile);
}
sourceFile->nodeCount = nodeCount;
sourceFile->identifierCount = identifierCount;
sourceFile->identifiers = identifiers;
// sourceFile->parseDiagnostics = attachFileToDiagnostics(parseDiagnostics, sourceFile);
copy(sourceFile->parseDiagnostics, attachFileToDiagnostics(parseDiagnostics, sourceFile));
if (!jsDocDiagnostics.empty())
{
// sourceFile->jsDocDiagnostics = attachFileToDiagnostics(jsDocDiagnostics, sourceFile);
copy(sourceFile->jsDocDiagnostics, attachFileToDiagnostics(jsDocDiagnostics, sourceFile));
}
auto result = JsonSourceFile(sourceFile);
clearState();
return result;
}
auto initializeState(string _fileName, string _sourceText, ScriptTarget _languageVersion,
IncrementalParser::SyntaxCursor _syntaxCursor, ScriptKind _scriptKind) -> void
{
fileName = normalizePath(_fileName);
sourceText = _sourceText;
languageVersion = _languageVersion;
syntaxCursor = _syntaxCursor;
scriptKind = _scriptKind;
languageVariant = getLanguageVariant(_scriptKind);
parseDiagnostics.clear();
parsingContext = ParsingContext::Unknown;
identifiers.clear();
privateIdentifiers.clear();
identifierCount = 0;
nodeCount = 0;
sourceFlags = NodeFlags::None;
topLevel = true;
switch (scriptKind)
{
case ScriptKind::JS:
case ScriptKind::JSX:
contextFlags = NodeFlags::JavaScriptFile;
break;
case ScriptKind::JSON:
contextFlags = NodeFlags::JavaScriptFile | NodeFlags::JsonFile;
break;
default:
contextFlags = NodeFlags::None;
break;
}
parseErrorBeforeNextFinishedNode = false;
// Initialize and prime the scanner before parsing the source elements.
scanner.setText(sourceText);
scanner.setOnError(std::bind(&Parser::scanError, this, std::placeholders::_1, std::placeholders::_2));
scanner.setScriptTarget(languageVersion);
scanner.setLanguageVariant(languageVariant);
}
auto clearState() -> void
{
// Clear out the text the scanner is pointing at, so it doesn't keep anything alive unnecessarily.
scanner.clearCommentDirectives();
scanner.setText(string());
scanner.setOnError(nullptr);
// Clear any data. We don't want to accidentally hold onto it for too long.
sourceText = string();
languageVersion = ScriptTarget::ES3;
syntaxCursor = undefined;
scriptKind = ScriptKind::Unknown;
languageVariant = LanguageVariant::Standard;
sourceFlags = NodeFlags::None;
parseDiagnostics.clear();
jsDocDiagnostics.clear();
parsingContext = ParsingContext::Unknown;
identifiers.clear();
notParenthesizedArrow.clear();
topLevel = true;
}
/** @internal */
auto isDeclarationFileName(string fileName) -> boolean
{
return fileExtensionIs(fileName, Extension::Dts);
}
auto parseSourceFileWorker(ScriptTarget languageVersion, boolean setParentNodes, ScriptKind scriptKind)
-> SourceFile
{
auto isDeclarationFile = isDeclarationFileName(fileName);
if (isDeclarationFile)
{
contextFlags |= NodeFlags::Ambient;
}
sourceFlags = contextFlags;
// Prime the scanner.
nextToken();
auto statements =
parseList<Statement>(ParsingContext::SourceElements, std::bind(&Parser::parseStatement, this));
Debug::_assert(token() == SyntaxKind::EndOfFileToken);
auto endOfFileToken = addJSDocComment(parseTokenNode<EndOfFileToken>());
auto sourceFile = createSourceFile(fileName, languageVersion, scriptKind, isDeclarationFile, statements,
endOfFileToken, sourceFlags);
// A member of ReadonlyArray<T> isn't assignable to a member of T[] (and prevents a direct cast) - but this is
// where we set up those members so they can be in the future
processCommentPragmas(sourceFile, sourceText);
auto reportPragmaDiagnostic = [&](pos_type pos, number end, DiagnosticMessage diagnostic) -> void {
parseDiagnostics.push_back(createDetachedDiagnostic(fileName, pos, end, diagnostic));
};
processPragmasIntoFields(sourceFile, reportPragmaDiagnostic);
copy(sourceFile->commentDirectives, scanner.getCommentDirectives());
sourceFile->nodeCount = nodeCount;
sourceFile->identifierCount = identifierCount;
sourceFile->identifiers = identifiers;
// sourceFile->parseDiagnostics = attachFileToDiagnostics(parseDiagnostics, sourceFile);
copy(sourceFile->parseDiagnostics, attachFileToDiagnostics(parseDiagnostics, sourceFile));
if (!jsDocDiagnostics.empty())
{
// sourceFile->jsDocDiagnostics = attachFileToDiagnostics(jsDocDiagnostics, sourceFile);
copy(sourceFile->jsDocDiagnostics, attachFileToDiagnostics(jsDocDiagnostics, sourceFile));
}
if (setParentNodes)
{
fixupParentReferences(sourceFile);
}
return sourceFile;
}
template <typename T> auto withJSDoc(T node, boolean hasJSDoc) -> T
{
return hasJSDoc ? addJSDocComment(node) : node;
}
boolean hasDeprecatedTag = false;
template <typename T> auto addJSDocComment(T node) -> T
{
// TODO:
// Debug::_assert(!node.as<JSDocContainer>()->jsDoc); // Should only be called once per node
/*
auto jsDoc = mapDefined(getJSDocCommentRanges(node, sourceText), [&] (auto comment) { return
JSDocParser::parseJSDocComment(node, comment->pos, comment->_end - comment->pos); }); if (jsDoc.size())
node->jsDoc = jsDoc; if (hasDeprecatedTag) { hasDeprecatedTag = false; node->flags |= NodeFlags::Deprecated;
}
*/
return node;
}
auto reparseTopLevelAwait(SourceFile sourceFile) -> SourceFile
{
auto savedSyntaxCursor = syntaxCursor;
auto baseSyntaxCursor = IncrementalParser::createSyntaxCursor(sourceFile);
auto containsPossibleTopLevelAwait = [](Node node) {
return !(node->flags & NodeFlags::AwaitContext) &&
!!(node->transformFlags & TransformFlags::ContainsPossibleTopLevelAwait);
};
auto findNextStatementWithAwait = [&](NodeArray<Statement> statements, number start) {
for (auto i = start; i < statements.size(); i++)
{
if (containsPossibleTopLevelAwait(statements[i]))
{
return i;
}
}
return -1;
};
auto findNextStatementWithoutAwait = [&](NodeArray<Statement> statements, number start) {
for (auto i = start; i < statements.size(); i++)
{
if (!containsPossibleTopLevelAwait(statements[i]))
{
return i;
}
}
return -1;
};
auto currentNode = [&](number position) {
auto node = baseSyntaxCursor.currentNode(position);
if (topLevel && node && containsPossibleTopLevelAwait(node))
{
node.intersectsChange = true;
}
return node;
};
syntaxCursor = IncrementalParser::SyntaxCursor{currentNode};
NodeArray<Statement> statements;
auto savedParseDiagnostics = parseDiagnostics;
parseDiagnostics.clear();
auto pos = 0;
auto start = findNextStatementWithAwait(sourceFile->statements, 0);
while (start != -1)
{
// append all statements between pos and start
auto prevStatement = sourceFile->statements[pos];
auto nextStatement = sourceFile->statements[start];
addRange(statements, sourceFile->statements, pos, start);
pos = findNextStatementWithoutAwait(sourceFile->statements, start);
// append all diagnostics associated with the copied range
auto diagnosticStart = findIndex(savedParseDiagnostics, [&](auto diagnostic, number index) {
return diagnostic->start >= prevStatement->pos;
});
auto diagnosticEnd =
diagnosticStart >= 0
? findIndex(
savedParseDiagnostics,
[&](auto diagnostic, number index) { return diagnostic->start >= nextStatement->pos; },
diagnosticStart)
: -1;
if (diagnosticStart >= 0)
{
addRange(parseDiagnostics, savedParseDiagnostics, diagnosticStart,
diagnosticEnd >= 0 ? diagnosticEnd : -1);
}
// reparse all statements between start and pos. We skip existing diagnostics for the same range and allow
// the parser to generate new ones.
speculationHelper<boolean>(
[&]() {
auto savedContextFlags = contextFlags;
contextFlags |= NodeFlags::AwaitContext;
scanner.setTextPos(nextStatement->pos);
nextToken();
while (token() != SyntaxKind::EndOfFileToken)
{
auto startPos = scanner.getStartPos();
auto statement = parseListElement<Statement>(ParsingContext::SourceElements,
std::bind(&Parser::parseStatement, this));
statements.push_back(statement);
if (startPos == scanner.getStartPos())
{
nextToken();
}
if (pos >= 0)
{
auto nonAwaitStatement = sourceFile->statements[pos];
if (statement->_end == nonAwaitStatement->pos)
{
// done reparsing this section
break;
}
if (statement->_end > nonAwaitStatement->pos)
{
// we ate into the next statement, so we must reparse it.
pos = findNextStatementWithoutAwait(sourceFile->statements, pos + 1);
}
}
}
contextFlags = savedContextFlags;
return true;
},
SpeculationKind::Reparse);
// find the next statement containing an `await`
start = pos >= 0 ? findNextStatementWithAwait(sourceFile->statements, pos) : -1;
}
// append all statements between pos and the end of the list
if (pos >= 0)
{
auto prevStatement = sourceFile->statements[pos];
addRange(statements, sourceFile->statements, pos);
// append all diagnostics associated with the copied range
auto diagnosticStart = findIndex(savedParseDiagnostics, [&](auto diagnostic, number index) {
return diagnostic->start >= prevStatement->pos;
});
if (diagnosticStart >= 0)
{
addRange(parseDiagnostics, savedParseDiagnostics, diagnosticStart);
}
}
syntaxCursor = savedSyntaxCursor;
return factory.updateSourceFile(
sourceFile, setTextRange(factory.createNodeArray(statements), (data::TextRange)sourceFile->statements));
}
auto createSourceFile(string fileName, ScriptTarget languageVersion, ScriptKind scriptKind,
boolean isDeclarationFile, NodeArray<Statement> statements, Node endOfFileToken,
NodeFlags flags) -> SourceFile
{
// code from createNode is inlined here so createNode won't have to deal with special case of creating source
// files this is quite rare comparing to other nodes and createNode should be.as<fast>().as<possible>()
auto sourceFile = factory.createSourceFile(statements, endOfFileToken, flags);
setTextRangePosWidth(sourceFile, 0, sourceText.size());
setExternalModuleIndicator(sourceFile);
// If we parsed this.as<an>() external module, it may contain top-level await
if (!isDeclarationFile && isExternalModule(sourceFile) &&
!!(sourceFile->transformFlags & TransformFlags::ContainsPossibleTopLevelAwait))
{
sourceFile = reparseTopLevelAwait(sourceFile);
}
sourceFile->text = sourceText;
sourceFile->bindDiagnostics.clear();
sourceFile->bindSuggestionDiagnostics.clear();
sourceFile->languageVersion = languageVersion;
sourceFile->fileName = fileName;
sourceFile->languageVariant = getLanguageVariant(scriptKind);
sourceFile->isDeclarationFile = isDeclarationFile;
sourceFile->scriptKind = scriptKind;
return sourceFile;
}
auto setContextFlag(boolean val, NodeFlags flag)
{
if (val)
{
contextFlags |= flag;
}
else
{
contextFlags &= ~flag;
}
}
auto setDisallowInContext(boolean val)
{
setContextFlag(val, NodeFlags::DisallowInContext);
}
auto setYieldContext(boolean val)
{
setContextFlag(val, NodeFlags::YieldContext);
}
auto setDecoratorContext(boolean val)
{
setContextFlag(val, NodeFlags::DecoratorContext);
}
auto setAwaitContext(boolean val)
{
setContextFlag(val, NodeFlags::AwaitContext);
}
template <typename T> auto doOutsideOfContext(NodeFlags context, std::function<T()> func) -> T
{
// contextFlagsToClear will contain only the context flags that are
// currently set that we need to temporarily clear
// We don't just blindly reset to the previous flags to ensure
// that we do not mutate cached flags for the incremental
// parser (ThisNodeHasError, ThisNodeOrAnySubNodesHasError, and
// HasAggregatedChildData).
auto contextFlagsToClear = context & contextFlags;
if (!!contextFlagsToClear)
{
// clear the requested context flags
setContextFlag(/*val*/ false, contextFlagsToClear);
auto result = func();
// restore the context flags we just cleared
setContextFlag(/*val*/ true, contextFlagsToClear);
return result;
}
// no need to do anything special.as<we>() are not in any of the requested contexts
return func();
}
template <typename T> auto doInsideOfContext(NodeFlags context, std::function<T()> func) -> T
{
// contextFlagsToSet will contain only the context flags that
// are not currently set that we need to temporarily enable.
// We don't just blindly reset to the previous flags to ensure
// that we do not mutate cached flags for the incremental
// parser (ThisNodeHasError, ThisNodeOrAnySubNodesHasError, and
// HasAggregatedChildData).
auto contextFlagsToSet = context & ~contextFlags;
if (!!contextFlagsToSet)
{
// set the requested context flags
setContextFlag(/*val*/ true, contextFlagsToSet);
auto result = func();
// reset the context flags we just set
setContextFlag(/*val*/ false, contextFlagsToSet);
return result;
}
// no need to do anything special.as<we>() are already in all of the requested contexts
return func();
}
template <typename T> auto allowInAnd(std::function<T()> func) -> T
{
return doOutsideOfContext(NodeFlags::DisallowInContext, func);
}
template <typename T> auto disallowInAnd(std::function<T()> func) -> T
{
return doInsideOfContext(NodeFlags::DisallowInContext, func);
}
template <typename T> auto doInYieldContext(std::function<T()> func) -> T
{
return doInsideOfContext(NodeFlags::YieldContext, func);
}
template <typename T> auto doInDecoratorContext(std::function<T()> func) -> T
{
return doInsideOfContext(NodeFlags::DecoratorContext, func);
}
template <typename T> auto doInAwaitContext(std::function<T()> func) -> T
{
return doInsideOfContext(NodeFlags::AwaitContext, func);
}
template <typename T> auto doOutsideOfAwaitContext(std::function<T()> func) -> T
{
return doOutsideOfContext(NodeFlags::AwaitContext, func);
}
template <typename T> auto doInYieldAndAwaitContext(std::function<T()> func) -> T
{
return doInsideOfContext(NodeFlags::YieldContext | NodeFlags::AwaitContext, func);
}
template <typename T> auto doOutsideOfYieldAndAwaitContext(std::function<T()> func) -> T
{
return doOutsideOfContext(NodeFlags::YieldContext | NodeFlags::AwaitContext, func);
}
auto inContext(NodeFlags flags)
{
return (contextFlags & flags) != NodeFlags::None;
}
auto inYieldContext()
{
return inContext(NodeFlags::YieldContext);
}
auto inDisallowInContext()
{
return inContext(NodeFlags::DisallowInContext);
}
auto inDecoratorContext()
{
return inContext(NodeFlags::DecoratorContext);
}
auto inAwaitContext()
{
return inContext(NodeFlags::AwaitContext);
}
auto parseErrorAtCurrentToken(DiagnosticMessage message, string arg0 = string()) -> void
{
parseErrorAt(scanner.getTokenPos(), scanner.getTextPos(), message, arg0);
}
auto parseErrorAtPosition(number start, number length, DiagnosticMessage message, string arg0 = string()) -> void
{
// Don't report another error if it would just be at the same position.as<the>() last error.
auto lastError = lastOrUndefined(parseDiagnostics);
if (!lastError || start != lastError->start)
{
parseDiagnostics.push_back(createDetachedDiagnostic(fileName, start, length, message, arg0));
}
// Mark that we've encountered an error. We'll set an appropriate bit on the next
// node we finish so that it can't be reused incrementally.
parseErrorBeforeNextFinishedNode = true;
}
auto parseErrorAt(number start, number end, DiagnosticMessage message) -> void
{
parseErrorAtPosition(start, end - start, message);
}
auto parseErrorAtRange(TextRange range, DiagnosticMessage message) -> void
{
parseErrorAt(range->pos, range->_end, message);
}
template <typename T> auto parseErrorAt(number start, number end, DiagnosticMessage message, T arg0) -> void
{
parseErrorAtPosition(start, end - start, message, arg0);
}
template <typename T> auto parseErrorAtRange(TextRange range, DiagnosticMessage message, T arg0) -> void
{
parseErrorAt(range->pos, range->_end, message, arg0);
}
auto scanError(DiagnosticMessage message, number length) -> void
{
parseErrorAtPosition(scanner.getTextPos(), length, message);
}
auto getNodePos() -> pos_type
{
return {scanner.getStartPos(), scanner.getTokenPos()};
}
auto hasPrecedingJSDocComment()
{
return scanner.hasPrecedingJSDocComment();
}
// Use this auto to access the current token instead of reading the currentToken
// variable. Since auto results aren't narrowed in control flow analysis, this ensures
// that the type checker doesn't make wrong assumptions about the type of the current
// token (e.g. a call to nextToken() changes the current token but the checker doesn't
// reason about this side effect). Mainstream VMs inline simple functions like this, so
// there is no performance penalty.
auto token() -> SyntaxKind
{
return currentToken;
}
auto nextTokenWithoutCheck()
{
return currentToken = scanner.scan();
}
template <typename T> auto nextTokenAnd(std::function<T()> func) -> T
{
nextToken();
return func();
}
auto nextToken() -> SyntaxKind
{
// if the keyword had an escape
if (isKeyword(currentToken) && (scanner.hasUnicodeEscape() || scanner.hasExtendedUnicodeEscape()))
{
// issue a parse error for the escape
parseErrorAt(scanner.getTokenPos(), scanner.getTextPos(),
data::DiagnosticMessage(Diagnostics::Keywords_cannot_contain_escape_characters));
}
return nextTokenWithoutCheck();
}
auto nextTokenJSDoc() -> SyntaxKind
{
return currentToken = scanner.scanJsDocToken();
}
auto reScanGreaterToken() -> SyntaxKind
{
return currentToken = scanner.reScanGreaterToken();
}
auto reScanSlashToken() -> SyntaxKind
{
return currentToken = scanner.reScanSlashToken();
}
auto reScanTemplateToken(boolean isTaggedTemplate) -> SyntaxKind
{
return currentToken = scanner.reScanTemplateToken(isTaggedTemplate);
}
auto reScanTemplateHeadOrNoSubstitutionTemplate() -> SyntaxKind
{
return currentToken = scanner.reScanTemplateHeadOrNoSubstitutionTemplate();
}
auto reScanLessThanToken() -> SyntaxKind
{
return currentToken = scanner.reScanLessThanToken();
}
auto scanJsxIdentifier() -> SyntaxKind
{
return currentToken = scanner.scanJsxIdentifier();
}
auto scanJsxText() -> SyntaxKind
{
return currentToken = scanner.scanJsxToken();
}
auto scanJsxAttributeValue() -> SyntaxKind
{
return currentToken = scanner.scanJsxAttributeValue();
}
template <typename T> auto speculationHelper(std::function<T()> callback, SpeculationKind speculationKind) -> T
{
// Keep track of the state we'll need to rollback to if lookahead fails (or if the
// caller asked us to always reset our state).
auto saveToken = currentToken;
// TODO: do we need it?
// auto saveParseDiagnosticsLength = parseDiagnostics.size();
auto saveParseErrorBeforeNextFinishedNode = parseErrorBeforeNextFinishedNode;
// it Note is not actually necessary to save/restore the context flags here. That's
// because the saving/restoring of these flags happens naturally through the recursive
// descent nature of our Parser:: However, we still store this here just so we can
// assert that invariant holds.
auto saveContextFlags = contextFlags;
// If we're only looking ahead, then tell the scanner to only lookahead.as<well>().
// Otherwise, if we're actually speculatively parsing, then tell the scanner to do the
// same.
auto result = speculationKind != SpeculationKind::TryParse ? scanner.lookAhead<T>(callback)
: scanner.tryScan<T>(callback);
Debug::_assert(saveContextFlags == contextFlags);
// If our callback returned something 'falsy' or we're just looking ahead,
// then unconditionally restore us to where we were.
if (!result || speculationKind != SpeculationKind::TryParse)
{
currentToken = saveToken;
if (speculationKind != SpeculationKind::Reparse)
{
// TODO: do we need it?
// parseDiagnostics.size() = saveParseDiagnosticsLength;
}
parseErrorBeforeNextFinishedNode = saveParseErrorBeforeNextFinishedNode;
}
return result;
}
/** Invokes the provided callback then unconditionally restores the parser to the state it
* was in immediately prior to invoking the callback. The result of invoking the callback
* is returned from this function.
*/
template <typename T> auto lookAhead(std::function<T()> callback) -> T
{
return speculationHelper<T>(callback, SpeculationKind::Lookahead);
}
/** Invokes the provided callback. If the callback returns something falsy, then it restores
* the parser to the state it was in immediately prior to invoking the callback. If the
* callback returns something truthy, then the parser state is not rolled back. The result
* of invoking the callback is returned from this function.
*/
template <typename T> auto tryParse(std::function<T()> callback) -> T
{
return speculationHelper<T>(callback, SpeculationKind::TryParse);
}
auto isBindingIdentifier() -> boolean
{
if (token() == SyntaxKind::Identifier)
{
return true;
}
return token() > SyntaxKind::LastReservedWord;
}
// Ignore strict mode flag because we will report an error in type checker instead.
auto isIdentifier() -> boolean
{
if (token() == SyntaxKind::Identifier)
{
return true;
}
// If we have a 'yield' keyword, and we're in the [yield] context, then 'yield' is
// considered a keyword and is not an identifier.
if (token() == SyntaxKind::YieldKeyword && inYieldContext())
{
return false;
}
// If we have a 'await' keyword, and we're in the [Await] context, then 'await' is
// considered a keyword and is not an identifier.
if (token() == SyntaxKind::AwaitKeyword && inAwaitContext())
{
return false;
}
return token() > SyntaxKind::LastReservedWord;
}
auto parseExpected(SyntaxKind kind, DiagnosticMessage diagnosticMessage = undefined, boolean shouldAdvance = true)
-> boolean
{
if (token() == kind)
{
if (shouldAdvance)
{
nextToken();
}
return true;
}
// Report specific message if provided with one. Otherwise, report generic fallback message.
if (!!diagnosticMessage)
{
parseErrorAtCurrentToken(diagnosticMessage);
}
else
{
parseErrorAtCurrentToken(data::DiagnosticMessage(Diagnostics::_0_expected), scanner.tokenToString(kind));
}
return false;
}
auto parseExpectedJSDoc(SyntaxKind kind)
{
if (token() == kind)
{
nextTokenJSDoc();
return true;
}
parseErrorAtCurrentToken(data::DiagnosticMessage(Diagnostics::_0_expected), scanner.tokenToString(kind));
return false;
}
auto parseOptional(SyntaxKind t) -> boolean
{
if (token() == t)
{
nextToken();
return true;
}
return false;
}
auto parseOptionalToken(SyntaxKind t) -> Node
{
if (token() == t)
{
return parseTokenNode<Node>();
}
return undefined;
}
auto parseOptionalTokenJSDoc(SyntaxKind t) -> Node
{
if (token() == t)
{
return parseTokenNodeJSDoc();
}
return undefined;
}
auto parseExpectedToken(SyntaxKind t, DiagnosticMessage diagnosticMessage = undefined, string arg0 = string())
-> Node
{
return parseOptionalToken(t) ||
[&]() { return createMissingNode(t, /*reportAtCurrentPosition*/ false, diagnosticMessage, arg0); };
}
auto parseExpectedTokenJSDoc(SyntaxKind t) -> Node
{
return parseOptionalTokenJSDoc(t) || [&]() {
return createMissingNode(t, /*reportAtCurrentPosition*/ false,
data::DiagnosticMessage(Diagnostics::_0_expected), scanner.tokenToString(t));
};
}
template <typename T> auto parseTokenNode() -> Node
{
auto pos = getNodePos();
auto kind = token();
nextToken();
return finishNode(factory.createToken<T>(kind), pos);
}
auto parseTokenNodeJSDoc() -> Node
{
auto pos = getNodePos();
auto kind = token();
nextTokenJSDoc();
return finishNode(factory.createToken<Node>(kind), pos);
}
auto canParseSemicolon()
{
// If there's a real semicolon, then we can always parse it out.
if (token() == SyntaxKind::SemicolonToken)
{
return true;
}
// We can parse out an optional semicolon in ASI cases in the following cases.
return token() == SyntaxKind::CloseBraceToken || token() == SyntaxKind::EndOfFileToken ||
scanner.hasPrecedingLineBreak();
}
auto parseSemicolon() -> boolean
{
if (canParseSemicolon())
{
if (token() == SyntaxKind::SemicolonToken)
{
// consume the semicolon if it was explicitly provided.
nextToken();
}
return true;
}
else
{
return parseExpected(SyntaxKind::SemicolonToken);
}
}
auto createNodeArray(NodeArray<Node> elements, pos_type pos, number end = -1, boolean hasTrailingComma = false)
-> NodeArray<Node>
{
auto array = factory.createNodeArray(elements, hasTrailingComma);
setTextRangePosEnd(array, pos, end != -1 ? end : scanner.getStartPos());
array->pos.textPos = pos.textPos;
return array;
}
template <typename T>
auto createNodeArray(NodeArray<T> elements, pos_type pos, number end = -1, boolean hasTrailingComma = false)
-> NodeArray<T>
{
auto array = factory.createNodeArray<T>(elements, hasTrailingComma);
setTextRangePosEnd(array, pos, end != -1 ? end : scanner.getStartPos());
array->pos.textPos = pos.textPos;
return array;
}
// TODO: use template instead of Node method to avoid casts
auto finishNode(Node node, pos_type pos, number end = -1) -> Node
{
setTextRangePosEnd(node, pos, end != -1 ? end : scanner.getStartPos());
node->pos.textPos = pos.textPos;
if (!!contextFlags)
{
node->flags |= contextFlags;
}
// Keep track on the node if we encountered an error while parsing it. If we did, then
// we cannot reuse the node incrementally. Once we've marked this node, clear out the
// flag so that we don't mark any subsequent nodes.
if (parseErrorBeforeNextFinishedNode)
{
parseErrorBeforeNextFinishedNode = false;
node->flags |= NodeFlags::ThisNodeHasError;
}
return node;
}
template <typename T = Node>
auto createMissingNode(SyntaxKind kind, boolean reportAtCurrentPosition,
DiagnosticMessage diagnosticMessage = undefined, string arg0 = string()) -> Node
{
if (reportAtCurrentPosition)
{
parseErrorAtPosition(scanner.getStartPos(), 0, diagnosticMessage, arg0);
}
else if (!!diagnosticMessage)
{
parseErrorAtCurrentToken(diagnosticMessage, arg0);
}
auto pos = getNodePos();
auto result =
kind == SyntaxKind::Identifier ? factory.createIdentifier(string()).as<Node>()
: isTemplateLiteralKind(kind)
? factory.createTemplateLiteralLikeNode(kind, string(), string(), /*templateFlags*/ TokenFlags::None)
.as<Node>()
: kind == SyntaxKind::NumericLiteral
? factory.createNumericLiteral(string(), /*numericLiteralFlags*/ TokenFlags::None).as<Node>()
: kind == SyntaxKind::StringLiteral
? factory.createStringLiteral(string(), /*isSingleQuote*/ false).as<Node>()
: kind == SyntaxKind::MissingDeclaration ? factory.createMissingDeclaration().as<Node>()
: factory.createToken<T>(kind).template as<Node>();
return finishNode(result, pos);
}
auto internIdentifier(string text) -> string
{
identifiers[text] = text;
return identifiers.at(text);
}
// An identifier that starts with two underscores has an extra underscore character prepended to it to avoid issues
// with magic property names like '__proto__'. The 'identifiers' object is used to share a single string instance
// for each identifier in order to reduce memory consumption.
auto createIdentifier(boolean isIdentifier, DiagnosticMessage diagnosticMessage = undefined,
DiagnosticMessage privateIdentifierDiagnosticMessage = undefined) -> Identifier
{
if (isIdentifier)
{
identifierCount++;
auto pos = getNodePos();
// Store original token kind if it is not just an Identifier so we can report appropriate error later in
// type checker
auto originalKeywordKind = token();
auto text = internIdentifier(scanner.getTokenValue());
nextTokenWithoutCheck();
return finishNode(factory.createIdentifier(text, /*typeArguments*/ undefined, originalKeywordKind), pos);
}
if (token() == SyntaxKind::PrivateIdentifier)
{
parseErrorAtCurrentToken(!!privateIdentifierDiagnosticMessage
? privateIdentifierDiagnosticMessage
: ts::DiagnosticMessage(data::DiagnosticMessage(
Diagnostics::Private_identifiers_are_not_allowed_outside_class_bodies)));
return createIdentifier(/*isIdentifier*/ true);
}
if (token() == SyntaxKind::Unknown &&
scanner.tryScan<boolean>([&]() { return scanner.reScanInvalidIdentifier() == SyntaxKind::Identifier; }))
{
// Scanner has already recorded an 'Invalid character' error, so no need to add another from the Parser::
return createIdentifier(/*isIdentifier*/ true);
}
identifierCount++;
// Only for end of file because the error gets reported incorrectly on embedded script tags.
auto reportAtCurrentPosition = token() == SyntaxKind::EndOfFileToken;
auto isReservedWord = scanner.isReservedWord();
auto msgArg = scanner.getTokenText();
auto defaultMessage = isReservedWord
? data::DiagnosticMessage(
Diagnostics::Identifier_expected_0_is_a_reserved_word_that_cannot_be_used_here)
: data::DiagnosticMessage(Diagnostics::Identifier_expected);
return createMissingNode<Identifier>(
SyntaxKind::Identifier, reportAtCurrentPosition,
!!diagnosticMessage ? diagnosticMessage : ts::DiagnosticMessage(defaultMessage), msgArg);
}
auto parseBindingIdentifier(DiagnosticMessage privateIdentifierDiagnosticMessage = undefined)
{
return createIdentifier(isBindingIdentifier(), /*diagnosticMessage*/ undefined,
privateIdentifierDiagnosticMessage);
}
auto parseIdentifier(DiagnosticMessage diagnosticMessage = undefined,
DiagnosticMessage privateIdentifierDiagnosticMessage = undefined) -> Identifier
{
return createIdentifier(isIdentifier(), diagnosticMessage, privateIdentifierDiagnosticMessage);
}
auto parseIdentifierName(DiagnosticMessage diagnosticMessage = undefined) -> Identifier
{
return createIdentifier(scanner.tokenIsIdentifierOrKeyword(token()), diagnosticMessage);
}
auto isLiteralPropertyName() -> boolean
{
return scanner.tokenIsIdentifierOrKeyword(token()) || token() == SyntaxKind::StringLiteral ||
token() == SyntaxKind::NumericLiteral;
}
auto parsePropertyNameWorker(boolean allowComputedPropertyNames) -> Node
{
if (token() == SyntaxKind::StringLiteral || token() == SyntaxKind::NumericLiteral)
{
auto node = parseLiteralNode();
node->text = internIdentifier(node->text);
return node;
}
if (allowComputedPropertyNames && token() == SyntaxKind::OpenBracketToken)
{
return parseComputedPropertyName();
}
if (token() == SyntaxKind::PrivateIdentifier)
{
return parsePrivateIdentifier();
}
return parseIdentifierName();
}
auto parsePropertyName() -> Node
{
return parsePropertyNameWorker(/*allowComputedPropertyNames*/ true);
}
auto parseComputedPropertyName() -> Node
{
// PropertyName [Yield]:
// LiteralPropertyName
// ComputedPropertyName[?Yield]
auto pos = getNodePos();
parseExpected(SyntaxKind::OpenBracketToken);
// We parse any expression (including a comma expression). But the grammar
// says that only an assignment expression is allowed, so the grammar checker
// will error if it sees a comma expression.
auto expression = allowInAnd<Expression>(std::bind(&Parser::parseExpression, this));
parseExpected(SyntaxKind::CloseBracketToken);
return finishNode(factory.createComputedPropertyName(expression), pos);
}
auto internPrivateIdentifier(string text) -> string
{
privateIdentifiers[text] = text;
return privateIdentifiers.at(text);
}
auto parsePrivateIdentifier() -> Node
{
auto pos = getNodePos();
auto node = factory.createPrivateIdentifier(internPrivateIdentifier(scanner.getTokenText()));
nextToken();
return finishNode(node, pos);
}
auto parseContextualModifier(SyntaxKind t) -> boolean
{
return token() == t && tryParse<boolean>(std::bind(&Parser::nextTokenCanFollowModifier, this));
}
auto nextTokenIsOnSameLineAndCanFollowModifier()
{
nextToken();
if (scanner.hasPrecedingLineBreak())
{
return false;
}
return canFollowModifier();
}
auto nextTokenCanFollowModifier() -> boolean
{
switch (token())
{
case SyntaxKind::ConstKeyword:
// 'const' is only a modifier if followed by 'enum'.
return nextToken() == SyntaxKind::EnumKeyword;
case SyntaxKind::ExportKeyword:
nextToken();
if (token() == SyntaxKind::DefaultKeyword)
{
return lookAhead<boolean>(std::bind(&Parser::nextTokenCanFollowDefaultKeyword, this));
}
if (token() == SyntaxKind::TypeKeyword)
{
return lookAhead<boolean>(std::bind(&Parser::nextTokenCanFollowExportModifier, this));
}
return canFollowExportModifier();
case SyntaxKind::DefaultKeyword:
return nextTokenCanFollowDefaultKeyword();
case SyntaxKind::StaticKeyword:
return nextTokenIsOnSameLineAndCanFollowModifier();
case SyntaxKind::GetKeyword:
case SyntaxKind::SetKeyword:
nextToken();
return canFollowModifier();
default:
return nextTokenIsOnSameLineAndCanFollowModifier();
}
}
auto canFollowExportModifier() -> boolean
{
return token() != SyntaxKind::AsteriskToken && token() != SyntaxKind::AsKeyword &&
token() != SyntaxKind::OpenBraceToken && canFollowModifier();
}
auto nextTokenCanFollowExportModifier() -> boolean
{
nextToken();
return canFollowExportModifier();
}
auto parseAnyContextualModifier() -> boolean
{
return isModifierKind(token()) && tryParse<boolean>(std::bind(&Parser::nextTokenCanFollowModifier, this));
}
auto canFollowModifier() -> boolean
{
return token() == SyntaxKind::OpenBracketToken || token() == SyntaxKind::OpenBraceToken ||
token() == SyntaxKind::AsteriskToken || token() == SyntaxKind::DotDotDotToken || isLiteralPropertyName();
}
auto nextTokenCanFollowDefaultKeyword() -> boolean
{
nextToken();
return token() == SyntaxKind::ClassKeyword || token() == SyntaxKind::FunctionKeyword ||
token() == SyntaxKind::InterfaceKeyword ||
(token() == SyntaxKind::AbstractKeyword &&
lookAhead<boolean>(std::bind(&Parser::nextTokenIsClassKeywordOnSameLine, this))) ||
(token() == SyntaxKind::AsyncKeyword &&
lookAhead<boolean>(std::bind(&Parser::nextTokenIsFunctionKeywordOnSameLine, this)));
}
// True if positioned at the start of a list element
auto isListElement(ParsingContext parsingContext, boolean inErrorRecovery) -> boolean
{
auto node = currentNode(parsingContext);
if (node)
{
return true;
}
switch (parsingContext)
{
case ParsingContext::SourceElements:
case ParsingContext::BlockStatements:
case ParsingContext::SwitchClauseStatements:
// If we're in error recovery, then we don't want to treat ';'.as<an>() empty statement.
// The problem is that ';' can show up in far too many contexts, and if we see one
// and assume it's a statement, then we may bail out inappropriately from whatever
// we're parsing. For example, if we have a semicolon in the middle of a class, then
// we really don't want to assume the class is over and we're on a statement in the
// outer module. We just want to consume and move on.
return !(token() == SyntaxKind::SemicolonToken && inErrorRecovery) && isStartOfStatement();
case ParsingContext::SwitchClauses:
return token() == SyntaxKind::CaseKeyword || token() == SyntaxKind::DefaultKeyword;
case ParsingContext::TypeMembers:
return lookAhead<boolean>(std::bind(&Parser::isTypeMemberStart, this));
case ParsingContext::ClassMembers:
// We allow semicolons.as<class>() elements (as specified by ES6).as<long>().as<we>()'re
// not in error recovery. If we're in error recovery, we don't want an errant
// semicolon to be treated.as<a>() class member (since they're almost always used
// for statements.
return lookAhead<boolean>(std::bind(&Parser::isClassMemberStart, this)) ||
(token() == SyntaxKind::SemicolonToken && !inErrorRecovery);
case ParsingContext::EnumMembers:
// Include open bracket computed properties. This technically also lets in indexers,
// which would be a candidate for improved error reporting.
return token() == SyntaxKind::OpenBracketToken || isLiteralPropertyName();
case ParsingContext::ObjectLiteralMembers:
switch (token())
{
case SyntaxKind::OpenBracketToken:
case SyntaxKind::AsteriskToken:
case SyntaxKind::DotDotDotToken:
case SyntaxKind::DotToken: // Not an object literal member, but don't want to close the object (see
// `tests/cases/fourslash/completionsDotInObjectLiteral.ts`)
return true;
default:
return isLiteralPropertyName();
}
case ParsingContext::RestProperties:
return isLiteralPropertyName();
case ParsingContext::ObjectBindingElements:
return token() == SyntaxKind::OpenBracketToken || token() == SyntaxKind::DotDotDotToken ||
isLiteralPropertyName();
case ParsingContext::HeritageClauseElement:
// If we see `{ ... }` then only consume it.as<an>() expression if it is followed by `,` or `{`
// That way we won't consume the body of a class in its heritage clause.
if (token() == SyntaxKind::OpenBraceToken)
{
return lookAhead<boolean>(std::bind(&Parser::isValidHeritageClauseObjectLiteral, this));
}
if (!inErrorRecovery)
{
return isStartOfLeftHandSideExpression() && !isHeritageClauseExtendsOrImplementsKeyword();
}
else
{
// If we're in error recovery we tighten up what we're willing to match.
// That way we don't treat something like "this".as<a>() valid heritage clause
// element during recovery.
return isIdentifier() && !isHeritageClauseExtendsOrImplementsKeyword();
}
case ParsingContext::VariableDeclarations:
return isBindingIdentifierOrPrivateIdentifierOrPattern();
case ParsingContext::ArrayBindingElements:
return token() == SyntaxKind::CommaToken || token() == SyntaxKind::DotDotDotToken ||
isBindingIdentifierOrPrivateIdentifierOrPattern();
case ParsingContext::TypeParameters:
return isIdentifier();
case ParsingContext::ArrayLiteralMembers:
switch (token())
{
case SyntaxKind::CommaToken:
case SyntaxKind::DotToken: // Not an array literal member, but don't want to close the array (see
// `tests/cases/fourslash/completionsDotInArrayLiteralInObjectLiteral.ts`)
return true;
}
// falls through
case ParsingContext::ArgumentExpressions:
return token() == SyntaxKind::DotDotDotToken || isStartOfExpression();
case ParsingContext::Parameters:
return isStartOfParameter(/*isJSDocParameter*/ false);
case ParsingContext::JSDocParameters:
return isStartOfParameter(/*isJSDocParameter*/ true);
case ParsingContext::TypeArguments:
case ParsingContext::TupleElementTypes:
return token() == SyntaxKind::CommaToken || isStartOfType();
case ParsingContext::HeritageClauses:
return isHeritageClause();
case ParsingContext::ImportOrExportSpecifiers:
return scanner.tokenIsIdentifierOrKeyword(token());
case ParsingContext::JsxAttributes:
return scanner.tokenIsIdentifierOrKeyword(token()) || token() == SyntaxKind::OpenBraceToken;
case ParsingContext::JsxChildren:
return true;
}
return Debug::fail<boolean>(S("Non-exhaustive case in 'isListElement'."));
}
auto isValidHeritageClauseObjectLiteral() -> boolean
{
Debug::_assert(token() == SyntaxKind::OpenBraceToken);
if (nextToken() == SyntaxKind::CloseBraceToken)
{
// if we see "extends {}" then only treat the {}.as<what>() we're extending (and not
// the class body) if we have:
//
// extends {} {
// extends {},
// extends {} extends
// extends {} implements
auto next = nextToken();
return next == SyntaxKind::CommaToken || next == SyntaxKind::OpenBraceToken ||
next == SyntaxKind::ExtendsKeyword || next == SyntaxKind::ImplementsKeyword;
}
return true;
}
auto nextTokenIsIdentifier() -> boolean
{
nextToken();
return isIdentifier();
}
auto nextTokenIsIdentifierOrKeyword() -> boolean
{
nextToken();
return scanner.tokenIsIdentifierOrKeyword(token());
}
auto nextTokenIsIdentifierOrKeywordOrGreaterThan() -> boolean
{
nextToken();
return scanner.tokenIsIdentifierOrKeywordOrGreaterThan(token());
}
auto isHeritageClauseExtendsOrImplementsKeyword() -> boolean
{
if (token() == SyntaxKind::ImplementsKeyword || token() == SyntaxKind::ExtendsKeyword)
{
return lookAhead<boolean>(std::bind(&Parser::nextTokenIsStartOfExpression, this));
}
return false;
}
auto nextTokenIsStartOfExpression() -> boolean
{
nextToken();
return isStartOfExpression();
}
auto nextTokenIsStartOfType() -> boolean
{
nextToken();
return isStartOfType();
}
// True if positioned at a list terminator
auto isListTerminator(ParsingContext kind) -> boolean
{
if (token() == SyntaxKind::EndOfFileToken)
{
// Being at the end of the file ends all lists.
return true;
}
switch (kind)
{
case ParsingContext::BlockStatements:
case ParsingContext::SwitchClauses:
case ParsingContext::TypeMembers:
case ParsingContext::ClassMembers:
case ParsingContext::EnumMembers:
case ParsingContext::ObjectLiteralMembers:
case ParsingContext::ObjectBindingElements:
case ParsingContext::ImportOrExportSpecifiers:
return token() == SyntaxKind::CloseBraceToken;
case ParsingContext::SwitchClauseStatements:
return token() == SyntaxKind::CloseBraceToken || token() == SyntaxKind::CaseKeyword ||
token() == SyntaxKind::DefaultKeyword;
case ParsingContext::HeritageClauseElement:
return token() == SyntaxKind::OpenBraceToken || token() == SyntaxKind::ExtendsKeyword ||
token() == SyntaxKind::ImplementsKeyword;
case ParsingContext::VariableDeclarations:
return isVariableDeclaratorListTerminator();
case ParsingContext::TypeParameters:
// Tokens other than '>' are here for better error recovery
return token() == SyntaxKind::GreaterThanToken || token() == SyntaxKind::OpenParenToken ||
token() == SyntaxKind::OpenBraceToken || token() == SyntaxKind::ExtendsKeyword ||
token() == SyntaxKind::ImplementsKeyword;
case ParsingContext::ArgumentExpressions:
// Tokens other than ')' are here for better error recovery
return token() == SyntaxKind::CloseParenToken || token() == SyntaxKind::SemicolonToken;
case ParsingContext::ArrayLiteralMembers:
case ParsingContext::TupleElementTypes:
case ParsingContext::ArrayBindingElements:
return token() == SyntaxKind::CloseBracketToken;
case ParsingContext::JSDocParameters:
case ParsingContext::Parameters:
case ParsingContext::RestProperties:
// Tokens other than ')' and ']' (the latter for index signatures) are here for better error recovery
return token() == SyntaxKind::CloseParenToken ||
token() == SyntaxKind::CloseBracketToken /*|| token == SyntaxKind::OpenBraceToken*/;
case ParsingContext::TypeArguments:
// All other tokens should cause the type-argument to terminate except comma token
return token() != SyntaxKind::CommaToken;
case ParsingContext::HeritageClauses:
return token() == SyntaxKind::OpenBraceToken || token() == SyntaxKind::CloseBraceToken;
case ParsingContext::JsxAttributes:
return token() == SyntaxKind::GreaterThanToken || token() == SyntaxKind::SlashToken;
case ParsingContext::JsxChildren:
return token() == SyntaxKind::LessThanToken &&
lookAhead<boolean>(std::bind(&Parser::nextTokenIsSlash, this));
default:
return false;
}
}
auto isVariableDeclaratorListTerminator() -> boolean
{
// If we can consume a semicolon (either explicitly, or with ASI), then consider us done
// with parsing the list of variable declarators.
if (canParseSemicolon())
{
return true;
}
// in the case where we're parsing the variable declarator of a 'for-in' statement, we
// are done if we see an 'in' keyword in front of us. Same with for-of
if (isInOrOfKeyword(token()))
{
return true;
}
// ERROR RECOVERY TWEAK:
// For better error recovery, if we see an '=>' then we just stop immediately. We've got an
// arrow auto here and it's going to be very unlikely that we'll resynchronize and get
// another variable declaration.
if (token() == SyntaxKind::EqualsGreaterThanToken)
{
return true;
}
// Keep trying to parse out variable declarators.
return false;
}
// True if positioned at element or terminator of the current list or any enclosing list
auto isInSomeParsingContext() -> boolean
{
for (auto kind = (number)ParsingContext::Unknown; kind < (number)ParsingContext::Count; kind++)
{
if (!!(parsingContext & (ParsingContext)(1 << kind)))
{
if (isListElement((ParsingContext)kind, /*inErrorRecovery*/ true) ||
isListTerminator((ParsingContext)kind))
{
return true;
}
}
}
return false;
}
// Parses a list of elements
template <typename T> auto parseList(ParsingContext kind, std::function<T()> parseElement) -> NodeArray<T>
{
auto saveParsingContext = parsingContext;
parsingContext |= (ParsingContext)(1 << (number)kind);
NodeArray<T> list;
auto listPos = getNodePos();
while (!isListTerminator(kind))
{
if (isListElement(kind, /*inErrorRecovery*/ false))
{
auto element = parseListElement(kind, parseElement);
list.push_back(element);
continue;
}
if (abortParsingListOrMoveToNextToken(kind))
{
break;
}
}
parsingContext = saveParsingContext;
return createNodeArray(list, listPos);
}
template <typename T> auto parseListElement(ParsingContext parsingContext, std::function<T()> parseElement) -> T
{
auto node = currentNode(parsingContext);
if (node)
{
return consumeNode(node).as<T>();
}
return parseElement();
}
auto currentNode(ParsingContext parsingContext) -> Node
{
// If we don't have a cursor or the parsing context isn't reusable, there's nothing to reuse.
//
// If there is an outstanding parse error that we've encountered, but not attached to
// some node, then we cannot get a node from the old source tree. This is because we
// want to mark the next node we encounter.as<being>() unusable.
//
// This Note may be too conservative. Perhaps we could reuse the node and set the bit
// on it (or its leftmost child).as<having>() the error. For now though, being conservative
// is nice and likely won't ever affect perf.
if (!syntaxCursor || !isReusableParsingContext(parsingContext) || parseErrorBeforeNextFinishedNode)
{
return undefined;
}
auto node = ((IncrementalParser::SyntaxCursor &)syntaxCursor).currentNode(scanner.getStartPos());
// Can't reuse a missing node->
// Can't reuse a node that intersected the change range.
// Can't reuse a node that contains a parse error. This is necessary so that we
// produce the same set of errors again.
if (nodeIsMissing(node) || node.intersectsChange || containsParseError(node))
{
return undefined;
}
// We can only reuse a node if it was parsed under the same strict mode that we're
// currently in. i.e. if we originally parsed a node in non-strict mode, but then
// the user added 'using strict' at the top of the file, then we can't use that node
// again.as<the>() presence of strict mode may cause us to parse the tokens in the file
// differently.
//
// we Note *can* reuse tokens when the strict mode changes. That's because tokens
// are unaffected by strict mode. It's just the parser will decide what to do with it
// differently depending on what mode it is in.
//
// This also applies to all our other context flags.as<well>().
auto nodeContextFlags = node->flags & NodeFlags::ContextFlags;
if (nodeContextFlags != contextFlags)
{
return undefined;
}
// Ok, we have a node that looks like it could be reused. Now verify that it is valid
// in the current list parsing context that we're currently at.
if (!canReuseNode(node, parsingContext))
{
return undefined;
}
if (node.as<JSDocContainer>()->jsDocCache.size() > 0)
{
// jsDocCache may include tags from parent nodes, which might have been modified.
node.as<JSDocContainer>()->jsDocCache.clear();
}
return node;
}
auto consumeNode(Node node) -> Node
{
// Move the scanner so it is after the node we just consumed.
scanner.setTextPos(node->_end);
nextToken();
return node;
}
auto isReusableParsingContext(ParsingContext parsingContext) -> boolean
{
switch (parsingContext)
{
case ParsingContext::ClassMembers:
case ParsingContext::SwitchClauses:
case ParsingContext::SourceElements:
case ParsingContext::BlockStatements:
case ParsingContext::SwitchClauseStatements:
case ParsingContext::EnumMembers:
case ParsingContext::TypeMembers:
case ParsingContext::VariableDeclarations:
case ParsingContext::JSDocParameters:
case ParsingContext::Parameters:
return true;
}
return false;
}
auto canReuseNode(Node node, ParsingContext parsingContext) -> boolean
{
switch (parsingContext)
{
case ParsingContext::ClassMembers:
return isReusableClassMember(node);
case ParsingContext::SwitchClauses:
return isReusableSwitchClause(node);
case ParsingContext::SourceElements:
case ParsingContext::BlockStatements:
case ParsingContext::SwitchClauseStatements:
return isReusableStatement(node);
case ParsingContext::EnumMembers:
return isReusableEnumMember(node);
case ParsingContext::TypeMembers:
return isReusableTypeMember(node);
case ParsingContext::VariableDeclarations:
return isReusableVariableDeclaration(node);
case ParsingContext::JSDocParameters:
case ParsingContext::Parameters:
return isReusableParameter(node);
// Any other lists we do not care about reusing nodes in. But feel free to add if
// you can do so safely. Danger areas involve nodes that may involve speculative
// parsing. If speculative parsing is involved with the node, then the range the
// parser reached while looking ahead might be in the edited range (see the example
// in canReuseVariableDeclaratorNode for a good case of this).
// case ParsingContext::HeritageClauses:
// This would probably be safe to reuse. There is no speculative parsing with
// heritage clauses.
// case ParsingContext::TypeParameters:
// This would probably be safe to reuse. There is no speculative parsing with
// type parameters. Note that that's because type *parameters* only occur in
// unambiguous *type* contexts. While type *arguments* occur in very ambiguous
// *expression* contexts.
// case ParsingContext::TupleElementTypes:
// This would probably be safe to reuse. There is no speculative parsing with
// tuple types.
// Technically, type argument list types are probably safe to reuse. While
// speculative parsing is involved with them (since type argument lists are only
// produced from speculative parsing a <.as<a>() type argument list), we only have
// the types because speculative parsing succeeded. Thus, the lookahead never
// went past the end of the list and rewound.
// case ParsingContext::TypeArguments:
// these Note are almost certainly not safe to ever reuse. Expressions commonly
// need a large amount of lookahead, and we should not reuse them.as<they>() may
// have actually intersected the edit.
// case ParsingContext::ArgumentExpressions:
// This is not safe to reuse for the same reason.as<the>() 'AssignmentExpression'
// cases. i.e. a property assignment may end with an expression, and thus might
// have lookahead far beyond it's old node->
// case ParsingContext::ObjectLiteralMembers:
// This is probably not safe to reuse. There can be speculative parsing with
// type names in a heritage clause. There can be generic names in the type
// name list, and there can be left hand side expressions (which can have type
// arguments.)
// case ParsingContext::HeritageClauseElement:
// Perhaps safe to reuse, but it's unlikely we'd see more than a dozen attributes
// on any given element. Same for children.
// case ParsingContext::JsxAttributes:
// case ParsingContext::JsxChildren:
}
return false;
}
auto isReusableClassMember(Node node) -> boolean
{
if (node)
{
switch ((SyntaxKind)node)
{
case SyntaxKind::Constructor:
case SyntaxKind::IndexSignature:
case SyntaxKind::GetAccessor:
case SyntaxKind::SetAccessor:
case SyntaxKind::PropertyDeclaration:
case SyntaxKind::SemicolonClassElement:
return true;
case SyntaxKind::MethodDeclaration:
// Method declarations are not necessarily reusable. An object-literal
// may have a method calls "constructor(...)" and we must reparse that
// into an actual .ConstructorDeclaration.
auto methodDeclaration = node.as<MethodDeclaration>();
auto nameIsConstructor =
methodDeclaration->name == SyntaxKind::Identifier &&
methodDeclaration->name.as<Identifier>()->originalKeywordKind == SyntaxKind::ConstructorKeyword;
return !nameIsConstructor;
}
}
return false;
}
auto isReusableSwitchClause(Node node) -> boolean
{
if (node)
{
switch ((SyntaxKind)node)
{
case SyntaxKind::CaseClause:
case SyntaxKind::DefaultClause:
return true;
}
}
return false;
}
auto isReusableStatement(Node node) -> boolean
{
if (node)
{
switch ((SyntaxKind)node)
{
case SyntaxKind::FunctionDeclaration:
case SyntaxKind::VariableStatement:
case SyntaxKind::Block:
case SyntaxKind::IfStatement:
case SyntaxKind::ExpressionStatement:
case SyntaxKind::ThrowStatement:
case SyntaxKind::ReturnStatement:
case SyntaxKind::SwitchStatement:
case SyntaxKind::BreakStatement:
case SyntaxKind::ContinueStatement:
case SyntaxKind::ForInStatement:
case SyntaxKind::ForOfStatement:
case SyntaxKind::ForStatement:
case SyntaxKind::WhileStatement:
case SyntaxKind::WithStatement:
case SyntaxKind::EmptyStatement:
case SyntaxKind::TryStatement:
case SyntaxKind::LabeledStatement:
case SyntaxKind::DoStatement:
case SyntaxKind::DebuggerStatement:
case SyntaxKind::ImportDeclaration:
case SyntaxKind::ImportEqualsDeclaration:
case SyntaxKind::ExportDeclaration:
case SyntaxKind::ExportAssignment:
case SyntaxKind::ModuleDeclaration:
case SyntaxKind::ClassDeclaration:
case SyntaxKind::InterfaceDeclaration:
case SyntaxKind::EnumDeclaration:
case SyntaxKind::TypeAliasDeclaration:
return true;
}
}
return false;
}
auto isReusableEnumMember(Node node) -> boolean
{
return node == SyntaxKind::EnumMember;
}
auto isReusableTypeMember(Node node) -> boolean
{
if (node)
{
switch ((SyntaxKind)node)
{
case SyntaxKind::ConstructSignature:
case SyntaxKind::MethodSignature:
case SyntaxKind::IndexSignature:
case SyntaxKind::PropertySignature:
case SyntaxKind::CallSignature:
return true;
}
}
return false;
}
auto isReusableVariableDeclaration(Node node) -> boolean
{
if (node != SyntaxKind::VariableDeclaration)
{
return false;
}
// Very subtle incremental parsing bug. Consider the following code:
//
// auto v = new List < A, B
//
// This is actually legal code. It's a list of variable declarators "v = new List<A"
// on one side and "B" on the other. If you then change that to:
//
// auto v = new List < A, B >()
//
// then we have a problem. "v = new List<A" doesn't intersect the change range, so we
// start reparsing at "B" and we completely fail to handle this properly.
//
// In order to prevent this, we do not allow a variable declarator to be reused if it
// has an initializer.
auto variableDeclarator = node.as<VariableDeclaration>();
return variableDeclarator->initializer == undefined;
}
auto isReusableParameter(Node node) -> boolean
{
if (node != SyntaxKind::Parameter)
{
return false;
}
// See the comment in isReusableVariableDeclaration for why we do this.
auto parameter = node.as<ParameterDeclaration>();
return parameter->initializer == undefined;
}
// Returns true if we should abort parsing.
auto abortParsingListOrMoveToNextToken(ParsingContext kind) -> boolean
{
parsingContextErrors(kind);
if (isInSomeParsingContext())
{
return true;
}
nextToken();
return false;
}
auto parsingContextErrors(ParsingContext context) -> void
{
switch (context)
{
case ParsingContext::SourceElements:
return parseErrorAtCurrentToken(data::DiagnosticMessage(Diagnostics::Declaration_or_statement_expected));
case ParsingContext::BlockStatements:
return parseErrorAtCurrentToken(data::DiagnosticMessage(Diagnostics::Declaration_or_statement_expected));
case ParsingContext::SwitchClauses:
return parseErrorAtCurrentToken(data::DiagnosticMessage(Diagnostics::case_or_default_expected));
case ParsingContext::SwitchClauseStatements:
return parseErrorAtCurrentToken(data::DiagnosticMessage(Diagnostics::Statement_expected));
case ParsingContext::RestProperties: // fallthrough
case ParsingContext::TypeMembers:
return parseErrorAtCurrentToken(data::DiagnosticMessage(Diagnostics::Property_or_signature_expected));
case ParsingContext::ClassMembers:
return parseErrorAtCurrentToken(data::DiagnosticMessage(
Diagnostics::Unexpected_token_A_constructor_method_accessor_or_property_was_expected));
case ParsingContext::EnumMembers:
return parseErrorAtCurrentToken(data::DiagnosticMessage(Diagnostics::Enum_member_expected));
case ParsingContext::HeritageClauseElement:
return parseErrorAtCurrentToken(data::DiagnosticMessage(Diagnostics::Expression_expected));
case ParsingContext::VariableDeclarations:
return isKeyword(token())
? parseErrorAtCurrentToken(
data::DiagnosticMessage(Diagnostics::_0_is_not_allowed_as_a_variable_declaration_name),
scanner.tokenToString(token()))
: parseErrorAtCurrentToken(data::DiagnosticMessage(Diagnostics::Variable_declaration_expected));
case ParsingContext::ObjectBindingElements:
return parseErrorAtCurrentToken(
data::DiagnosticMessage(Diagnostics::Property_destructuring_pattern_expected));
case ParsingContext::ArrayBindingElements:
return parseErrorAtCurrentToken(
data::DiagnosticMessage(Diagnostics::Array_element_destructuring_pattern_expected));
case ParsingContext::ArgumentExpressions:
return parseErrorAtCurrentToken(data::DiagnosticMessage(Diagnostics::Argument_expression_expected));
case ParsingContext::ObjectLiteralMembers:
return parseErrorAtCurrentToken(data::DiagnosticMessage(Diagnostics::Property_assignment_expected));
case ParsingContext::ArrayLiteralMembers:
return parseErrorAtCurrentToken(data::DiagnosticMessage(Diagnostics::Expression_or_comma_expected));
case ParsingContext::JSDocParameters:
return parseErrorAtCurrentToken(data::DiagnosticMessage(Diagnostics::Parameter_declaration_expected));
case ParsingContext::Parameters:
return parseErrorAtCurrentToken(data::DiagnosticMessage(Diagnostics::Parameter_declaration_expected));
case ParsingContext::TypeParameters:
return parseErrorAtCurrentToken(data::DiagnosticMessage(Diagnostics::Type_parameter_declaration_expected));
case ParsingContext::TypeArguments:
return parseErrorAtCurrentToken(data::DiagnosticMessage(Diagnostics::Type_argument_expected));
case ParsingContext::TupleElementTypes:
return parseErrorAtCurrentToken(data::DiagnosticMessage(Diagnostics::Type_expected));
case ParsingContext::HeritageClauses:
return parseErrorAtCurrentToken(data::DiagnosticMessage(Diagnostics::Unexpected_token_expected));
case ParsingContext::ImportOrExportSpecifiers:
return parseErrorAtCurrentToken(data::DiagnosticMessage(Diagnostics::Identifier_expected));
case ParsingContext::JsxAttributes:
return parseErrorAtCurrentToken(data::DiagnosticMessage(Diagnostics::Identifier_expected));
case ParsingContext::JsxChildren:
return parseErrorAtCurrentToken(data::DiagnosticMessage(Diagnostics::Identifier_expected));
return; // GH TODO#18217 `Debug::_assertNever default(context);`
}
}
// Parses a comma-delimited list of elements
template <typename T>
auto parseDelimitedList(ParsingContext kind, std::function<T()> parseElement,
boolean considerSemicolonAsDelimiter = false) -> NodeArray<T>
{
auto saveParsingContext = parsingContext;
parsingContext |= (ParsingContext)(1 << (number)kind);
NodeArray<T> list;
auto listPos = getNodePos();
auto commaStart = -1; // Meaning the previous token was not a comma
while (true)
{
if (isListElement(kind, /*inErrorRecovery*/ false))
{
auto startPos = scanner.getStartPos();
list.push_back(parseListElement<T>(kind, parseElement));
commaStart = scanner.getTokenPos();
if (parseOptional(SyntaxKind::CommaToken))
{
// No need to check for a zero length node since we know we parsed a comma
continue;
}
commaStart = -1; // Back to the state where the last token was not a comma
if (isListTerminator(kind))
{
break;
}
// We didn't get a comma, and the list wasn't terminated, explicitly parse
// out a comma so we give a good error message.
parseExpected(SyntaxKind::CommaToken, getExpectedCommaDiagnostic(kind));
// If the token was a semicolon, and the caller allows that, then skip it and
// continue. This ensures we get back on track and don't result in tons of
// parse errors. For example, this can happen when people do things like use
// a semicolon to delimit object literal members. we Note'll have already
// reported an error when we called parseExpected above.
if (considerSemicolonAsDelimiter && token() == SyntaxKind::SemicolonToken &&
!scanner.hasPrecedingLineBreak())
{
nextToken();
}
if (startPos == scanner.getStartPos())
{
// What we're parsing isn't actually remotely recognizable.as<a>() element and we've consumed no
// tokens whatsoever Consume a token to advance the parser in some way and avoid an infinite loop
// This can happen when we're speculatively parsing parenthesized expressions which we think may be
// arrow functions, or when a modifier keyword which is disallowed.as<a>() parameter name (ie,
// `static` in strict mode) is supplied
nextToken();
}
continue;
}
if (isListTerminator(kind))
{
break;
}
if (abortParsingListOrMoveToNextToken(kind))
{
break;
}
}
parsingContext = saveParsingContext;
// Recording the trailing comma is deliberately done after the previous
// loop, and not just if we see a list terminator. This is because the list
// may have ended incorrectly, but it is still important to know if there
// was a trailing comma.
// Check if the last token was a comma.
// Always preserve a trailing comma by marking it on the NodeArray
return createNodeArray<T>(list, listPos, /*end*/ -1, commaStart >= 0);
}
auto getExpectedCommaDiagnostic(ParsingContext kind) -> DiagnosticMessage
{
return kind == ParsingContext::EnumMembers ? DiagnosticMessage(data::DiagnosticMessage(
Diagnostics::An_enum_member_name_must_be_followed_by_a_or))
: undefined;
}
template <typename T> using MissingList = NodeArray<T>;
template <typename T> auto createMissingList() -> MissingList<T>
{
auto list = createNodeArray<T>(NodeArray<T>(), getNodePos());
list.isMissingList = true;
return list;
}
template <typename T> auto isMissingList(NodeArray<T> arr) -> boolean
{
return arr.isMissingList;
}
template <typename T>
auto parseBracketedList(ParsingContext kind, std::function<T()> parseElement, SyntaxKind open, SyntaxKind close)
-> NodeArray<T>
{
if (parseExpected(open))
{
auto result = parseDelimitedList(kind, parseElement);
parseExpected(close);
return result;
}
return createMissingList<T>();
}
auto parseEntityName(boolean allowReservedWords, DiagnosticMessage diagnosticMessage = undefined) -> Identifier
{
auto pos = getNodePos();
auto entity = allowReservedWords ? parseIdentifierName(diagnosticMessage) : parseIdentifier(diagnosticMessage);
auto dotPos = getNodePos();
while (parseOptional(SyntaxKind::DotToken))
{
if (token() == SyntaxKind::LessThanToken)
{
// the entity is part of a JSDoc-style generic, so record the trailing dot for later error reporting
entity->jsdocDotPos = dotPos;
break;
}
dotPos = getNodePos();
entity = finishNode(
factory.createQualifiedName(
entity,
parseRightSideOfDot(allowReservedWords, /* allowPrivateIdentifiers */ false).as<Identifier>()),
pos);
}
return entity;
}
auto createQualifiedName(EntityName entity, Identifier name) -> QualifiedName
{
return finishNode(factory.createQualifiedName(entity, name), entity->pos).as<QualifiedName>();
}
auto parseRightSideOfDot(boolean allowIdentifierNames, boolean allowPrivateIdentifiers) -> Node
{
// Technically a keyword is valid here.as<all>() identifiers and keywords are identifier names.
// However, often we'll encounter this in error situations when the identifier or keyword
// is actually starting another valid construct.
//
// So, we check for the following specific case:
//
// name.
// identifierOrKeyword identifierNameOrKeyword
//
// the Note newlines are important here. For example, if that above code
// were rewritten into:
//
// name.identifierOrKeyword
// identifierNameOrKeyword
//
// Then we would consider it valid. That's because ASI would take effect and
// the code would be implicitly: "name.identifierOrKeyword; identifierNameOrKeyword".
// In the first case though, ASI will not take effect because there is not a
// line terminator after the identifier or keyword.
if (scanner.hasPrecedingLineBreak() && scanner.tokenIsIdentifierOrKeyword(token()))
{
auto matchesPattern =
lookAhead<boolean>(std::bind(&Parser::nextTokenIsIdentifierOrKeywordOnSameLine, this));
if (matchesPattern)
{
// Report that we need an identifier. However, report it right after the dot,
// and not on the next token. This is because the next token might actually
// be an identifier and the error would be quite confusing.
return createMissingNode<Identifier>(SyntaxKind::Identifier, /*reportAtCurrentPosition*/ true,
data::DiagnosticMessage(Diagnostics::Identifier_expected));
}
}
if (token() == SyntaxKind::PrivateIdentifier)
{
auto node = parsePrivateIdentifier();
return allowPrivateIdentifiers
? node
: createMissingNode<Identifier>(SyntaxKind::Identifier, /*reportAtCurrentPosition*/ true,
data::DiagnosticMessage(Diagnostics::Identifier_expected));
}
return allowIdentifierNames ? parseIdentifierName() : parseIdentifier();
}
auto parseTemplateSpans(boolean isTaggedTemplate) -> NodeArray<TemplateSpan>
{
auto pos = getNodePos();
NodeArray<TemplateSpan> list;
TemplateSpan node;
do
{
node = parseTemplateSpan(isTaggedTemplate);
list.push_back(node);
} while (node->literal == SyntaxKind::TemplateMiddle);
return createNodeArray(list, pos);
}
auto parseTemplateExpression(boolean isTaggedTemplate) -> TemplateExpression
{
auto pos = getNodePos();
auto head = parseTemplateHead(isTaggedTemplate);
auto spans = parseTemplateSpans(isTaggedTemplate);
return finishNode(factory.createTemplateExpression(head, spans), pos);
}
auto parseTemplateType() -> TemplateLiteralTypeNode
{
auto pos = getNodePos();
auto head = parseTemplateHead(/*isTaggedTemplate*/ false);
auto spans = parseTemplateTypeSpans();
return finishNode(factory.createTemplateLiteralType(head, spans), pos);
}
auto parseTemplateTypeSpans() -> NodeArray<TemplateLiteralTypeSpan>
{
auto pos = getNodePos();
NodeArray<TemplateLiteralTypeSpan> list;
TemplateLiteralTypeSpan node;
do
{
node = parseTemplateTypeSpan();
list.push_back(node);
} while (node->literal == SyntaxKind::TemplateMiddle);
return createNodeArray(list, pos);
}
auto parseTemplateTypeSpan() -> TemplateLiteralTypeSpan
{
auto pos = getNodePos();
auto type = parseType();
auto span = parseLiteralOfTemplateSpan(/*isTaggedTemplate*/ false);
return finishNode(factory.createTemplateLiteralTypeSpan(type, span), pos);
}
auto parseLiteralOfTemplateSpan(boolean isTaggedTemplate) -> Node
{
if (token() == SyntaxKind::CloseBraceToken)
{
reScanTemplateToken(isTaggedTemplate);
return parseTemplateMiddleOrTemplateTail();
}
else
{
// TODO(rbuckton) -> Do we need to call `parseExpectedToken` or can we just call `createMissingNode`
// directly?
return parseExpectedToken(SyntaxKind::TemplateTail, data::DiagnosticMessage(Diagnostics::_0_expected),
scanner.tokenToString(SyntaxKind::CloseBraceToken));
}
}
auto parseTemplateSpan(boolean isTaggedTemplate) -> TemplateSpan
{
auto pos = getNodePos();
auto expression = allowInAnd<Expression>(std::bind(&Parser::parseExpression, this));
auto span = parseLiteralOfTemplateSpan(isTaggedTemplate);
return finishNode(factory.createTemplateSpan(expression, span), pos);
}
auto parseLiteralNode() -> LiteralExpression
{
return parseLiteralLikeNode(token()).as<LiteralExpression>();
}
auto parseTemplateHead(boolean isTaggedTemplate) -> TemplateHead
{
if (isTaggedTemplate)
{
reScanTemplateHeadOrNoSubstitutionTemplate();
}
auto fragment = parseLiteralLikeNode(token());
Debug::_assert(fragment == SyntaxKind::TemplateHead, S("Template head has wrong token kind"));
return fragment.as<TemplateHead>();
}
auto parseTemplateMiddleOrTemplateTail() -> Node
{
auto fragment = parseLiteralLikeNode(token());
Debug::_assert(fragment == SyntaxKind::TemplateMiddle || fragment == SyntaxKind::TemplateTail,
S("Template fragment has wrong token kind"));
return fragment;
}
auto getTemplateLiteralRawText(SyntaxKind kind) -> string
{
auto isLast = kind == SyntaxKind::NoSubstitutionTemplateLiteral || kind == SyntaxKind::TemplateTail;
auto tokenText = scanner.getTokenText();
return safe_string(tokenText).substring(1, tokenText.size() - (scanner.isUnterminated() ? 0 : isLast ? 1 : 2));
}
auto parseLiteralLikeNode(SyntaxKind kind) -> LiteralLikeNode
{
auto pos = getNodePos();
LiteralLikeNode node =
isTemplateLiteralKind(kind)
? factory
.createTemplateLiteralLikeNode(kind, scanner.getTokenValue(), getTemplateLiteralRawText(kind),
scanner.getTokenFlags() & TokenFlags::TemplateLiteralLikeFlags)
.as<LiteralLikeNode>()
:
// Octal literals are not allowed in strict mode or ES5
// Note that theoretically the following condition would hold true literals like 009,
// which is not octal. But because of how the scanner separates the tokens, we would
// never get a token like this. Instead, we would get 00 and 9.as<two>() separate tokens.
// We also do not need to check for negatives because any prefix operator would be part of a
// parent unary expression.
kind == SyntaxKind::NumericLiteral
? factory.createNumericLiteral(scanner.getTokenValue(), scanner.getNumericLiteralFlags())
.as<LiteralLikeNode>()
: kind == SyntaxKind::StringLiteral
? factory
.createStringLiteral(scanner.getTokenValue(), /*isSingleQuote*/ /*undefined*/ false,
scanner.hasExtendedUnicodeEscape())
.as<LiteralLikeNode>()
: isLiteralKind(kind) ? factory.createLiteralLikeNode(kind, scanner.getTokenValue())
: Debug::fail<LiteralLikeNode>();
if (scanner.hasExtendedUnicodeEscape())
{
node->hasExtendedUnicodeEscape = true;
}
if (scanner.isUnterminated())
{
node->isUnterminated = true;
}
nextToken();
return finishNode(node, pos);
}
// TYPES
auto parseEntityNameOfTypeReference() -> Node
{
return parseEntityName(/*allowReservedWords*/ true, data::DiagnosticMessage(Diagnostics::Type_expected));
}
auto parseTypeArgumentsOfTypeReference() -> NodeArray<TypeNode>
{
if (!scanner.hasPrecedingLineBreak() && reScanLessThanToken() == SyntaxKind::LessThanToken)
{
return parseBracketedList<TypeNode>(ParsingContext::TypeArguments, std::bind(&Parser::parseType, this),
SyntaxKind::LessThanToken, SyntaxKind::GreaterThanToken);
}
return undefined;
}
auto parseTypeReference() -> TypeReferenceNode
{
auto pos = getNodePos();
auto entityNameOfTypeReference = parseEntityNameOfTypeReference();
auto typeArgumentsOfTypeReference = parseTypeArgumentsOfTypeReference();
return finishNode(factory.createTypeReferenceNode(entityNameOfTypeReference, typeArgumentsOfTypeReference),
pos);
}
// If true, we should abort parsing an error function.
auto typeHasArrowFunctionBlockingParseError(TypeNode node) -> boolean
{
switch ((SyntaxKind)node)
{
case SyntaxKind::TypeReference:
return nodeIsMissing(node.as<TypeReferenceNode>()->typeName);
case SyntaxKind::FunctionType:
case SyntaxKind::ConstructorType: {
auto res = node.as<FunctionOrConstructorTypeNode>();
if (res == SyntaxKind::FunctionType)
{
auto res1 = res.as<FunctionTypeNode>();
return isMissingList(res1->parameters) || typeHasArrowFunctionBlockingParseError(res1->type);
}
else
{
auto res1 = res.as<ConstructorTypeNode>();
return isMissingList(res1->parameters) || typeHasArrowFunctionBlockingParseError(res1->type);
}
}
case SyntaxKind::ParenthesizedType:
return typeHasArrowFunctionBlockingParseError(node.as<ParenthesizedTypeNode>()->type);
default:
return false;
}
}
auto parseThisTypePredicate(ThisTypeNode lhs) -> TypePredicateNode
{
nextToken();
return finishNode(factory.createTypePredicateNode(/*assertsModifier*/ undefined, lhs, parseType()), lhs->pos);
}
auto parseThisTypeNode() -> ThisTypeNode
{
auto pos = getNodePos();
nextToken();
return finishNode(factory.createThisTypeNode(), pos);
}
auto parseJSDocAllType() -> Node
{
auto pos = getNodePos();
nextToken();
return finishNode(factory.createJSDocAllType(), pos);
}
auto parseJSDocNonNullableType() -> TypeNode
{
auto pos = getNodePos();
nextToken();
return finishNode(factory.createJSDocNonNullableType(parseNonArrayType()), pos);
}
auto parseJSDocUnknownOrNullableType() -> Node
{
auto pos = getNodePos();
// skip the ?
nextToken();
// Need to lookahead to decide if this is a nullable or unknown type.
// Here are cases where we'll pick the unknown type:
//
// Foo(?,
// { a: ? }
// Foo(?)
// Foo<?>
// Foo(?=
// (?|
if (token() == SyntaxKind::CommaToken || token() == SyntaxKind::CloseBraceToken ||
token() == SyntaxKind::CloseParenToken || token() == SyntaxKind::GreaterThanToken ||
token() == SyntaxKind::EqualsToken || token() == SyntaxKind::BarToken)
{
return finishNode(factory.createJSDocUnknownType(), pos);
}
else
{
return finishNode(factory.createJSDocNullableType(parseType()), pos);
}
}
auto parseJSDocFunctionType() -> Node
{
auto pos = getNodePos();
auto hasJSDoc = hasPrecedingJSDocComment();
if (lookAhead<boolean>(std::bind(&Parser::nextTokenIsOpenParen, this)))
{
nextToken();
auto parameters = parseParameters(SignatureFlags::Type | SignatureFlags::JSDoc);
auto type = parseReturnType(SyntaxKind::ColonToken, /*isType*/ false);
return withJSDoc(finishNode(factory.createJSDocFunctionType(parameters, type), pos), hasJSDoc);
}
return finishNode(factory.createTypeReferenceNode(parseIdentifierName(), /*typeArguments*/ undefined), pos);
}
auto parseJSDocParameter() -> ParameterDeclaration
{
auto pos = getNodePos();
Identifier name;
if (token() == SyntaxKind::ThisKeyword || token() == SyntaxKind::NewKeyword)
{
name = parseIdentifierName();
parseExpected(SyntaxKind::ColonToken);
}
return finishNode(factory.createParameterDeclaration(
/*decorators*/ undefined,
/*modifiers*/ undefined,
/*dotDotDotToken*/ undefined,
// TODO(rbuckton) -> JSDoc parameters don't have names (except `this`/`new`), should we
// manufacture an empty identifier?
name,
/*questionToken*/ undefined, parseJSDocType(),
/*initializer*/ undefined),
pos);
}
auto parseJSDocType() -> TypeNode
{
scanner.setInJSDocType(true);
auto pos = getNodePos();
if (parseOptional(SyntaxKind::ModuleKeyword))
{
// TODO(rbuckton) -> We never set the type for a JSDocNamepathType. What should we put here?
auto moduleTag = factory.createJSDocNamepathType(/*type*/ undefined);
while (true)
{
switch (token())
{
case SyntaxKind::CloseBraceToken:
case SyntaxKind::EndOfFileToken:
case SyntaxKind::CommaToken:
case SyntaxKind::WhitespaceTrivia:
break;
default:
nextTokenJSDoc();
}
}
scanner.setInJSDocType(false);
return finishNode(moduleTag, pos);
}
auto hasDotDotDot = parseOptional(SyntaxKind::DotDotDotToken);
auto type = parseTypeOrTypePredicate();
scanner.setInJSDocType(false);
if (hasDotDotDot)
{
type = finishNode(factory.createJSDocVariadicType(type), pos);
}
if (token() == SyntaxKind::EqualsToken)
{
nextToken();
return finishNode(factory.createJSDocOptionalType(type), pos);
}
return type;
}
auto parseTypeQuery() -> TypeQueryNode
{
auto pos = getNodePos();
parseExpected(SyntaxKind::TypeOfKeyword);
return finishNode(factory.createTypeQueryNode(parseEntityName(/*allowReservedWords*/ true)), pos);
}
auto parseTypeParameter() -> TypeParameterDeclaration
{
auto pos = getNodePos();
auto name = parseIdentifier();
TypeNode constraint;
Expression expression;
if (parseOptional(SyntaxKind::ExtendsKeyword))
{
// It's not uncommon for people to write improper constraints to a generic. If the
// user writes a constraint that is an expression and not an actual type, then parse
// it out.as<an>() expression (so we can recover well), but report that a type is needed
// instead.
if (isStartOfType() || !isStartOfExpression())
{
constraint = parseType();
}
else
{
// It was not a type, and it looked like an expression. Parse out an expression
// here so we recover well. it Note is important that we call parseUnaryExpression
// and not parseExpression here. If the user has:
//
// <T extends string()>
//
// We do *not* want to consume the `>`.as<we>()'re consuming the expression for string().
expression = parseUnaryExpressionOrHigher();
}
}
auto defaultType = parseOptional(SyntaxKind::EqualsToken) ? parseType() : undefined;
auto node = factory.createTypeParameterDeclaration(name, constraint, defaultType);
node->expression = expression;
return finishNode(node, pos);
}
auto parseTypeParameters() -> NodeArray<TypeParameterDeclaration>
{
if (token() == SyntaxKind::LessThanToken)
{
return parseBracketedList<TypeParameterDeclaration>(
ParsingContext::TypeParameters, std::bind(&Parser::parseTypeParameter, this), SyntaxKind::LessThanToken,
SyntaxKind::GreaterThanToken);
}
return undefined;
}
auto isStartOfParameter(boolean isJSDocParameter) -> boolean
{
return token() == SyntaxKind::DotDotDotToken || isBindingIdentifierOrPrivateIdentifierOrPattern() ||
isModifierKind(token()) || token() == SyntaxKind::AtToken ||
isStartOfType(/*inStartOfParameter*/ !isJSDocParameter);
}
auto parseNameOfParameter(ModifiersArray modifiers)
{
// FormalParameter [Yield,Await]:
// BindingElement[?Yield,?Await]
auto name = parseIdentifierOrPattern(
data::DiagnosticMessage(Diagnostics::Private_identifiers_cannot_be_used_as_parameters));
if (getFullWidth(name) == 0 && !some<ModifiersArray>(modifiers) && isModifierKind(token()))
{
// in cases like
// 'use strict'
// auto foo(static)
// isParameter('static') == true, because of isModifier('static')
// however 'static' is not a legal identifier in a strict mode.
// so result of this auto will be ParameterDeclaration (flags = 0, name = missing, type = undefined,
// initializer = undefined) and current token will not change => parsing of the enclosing parameter list
// will last till the end of time (or OOM) to avoid this we'll advance cursor to the next token.
nextToken();
}
return name;
}
auto parseParameterInOuterAwaitContext() -> ParameterDeclaration
{
return parseParameterWorker(/*inOuterAwaitContext*/ true);
}
auto parseParameter() -> ParameterDeclaration
{
return parseParameterWorker(/*inOuterAwaitContext*/ false);
}
auto parseParameterWorker(boolean inOuterAwaitContext) -> ParameterDeclaration
{
auto pos = getNodePos();
auto hasJSDoc = hasPrecedingJSDocComment();
if (token() == SyntaxKind::ThisKeyword)
{
auto identifier = createIdentifier(/*isIdentifier*/ true);
auto typeAnnotation = parseTypeAnnotation();
auto node = factory.createParameterDeclaration(
/*decorators*/ undefined,
/*modifiers*/ undefined,
/*dotDotDotToken*/ undefined, identifier,
/*questionToken*/ undefined, typeAnnotation,
/*initializer*/ undefined);
return withJSDoc(finishNode(node, pos), hasJSDoc);
}
// FormalParameter [Yield,Await]:
// BindingElement[?Yield,?Await]
// Decorators are parsed in the outer [Await] context, the rest of the parameter is parsed in the function's
// [Await] context->
auto decorators = inOuterAwaitContext
? doInAwaitContext<NodeArray<Decorator>>(std::bind(&Parser::parseDecorators, this))
: parseDecorators();
auto savedTopLevel = topLevel;
topLevel = false;
auto modifiers = parseModifiers();
auto dotDotDotToken = parseOptionalToken(SyntaxKind::DotDotDotToken);
auto nameOfParameter = parseNameOfParameter(modifiers);
auto questionToken = parseOptionalToken(SyntaxKind::QuestionToken);
auto typeAnnotation = parseTypeAnnotation();
auto initializer = parseInitializer();
auto node = withJSDoc(
finishNode(factory.createParameterDeclaration(decorators, modifiers, dotDotDotToken, nameOfParameter,
questionToken, typeAnnotation, initializer),
pos),
hasJSDoc);
topLevel = savedTopLevel;
return node;
}
auto parseReturnType(SyntaxKind returnToken, boolean isType) -> TypeNode
{
if (shouldParseReturnType(returnToken, isType))
{
return parseTypeOrTypePredicate();
}
return undefined;
}
auto shouldParseReturnType(SyntaxKind returnToken, boolean isType) -> boolean
{
if (returnToken == SyntaxKind::EqualsGreaterThanToken)
{
parseExpected(returnToken);
return true;
}
else if (parseOptional(SyntaxKind::ColonToken))
{
return true;
}
else if (isType && token() == SyntaxKind::EqualsGreaterThanToken)
{
// This is easy to get backward, especially in type contexts, so parse the type anyway
parseErrorAtCurrentToken(data::DiagnosticMessage(Diagnostics::_0_expected),
scanner.tokenToString(SyntaxKind::ColonToken));
nextToken();
return true;
}
return false;
}
auto parseParametersWorker(SignatureFlags flags)
{
// FormalParameters [Yield,Await]: (modified)
// [empty]
// FormalParameterList[?Yield,Await]
//
// FormalParameter[Yield,Await]: (modified)
// BindingElement[?Yield,Await]
//
// BindingElement [Yield,Await]: (modified)
// SingleNameBinding[?Yield,?Await]
// BindingPattern[?Yield,?Await]Initializer [In, ?Yield,?Await] opt
//
// SingleNameBinding [Yield,Await]:
// BindingIdentifier[?Yield,?Await]Initializer [In, ?Yield,?Await] opt
auto savedYieldContext = inYieldContext();
auto savedAwaitContext = inAwaitContext();
setYieldContext(!!(flags & SignatureFlags::Yield));
setAwaitContext(!!(flags & SignatureFlags::Await));
auto parameters = !!(flags & SignatureFlags::JSDoc)
? parseDelimitedList<ParameterDeclaration>(ParsingContext::JSDocParameters,
std::bind(&Parser::parseJSDocParameter, this))
: parseDelimitedList<ParameterDeclaration>(
ParsingContext::Parameters,
savedAwaitContext ? std::bind(&Parser::parseParameterInOuterAwaitContext, this)
: std::bind(&Parser::parseParameter, this));
setYieldContext(savedYieldContext);
setAwaitContext(savedAwaitContext);
return parameters;
}
auto parseParameters(SignatureFlags flags) -> NodeArray<ParameterDeclaration>
{
// FormalParameters [Yield,Await]: (modified)
// [empty]
// FormalParameterList[?Yield,Await]
//
// FormalParameter[Yield,Await]: (modified)
// BindingElement[?Yield,Await]
//
// BindingElement [Yield,Await]: (modified)
// SingleNameBinding[?Yield,?Await]
// BindingPattern[?Yield,?Await]Initializer [In, ?Yield,?Await] opt
//
// SingleNameBinding [Yield,Await]:
// BindingIdentifier[?Yield,?Await]Initializer [In, ?Yield,?Await] opt
if (!parseExpected(SyntaxKind::OpenParenToken))
{
return createMissingList<ParameterDeclaration>();
}
auto parameters = parseParametersWorker(flags);
parseExpected(SyntaxKind::CloseParenToken);
return parameters;
}
auto parseTypeMemberSemicolon()
{
// We allow type members to be separated by commas or (possibly ASI) semicolons.
// First check if it was a comma. If so, we're done with the member.
if (parseOptional(SyntaxKind::CommaToken))
{
return;
}
// Didn't have a comma. We must have a (possible ASI) semicolon.
parseSemicolon();
}
auto parseSignatureMember(SyntaxKind kind) -> Node
{
auto pos = getNodePos();
auto hasJSDoc = hasPrecedingJSDocComment();
if (kind == SyntaxKind::ConstructSignature)
{
parseExpected(SyntaxKind::NewKeyword);
}
auto typeParameters = parseTypeParameters();
auto parameters = parseParameters(SignatureFlags::Type);
auto type = parseReturnType(SyntaxKind::ColonToken, /*isType*/ true);
parseTypeMemberSemicolon();
auto node =
kind == SyntaxKind::CallSignature
? factory.createCallSignature(typeParameters, parameters, type).as<SignatureDeclarationBase>()
: factory.createConstructSignature(typeParameters, parameters, type).as<SignatureDeclarationBase>();
return withJSDoc(finishNode(node, pos), hasJSDoc);
}
auto isIndexSignature() -> boolean
{
return token() == SyntaxKind::OpenBracketToken &&
lookAhead<boolean>(std::bind(&Parser::isUnambiguouslyIndexSignature, this));
}
auto isUnambiguouslyIndexSignature() -> boolean
{
// The only allowed sequence is:
//
// [id:
//
// However, for error recovery, we also check the following cases:
//
// [...
// [id,
// [id?,
// [id?:
// [id?]
// [public id
// [private id
// [protected id
// []
//
nextToken();
if (token() == SyntaxKind::DotDotDotToken || token() == SyntaxKind::CloseBracketToken)
{
return true;
}
if (isModifierKind(token()))
{
nextToken();
if (isIdentifier())
{
return true;
}
}
else if (!isIdentifier())
{
return false;
}
else
{
// Skip the identifier
nextToken();
}
// A colon signifies a well formed indexer
// A comma should be a badly formed indexer because comma expressions are not allowed
// in computed properties.
if (token() == SyntaxKind::ColonToken || token() == SyntaxKind::CommaToken)
{
return true;
}
// Question mark could be an indexer with an optional property,
// or it could be a conditional expression in a computed property.
if (token() != SyntaxKind::QuestionToken)
{
return false;
}
// If any of the following tokens are after the question mark, it cannot
// be a conditional expression, so treat it.as<an>() indexer.
nextToken();
return token() == SyntaxKind::ColonToken || token() == SyntaxKind::CommaToken ||
token() == SyntaxKind::CloseBracketToken;
}
auto parseIndexSignatureDeclaration(pos_type pos, boolean hasJSDoc, NodeArray<Decorator> decorators,
NodeArray<Modifier> modifiers) -> IndexSignatureDeclaration
{
auto parameters = parseBracketedList<ParameterDeclaration>(
ParsingContext::Parameters, std::bind(&Parser::parseParameter, this), SyntaxKind::OpenBracketToken,
SyntaxKind::CloseBracketToken);
auto type = parseTypeAnnotation();
parseTypeMemberSemicolon();
auto node = factory.createIndexSignature(decorators, modifiers, parameters, type);
return withJSDoc(finishNode(node, pos), hasJSDoc);
}
auto parsePropertyOrMethodSignature(pos_type pos, boolean hasJSDoc, NodeArray<Modifier> modifiers) -> Node
{
auto name = parsePropertyName();
auto questionToken = parseOptionalToken(SyntaxKind::QuestionToken);
Node node;
if (token() == SyntaxKind::OpenParenToken || token() == SyntaxKind::LessThanToken)
{
// Method signatures don't exist in expression contexts. So they have neither
// [Yield] nor [Await]
auto typeParameters = parseTypeParameters();
auto parameters = parseParameters(SignatureFlags::Type);
auto type = parseReturnType(SyntaxKind::ColonToken, /*isType*/ true);
node = factory.createMethodSignature(modifiers, name, questionToken, typeParameters, parameters, type);
}
else
{
auto type = parseTypeAnnotation();
node = factory.createPropertySignature(modifiers, name, questionToken, type);
// Although type literal properties cannot not have initializers, we attempt
// to parse an initializer so we can report in the checker that an interface
// property or type literal property cannot have an initializer.
if (token() == SyntaxKind::EqualsToken)
node.as<PropertySignature>()->initializer = parseInitializer();
}
parseTypeMemberSemicolon();
return withJSDoc(finishNode(node, pos), hasJSDoc);
}
auto isTypeMemberStart() -> boolean
{
// Return true if we have the start of a signature member
if (token() == SyntaxKind::OpenParenToken || token() == SyntaxKind::LessThanToken)
{
return true;
}
auto idToken = false;
// Eat up all modifiers, but hold on to the last one in case it is actually an identifier
while (isModifierKind(token()))
{
idToken = true;
nextToken();
}
// Index signatures and computed property names are type members
if (token() == SyntaxKind::OpenBracketToken)
{
return true;
}
// Try to get the first property-like token following all modifiers
if (isLiteralPropertyName())
{
idToken = true;
nextToken();
}
// If we were able to get any potential identifier, check that it is
// the start of a member declaration
if (idToken)
{
return token() == SyntaxKind::OpenParenToken || token() == SyntaxKind::LessThanToken ||
token() == SyntaxKind::QuestionToken || token() == SyntaxKind::ColonToken ||
token() == SyntaxKind::CommaToken || canParseSemicolon();
}
return false;
}
auto parseTypeMember() -> TypeElement
{
if (token() == SyntaxKind::OpenParenToken || token() == SyntaxKind::LessThanToken)
{
return parseSignatureMember(SyntaxKind::CallSignature);
}
if (token() == SyntaxKind::NewKeyword &&
lookAhead<boolean>(std::bind(&Parser::nextTokenIsOpenParenOrLessThan, this)))
{
return parseSignatureMember(SyntaxKind::ConstructSignature);
}
auto pos = getNodePos();
auto hasJSDoc = hasPrecedingJSDocComment();
auto modifiers = parseModifiers();
if (isIndexSignature())
{
return parseIndexSignatureDeclaration(pos, hasJSDoc, /*decorators*/ undefined, modifiers);
}
return parsePropertyOrMethodSignature(pos, hasJSDoc, modifiers);
}
auto nextTokenIsOpenParenOrLessThan() -> boolean
{
nextToken();
return token() == SyntaxKind::OpenParenToken || token() == SyntaxKind::LessThanToken;
}
auto nextTokenIsDot()
{
return nextToken() == SyntaxKind::DotToken;
}
auto nextTokenIsOpenParenOrLessThanOrDot() -> boolean
{
switch (nextToken())
{
case SyntaxKind::OpenParenToken:
case SyntaxKind::LessThanToken:
case SyntaxKind::DotToken:
return true;
}
return false;
}
auto parseTypeLiteral() -> TypeLiteralNode
{
auto pos = getNodePos();
return finishNode(factory.createTypeLiteralNode(parseObjectTypeMembers()), pos);
}
auto parseObjectTypeMembers() -> NodeArray<TypeElement>
{
NodeArray<TypeElement> members;
if (parseExpected(SyntaxKind::OpenBraceToken))
{
members = parseList<TypeElement>(ParsingContext::TypeMembers, std::bind(&Parser::parseTypeMember, this));
parseExpected(SyntaxKind::CloseBraceToken);
}
else
{
members = createMissingList<TypeElement>();
}
return members;
}
auto isStartOfMappedType()
{
nextToken();
if (token() == SyntaxKind::PlusToken || token() == SyntaxKind::MinusToken)
{
return nextToken() == SyntaxKind::ReadonlyKeyword;
}
if (token() == SyntaxKind::ReadonlyKeyword)
{
nextToken();
}
return token() == SyntaxKind::OpenBracketToken && nextTokenIsIdentifier() &&
nextToken() == SyntaxKind::InKeyword;
}
auto parseMappedTypeParameter()
{
auto pos = getNodePos();
auto name = parseIdentifierName();
parseExpected(SyntaxKind::InKeyword);
auto type = parseType();
return finishNode(factory.createTypeParameterDeclaration(name, type, /*defaultType*/ undefined), pos);
}
auto parseMappedType()
{
auto pos = getNodePos();
parseExpected(SyntaxKind::OpenBraceToken);
Node readonlyToken;
if (token() == SyntaxKind::ReadonlyKeyword || token() == SyntaxKind::PlusToken ||
token() == SyntaxKind::MinusToken)
{
// readonlyToken = parseTokenNode<ReadonlyKeyword, PlusToken, MinusToken>();
readonlyToken = parseTokenNode<Node>();
if (readonlyToken != SyntaxKind::ReadonlyKeyword)
{
parseExpected(SyntaxKind::ReadonlyKeyword);
}
}
parseExpected(SyntaxKind::OpenBracketToken);
auto typeParameter = parseMappedTypeParameter();
auto nameType = parseOptional(SyntaxKind::AsKeyword) ? parseType() : undefined;
parseExpected(SyntaxKind::CloseBracketToken);
Node questionToken;
if (token() == SyntaxKind::QuestionToken || token() == SyntaxKind::PlusToken ||
token() == SyntaxKind::MinusToken)
{
// questionToken = parseTokenNode<QuestionToken, PlusToken, MinusToken>();
questionToken = parseTokenNode<Node>();
if (questionToken != SyntaxKind::QuestionToken)
{
parseExpected(SyntaxKind::QuestionToken);
}
}
auto type = parseTypeAnnotation();
parseSemicolon();
parseExpected(SyntaxKind::CloseBraceToken);
return finishNode(factory.createMappedTypeNode(readonlyToken, typeParameter, nameType, questionToken, type),
pos);
}
auto parseTupleElementType() -> TypeNode
{
auto pos = getNodePos();
if (parseOptional(SyntaxKind::DotDotDotToken))
{
return finishNode(factory.createRestTypeNode(parseType()), pos);
}
auto type = parseType();
if (isJSDocNullableType(type) && type->pos == type.as<JSDocNullableType>()->type->pos)
{
auto node = factory.createOptionalTypeNode(type.as<JSDocNullableType>()->type);
setTextRange(node, type);
node->flags = type->flags;
return node;
}
return type;
}
auto isNextTokenColonOrQuestionColon()
{
return nextToken() == SyntaxKind::ColonToken ||
(token() == SyntaxKind::QuestionToken && nextToken() == SyntaxKind::ColonToken);
}
auto isTupleElementName()
{
if (token() == SyntaxKind::DotDotDotToken)
{
return scanner.tokenIsIdentifierOrKeyword(nextToken()) && isNextTokenColonOrQuestionColon();
}
return scanner.tokenIsIdentifierOrKeyword(token()) && isNextTokenColonOrQuestionColon();
}
auto parseTupleElementNameOrTupleElementType() -> Node
{
if (lookAhead<boolean>(std::bind(&Parser::isTupleElementName, this)))
{
auto pos = getNodePos();
auto hasJSDoc = hasPrecedingJSDocComment();
auto dotDotDotToken = parseOptionalToken(SyntaxKind::DotDotDotToken);
auto name = parseIdentifierName();
auto questionToken = parseOptionalToken(SyntaxKind::QuestionToken);
parseExpected(SyntaxKind::ColonToken);
auto type = parseTupleElementType();
auto node = factory.createNamedTupleMember(dotDotDotToken, name, questionToken, type);
return withJSDoc(finishNode(node, pos), hasJSDoc);
}
return parseTupleElementType();
}
auto parseTupleType() -> TupleTypeNode
{
auto pos = getNodePos();
return finishNode(
factory.createTupleTypeNode(parseBracketedList<Node>(
ParsingContext::TupleElementTypes, std::bind(&Parser::parseTupleElementNameOrTupleElementType, this),
SyntaxKind::OpenBracketToken, SyntaxKind::CloseBracketToken)),
pos);
}
auto parseParenthesizedType() -> TypeNode
{
auto pos = getNodePos();
parseExpected(SyntaxKind::OpenParenToken);
auto type = parseType();
parseExpected(SyntaxKind::CloseParenToken);
return finishNode(factory.createParenthesizedType(type), pos);
}
auto parseModifiersForConstructorType() -> NodeArray<Modifier>
{
ModifiersArray modifiers;
if (token() == SyntaxKind::AbstractKeyword)
{
auto pos = getNodePos();
nextToken();
auto modifier = finishNode(factory.createToken(SyntaxKind::AbstractKeyword), pos);
modifiers = createNodeArray<Modifier>(ModifiersArray(modifier), pos);
}
return modifiers;
}
auto parseFunctionOrConstructorType() -> TypeNode
{
auto pos = getNodePos();
auto hasJSDoc = hasPrecedingJSDocComment();
auto modifiers = parseModifiersForConstructorType();
auto isConstructorType = parseOptional(SyntaxKind::NewKeyword);
auto typeParameters = parseTypeParameters();
auto parameters = parseParameters(SignatureFlags::Type);
auto type = parseReturnType(SyntaxKind::EqualsGreaterThanToken, /*isType*/ false);
auto node = isConstructorType ? factory.createConstructorTypeNode(modifiers, typeParameters, parameters, type)
.as<FunctionOrConstructorTypeNodeBase>()
: factory.createFunctionTypeNode(typeParameters, parameters, type)
.as<FunctionOrConstructorTypeNodeBase>();
if (!isConstructorType)
copy(node->modifiers, modifiers);
return withJSDoc(finishNode(node, pos), hasJSDoc);
}
auto parseKeywordAndNoDot() -> TypeNode
{
auto node = parseTokenNode<TypeNode>();
return token() == SyntaxKind::DotToken ? undefined : node;
}
auto parseLiteralTypeNode(boolean negative = false) -> LiteralTypeNode
{
auto pos = getNodePos();
if (negative)
{
nextToken();
}
Node expression = token() == SyntaxKind::TrueKeyword || token() == SyntaxKind::FalseKeyword ||
token() == SyntaxKind::NullKeyword
? parseTokenNode</*BooleanLiteral, NullLiteral*/ Node>().as<Expression>()
: parseLiteralLikeNode(token()).as<Expression>();
if (negative)
{
expression = finishNode(factory.createPrefixUnaryExpression(SyntaxKind::MinusToken, expression), pos);
}
return finishNode(factory.createLiteralTypeNode(expression), pos);
}
auto isStartOfTypeOfImportType()
{
nextToken();
return token() == SyntaxKind::ImportKeyword;
}
auto parseImportType() -> ImportTypeNode
{
sourceFlags |= NodeFlags::PossiblyContainsDynamicImport;
auto pos = getNodePos();
auto isTypeOf = parseOptional(SyntaxKind::TypeOfKeyword);
parseExpected(SyntaxKind::ImportKeyword);
parseExpected(SyntaxKind::OpenParenToken);
auto type = parseType();
parseExpected(SyntaxKind::CloseParenToken);
auto qualifier = parseOptional(SyntaxKind::DotToken) ? parseEntityNameOfTypeReference() : undefined;
auto typeArguments = parseTypeArgumentsOfTypeReference();
return finishNode(factory.createImportTypeNode(type, qualifier, typeArguments, isTypeOf), pos);
}
auto nextTokenIsNumericOrBigIntLiteral()
{
nextToken();
return token() == SyntaxKind::NumericLiteral || token() == SyntaxKind::BigIntLiteral;
}
auto parseNonArrayType() -> /*TypeNode*/ Node
{
switch (token())
{
case SyntaxKind::AnyKeyword:
case SyntaxKind::UnknownKeyword:
case SyntaxKind::StringKeyword:
case SyntaxKind::NumberKeyword:
case SyntaxKind::BigIntKeyword:
case SyntaxKind::SymbolKeyword:
case SyntaxKind::BooleanKeyword:
case SyntaxKind::UndefinedKeyword:
case SyntaxKind::NeverKeyword:
case SyntaxKind::ObjectKeyword:
// If these are followed by a dot, then parse these out.as<a>() dotted type reference instead.
return tryParse<TypeNode>(std::bind(&Parser::parseKeywordAndNoDot, this)) ||
[&]() { return parseTypeReference(); };
case SyntaxKind::AsteriskEqualsToken:
// If there is '*=', treat it as * followed by postfix =
scanner.reScanAsteriskEqualsToken();
// falls through
case SyntaxKind::AsteriskToken:
return parseJSDocAllType();
case SyntaxKind::QuestionQuestionToken:
// If there is '??', treat it.as<prefix>()-'?' in JSDoc type.
scanner.reScanQuestionToken();
// falls through
case SyntaxKind::QuestionToken:
return parseJSDocUnknownOrNullableType();
case SyntaxKind::FunctionKeyword:
return parseJSDocFunctionType();
case SyntaxKind::ExclamationToken:
return parseJSDocNonNullableType();
case SyntaxKind::NoSubstitutionTemplateLiteral:
case SyntaxKind::StringLiteral:
case SyntaxKind::NumericLiteral:
case SyntaxKind::BigIntLiteral:
case SyntaxKind::TrueKeyword:
case SyntaxKind::FalseKeyword:
case SyntaxKind::NullKeyword:
return parseLiteralTypeNode();
case SyntaxKind::MinusToken:
return lookAhead<boolean>(std::bind(&Parser::nextTokenIsNumericOrBigIntLiteral, this))
? parseLiteralTypeNode(/*negative*/ true).as<Node>()
: parseTypeReference().as<Node>();
case SyntaxKind::VoidKeyword:
return parseTokenNode<TypeNode>();
case SyntaxKind::ThisKeyword: {
auto thisKeyword = parseThisTypeNode();
if (token() == SyntaxKind::IsKeyword && !scanner.hasPrecedingLineBreak())
{
return parseThisTypePredicate(thisKeyword);
}
else
{
return thisKeyword;
}
}
case SyntaxKind::TypeOfKeyword:
return lookAhead<boolean>(std::bind(&Parser::isStartOfTypeOfImportType, this))
? parseImportType().as<Node>()
: parseTypeQuery().as<Node>();
case SyntaxKind::OpenBraceToken:
return lookAhead<boolean>(std::bind(&Parser::isStartOfMappedType, this)) ? parseMappedType()
: parseTypeLiteral().as<Node>();
case SyntaxKind::OpenBracketToken:
return parseTupleType();
case SyntaxKind::OpenParenToken:
return parseParenthesizedType();
case SyntaxKind::ImportKeyword:
return parseImportType();
case SyntaxKind::AssertsKeyword:
return lookAhead<boolean>(std::bind(&Parser::nextTokenIsIdentifierOrKeywordOnSameLine, this))
? parseAssertsTypePredicate().as<Node>()
: parseTypeReference().as<Node>();
case SyntaxKind::TemplateHead:
return parseTemplateType();
default:
return parseTypeReference();
}
}
auto isStartOfType(boolean inStartOfParameter = false) -> boolean
{
switch (token())
{
case SyntaxKind::AnyKeyword:
case SyntaxKind::UnknownKeyword:
case SyntaxKind::StringKeyword:
case SyntaxKind::NumberKeyword:
case SyntaxKind::BigIntKeyword:
case SyntaxKind::BooleanKeyword:
case SyntaxKind::ReadonlyKeyword:
case SyntaxKind::SymbolKeyword:
case SyntaxKind::UniqueKeyword:
case SyntaxKind::VoidKeyword:
case SyntaxKind::UndefinedKeyword:
case SyntaxKind::NullKeyword:
case SyntaxKind::ThisKeyword:
case SyntaxKind::TypeOfKeyword:
case SyntaxKind::NeverKeyword:
case SyntaxKind::OpenBraceToken:
case SyntaxKind::OpenBracketToken:
case SyntaxKind::LessThanToken:
case SyntaxKind::BarToken:
case SyntaxKind::AmpersandToken:
case SyntaxKind::NewKeyword:
case SyntaxKind::StringLiteral:
case SyntaxKind::NumericLiteral:
case SyntaxKind::BigIntLiteral:
case SyntaxKind::TrueKeyword:
case SyntaxKind::FalseKeyword:
case SyntaxKind::ObjectKeyword:
case SyntaxKind::AsteriskToken:
case SyntaxKind::QuestionToken:
case SyntaxKind::ExclamationToken:
case SyntaxKind::DotDotDotToken:
case SyntaxKind::InferKeyword:
case SyntaxKind::ImportKeyword:
case SyntaxKind::AssertsKeyword:
case SyntaxKind::NoSubstitutionTemplateLiteral:
case SyntaxKind::TemplateHead:
return true;
case SyntaxKind::FunctionKeyword:
return !inStartOfParameter;
case SyntaxKind::MinusToken:
return !inStartOfParameter &&
lookAhead<boolean>(std::bind(&Parser::nextTokenIsNumericOrBigIntLiteral, this));
case SyntaxKind::OpenParenToken:
// Only consider '(' the start of a type if followed by ')', '...', an identifier, a modifier,
// or something that starts a type. We don't want to consider things like '(1)' a type.
return !inStartOfParameter &&
lookAhead<boolean>(std::bind(&Parser::isStartOfParenthesizedOrFunctionType, this));
default:
return isIdentifier();
}
}
auto isStartOfParenthesizedOrFunctionType() -> boolean
{
nextToken();
return token() == SyntaxKind::CloseParenToken || isStartOfParameter(/*isJSDocParameter*/ false) ||
isStartOfType();
}
auto parsePostfixTypeOrHigher() -> TypeNode
{
auto pos = getNodePos();
auto type = parseNonArrayType();
while (!scanner.hasPrecedingLineBreak())
{
switch (token())
{
case SyntaxKind::ExclamationToken:
nextToken();
type = finishNode(factory.createJSDocNonNullableType(type), pos);
break;
case SyntaxKind::QuestionToken:
// If next token is start of a type we have a conditional type
if (lookAhead<boolean>(std::bind(&Parser::nextTokenIsStartOfType, this)))
{
return type;
}
nextToken();
type = finishNode(factory.createJSDocNullableType(type), pos);
break;
case SyntaxKind::OpenBracketToken:
parseExpected(SyntaxKind::OpenBracketToken);
if (isStartOfType())
{
auto indexType = parseType();
parseExpected(SyntaxKind::CloseBracketToken);
type = finishNode(factory.createIndexedAccessTypeNode(type, indexType), pos);
}
else
{
parseExpected(SyntaxKind::CloseBracketToken);
type = finishNode(factory.createArrayTypeNode(type), pos);
}
break;
default:
return type;
}
}
return type;
}
auto parseTypeOperator(SyntaxKind operator_) -> TypeNode
{
auto pos = getNodePos();
parseExpected(operator_);
return finishNode(factory.createTypeOperatorNode(operator_, parseTypeOperatorOrHigher()), pos);
}
auto parseTypeParameterOfInferType()
{
auto pos = getNodePos();
return finishNode(factory.createTypeParameterDeclaration(parseIdentifier(),
/*constraint*/ undefined,
/*defaultType*/ undefined),
pos);
}
auto parseInferType() -> InferTypeNode
{
auto pos = getNodePos();
parseExpected(SyntaxKind::InferKeyword);
return finishNode(factory.createInferTypeNode(parseTypeParameterOfInferType()), pos);
}
auto parseTypeOperatorOrHigher() -> /*TypeNode*/ Node
{
auto _operator = token();
switch (_operator)
{
case SyntaxKind::KeyOfKeyword:
case SyntaxKind::UniqueKeyword:
case SyntaxKind::ReadonlyKeyword:
return parseTypeOperator(_operator);
case SyntaxKind::InferKeyword:
return parseInferType();
}
return parsePostfixTypeOrHigher();
}
auto parseFunctionOrConstructorTypeToError(boolean isInUnionType) -> TypeNode
{
// the auto type and constructor type shorthand notation
// are not allowed directly in unions and intersections, but we'll
// try to parse them gracefully and issue a helpful message.
if (isStartOfFunctionTypeOrConstructorType())
{
auto type = parseFunctionOrConstructorType();
DiagnosticMessage diagnostic;
if (isFunctionTypeNode(type))
{
diagnostic =
isInUnionType
? data::DiagnosticMessage(
Diagnostics::Function_type_notation_must_be_parenthesized_when_used_in_a_union_type)
: data::DiagnosticMessage(
Diagnostics::
Function_type_notation_must_be_parenthesized_when_used_in_an_intersection_type);
}
else
{
diagnostic =
isInUnionType
? data::DiagnosticMessage(
Diagnostics::Constructor_type_notation_must_be_parenthesized_when_used_in_a_union_type)
: data::DiagnosticMessage(
Diagnostics::
Constructor_type_notation_must_be_parenthesized_when_used_in_an_intersection_type);
}
parseErrorAtRange(type, diagnostic);
return type;
}
return undefined;
}
auto parseUnionOrIntersectionType(SyntaxKind operator_, std::function<TypeNode()> parseConstituentType,
std::function<UnionOrIntersectionTypeNode(NodeArray<TypeNode>)> createTypeNode)
-> TypeNode
{
auto pos = getNodePos();
auto isUnionType = operator_ == SyntaxKind::BarToken;
auto hasLeadingOperator = parseOptional(operator_);
Node type = (hasLeadingOperator ? parseFunctionOrConstructorTypeToError(isUnionType) : undefined) ||
[&]() { return parseConstituentType(); };
if (token() == operator_ || hasLeadingOperator)
{
auto types = NodeArray<TypeNode>(type);
while (parseOptional(operator_))
{
types.push_back(parseFunctionOrConstructorTypeToError(isUnionType) ||
[&]() { return parseConstituentType(); });
}
type = finishNode(createTypeNode(createNodeArray(types, pos)), pos);
}
return type;
}
auto parseIntersectionTypeOrHigher() -> TypeNode
{
return parseUnionOrIntersectionType(
SyntaxKind::AmpersandToken, std::bind(&Parser::parseTypeOperatorOrHigher, this),
std::bind(&NodeFactory::createIntersectionTypeNode, factory, std::placeholders::_1));
}
auto parseUnionTypeOrHigher() -> TypeNode
{
return parseUnionOrIntersectionType(
SyntaxKind::BarToken, std::bind(&Parser::parseIntersectionTypeOrHigher, this),
std::bind(&NodeFactory::createUnionTypeNode, factory, std::placeholders::_1));
}
auto nextTokenIsNewKeyword() -> boolean
{
nextToken();
return token() == SyntaxKind::NewKeyword;
}
auto isStartOfFunctionTypeOrConstructorType() -> boolean
{
if (token() == SyntaxKind::LessThanToken)
{
return true;
}
if (token() == SyntaxKind::OpenParenToken &&
lookAhead<boolean>(std::bind(&Parser::isUnambiguouslyStartOfFunctionType, this)))
{
return true;
}
return token() == SyntaxKind::NewKeyword ||
token() == SyntaxKind::AbstractKeyword &&
lookAhead<boolean>(std::bind(&Parser::nextTokenIsNewKeyword, this));
}
auto skipParameterStart() -> boolean
{
if (isModifierKind(token()))
{
// Skip modifiers
parseModifiers();
}
if (isIdentifier() || token() == SyntaxKind::ThisKeyword)
{
nextToken();
return true;
}
if (token() == SyntaxKind::OpenBracketToken || token() == SyntaxKind::OpenBraceToken)
{
// Return true if we can parse an array or object binding pattern with no errors
auto previousErrorCount = parseDiagnostics.size();
parseIdentifierOrPattern();
return previousErrorCount == parseDiagnostics.size();
}
return false;
}
auto isUnambiguouslyStartOfFunctionType() -> boolean
{
nextToken();
if (token() == SyntaxKind::CloseParenToken || token() == SyntaxKind::DotDotDotToken)
{
// ( )
// ( ...
return true;
}
if (skipParameterStart())
{
// We successfully skipped modifiers (if any) and an identifier or binding pattern,
// now see if we have something that indicates a parameter declaration
if (token() == SyntaxKind::ColonToken || token() == SyntaxKind::CommaToken ||
token() == SyntaxKind::QuestionToken || token() == SyntaxKind::EqualsToken)
{
// ( xxx :
// ( xxx ,
// ( xxx ?
// ( xxx =
return true;
}
if (token() == SyntaxKind::CloseParenToken)
{
nextToken();
if (token() == SyntaxKind::EqualsGreaterThanToken)
{
// ( xxx ) =>
return true;
}
}
}
return false;
}
auto parseTypeOrTypePredicate() -> TypeNode
{
auto pos = getNodePos();
auto typePredicateVariable =
isIdentifier() ? tryParse<Identifier>(std::bind(&Parser::parseTypePredicatePrefix, this)) : undefined;
auto type = parseType();
if (!!typePredicateVariable)
{
return finishNode(
factory.createTypePredicateNode(/*assertsModifier*/ undefined, typePredicateVariable, type), pos);
}
else
{
return type;
}
}
auto parseTypePredicatePrefix() -> Identifier
{
auto id = parseIdentifier();
if (token() == SyntaxKind::IsKeyword && !scanner.hasPrecedingLineBreak())
{
nextToken();
return id;
}
return undefined;
}
auto parseAssertsTypePredicate() -> TypeNode
{
auto pos = getNodePos();
auto assertsModifier = parseExpectedToken(SyntaxKind::AssertsKeyword);
auto parameterName =
token() == SyntaxKind::ThisKeyword ? parseThisTypeNode().as<Node>() : parseIdentifier().as<Node>();
auto type = parseOptional(SyntaxKind::IsKeyword) ? parseType() : undefined;
return finishNode(factory.createTypePredicateNode(assertsModifier, parameterName, type), pos);
}
auto parseType() -> TypeNode
{
// The rules about 'yield' only apply to actual code/expression contexts. They don't
// apply to 'type' contexts. So we disable these parameters here before moving on.
return doOutsideOfContext<TypeNode>(NodeFlags::TypeExcludesFlags, std::bind(&Parser::parseTypeWorker0, this));
}
auto parseTypeWorker0() -> TypeNode
{
return parseTypeWorker();
}
auto parseTypeWorker(boolean noConditionalTypes = false) -> TypeNode
{
if (isStartOfFunctionTypeOrConstructorType())
{
return parseFunctionOrConstructorType();
}
auto pos = getNodePos();
auto type = parseUnionTypeOrHigher();
if (!noConditionalTypes && !scanner.hasPrecedingLineBreak() && parseOptional(SyntaxKind::ExtendsKeyword))
{
// The type following 'extends' is not permitted to be another conditional type
auto extendsType = parseTypeWorker(/*noConditionalTypes*/ true);
parseExpected(SyntaxKind::QuestionToken);
auto trueType = parseTypeWorker();
parseExpected(SyntaxKind::ColonToken);
auto falseType = parseTypeWorker();
return finishNode(factory.createConditionalTypeNode(type, extendsType, trueType, falseType), pos);
}
return type;
}
auto parseTypeAnnotation() -> TypeNode
{
return parseOptional(SyntaxKind::ColonToken) ? parseType() : undefined;
}
// EXPRESSIONS
auto isStartOfLeftHandSideExpression() -> boolean
{
switch (token())
{
case SyntaxKind::ThisKeyword:
case SyntaxKind::SuperKeyword:
case SyntaxKind::NullKeyword:
case SyntaxKind::TrueKeyword:
case SyntaxKind::FalseKeyword:
case SyntaxKind::NumericLiteral:
case SyntaxKind::BigIntLiteral:
case SyntaxKind::StringLiteral:
case SyntaxKind::NoSubstitutionTemplateLiteral:
case SyntaxKind::TemplateHead:
case SyntaxKind::OpenParenToken:
case SyntaxKind::OpenBracketToken:
case SyntaxKind::OpenBraceToken:
case SyntaxKind::FunctionKeyword:
case SyntaxKind::ClassKeyword:
case SyntaxKind::NewKeyword:
case SyntaxKind::SlashToken:
case SyntaxKind::SlashEqualsToken:
case SyntaxKind::Identifier:
return true;
case SyntaxKind::ImportKeyword:
return lookAhead<boolean>(std::bind(&Parser::nextTokenIsOpenParenOrLessThanOrDot, this));
default:
return isIdentifier();
}
}
auto isStartOfExpression() -> boolean
{
if (isStartOfLeftHandSideExpression())
{
return true;
}
switch (token())
{
case SyntaxKind::PlusToken:
case SyntaxKind::MinusToken:
case SyntaxKind::TildeToken:
case SyntaxKind::ExclamationToken:
case SyntaxKind::DeleteKeyword:
case SyntaxKind::TypeOfKeyword:
case SyntaxKind::VoidKeyword:
case SyntaxKind::PlusPlusToken:
case SyntaxKind::MinusMinusToken:
case SyntaxKind::LessThanToken:
case SyntaxKind::AwaitKeyword:
case SyntaxKind::YieldKeyword:
case SyntaxKind::PrivateIdentifier:
// Yield/await always starts an expression. Either it is an identifier (in which case
// it is definitely an expression). Or it's a keyword (either because we're in
// a generator or async function, or in strict mode (or both)) and it started a yield or await expression.
return true;
default:
// Error tolerance. If we see the start of some binary operator, we consider
// that the start of an expression. That way we'll parse out a missing identifier,
// give a good message about an identifier being missing, and then consume the
// rest of the binary expression.
if (isBinaryOperator())
{
return true;
}
return isIdentifier();
}
}
auto isStartOfExpressionStatement() -> boolean
{
// As per the grammar, none of '{' or 'function' or 'class' can start an expression statement.
return token() != SyntaxKind::OpenBraceToken && token() != SyntaxKind::FunctionKeyword &&
token() != SyntaxKind::ClassKeyword && token() != SyntaxKind::AtToken && isStartOfExpression();
}
auto parseExpression() -> Expression
{
// Expression[in]:
// AssignmentExpression[in]
// Expression[in] , AssignmentExpression[in]
// clear the decorator context when parsing Expression,.as<it>() should be unambiguous when parsing a decorator
auto saveDecoratorContext = inDecoratorContext();
if (saveDecoratorContext)
{
setDecoratorContext(/*val*/ false);
}
auto pos = getNodePos();
auto expr = parseAssignmentExpressionOrHigher();
BinaryOperatorToken operatorToken;
while ((operatorToken = parseOptionalToken(SyntaxKind::CommaToken)))
{
expr = makeBinaryExpression(expr, operatorToken, parseAssignmentExpressionOrHigher(), pos);
}
if (saveDecoratorContext)
{
setDecoratorContext(/*val*/ true);
}
return expr;
}
auto parseInitializer() -> Expression
{
return parseOptional(SyntaxKind::EqualsToken) ? parseAssignmentExpressionOrHigher() : undefined;
}
auto parseAssignmentExpressionOrHigher() -> Expression
{
// AssignmentExpression[in,yield]:
// 1) ConditionalExpression[?in,?yield]
// 2) LeftHandSideExpression = AssignmentExpression[?in,?yield]
// 3) LeftHandSideExpression AssignmentOperator AssignmentExpression[?in,?yield]
// 4) ArrowFunctionExpression[?in,?yield]
// 5) AsyncArrowFunctionExpression[in,yield,await]
// 6) [+Yield] YieldExpression[?In]
//
// for Note ease of implementation we treat productions '2' and '3'.as<the>() same thing.
// (i.e. they're both BinaryExpressions with an assignment operator in it).
// First, do the simple check if we have a YieldExpression (production '6').
if (isYieldExpression())
{
return parseYieldExpression();
}
// Then, check if we have an arrow auto (production '4' and '5') that starts with a parenthesized
// parameter list or is an async arrow function.
// AsyncArrowFunctionExpression:
// 1) async[no LineTerminator here]AsyncArrowBindingIdentifier[?Yield][no LineTerminator
// here]=>AsyncConciseBody[?In] 2) CoverCallExpressionAndAsyncArrowHead[?Yield, ?Await][no LineTerminator
// here]=>AsyncConciseBody[?In]
// Production (1) of AsyncArrowFunctionExpression is parsed in "tryParseAsyncSimpleArrowFunctionExpression".
// And production (2) is parsed in "tryParseParenthesizedArrowFunctionExpression".
//
// If we do successfully parse arrow-function, we must *not* recurse for productions 1, 2 or 3. An ArrowFunction
// is not a LeftHandSideExpression, nor does it start a ConditionalExpression. So we are done with
// AssignmentExpression if we see one.
auto arrowExpression = tryParseParenthesizedArrowFunctionExpression() ||
[&]() { return tryParseAsyncSimpleArrowFunctionExpression(); };
if (arrowExpression)
{
return arrowExpression;
}
// Now try to see if we're in production '1', '2' or '3'. A conditional expression can
// start with a LogicalOrExpression, while the assignment productions can only start with
// LeftHandSideExpressions.
//
// So, first, we try to just parse out a BinaryExpression. If we get something that is a
// LeftHandSide or higher, then we can try to parse out the assignment expression part.
// Otherwise, we try to parse out the conditional expression bit. We want to allow any
// binary expression here, so we pass in the 'lowest' precedence here so that it matches
// and consumes anything.
auto pos = getNodePos();
auto expr = parseBinaryExpressionOrHigher(OperatorPrecedence::Lowest);
// To avoid a look-ahead, we did not handle the case of an arrow auto with a single un-parenthesized
// parameter ('x => ...') above. We handle it here by checking if the parsed expression was a single
// identifier and the current token is an arrow.
if (expr == SyntaxKind::Identifier && token() == SyntaxKind::EqualsGreaterThanToken)
{
return parseSimpleArrowFunctionExpression(pos, expr.as<Identifier>(), /*asyncModifier*/ undefined);
}
// Now see if we might be in cases '2' or '3'.
// If the expression was a LHS expression, and we have an assignment operator, then
// we're in '2' or '3'. Consume the assignment and return.
//
// we Note call reScanGreaterToken so that we get an appropriately merged token
// for cases like `> > =` becoming `>>=`
if (isLeftHandSideExpression(expr) && isAssignmentOperator(reScanGreaterToken()))
{
auto operatorToken = parseTokenNode<Node>();
auto rightExpr = parseAssignmentExpressionOrHigher();
return makeBinaryExpression(expr, operatorToken, rightExpr, pos);
}
// It wasn't an assignment or a lambda. This is a conditional expression:
return parseConditionalExpressionRest(expr, pos);
}
auto isYieldExpression() -> boolean
{
if (token() == SyntaxKind::YieldKeyword)
{
// If we have a 'yield' keyword, and this is a context where yield expressions are
// allowed, then definitely parse out a yield expression.
if (inYieldContext())
{
return true;
}
// We're in a context where 'yield expr' is not allowed. However, if we can
// definitely tell that the user was trying to parse a 'yield expr' and not
// just a normal expr that start with a 'yield' identifier, then parse out
// a 'yield expr'. We can then report an error later that they are only
// allowed in generator expressions.
//
// for example, if we see 'yield(foo)', then we'll have to treat that.as<an>()
// invocation expression of something called 'yield'. However, if we have
// 'yield foo' then that is not legal.as<a>() normal expression, so we can
// definitely recognize this.as<a>() yield expression.
//
// for now we just check if the next token is an identifier. More heuristics
// can be added here later.as<necessary>(). We just need to make sure that we
// don't accidentally consume something legal.
return lookAhead<boolean>(std::bind(&Parser::nextTokenIsIdentifierOrKeywordOrLiteralOnSameLine, this));
}
return false;
}
auto nextTokenIsIdentifierOnSameLine()
{
nextToken();
return !scanner.hasPrecedingLineBreak() && isIdentifier();
}
auto parseYieldExpression() -> YieldExpression
{
auto pos = getNodePos();
// YieldExpression[In] :
// yield
// yield [no LineTerminator here] [Lexical goal InputElementRegExp]AssignmentExpression[?In, Yield]
// yield [no LineTerminator here] * [Lexical goal InputElementRegExp]AssignmentExpression[?In, Yield]
nextToken();
if (!scanner.hasPrecedingLineBreak() && (token() == SyntaxKind::AsteriskToken || isStartOfExpression()))
{
auto asteriskToken = parseOptionalToken(SyntaxKind::AsteriskToken);
auto expression = parseAssignmentExpressionOrHigher();
return finishNode(factory.createYieldExpression(asteriskToken, expression), pos);
}
else
{
// if the next token is not on the same line.as<yield>(). or we don't have an '*' or
// the start of an expression, then this is just a simple "yield" expression.
return finishNode(factory.createYieldExpression(/*asteriskToken*/ undefined, /*expression*/ undefined),
pos);
}
}
auto parseSimpleArrowFunctionExpression(pos_type pos, Identifier identifier, NodeArray<Modifier> asyncModifier)
-> ArrowFunction
{
Debug::_assert(token() == SyntaxKind::EqualsGreaterThanToken,
S("parseSimpleArrowFunctionExpression should only have been called if we had a =>"));
auto parameter = factory.createParameterDeclaration(
/*decorators*/ undefined,
/*modifiers*/ undefined,
/*dotDotDotToken*/ undefined, identifier,
/*questionToken*/ undefined,
/*type*/ undefined,
/*initializer*/ undefined);
finishNode(parameter, identifier->pos);
auto parameters = createNodeArray<ParameterDeclaration>(NodeArray<ParameterDeclaration>({parameter}),
parameter->pos, parameter->_end);
auto equalsGreaterThanToken = parseExpectedToken(SyntaxKind::EqualsGreaterThanToken);
auto body = parseArrowFunctionExpressionBody(/*isAsync*/ !!asyncModifier);
auto node = factory.createArrowFunction(asyncModifier, /*typeParameters*/ undefined, parameters,
/*type*/ undefined, equalsGreaterThanToken, body);
return addJSDocComment(finishNode(node, pos));
}
auto tryParseParenthesizedArrowFunctionExpression() -> Expression
{
auto triState = isParenthesizedArrowFunctionExpression();
if (triState == Tristate::False)
{
// It's definitely not a parenthesized arrow auto expression.
return undefined;
}
// If we definitely have an arrow function, then we can just parse one, not requiring a
// following => or { token. Otherwise, we *might* have an arrow function. Try to parse
// it out, but don't allow any ambiguity, and return 'undefined' if this could be an
// expression instead.
return triState == Tristate::True ? parseParenthesizedArrowFunctionExpression(/*allowAmbiguity*/ true)
: tryParse<ArrowFunction>(std::bind(
&Parser::parsePossibleParenthesizedArrowFunctionExpression, this));
}
// True -> We definitely expect a parenthesized arrow auto here.
// False -> There *cannot* be a parenthesized arrow auto here.
// Unknown -> There *might* be a parenthesized arrow auto here.
// Speculatively look ahead to be sure, and rollback if not.
auto isParenthesizedArrowFunctionExpression() -> Tristate
{
if (token() == SyntaxKind::OpenParenToken || token() == SyntaxKind::LessThanToken ||
token() == SyntaxKind::AsyncKeyword)
{
return lookAhead<Tristate>(std::bind(&Parser::isParenthesizedArrowFunctionExpressionWorker, this));
}
if (token() == SyntaxKind::EqualsGreaterThanToken)
{
// ERROR RECOVERY TWEAK:
// If we see a standalone => try to parse it.as<an>() arrow auto expression.as<that>()'s
// likely what the user intended to write.
return Tristate::True;
}
// Definitely not a parenthesized arrow function.
return Tristate::False;
}
auto isParenthesizedArrowFunctionExpressionWorker() -> Tristate
{
if (token() == SyntaxKind::AsyncKeyword)
{
nextToken();
if (scanner.hasPrecedingLineBreak())
{
return Tristate::False;
}
if (token() != SyntaxKind::OpenParenToken && token() != SyntaxKind::LessThanToken)
{
return Tristate::False;
}
}
auto first = token();
auto second = nextToken();
if (first == SyntaxKind::OpenParenToken)
{
if (second == SyntaxKind::CloseParenToken)
{
// Simple cases: "() =>", "() -> ", and "() {".
// This is an arrow auto with no parameters.
// The last one is not actually an arrow function,
// but this is probably what the user intended.
auto third = nextToken();
switch (third)
{
case SyntaxKind::EqualsGreaterThanToken:
case SyntaxKind::ColonToken:
case SyntaxKind::OpenBraceToken:
return Tristate::True;
default:
return Tristate::False;
}
}
// If encounter "([" or "({", this could be the start of a binding pattern.
// Examples:
// ([ x ]) => { }
// ({ x }) => { }
// ([ x ])
// ({ x })
if (second == SyntaxKind::OpenBracketToken || second == SyntaxKind::OpenBraceToken)
{
return Tristate::Unknown;
}
// Simple case: "(..."
// This is an arrow auto with a rest parameter.
if (second == SyntaxKind::DotDotDotToken)
{
return Tristate::True;
}
// Check for "(xxx yyy", where xxx is a modifier and yyy is an identifier. This
// isn't actually allowed, but we want to treat it.as<a>() lambda so we can provide
// a good error message.
if (isModifierKind(second) && second != SyntaxKind::AsyncKeyword &&
lookAhead<boolean>(std::bind(&Parser::nextTokenIsIdentifier, this)))
{
return Tristate::True;
}
// If we had "(" followed by something that's not an identifier,
// then this definitely doesn't look like a lambda. "this" is not
// valid, but we want to parse it and then give a semantic error.
if (!isIdentifier() && second != SyntaxKind::ThisKeyword)
{
return Tristate::False;
}
switch (nextToken())
{
case SyntaxKind::ColonToken:
// If we have something like "(a:", then we must have a
// type-annotated parameter in an arrow auto expression.
return Tristate::True;
case SyntaxKind::QuestionToken:
nextToken();
// If we have "(a?:" or "(a?," or "(a?=" or "(a?)" then it is definitely a lambda.
if (token() == SyntaxKind::ColonToken || token() == SyntaxKind::CommaToken ||
token() == SyntaxKind::EqualsToken || token() == SyntaxKind::CloseParenToken)
{
return Tristate::True;
}
// Otherwise it is definitely not a lambda.
return Tristate::False;
case SyntaxKind::CommaToken:
case SyntaxKind::EqualsToken:
case SyntaxKind::CloseParenToken:
// If we have "(a," or "(a=" or "(a)" this *could* be an arrow function
return Tristate::Unknown;
}
// It is definitely not an arrow function
return Tristate::False;
}
else
{
Debug::_assert(first == SyntaxKind::LessThanToken);
// If we have "<" not followed by an identifier,
// then this definitely is not an arrow function.
if (!isIdentifier())
{
return Tristate::False;
}
// JSX overrides
if (languageVariant == LanguageVariant::JSX)
{
auto isArrowFunctionInJsx = lookAhead<boolean>([&]() {
auto third = nextToken();
if (third == SyntaxKind::ExtendsKeyword)
{
auto fourth = nextToken();
switch (fourth)
{
case SyntaxKind::EqualsToken:
case SyntaxKind::GreaterThanToken:
return false;
default:
return true;
}
}
else if (third == SyntaxKind::CommaToken)
{
return true;
}
return false;
});
if (isArrowFunctionInJsx)
{
return Tristate::True;
}
return Tristate::False;
}
// This *could* be a parenthesized arrow function.
return Tristate::Unknown;
}
}
auto parsePossibleParenthesizedArrowFunctionExpression() -> ArrowFunction
{
auto tokenPos = scanner.getTokenPos();
if (std::find(notParenthesizedArrow.begin(), notParenthesizedArrow.end(), tokenPos) !=
notParenthesizedArrow.end())
{
return undefined;
}
auto result = parseParenthesizedArrowFunctionExpression(/*allowAmbiguity*/ false);
if (!result)
{
notParenthesizedArrow.push_back(tokenPos);
}
return result;
}
auto tryParseAsyncSimpleArrowFunctionExpression() -> ArrowFunction
{
// We do a check here so that we won't be doing unnecessarily call to "lookAhead"
if (token() == SyntaxKind::AsyncKeyword)
{
if (lookAhead<Tristate>(std::bind(&Parser::isUnParenthesizedAsyncArrowFunctionWorker, this)) ==
Tristate::True)
{
auto pos = getNodePos();
auto asyncModifier = parseModifiersForArrowFunction();
auto expr = parseBinaryExpressionOrHigher(OperatorPrecedence::Lowest);
return parseSimpleArrowFunctionExpression(pos, expr.as<Identifier>(), asyncModifier);
}
}
return undefined;
}
auto isUnParenthesizedAsyncArrowFunctionWorker() -> Tristate
{
// AsyncArrowFunctionExpression:
// 1) async[no LineTerminator here]AsyncArrowBindingIdentifier[?Yield][no LineTerminator
// here]=>AsyncConciseBody[?In] 2) CoverCallExpressionAndAsyncArrowHead[?Yield, ?Await][no LineTerminator
// here]=>AsyncConciseBody[?In]
if (token() == SyntaxKind::AsyncKeyword)
{
nextToken();
// If the "async" is followed by "=>" token then it is not a beginning of an async arrow-function
// but instead a simple arrow-auto which will be parsed inside "parseAssignmentExpressionOrHigher"
if (scanner.hasPrecedingLineBreak() || token() == SyntaxKind::EqualsGreaterThanToken)
{
return Tristate::False;
}
// Check for un-parenthesized AsyncArrowFunction
auto expr = parseBinaryExpressionOrHigher(OperatorPrecedence::Lowest);
if (!scanner.hasPrecedingLineBreak() && expr == SyntaxKind::Identifier &&
token() == SyntaxKind::EqualsGreaterThanToken)
{
return Tristate::True;
}
}
return Tristate::False;
}
auto parseParenthesizedArrowFunctionExpression(boolean allowAmbiguity) -> ArrowFunction
{
auto pos = getNodePos();
auto hasJSDoc = hasPrecedingJSDocComment();
auto modifiers = parseModifiersForArrowFunction();
auto isAsync = some(modifiers, isAsyncModifier) ? SignatureFlags::Await : SignatureFlags::None;
// Arrow functions are never generators.
//
// If we're speculatively parsing a signature for a parenthesized arrow function, then
// we have to have a complete parameter list. Otherwise we might see something like
// a => (b => c)
// And think that "(b =>" was actually a parenthesized arrow auto with a missing
// close paren.
auto typeParameters = parseTypeParameters();
NodeArray<ParameterDeclaration> parameters;
if (!parseExpected(SyntaxKind::OpenParenToken))
{
if (!allowAmbiguity)
{
return undefined;
}
parameters = createMissingList<ParameterDeclaration>();
}
else
{
parameters = parseParametersWorker(isAsync);
if (!parseExpected(SyntaxKind::CloseParenToken) && !allowAmbiguity)
{
return undefined;
}
}
auto type = parseReturnType(SyntaxKind::ColonToken, /*isType*/ false);
if (!!type && !allowAmbiguity && typeHasArrowFunctionBlockingParseError(type))
{
return undefined;
}
// Parsing a signature isn't enough.
// Parenthesized arrow signatures often look like other valid expressions.
// For instance:
// - "(x = 10)" is an assignment expression parsed.as<a>() signature with a default parameter value.
// - "(x,y)" is a comma expression parsed.as<a>() signature with two parameters.
// - "a ? (b) -> c" will have "(b) ->" parsed.as<a>() signature with a return type annotation.
// - "a ? (b) -> function() {}" will too, since function() is a valid JSDoc auto type.
//
// So we need just a bit of lookahead to ensure that it can only be a signature.
auto hasJSDocFunctionType = !!type && isJSDocFunctionType(type);
if (!allowAmbiguity && token() != SyntaxKind::EqualsGreaterThanToken &&
(hasJSDocFunctionType || token() != SyntaxKind::OpenBraceToken))
{
// Returning undefined here will cause our caller to rewind to where we started from.
return undefined;
}
// If we have an arrow, then try to parse the body. Even if not, try to parse if we
// have an opening brace, just in case we're in an error state.
auto lastToken = token();
auto equalsGreaterThanToken = parseExpectedToken(SyntaxKind::EqualsGreaterThanToken);
auto body = (lastToken == SyntaxKind::EqualsGreaterThanToken || lastToken == SyntaxKind::OpenBraceToken)
? parseArrowFunctionExpressionBody(some(modifiers, isAsyncModifier))
: parseIdentifier().as<Node>();
auto node =
factory.createArrowFunction(modifiers, typeParameters, parameters, type, equalsGreaterThanToken, body);
return withJSDoc(finishNode(node, pos), hasJSDoc);
}
auto parseArrowFunctionExpressionBody(boolean isAsync) -> Node
{
if (token() == SyntaxKind::OpenBraceToken)
{
return parseFunctionBlock(isAsync ? SignatureFlags::Await : SignatureFlags::None);
}
if (token() != SyntaxKind::SemicolonToken && token() != SyntaxKind::FunctionKeyword &&
token() != SyntaxKind::ClassKeyword && isStartOfStatement() && !isStartOfExpressionStatement())
{
// Check if we got a plain statement (i.e. no expression-statements, no function/class
// expressions/declarations)
//
// Here we try to recover from a potential error situation in the case where the
// user meant to supply a block. For example, if the user wrote:
//
// a =>
// auto v = 0;
// }
//
// they may be missing an open brace. Check to see if that's the case so we can
// try to recover better. If we don't do this, then the next close curly we see may end
// up preemptively closing the containing construct.
//
// even Note when 'IgnoreMissingOpenBrace' is passed, parseBody will still error.
return parseFunctionBlock(SignatureFlags::IgnoreMissingOpenBrace |
(isAsync ? SignatureFlags::Await : SignatureFlags::None));
}
auto savedTopLevel = topLevel;
topLevel = false;
auto node =
isAsync ? doInAwaitContext<Expression>(std::bind(&Parser::parseAssignmentExpressionOrHigher, this))
: doOutsideOfAwaitContext<Expression>(std::bind(&Parser::parseAssignmentExpressionOrHigher, this));
topLevel = savedTopLevel;
return node;
}
auto parseConditionalExpressionRest(Expression leftOperand, pos_type pos) -> Expression
{
// we Note are passed in an expression which was produced from parseBinaryExpressionOrHigher.
auto questionToken = parseOptionalToken(SyntaxKind::QuestionToken);
if (!questionToken)
{
return leftOperand;
}
// we Note explicitly 'allowIn' in the whenTrue part of the condition expression, and
// we do not that for the 'whenFalse' part.
auto whenTrue = doOutsideOfContext<Expression>(disallowInAndDecoratorContext,
std::bind(&Parser::parseAssignmentExpressionOrHigher, this));
auto colonToken = parseExpectedToken(SyntaxKind::ColonToken);
auto whenFalse = nodeIsPresent(colonToken)
? parseAssignmentExpressionOrHigher().as<Node>()
: createMissingNode<Identifier>(SyntaxKind::Identifier, /*reportAtCurrentPosition*/ false,
data::DiagnosticMessage(Diagnostics::_0_expected),
scanner.tokenToString(SyntaxKind::ColonToken));
return finishNode(
factory.createConditionalExpression(leftOperand, questionToken, whenTrue, colonToken, whenFalse), pos);
}
auto parseBinaryExpressionOrHigher(OperatorPrecedence precedence) -> Expression
{
auto pos = getNodePos();
auto leftOperand = parseUnaryExpressionOrHigher();
return parseBinaryExpressionRest(precedence, leftOperand, pos);
}
auto isInOrOfKeyword(SyntaxKind t) -> boolean
{
return t == SyntaxKind::InKeyword || t == SyntaxKind::OfKeyword;
}
auto parseBinaryExpressionRest(OperatorPrecedence precedence, Expression leftOperand, pos_type pos) -> Expression
{
while (true)
{
// We either have a binary operator here, or we're finished. We call
// reScanGreaterToken so that we merge token sequences like > and = into >=
reScanGreaterToken();
auto newPrecedence = getBinaryOperatorPrecedence(token());
// Check the precedence to see if we should "take" this operator
// - For left associative operator (all operator but **), consume the operator,
// recursively call the auto below, and parse binaryExpression.as<a>() rightOperand
// of the caller if the new precedence of the operator is greater then or equal to the current precedence.
// For example:
// a - b - c;
// ^token; leftOperand = b. Return b to the caller.as<a>() rightOperand
// a * b - c
// ^token; leftOperand = b. Return b to the caller.as<a>() rightOperand
// a - b * c;
// ^token; leftOperand = b. Return b * c to the caller.as<a>() rightOperand
// - For right associative operator (**), consume the operator, recursively call the function
// and parse binaryExpression.as<a>() rightOperand of the caller if the new precedence of
// the operator is strictly grater than the current precedence
// For example:
// a ** b ** c;
// ^^token; leftOperand = b. Return b ** c to the caller.as<a>() rightOperand
// a - b ** c;
// ^^token; leftOperand = b. Return b ** c to the caller.as<a>() rightOperand
// a ** b - c
// ^token; leftOperand = b. Return b to the caller.as<a>() rightOperand
auto consumeCurrentOperator =
token() == SyntaxKind::AsteriskAsteriskToken ? newPrecedence >= precedence : newPrecedence > precedence;
if (!consumeCurrentOperator)
{
break;
}
if (token() == SyntaxKind::InKeyword && inDisallowInContext())
{
break;
}
if (token() == SyntaxKind::AsKeyword)
{
// Make sure we *do* perform ASI for constructs like this:
// var x = foo
// as (Bar)
// This should be parsed.as<an>() initialized variable, followed
// by a auto call to 'as' with the argument 'Bar'
if (scanner.hasPrecedingLineBreak())
{
break;
}
else
{
nextToken();
leftOperand = makeAsExpression(leftOperand, parseType());
}
}
else
{
auto tokenNode = parseTokenNode<Node>();
auto binaryExpressionOrHigher = parseBinaryExpressionOrHigher(newPrecedence);
leftOperand = makeBinaryExpression(leftOperand, tokenNode, binaryExpressionOrHigher, pos);
}
}
return leftOperand;
}
auto isBinaryOperator() -> boolean
{
if (inDisallowInContext() && token() == SyntaxKind::InKeyword)
{
return false;
}
return getBinaryOperatorPrecedence(token()) > (OperatorPrecedence)0;
}
auto makeBinaryExpression(Expression left, BinaryOperatorToken operatorToken, Expression right, pos_type pos)
-> BinaryExpression
{
return finishNode(factory.createBinaryExpression(left, operatorToken, right), pos);
}
auto makeAsExpression(Expression left, TypeNode right) -> AsExpression
{
return finishNode(factory.createAsExpression(left, right), left->pos);
}
auto parsePrefixUnaryExpression() -> Node
{
auto pos = getNodePos();
auto _operator = token();
auto unaryExpression = nextTokenAnd<UnaryExpression>(std::bind(&Parser::parseSimpleUnaryExpression, this));
return finishNode(factory.createPrefixUnaryExpression(_operator, unaryExpression), pos);
}
auto parseDeleteExpression() -> Node
{
auto pos = getNodePos();
return finishNode(factory.createDeleteExpression(
nextTokenAnd<UnaryExpression>(std::bind(&Parser::parseSimpleUnaryExpression, this))),
pos);
}
auto parseTypeOfExpression() -> Node
{
auto pos = getNodePos();
return finishNode(factory.createTypeOfExpression(
nextTokenAnd<UnaryExpression>(std::bind(&Parser::parseSimpleUnaryExpression, this))),
pos);
}
auto parseVoidExpression() -> Node
{
auto pos = getNodePos();
return finishNode(factory.createVoidExpression(
nextTokenAnd<UnaryExpression>(std::bind(&Parser::parseSimpleUnaryExpression, this))),
pos);
}
auto isAwaitExpression() -> boolean
{
if (token() == SyntaxKind::AwaitKeyword)
{
if (inAwaitContext())
{
return true;
}
// here we are using similar heuristics as 'isYieldExpression'
return lookAhead<boolean>(std::bind(&Parser::nextTokenIsIdentifierOrKeywordOrLiteralOnSameLine, this));
}
return false;
}
auto parseAwaitExpression() -> Node
{
auto pos = getNodePos();
return finishNode(factory.createAwaitExpression(
nextTokenAnd<UnaryExpression>(std::bind(&Parser::parseSimpleUnaryExpression, this))),
pos);
}
/**
* Parse ES7 exponential expression and await expression
*
* ES7 ExponentiationExpression:
* 1) UnaryExpression[?Yield]
* 2) UpdateExpression[?Yield] ** ExponentiationExpression[?Yield]
*
*/
auto parseUnaryExpressionOrHigher() -> Node
{
/**
* ES7 UpdateExpression:
* 1) LeftHandSideExpression[?Yield]
* 2) LeftHandSideExpression[?Yield][no LineTerminator here]++
* 3) LeftHandSideExpression[?Yield][no LineTerminator here]--
* 4) ++UnaryExpression[?Yield]
* 5) --UnaryExpression[?Yield]
*/
if (isUpdateExpression())
{
auto pos = getNodePos();
auto updateExpression = parseUpdateExpression();
return token() == SyntaxKind::AsteriskAsteriskToken
? parseBinaryExpressionRest(getBinaryOperatorPrecedence(token()), updateExpression, pos)
: updateExpression.as<Expression>();
}
/**
* ES7 UnaryExpression:
* 1) UpdateExpression[?yield]
* 2) delete UpdateExpression[?yield]
* 3) void UpdateExpression[?yield]
* 4) typeof UpdateExpression[?yield]
* 5) + UpdateExpression[?yield]
* 6) - UpdateExpression[?yield]
* 7) ~ UpdateExpression[?yield]
* 8) ! UpdateExpression[?yield]
*/
auto unaryOperator = token();
auto simpleUnaryExpression = parseSimpleUnaryExpression();
if (token() == SyntaxKind::AsteriskAsteriskToken)
{
auto safe_sourceText = safe_string(sourceText);
auto pos = scanner.skipTrivia(safe_sourceText, simpleUnaryExpression->pos);
auto end = simpleUnaryExpression->_end;
if (simpleUnaryExpression == SyntaxKind::TypeAssertionExpression)
{
parseErrorAt(
pos, end,
data::DiagnosticMessage(
Diagnostics::
A_type_assertion_expression_is_not_allowed_in_the_left_hand_side_of_an_exponentiation_expression_Consider_enclosing_the_expression_in_parentheses));
}
else
{
parseErrorAt(
pos, end,
data::DiagnosticMessage(
Diagnostics::
An_unary_expression_with_the_0_operator_is_not_allowed_in_the_left_hand_side_of_an_exponentiation_expression_Consider_enclosing_the_expression_in_parentheses),
scanner.tokenToString(unaryOperator));
}
}
return simpleUnaryExpression;
}
/**
* Parse ES7 simple-unary expression or higher:
*
* ES7 UnaryExpression:
* 1) UpdateExpression[?yield]
* 2) delete UnaryExpression[?yield]
* 3) void UnaryExpression[?yield]
* 4) typeof UnaryExpression[?yield]
* 5) + UnaryExpression[?yield]
* 6) - UnaryExpression[?yield]
* 7) ~ UnaryExpression[?yield]
* 8) ! UnaryExpression[?yield]
* 9) [+Await] await UnaryExpression[?yield]
*/
auto parseSimpleUnaryExpression() -> UnaryExpression
{
switch (token())
{
case SyntaxKind::PlusToken:
case SyntaxKind::MinusToken:
case SyntaxKind::TildeToken:
case SyntaxKind::ExclamationToken:
return parsePrefixUnaryExpression();
case SyntaxKind::DeleteKeyword:
return parseDeleteExpression();
case SyntaxKind::TypeOfKeyword:
return parseTypeOfExpression();
case SyntaxKind::VoidKeyword:
return parseVoidExpression();
case SyntaxKind::LessThanToken:
// This is modified UnaryExpression grammar in TypeScript
// UnaryExpression (modified) ->
// < type > UnaryExpression
return parseTypeAssertion();
case SyntaxKind::AwaitKeyword:
if (isAwaitExpression())
{
return parseAwaitExpression();
}
// falls through
default:
return parseUpdateExpression();
}
}
/**
* Check if the current token can possibly be an ES7 increment expression.
*
* ES7 UpdateExpression:
* LeftHandSideExpression[?Yield]
* LeftHandSideExpression[?Yield][no LineTerminator here]++
* LeftHandSideExpression[?Yield][no LineTerminator here]--
* ++LeftHandSideExpression[?Yield]
* --LeftHandSideExpression[?Yield]
*/
auto isUpdateExpression() -> boolean
{
// This auto is called inside parseUnaryExpression to decide
// whether to call parseSimpleUnaryExpression or call parseUpdateExpression directly
switch (token())
{
case SyntaxKind::PlusToken:
case SyntaxKind::MinusToken:
case SyntaxKind::TildeToken:
case SyntaxKind::ExclamationToken:
case SyntaxKind::DeleteKeyword:
case SyntaxKind::TypeOfKeyword:
case SyntaxKind::VoidKeyword:
case SyntaxKind::AwaitKeyword:
return false;
case SyntaxKind::LessThanToken:
// If we are not in JSX context, we are parsing TypeAssertion which is an UnaryExpression
if (languageVariant != LanguageVariant::JSX)
{
return false;
}
// We are in JSX context and the token is part of JSXElement.
// falls through
default:
return true;
}
}
/**
* Parse ES7 UpdateExpression. UpdateExpression is used instead of ES6's PostFixExpression.
*
* ES7 UpdateExpression[yield]:
* 1) LeftHandSideExpression[?yield]
* 2) LeftHandSideExpression[?yield] [[no LineTerminator here]]++
* 3) LeftHandSideExpression[?yield] [[no LineTerminator here]]--
* 4) ++LeftHandSideExpression[?yield]
* 5) --LeftHandSideExpression[?yield]
* In TypeScript (2), (3) are parsed.as<PostfixUnaryExpression>(). (4), (5) are parsed.as<PrefixUnaryExpression>()
*/
auto parseUpdateExpression() -> UpdateExpression
{
if (token() == SyntaxKind::PlusPlusToken || token() == SyntaxKind::MinusMinusToken)
{
auto pos = getNodePos();
auto _operator = token();
auto leftHandSideExpressionOrHigher =
nextTokenAnd<LeftHandSideExpression>(std::bind(&Parser::parseLeftHandSideExpressionOrHigher, this));
return finishNode(factory.createPrefixUnaryExpression(_operator, leftHandSideExpressionOrHigher), pos);
}
else if (languageVariant == LanguageVariant::JSX && token() == SyntaxKind::LessThanToken &&
lookAhead<boolean>(std::bind(&Parser::nextTokenIsIdentifierOrKeywordOrGreaterThan, this)))
{
// JSXElement is part of primaryExpression
return parseJsxElementOrSelfClosingElementOrFragment(/*inExpressionContext*/ true);
}
auto expression = parseLeftHandSideExpressionOrHigher();
Debug::_assert(isLeftHandSideExpression(expression));
if ((token() == SyntaxKind::PlusPlusToken || token() == SyntaxKind::MinusMinusToken) &&
!scanner.hasPrecedingLineBreak())
{
auto _operator = token();
nextToken();
return finishNode(factory.createPostfixUnaryExpression(expression, _operator), expression->pos);
}
return expression;
}
auto parseLeftHandSideExpressionOrHigher() -> LeftHandSideExpression
{
// Original Ecma:
// See LeftHandSideExpression 11.2
// NewExpression
// CallExpression
//
// Our simplification:
//
// See LeftHandSideExpression 11.2
// MemberExpression
// CallExpression
//
// See comment in parseMemberExpressionOrHigher on how we replaced NewExpression with
// MemberExpression to make our lives easier.
//
// to best understand the below code, it's important to see how CallExpression expands
// out into its own productions:
//
// CallExpression:
// MemberExpression Arguments
// CallExpression Arguments
// CallExpression[Expression]
// CallExpression.IdentifierName
// import (AssignmentExpression)
// super Arguments
// super.IdentifierName
//
// Because of the recursion in these calls, we need to bottom out first. There are three
// bottom out states we can run 1 into) We see 'super' which must start either of
// the last two CallExpression productions. 2) We see 'import' which must start import call.
// 3)we have a MemberExpression which either completes the LeftHandSideExpression,
// or starts the beginning of the first four CallExpression productions.
auto pos = getNodePos();
MemberExpression expression;
if (token() == SyntaxKind::ImportKeyword)
{
if (lookAhead<boolean>(std::bind(&Parser::nextTokenIsOpenParenOrLessThan, this)))
{
// We don't want to eagerly consume all import keyword.as<import>() call expression so we look ahead to
// find "(" For example:
// var foo3 = require("subfolder
// import *.as<foo1>() from "module-from-node
// We want this import to be a statement rather than import call expression
sourceFlags |= NodeFlags::PossiblyContainsDynamicImport;
expression = parseTokenNode<PrimaryExpression>();
}
else if (lookAhead<boolean>(std::bind(&Parser::nextTokenIsDot, this)))
{
// This is an 'import.*' metaproperty (i.e. 'import.meta')
nextToken(); // advance past the 'import'
nextToken(); // advance past the dot
expression =
finishNode(factory.createMetaProperty(SyntaxKind::ImportKeyword, parseIdentifierName()), pos);
sourceFlags |= NodeFlags::PossiblyContainsImportMeta;
}
else
{
expression = parseMemberExpressionOrHigher();
}
}
else
{
expression = token() == SyntaxKind::SuperKeyword ? parseSuperExpression() : parseMemberExpressionOrHigher();
}
// Now, we *may* be complete. However, we might have consumed the start of a
// CallExpression or OptionalExpression. As such, we need to consume the rest
// of it here to be complete.
return parseCallExpressionRest(pos, expression);
}
auto parseMemberExpressionOrHigher() -> MemberExpression
{
// to Note make our lives simpler, we decompose the NewExpression productions and
// place ObjectCreationExpression and FunctionExpression into PrimaryExpression.
// like so:
//
// PrimaryExpression : See 11.1
// this
// Identifier
// Literal
// ArrayLiteral
// ObjectLiteral
// (Expression)
// FunctionExpression
// new MemberExpression Arguments?
//
// MemberExpression : See 11.2
// PrimaryExpression
// MemberExpression[Expression]
// MemberExpression.IdentifierName
//
// CallExpression : See 11.2
// MemberExpression
// CallExpression Arguments
// CallExpression[Expression]
// CallExpression.IdentifierName
//
// Technically this is ambiguous. i.e. CallExpression defines:
//
// CallExpression:
// CallExpression Arguments
//
// If you see: "new Foo()"
//
// Then that could be treated.as<a>() single ObjectCreationExpression, or it could be
// treated.as<the>() invocation of "new Foo". We disambiguate that in code (to match
// the original grammar) by making sure that if we see an ObjectCreationExpression
// we always consume arguments if they are there. So we treat "new Foo()".as<an>()
// object creation only, and not at all.as<an>() invocation. Another way to think
// about this is that for every "new" that we see, we will consume an argument list if
// it is there.as<part>() of the *associated* object creation node-> Any additional
// argument lists we see, will become invocation expressions.
//
// Because there are no other places in the grammar now that refer to FunctionExpression
// or ObjectCreationExpression, it is safe to push down into the PrimaryExpression
// production.
//
// Because CallExpression and MemberExpression are left recursive, we need to bottom out
// of the recursion immediately. So we parse out a primary expression to start with.
auto pos = getNodePos();
auto expression = parsePrimaryExpression();
return parseMemberExpressionRest(pos, expression, /*allowOptionalChain*/ true);
}
auto parseSuperExpression() -> MemberExpression
{
auto pos = getNodePos();
auto expression = parseTokenNode<PrimaryExpression>();
if (token() == SyntaxKind::LessThanToken)
{
auto startPos = getNodePos();
auto typeArguments =
tryParse<NodeArray<TypeNode>>(std::bind(&Parser::parseTypeArgumentsInExpression, this));
if (typeArguments != undefined)
{
parseErrorAt(startPos, getNodePos(),
data::DiagnosticMessage(Diagnostics::super_may_not_use_type_arguments));
}
}
if (token() == SyntaxKind::OpenParenToken || token() == SyntaxKind::DotToken ||
token() == SyntaxKind::OpenBracketToken)
{
return expression;
}
// If we have seen "super" it must be followed by '(' or '.'.
// If it wasn't then just try to parse out a '.' and report an error.
parseExpectedToken(
SyntaxKind::DotToken,
data::DiagnosticMessage(Diagnostics::super_must_be_followed_by_an_argument_list_or_member_access));
// private names will never work with `super` (`super.#foo`), but that's a semantic error, not syntactic
return finishNode(
factory.createPropertyAccessExpression(
expression, parseRightSideOfDot(/*allowIdentifierNames*/ true, /*allowPrivateIdentifiers*/ true)),
pos);
}
auto parseJsxElementOrSelfClosingElementOrFragment(boolean inExpressionContext, number topInvalidNodePosition = -1)
-> Node
{
auto pos = getNodePos();
auto opening = parseJsxOpeningOrSelfClosingElementOrOpeningFragment(inExpressionContext);
Node result;
if (opening == SyntaxKind::JsxOpeningElement)
{
auto children = parseJsxChildren(opening);
auto closingElement = parseJsxClosingElement(inExpressionContext);
if (!tagNamesAreEquivalent(opening.as<JsxOpeningElement>()->tagName.as<JsxTagNameExpression>(),
closingElement->tagName.as<JsxTagNameExpression>()))
{
parseErrorAtRange(closingElement,
data::DiagnosticMessage(Diagnostics::Expected_corresponding_JSX_closing_tag_for_0),
getTextOfNodeFromSourceText(sourceText, opening.as<JsxOpeningElement>()->tagName));
}
result = finishNode(factory.createJsxElement(opening, children, closingElement), pos);
}
else if (opening == SyntaxKind::JsxOpeningFragment)
{
auto jsxChildren = parseJsxChildren(opening);
auto jsxClosingFragment = parseJsxClosingFragment(inExpressionContext);
result = finishNode(factory.createJsxFragment(opening, jsxChildren, jsxClosingFragment), pos);
}
else
{
Debug::_assert(opening == SyntaxKind::JsxSelfClosingElement);
// Nothing else to do for self-closing elements
result = opening;
}
// If the user writes the invalid code '<div></div><div></div>' in an expression context (i.e. not wrapped in
// an enclosing tag), we'll naively try to parse ^ this.as<a>() 'less than' operator and the remainder of the
// tag
//.as<garbage>(), which will cause the formatter to badly mangle the JSX. Perform a speculative parse of a JSX
// element if we see a < token so that we can wrap it in a synthetic binary expression so the formatter
// does less damage and we can report a better error.
// Since JSX elements are invalid < operands anyway, this lookahead parse will only occur in error scenarios
// of one sort or another.
if (inExpressionContext && token() == SyntaxKind::LessThanToken)
{
auto topBadPos = topInvalidNodePosition == -1 ? static_cast<number>(result->pos) : topInvalidNodePosition;
auto invalidElement = tryParse<Node>([&]() {
return parseJsxElementOrSelfClosingElementOrFragment(/*inExpressionContext*/ true, topBadPos);
});
if (invalidElement)
{
auto operatorToken = createMissingNode(SyntaxKind::CommaToken, /*reportAtCurrentPosition*/ false);
setTextRangePosWidth(operatorToken, invalidElement->pos, 0);
auto safe_str = safe_string(sourceText);
parseErrorAt(scanner.skipTrivia(safe_str, topBadPos), invalidElement->_end,
data::DiagnosticMessage(Diagnostics::JSX_expressions_must_have_one_parent_element));
return finishNode(factory.createBinaryExpression(result, operatorToken, invalidElement), pos);
}
}
return result;
}
auto parseJsxText() -> JsxText
{
auto pos = getNodePos();
auto tokenValue = scanner.getTokenValue();
auto containsOnlyTriviaWhiteSpaces = currentToken == SyntaxKind::JsxTextAllWhiteSpaces;
auto node = factory.createJsxText(tokenValue, containsOnlyTriviaWhiteSpaces);
currentToken = scanner.scanJsxToken();
return finishNode(node, pos);
}
auto parseJsxChild(Node openingTag, SyntaxKind token) -> JsxChild
{
switch (token)
{
case SyntaxKind::EndOfFileToken:
// If we hit EOF, issue the error at the tag that lacks the closing element
// rather than at the end of the file (which is useless)
if (isJsxOpeningFragment(openingTag))
{
parseErrorAtRange(openingTag,
data::DiagnosticMessage(Diagnostics::JSX_fragment_has_no_corresponding_closing_tag));
}
else
{
// We want the error span to cover only 'Foo.Bar' in < Foo.Bar >
// or to cover only 'Foo' in < Foo >
auto tag = openingTag.as<JsxOpeningElement>()->tagName;
auto safe_str = safe_string(sourceText);
auto start = scanner.skipTrivia(safe_str, tag->pos);
parseErrorAt(start, tag->_end,
data::DiagnosticMessage(Diagnostics::JSX_element_0_has_no_corresponding_closing_tag),
getTextOfNodeFromSourceText(sourceText, openingTag.as<JsxOpeningElement>()->tagName));
}
return undefined;
case SyntaxKind::LessThanSlashToken:
case SyntaxKind::ConflictMarkerTrivia:
return undefined;
case SyntaxKind::JsxText:
case SyntaxKind::JsxTextAllWhiteSpaces:
return parseJsxText();
case SyntaxKind::OpenBraceToken:
return parseJsxExpression(/*inExpressionContext*/ false);
case SyntaxKind::LessThanToken:
return parseJsxElementOrSelfClosingElementOrFragment(/*inExpressionContext*/ false);
default:
return Debug::_assertNever(/*token*/ Node());
}
}
auto parseJsxChildren(Node openingTag) -> NodeArray<JsxChild>
{
NodeArray<JsxChild> list;
auto listPos = getNodePos();
auto saveParsingContext = parsingContext;
parsingContext |= (ParsingContext)(1 << (number)ParsingContext::JsxChildren);
while (true)
{
auto child = parseJsxChild(openingTag, currentToken = scanner.reScanJsxToken());
if (!child)
break;
list.push_back(child);
}
parsingContext = saveParsingContext;
return createNodeArray(list, listPos);
}
auto parseJsxAttributes() -> JsxAttributes
{
auto pos = getNodePos();
return finishNode(factory.createJsxAttributes(parseList<Node>(ParsingContext::JsxAttributes,
std::bind(&Parser::parseJsxAttribute, this))),
pos);
}
auto parseJsxOpeningOrSelfClosingElementOrOpeningFragment(boolean inExpressionContext) -> Node
{
auto pos = getNodePos();
parseExpected(SyntaxKind::LessThanToken);
if (token() == SyntaxKind::GreaterThanToken)
{
// See below for explanation of scanJsxText
scanJsxText();
return finishNode(factory.createJsxOpeningFragment(), pos);
}
auto tagName = parseJsxElementName();
auto typeArguments =
(contextFlags & NodeFlags::JavaScriptFile) == NodeFlags::None ? tryParseTypeArguments() : undefined;
auto attributes = parseJsxAttributes();
JsxOpeningLikeElement node;
if (token() == SyntaxKind::GreaterThanToken)
{
// Closing tag, so scan the immediately-following text with the JSX scanning instead
// of regular scanning to avoid treating illegal characters (e.g. '#').as<immediate>()
// scanning errors
scanJsxText();
node = factory.createJsxOpeningElement(tagName, typeArguments, attributes);
}
else
{
parseExpected(SyntaxKind::SlashToken);
if (inExpressionContext)
{
parseExpected(SyntaxKind::GreaterThanToken);
}
else
{
parseExpected(SyntaxKind::GreaterThanToken, /*diagnostic*/ undefined, /*shouldAdvance*/ false);
scanJsxText();
}
node = factory.createJsxSelfClosingElement(tagName, typeArguments, attributes);
}
return finishNode(node, pos);
}
auto parseJsxElementName() -> JsxTagNameExpression
{
auto pos = getNodePos();
scanJsxIdentifier();
// JsxElement can have name in the form of
// propertyAccessExpression
// primaryExpression in the form of an identifier and "this" keyword
// We can't just simply use parseLeftHandSideExpressionOrHigher because then we will start consider class,auto
// etc.as<a>() keyword We only want to consider "this".as<a>() primaryExpression
JsxTagNameExpression expression =
token() == SyntaxKind::ThisKeyword ? parseTokenNode<ThisExpression>() : parseIdentifierName().as<Node>();
while (parseOptional(SyntaxKind::DotToken))
{
expression = finishNode(factory.createPropertyAccessExpression(
expression, parseRightSideOfDot(/*allowIdentifierNames*/ true,
/*allowPrivateIdentifiers*/ false)),
pos)
.as<JsxTagNamePropertyAccess>();
}
return expression;
}
auto parseJsxExpression(boolean inExpressionContext) -> JsxExpression
{
auto pos = getNodePos();
if (!parseExpected(SyntaxKind::OpenBraceToken))
{
return undefined;
}
Node dotDotDotToken;
Expression expression;
if (token() != SyntaxKind::CloseBraceToken)
{
dotDotDotToken = parseOptionalToken(SyntaxKind::DotDotDotToken);
// Only an AssignmentExpression is valid here per the JSX spec,
// but we can unambiguously parse a comma sequence and provide
// a better error message in grammar checking.
expression = parseExpression();
}
if (inExpressionContext)
{
parseExpected(SyntaxKind::CloseBraceToken);
}
else
{
if (parseExpected(SyntaxKind::CloseBraceToken, /*message*/ undefined, /*shouldAdvance*/ false))
{
scanJsxText();
}
}
return finishNode(factory.createJsxExpression(dotDotDotToken, expression), pos);
}
auto parseJsxAttribute() -> Node
{
if (token() == SyntaxKind::OpenBraceToken)
{
return parseJsxSpreadAttribute();
}
scanJsxIdentifier();
auto pos = getNodePos();
auto identifierName = parseIdentifierName();
auto initializer = token() != SyntaxKind::EqualsToken ? undefined
: scanJsxAttributeValue() == SyntaxKind::StringLiteral
? parseLiteralNode().as<Node>()
: parseJsxExpression(/*inExpressionContext*/ true).as<Node>();
return finishNode(factory.createJsxAttribute(identifierName, initializer), pos);
}
auto parseJsxSpreadAttribute() -> JsxSpreadAttribute
{
auto pos = getNodePos();
parseExpected(SyntaxKind::OpenBraceToken);
parseExpected(SyntaxKind::DotDotDotToken);
auto expression = parseExpression();
parseExpected(SyntaxKind::CloseBraceToken);
return finishNode(factory.createJsxSpreadAttribute(expression), pos);
}
auto parseJsxClosingElement(boolean inExpressionContext) -> JsxClosingElement
{
auto pos = getNodePos();
parseExpected(SyntaxKind::LessThanSlashToken);
auto tagName = parseJsxElementName();
if (inExpressionContext)
{
parseExpected(SyntaxKind::GreaterThanToken);
}
else
{
parseExpected(SyntaxKind::GreaterThanToken, /*diagnostic*/ undefined, /*shouldAdvance*/ false);
scanJsxText();
}
return finishNode(factory.createJsxClosingElement(tagName), pos);
}
auto parseJsxClosingFragment(boolean inExpressionContext) -> JsxClosingFragment
{
auto pos = getNodePos();
parseExpected(SyntaxKind::LessThanSlashToken);
if (scanner.tokenIsIdentifierOrKeyword(token()))
{
parseErrorAtRange(
parseJsxElementName(),
data::DiagnosticMessage(Diagnostics::Expected_corresponding_closing_tag_for_JSX_fragment));
}
if (inExpressionContext)
{
parseExpected(SyntaxKind::GreaterThanToken);
}
else
{
parseExpected(SyntaxKind::GreaterThanToken, /*diagnostic*/ undefined, /*shouldAdvance*/ false);
scanJsxText();
}
return finishNode(factory.createJsxJsxClosingFragment(), pos);
}
auto parseTypeAssertion() -> TypeAssertion
{
auto pos = getNodePos();
parseExpected(SyntaxKind::LessThanToken);
auto type = parseType();
parseExpected(SyntaxKind::GreaterThanToken);
auto expression = parseSimpleUnaryExpression();
return finishNode(factory.createTypeAssertion(type, expression), pos);
}
auto nextTokenIsIdentifierOrKeywordOrOpenBracketOrTemplate() -> boolean
{
nextToken();
return scanner.tokenIsIdentifierOrKeyword(token()) || token() == SyntaxKind::OpenBracketToken ||
isTemplateStartOfTaggedTemplate();
}
auto isStartOfOptionalPropertyOrElementAccessChain() -> boolean
{
return token() == SyntaxKind::QuestionDotToken &&
lookAhead<boolean>(std::bind(&Parser::nextTokenIsIdentifierOrKeywordOrOpenBracketOrTemplate, this));
}
auto tryReparseOptionalChain(Expression node) -> boolean
{
if (!!(node->flags & NodeFlags::OptionalChain))
{
return true;
}
// check for an optional chain in a non-null expression
if (isNonNullExpression(node))
{
auto expr = node.as<NonNullExpression>()->expression;
while (isNonNullExpression(expr) && !(expr->flags & NodeFlags::OptionalChain))
{
expr = expr.as<NonNullExpression>()->expression;
}
if (!!(expr->flags & NodeFlags::OptionalChain))
{
// this is part of an optional chain. Walk down from `node` to `expression` and set the flag.
while (isNonNullExpression(node))
{
(node.asMutable<NonNullExpression>())->flags |= NodeFlags::OptionalChain;
node = node.as<NonNullExpression>()->expression;
}
return true;
}
}
return false;
}
auto parsePropertyAccessExpressionRest(pos_type pos, LeftHandSideExpression expression,
QuestionDotToken questionDotToken)
{
auto name = parseRightSideOfDot(/*allowIdentifierNames*/ true, /*allowPrivateIdentifiers*/ true);
auto isOptionalChain = (number)questionDotToken || tryReparseOptionalChain(expression);
auto propertyAccess =
isOptionalChain
? factory.createPropertyAccessChain(expression, questionDotToken, name).as<PropertyAccessExpression>()
: factory.createPropertyAccessExpression(expression, name);
if (isOptionalChain && isPrivateIdentifier(propertyAccess->name))
{
parseErrorAtRange(
propertyAccess->name,
data::DiagnosticMessage(Diagnostics::An_optional_chain_cannot_contain_private_identifiers));
}
return finishNode(propertyAccess, pos);
}
auto parseElementAccessExpressionRest(pos_type pos, LeftHandSideExpression expression,
QuestionDotToken questionDotToken)
{
Expression argumentExpression;
if (token() == SyntaxKind::CloseBracketToken)
{
argumentExpression = createMissingNode<Identifier>(
SyntaxKind::Identifier, /*reportAtCurrentPosition*/ true,
data::DiagnosticMessage(Diagnostics::An_element_access_expression_should_take_an_argument));
}
else
{
auto argument = allowInAnd<Expression>(std::bind(&Parser::parseExpression, this));
if (isStringOrNumericLiteralLike(argument))
{
argument.as<LiteralLikeNode>()->text = internIdentifier(argument.as<LiteralLikeNode>()->text);
}
argumentExpression = argument;
}
parseExpected(SyntaxKind::CloseBracketToken);
auto indexedAccess = (number)questionDotToken || tryReparseOptionalChain(expression)
? factory.createElementAccessChain(expression, questionDotToken, argumentExpression)
.as<ElementAccessExpression>()
: factory.createElementAccessExpression(expression, argumentExpression);
return finishNode(indexedAccess, pos);
}
auto parseMemberExpressionRest(pos_type pos, LeftHandSideExpression expression, boolean allowOptionalChain)
-> MemberExpression
{
while (true)
{
Node questionDotToken;
auto isPropertyAccess = false;
if (allowOptionalChain && isStartOfOptionalPropertyOrElementAccessChain())
{
questionDotToken = parseExpectedToken(SyntaxKind::QuestionDotToken);
isPropertyAccess = scanner.tokenIsIdentifierOrKeyword(token());
}
else
{
isPropertyAccess = parseOptional(SyntaxKind::DotToken);
}
if (isPropertyAccess)
{
expression = parsePropertyAccessExpressionRest(pos, expression, questionDotToken);
continue;
}
if (!questionDotToken && token() == SyntaxKind::ExclamationToken && !scanner.hasPrecedingLineBreak())
{
nextToken();
expression = finishNode(factory.createNonNullExpression(expression), pos);
continue;
}
// when in the [Decorator] context, we do not parse ElementAccess.as<it>() could be part of a
// ComputedPropertyName
if ((questionDotToken || !inDecoratorContext()) && parseOptional(SyntaxKind::OpenBracketToken))
{
expression = parseElementAccessExpressionRest(pos, expression, questionDotToken);
continue;
}
if (isTemplateStartOfTaggedTemplate())
{
expression = parseTaggedTemplateRest(pos, expression, questionDotToken, /*typeArguments*/ undefined);
continue;
}
return expression.as<MemberExpression>();
}
}
auto isTemplateStartOfTaggedTemplate() -> boolean
{
return token() == SyntaxKind::NoSubstitutionTemplateLiteral || token() == SyntaxKind::TemplateHead;
}
auto toNoSubstitutionTemplateLiteral(LiteralExpression literalExpression) -> NoSubstitutionTemplateLiteral
{
auto node = factory.createBaseNode<NoSubstitutionTemplateLiteral>(SyntaxKind::NoSubstitutionTemplateLiteral);
setTextRange(node, literalExpression);
node->rawText = literalExpression->text;
return node;
}
auto parseTaggedTemplateRest(pos_type pos, LeftHandSideExpression tag, QuestionDotToken questionDotToken,
NodeArray<TypeNode> typeArguments) -> Node
{
auto tagExpression = factory.createTaggedTemplateExpression(
tag, typeArguments,
token() == SyntaxKind::NoSubstitutionTemplateLiteral
? (reScanTemplateHeadOrNoSubstitutionTemplate(),
toNoSubstitutionTemplateLiteral(parseLiteralNode()).as<TemplateLiteralLikeNode>())
: parseTemplateExpression(/*isTaggedTemplate*/ true).as<TemplateLiteralLikeNode>());
if ((number)questionDotToken || !!(tag->flags & NodeFlags::OptionalChain))
{
(tagExpression.asMutable<Node>())->flags |= NodeFlags::OptionalChain;
}
tagExpression->questionDotToken = questionDotToken;
return finishNode(tagExpression, pos);
}
auto parseCallExpressionRest(pos_type pos, LeftHandSideExpression expression) -> LeftHandSideExpression
{
while (true)
{
expression = parseMemberExpressionRest(pos, expression, /*allowOptionalChain*/ true);
auto questionDotToken = parseOptionalToken(SyntaxKind::QuestionDotToken);
// handle 'foo<<T>()'
// parse template arguments only in TypeScript files (not in JavaScript files).
if ((contextFlags & NodeFlags::JavaScriptFile) == NodeFlags::None &&
(token() == SyntaxKind::LessThanToken || token() == SyntaxKind::LessThanLessThanToken))
{
// See if this is the start of a generic invocation. If so, consume it and
// keep checking for postfix expressions. Otherwise, it's just a '<' that's
// part of an arithmetic expression. Break out so we consume it higher in the
// stack.
auto typeArguments =
tryParse<NodeArray<TypeNode>>(std::bind(&Parser::parseTypeArgumentsInExpression, this));
if (!!typeArguments)
{
if (isTemplateStartOfTaggedTemplate())
{
expression = parseTaggedTemplateRest(pos, expression, questionDotToken, typeArguments);
continue;
}
auto argumentList = parseArgumentList();
auto callExpr =
questionDotToken || tryReparseOptionalChain(expression)
? factory.createCallChain(expression, questionDotToken, typeArguments, argumentList)
.as<CallExpression>()
: factory.createCallExpression(expression, typeArguments, argumentList);
expression = finishNode(callExpr, pos);
continue;
}
}
else if (token() == SyntaxKind::OpenParenToken)
{
auto argumentList = parseArgumentList();
auto callExpr =
questionDotToken || tryReparseOptionalChain(expression)
? factory
.createCallChain(expression, questionDotToken, /*typeArguments*/ undefined, argumentList)
.as<CallExpression>()
: factory.createCallExpression(expression, /*typeArguments*/ undefined, argumentList);
expression = finishNode(callExpr, pos);
continue;
}
if (questionDotToken)
{
// We failed to parse anything, so report a missing identifier here.
auto name = createMissingNode<Identifier>(SyntaxKind::Identifier, /*reportAtCurrentPosition*/ false,
data::DiagnosticMessage(Diagnostics::Identifier_expected));
expression = finishNode(factory.createPropertyAccessChain(expression, questionDotToken, name), pos);
}
break;
}
return expression;
}
auto parseArgumentList() -> NodeArray<Expression>
{
parseExpected(SyntaxKind::OpenParenToken);
auto result = parseDelimitedList<Expression>(ParsingContext::ArgumentExpressions,
std::bind(&Parser::parseArgumentExpression, this));
parseExpected(SyntaxKind::CloseParenToken);
return result;
}
auto parseTypeArgumentsInExpression() -> NodeArray<TypeNode>
{
if ((contextFlags & NodeFlags::JavaScriptFile) != NodeFlags::None)
{
// TypeArguments must not be parsed in JavaScript files to avoid ambiguity with binary operators.
return undefined;
}
if (reScanLessThanToken() != SyntaxKind::LessThanToken)
{
return undefined;
}
nextToken();
auto typeArguments =
parseDelimitedList<TypeNode>(ParsingContext::TypeArguments, std::bind(&Parser::parseType, this));
if (!parseExpected(SyntaxKind::GreaterThanToken))
{
// If it doesn't have the closing `>` then it's definitely not an type argument list.
return undefined;
}
// If we have a '<', then only parse this.as<a>() argument list if the type arguments
// are complete and we have an open paren. if we don't, rewind and return nothing.
return !!typeArguments && canFollowTypeArgumentsInExpression() ? typeArguments : undefined;
}
auto canFollowTypeArgumentsInExpression() -> boolean
{
switch (token())
{
case SyntaxKind::OpenParenToken: // foo<x>(
case SyntaxKind::NoSubstitutionTemplateLiteral: // foo<T> `...`
case SyntaxKind::TemplateHead: // foo<T> `...${100}...`
// these are the only tokens can legally follow a type argument
// list. So we definitely want to treat them.as<type>() arg lists.
// falls through
case SyntaxKind::DotToken: // foo<x>.
case SyntaxKind::CloseParenToken: // foo<x>)
case SyntaxKind::CloseBracketToken: // foo<x>]
case SyntaxKind::ColonToken: // foo<x>:
case SyntaxKind::SemicolonToken: // foo<x>;
case SyntaxKind::QuestionToken: // foo<x>?
case SyntaxKind::EqualsEqualsToken: // foo<x> ==
case SyntaxKind::EqualsEqualsEqualsToken: // foo<x> ==
case SyntaxKind::ExclamationEqualsToken: // foo<x> !=
case SyntaxKind::ExclamationEqualsEqualsToken: // foo<x> !=
case SyntaxKind::AmpersandAmpersandToken: // foo<x> &&
case SyntaxKind::BarBarToken: // foo<x> ||
case SyntaxKind::QuestionQuestionToken: // foo<x> ??
case SyntaxKind::CaretToken: // foo<x> ^
case SyntaxKind::AmpersandToken: // foo<x> &
case SyntaxKind::BarToken: // foo<x> |
case SyntaxKind::CloseBraceToken: // foo<x> }
case SyntaxKind::EndOfFileToken: // foo<x>
// these cases can't legally follow a type arg list. However, they're not legal
// expressions either. The user is probably in the middle of a generic type. So
// treat it.as<such>().
return true;
case SyntaxKind::CommaToken: // foo<x>,
case SyntaxKind::OpenBraceToken: // foo<x> {
// We don't want to treat these.as<type>() arguments. Otherwise we'll parse this
//.as<an>() invocation expression. Instead, we want to parse out the expression
// in isolation from the type arguments.
// falls through
default:
// Anything else treat.as<an>() expression.
return false;
}
}
auto parsePrimaryExpression() -> PrimaryExpression
{
switch (token())
{
case SyntaxKind::NumericLiteral:
case SyntaxKind::BigIntLiteral:
case SyntaxKind::StringLiteral:
case SyntaxKind::NoSubstitutionTemplateLiteral:
return parseLiteralNode();
case SyntaxKind::ThisKeyword:
case SyntaxKind::SuperKeyword:
case SyntaxKind::NullKeyword:
case SyntaxKind::TrueKeyword:
case SyntaxKind::FalseKeyword:
return parseTokenNode<PrimaryExpression>();
case SyntaxKind::OpenParenToken:
return parseParenthesizedExpression();
case SyntaxKind::OpenBracketToken:
return parseArrayLiteralExpression();
case SyntaxKind::OpenBraceToken:
return parseObjectLiteralExpression();
case SyntaxKind::AsyncKeyword:
// Async arrow functions are parsed earlier in parseAssignmentExpressionOrHigher.
// If we encounter `async [no LineTerminator here] function` then this is an async
// function; otherwise, its an identifier.
if (!lookAhead<boolean>(std::bind(&Parser::nextTokenIsFunctionKeywordOnSameLine, this)))
{
break;
}
return parseFunctionExpression();
case SyntaxKind::ClassKeyword:
return parseClassExpression();
case SyntaxKind::FunctionKeyword:
return parseFunctionExpression();
case SyntaxKind::NewKeyword:
return parseNewExpressionOrNewDotTarget();
case SyntaxKind::SlashToken:
case SyntaxKind::SlashEqualsToken:
if (reScanSlashToken() == SyntaxKind::RegularExpressionLiteral)
{
return parseLiteralNode();
}
break;
case SyntaxKind::TemplateHead:
return parseTemplateExpression(/* isTaggedTemplate */ false);
}
return parseIdentifier(data::DiagnosticMessage(Diagnostics::Expression_expected));
}
auto parseParenthesizedExpression() -> ParenthesizedExpression
{
auto pos = getNodePos();
auto hasJSDoc = hasPrecedingJSDocComment();
parseExpected(SyntaxKind::OpenParenToken);
auto expression = allowInAnd<Expression>(std::bind(&Parser::parseExpression, this));
parseExpected(SyntaxKind::CloseParenToken);
return withJSDoc(finishNode(factory.createParenthesizedExpression(expression), pos), hasJSDoc);
}
auto parseSpreadElement() -> Expression
{
auto pos = getNodePos();
parseExpected(SyntaxKind::DotDotDotToken);
auto expression = parseAssignmentExpressionOrHigher();
return finishNode(factory.createSpreadElement(expression), pos);
}
auto parseArgumentOrArrayLiteralElement() -> Expression
{
return token() == SyntaxKind::DotDotDotToken ? parseSpreadElement()
: token() == SyntaxKind::CommaToken
? finishNode(factory.createOmittedExpression(), getNodePos()).as<Expression>()
: parseAssignmentExpressionOrHigher();
}
auto parseArgumentExpression() -> Expression
{
return doOutsideOfContext<Expression>(disallowInAndDecoratorContext,
std::bind(&Parser::parseArgumentOrArrayLiteralElement, this));
}
auto parseArrayLiteralExpression() -> Node
{
auto pos = getNodePos();
parseExpected(SyntaxKind::OpenBracketToken);
auto multiLine = scanner.hasPrecedingLineBreak();
auto elements = parseDelimitedList<Expression>(ParsingContext::ArrayLiteralMembers,
std::bind(&Parser::parseArgumentOrArrayLiteralElement, this));
parseExpected(SyntaxKind::CloseBracketToken);
return finishNode(factory.createArrayLiteralExpression(elements, multiLine), pos);
}
auto parseObjectLiteralElement() -> ObjectLiteralElementLike
{
auto pos = getNodePos();
auto hasJSDoc = hasPrecedingJSDocComment();
if (parseOptionalToken(SyntaxKind::DotDotDotToken))
{
auto expression = parseAssignmentExpressionOrHigher();
return withJSDoc(finishNode(factory.createSpreadAssignment(expression), pos), hasJSDoc);
}
auto decorators = parseDecorators();
auto modifiers = parseModifiers();
if (parseContextualModifier(SyntaxKind::GetKeyword))
{
return parseAccessorDeclaration(pos, hasJSDoc, decorators, modifiers, SyntaxKind::GetAccessor);
}
if (parseContextualModifier(SyntaxKind::SetKeyword))
{
return parseAccessorDeclaration(pos, hasJSDoc, decorators, modifiers, SyntaxKind::SetAccessor);
}
auto asteriskToken = parseOptionalToken(SyntaxKind::AsteriskToken);
auto tokenIsIdentifier = isIdentifier();
auto name = parsePropertyName();
// Disallowing of optional property assignments and definite assignment assertion happens in the grammar
// checker.
auto questionToken = parseOptionalToken(SyntaxKind::QuestionToken);
auto exclamationToken = parseOptionalToken(SyntaxKind::ExclamationToken);
if (asteriskToken || token() == SyntaxKind::OpenParenToken || token() == SyntaxKind::LessThanToken)
{
return parseMethodDeclaration(pos, hasJSDoc, decorators, modifiers, asteriskToken, name, questionToken,
exclamationToken);
}
// check if it is short-hand property assignment or normal property assignment
// if NOTE token is EqualsToken it is interpreted.as<CoverInitializedName>() production
// CoverInitializedName[Yield] :
// IdentifierReference[?Yield] Initializer[In, ?Yield]
// this is necessary because ObjectLiteral productions are also used to cover grammar for
// ObjectAssignmentPattern
PropertyAssignment node;
auto isShorthandPropertyAssignment = tokenIsIdentifier && (token() != SyntaxKind::ColonToken);
if (isShorthandPropertyAssignment)
{
auto equalsToken = parseOptionalToken(SyntaxKind::EqualsToken);
auto objectAssignmentInitializer =
equalsToken ? allowInAnd<Expression>(std::bind(&Parser::parseAssignmentExpressionOrHigher, this))
: undefined;
auto nodeSpa =
factory.createShorthandPropertyAssignment(name.as<Identifier>(), objectAssignmentInitializer);
// Save equals token for error reporting.
// TODO(rbuckton) -> Consider manufacturing this when we need to report an error.as<it>() is otherwise not
// useful.
nodeSpa->equalsToken = equalsToken;
node = nodeSpa.as<PropertyAssignment>();
}
else
{
parseExpected(SyntaxKind::ColonToken);
auto initializer = allowInAnd<Expression>(std::bind(&Parser::parseAssignmentExpressionOrHigher, this));
node = factory.createPropertyAssignment(name, initializer);
}
// Decorators, Modifiers, questionToken, and exclamationToken are not supported by property assignments and are
// reported in the grammar checker
node->decorators = decorators;
copy(node->modifiers, modifiers);
node->questionToken = questionToken;
node->exclamationToken = exclamationToken;
return withJSDoc(finishNode(node, pos), hasJSDoc);
}
auto parseObjectLiteralExpression() -> Node
{
auto pos = getNodePos();
auto openBracePosition = scanner.getTokenPos();
parseExpected(SyntaxKind::OpenBraceToken);
auto multiLine = scanner.hasPrecedingLineBreak();
auto properties = parseDelimitedList<ObjectLiteralElementLike>(
ParsingContext::ObjectLiteralMembers, std::bind(&Parser::parseObjectLiteralElement, this),
/*considerSemicolonAsDelimiter*/ true);
if (!parseExpected(SyntaxKind::CloseBraceToken))
{
auto lastError = lastOrUndefined(parseDiagnostics);
if (!!lastError && lastError->code == data::DiagnosticMessage(Diagnostics::_0_expected).code)
{
addRelatedInfo(lastError, createDetachedDiagnostic(
fileName, openBracePosition, 1,
data::DiagnosticMessage(
Diagnostics::The_parser_expected_to_find_a_to_match_the_token_here)));
}
}
return finishNode(factory.createObjectLiteralExpression(properties, multiLine), pos);
}
auto parseFunctionExpression() -> FunctionExpression
{
// GeneratorExpression:
// function* BindingIdentifier [Yield][opt](FormalParameters[Yield]){ GeneratorBody }
//
// FunctionExpression:
// auto BindingIdentifier[opt](FormalParameters){ FunctionBody }
auto saveDecoratorContext = inDecoratorContext();
if (saveDecoratorContext)
{
setDecoratorContext(/*val*/ false);
}
auto pos = getNodePos();
auto hasJSDoc = hasPrecedingJSDocComment();
auto modifiers = parseModifiers();
parseExpected(SyntaxKind::FunctionKeyword);
auto asteriskToken = parseOptionalToken(SyntaxKind::AsteriskToken);
auto isGenerator = asteriskToken ? SignatureFlags::Yield : SignatureFlags::None;
auto isAsync = some(modifiers, isAsyncModifier) ? SignatureFlags::Await : SignatureFlags::None;
auto name = !!isGenerator && !!isAsync
? doInYieldAndAwaitContext<Identifier>(std::bind(&Parser::parseOptionalBindingIdentifier, this))
: !!isGenerator
? doInYieldContext<Identifier>(std::bind(&Parser::parseOptionalBindingIdentifier, this))
: !!isAsync ? doInAwaitContext<Identifier>(std::bind(&Parser::parseOptionalBindingIdentifier, this))
: parseOptionalBindingIdentifier();
auto typeParameters = parseTypeParameters();
auto parameters = parseParameters(isGenerator | isAsync);
auto type = parseReturnType(SyntaxKind::ColonToken, /*isType*/ false);
auto body = parseFunctionBlock(isGenerator | isAsync);
if (saveDecoratorContext)
{
setDecoratorContext(/*val*/ true);
}
auto node =
factory.createFunctionExpression(modifiers, asteriskToken, name, typeParameters, parameters, type, body);
return withJSDoc(finishNode(node, pos), hasJSDoc);
}
auto parseOptionalBindingIdentifier() -> Identifier
{
return isBindingIdentifier() ? parseBindingIdentifier() : undefined;
}
auto parseNewExpressionOrNewDotTarget() -> Node
{
auto pos = getNodePos();
parseExpected(SyntaxKind::NewKeyword);
if (parseOptional(SyntaxKind::DotToken))
{
auto name = parseIdentifierName();
return finishNode(factory.createMetaProperty(SyntaxKind::NewKeyword, name), pos);
}
auto expressionPos = getNodePos();
auto expression = parsePrimaryExpression();
NodeArray<TypeNode> typeArguments;
while (true)
{
expression = parseMemberExpressionRest(expressionPos, expression, /*allowOptionalChain*/ false);
typeArguments = tryParse<NodeArray<TypeNode>>(std::bind(&Parser::parseTypeArgumentsInExpression, this));
if (isTemplateStartOfTaggedTemplate())
{
Debug::_assert(!!typeArguments, S("Expected a type argument list; all plain tagged template starts "
"should be consumed in 'parseMemberExpressionRest'"));
expression =
parseTaggedTemplateRest(expressionPos, expression, /*optionalChain*/ undefined, typeArguments);
typeArguments = undefined;
}
break;
}
NodeArray<Expression> argumentsArray;
if (token() == SyntaxKind::OpenParenToken)
{
argumentsArray = parseArgumentList();
}
else if (!!typeArguments)
{
parseErrorAt(
pos, scanner.getStartPos(),
data::DiagnosticMessage(
Diagnostics::
A_new_expression_with_type_arguments_must_always_be_followed_by_a_parenthesized_argument_list));
}
return finishNode(factory.createNewExpression(expression, typeArguments, argumentsArray), pos);
}
// STATEMENTS
auto parseBlock(boolean ignoreMissingOpenBrace, DiagnosticMessage diagnosticMessage = undefined) -> Block
{
auto pos = getNodePos();
auto openBracePosition = scanner.getTokenPos();
if (parseExpected(SyntaxKind::OpenBraceToken, diagnosticMessage) || ignoreMissingOpenBrace)
{
auto multiLine = scanner.hasPrecedingLineBreak();
auto statements =
parseList<Statement>(ParsingContext::BlockStatements, std::bind(&Parser::parseStatement, this));
if (!parseExpected(SyntaxKind::CloseBraceToken))
{
auto lastError = lastOrUndefined(parseDiagnostics);
if (!!lastError && lastError->code == data::DiagnosticMessage(Diagnostics::_0_expected).code)
{
addRelatedInfo(lastError,
createDetachedDiagnostic(
fileName, openBracePosition, 1,
data::DiagnosticMessage(
Diagnostics::The_parser_expected_to_find_a_to_match_the_token_here)));
}
}
return finishNode(factory.createBlock(statements, multiLine), pos);
}
else
{
auto statements = createMissingList<Statement>();
return finishNode(factory.createBlock(statements, /*multiLine*/ false), pos);
}
}
auto parseFunctionBlock(SignatureFlags flags, DiagnosticMessage diagnosticMessage = undefined) -> Block
{
auto savedYieldContext = inYieldContext();
setYieldContext(!!(flags & SignatureFlags::Yield));
auto savedAwaitContext = inAwaitContext();
setAwaitContext(!!(flags & SignatureFlags::Await));
auto savedTopLevel = topLevel;
topLevel = false;
// We may be in a [Decorator] context when parsing a auto expression or
// arrow function. The body of the auto is not in [Decorator] context->
auto saveDecoratorContext = inDecoratorContext();
if (saveDecoratorContext)
{
setDecoratorContext(/*val*/ false);
}
auto block = parseBlock(!!(flags & SignatureFlags::IgnoreMissingOpenBrace), diagnosticMessage);
if (saveDecoratorContext)
{
setDecoratorContext(/*val*/ true);
}
topLevel = savedTopLevel;
setYieldContext(savedYieldContext);
setAwaitContext(savedAwaitContext);
return block;
}
auto parseEmptyStatement() -> Statement
{
auto pos = getNodePos();
parseExpected(SyntaxKind::SemicolonToken);
return finishNode(factory.createEmptyStatement(), pos);
}
auto parseIfStatement() -> IfStatement
{
auto pos = getNodePos();
parseExpected(SyntaxKind::IfKeyword);
parseExpected(SyntaxKind::OpenParenToken);
auto expression = allowInAnd<Expression>(std::bind(&Parser::parseExpression, this));
parseExpected(SyntaxKind::CloseParenToken);
auto thenStatement = parseStatement();
auto elseStatement = parseOptional(SyntaxKind::ElseKeyword) ? parseStatement() : undefined;
return finishNode(factory.createIfStatement(expression, thenStatement, elseStatement), pos);
}
auto parseDoStatement() -> DoStatement
{
auto pos = getNodePos();
parseExpected(SyntaxKind::DoKeyword);
auto statement = parseStatement();
parseExpected(SyntaxKind::WhileKeyword);
parseExpected(SyntaxKind::OpenParenToken);
auto expression = allowInAnd<Expression>(std::bind(&Parser::parseExpression, this));
parseExpected(SyntaxKind::CloseParenToken);
// https From://mail.mozilla.org/pipermail/es-discuss/2011-August/016188.html
// 157 min --- All allen at wirfs-brock.com CONF --- "do{;}while(false)false" prohibited in
// spec but allowed in consensus reality. Approved -- this is the de-facto standard whereby
// do;while(0)x will have a semicolon inserted before x.
parseOptional(SyntaxKind::SemicolonToken);
return finishNode(factory.createDoStatement(statement, expression), pos);
}
auto parseWhileStatement() -> WhileStatement
{
auto pos = getNodePos();
parseExpected(SyntaxKind::WhileKeyword);
parseExpected(SyntaxKind::OpenParenToken);
auto expression = allowInAnd<Expression>(std::bind(&Parser::parseExpression, this));
parseExpected(SyntaxKind::CloseParenToken);
auto statement = parseStatement();
return finishNode(factory.createWhileStatement(expression, statement), pos);
}
auto parseForOrForInOrForOfStatement() -> Statement
{
auto pos = getNodePos();
parseExpected(SyntaxKind::ForKeyword);
auto awaitToken = parseOptionalToken(SyntaxKind::AwaitKeyword);
parseExpected(SyntaxKind::OpenParenToken);
Node initializer;
if (token() != SyntaxKind::SemicolonToken)
{
if (token() == SyntaxKind::VarKeyword || token() == SyntaxKind::LetKeyword ||
token() == SyntaxKind::ConstKeyword)
{
initializer = parseVariableDeclarationList(/*inForStatementInitializer*/ true);
}
else
{
initializer = disallowInAnd<Expression>(std::bind(&Parser::parseExpression, this));
}
}
Node node;
if (awaitToken ? parseExpected(SyntaxKind::OfKeyword) : parseOptional(SyntaxKind::OfKeyword))
{
auto expression = allowInAnd<Expression>(std::bind(&Parser::parseAssignmentExpressionOrHigher, this));
parseExpected(SyntaxKind::CloseParenToken);
node = factory.createForOfStatement(awaitToken, initializer, expression, parseStatement());
}
else if (parseOptional(SyntaxKind::InKeyword))
{
auto expression = allowInAnd<Expression>(std::bind(&Parser::parseExpression, this));
parseExpected(SyntaxKind::CloseParenToken);
node = factory.createForInStatement(initializer, expression, parseStatement());
}
else
{
parseExpected(SyntaxKind::SemicolonToken);
auto condition = token() != SyntaxKind::SemicolonToken && token() != SyntaxKind::CloseParenToken
? allowInAnd<Expression>(std::bind(&Parser::parseExpression, this))
: undefined;
parseExpected(SyntaxKind::SemicolonToken);
auto incrementor = token() != SyntaxKind::CloseParenToken
? allowInAnd<Expression>(std::bind(&Parser::parseExpression, this))
: undefined;
parseExpected(SyntaxKind::CloseParenToken);
node = factory.createForStatement(initializer, condition, incrementor, parseStatement());
}
return finishNode(node, pos);
}
auto parseBreakOrContinueStatement(SyntaxKind kind) -> BreakOrContinueStatement
{
auto pos = getNodePos();
parseExpected(kind == SyntaxKind::BreakStatement ? SyntaxKind::BreakKeyword : SyntaxKind::ContinueKeyword);
auto label = canParseSemicolon() ? undefined : parseIdentifier();
parseSemicolon();
auto node = kind == SyntaxKind::BreakStatement
? factory.createBreakStatement(label).as<BreakOrContinueStatement>()
: factory.createContinueStatement(label).as<BreakOrContinueStatement>();
return finishNode(node, pos);
}
auto parseReturnStatement() -> ReturnStatement
{
auto pos = getNodePos();
parseExpected(SyntaxKind::ReturnKeyword);
auto expression =
canParseSemicolon() ? undefined : allowInAnd<Expression>(std::bind(&Parser::parseExpression, this));
parseSemicolon();
return finishNode(factory.createReturnStatement(expression), pos);
}
auto parseWithStatement() -> WithStatement
{
auto pos = getNodePos();
parseExpected(SyntaxKind::WithKeyword);
parseExpected(SyntaxKind::OpenParenToken);
auto expression = allowInAnd<Expression>(std::bind(&Parser::parseExpression, this));
parseExpected(SyntaxKind::CloseParenToken);
auto statement =
doInsideOfContext<Statement>(NodeFlags::InWithStatement, std::bind(&Parser::parseStatement, this));
return finishNode(factory.createWithStatement(expression, statement), pos);
}
auto parseCaseClause() -> CaseClause
{
auto pos = getNodePos();
parseExpected(SyntaxKind::CaseKeyword);
auto expression = allowInAnd<Expression>(std::bind(&Parser::parseExpression, this));
parseExpected(SyntaxKind::ColonToken);
auto statements =
parseList<Statement>(ParsingContext::SwitchClauseStatements, std::bind(&Parser::parseStatement, this));
return finishNode(factory.createCaseClause(expression, statements), pos);
}
auto parseDefaultClause() -> DefaultClause
{
auto pos = getNodePos();
parseExpected(SyntaxKind::DefaultKeyword);
parseExpected(SyntaxKind::ColonToken);
auto statements =
parseList<Statement>(ParsingContext::SwitchClauseStatements, std::bind(&Parser::parseStatement, this));
return finishNode(factory.createDefaultClause(statements), pos);
}
auto parseCaseOrDefaultClause() -> CaseOrDefaultClause
{
return token() == SyntaxKind::CaseKeyword ? (CaseOrDefaultClause)parseCaseClause()
: (CaseOrDefaultClause)parseDefaultClause();
}
auto parseCaseBlock() -> CaseBlock
{
auto pos = getNodePos();
parseExpected(SyntaxKind::OpenBraceToken);
auto clauses = parseList<CaseOrDefaultClause>(ParsingContext::SwitchClauses,
std::bind(&Parser::parseCaseOrDefaultClause, this));
parseExpected(SyntaxKind::CloseBraceToken);
return finishNode(factory.createCaseBlock(clauses), pos);
}
auto parseSwitchStatement() -> SwitchStatement
{
auto pos = getNodePos();
parseExpected(SyntaxKind::SwitchKeyword);
parseExpected(SyntaxKind::OpenParenToken);
auto expression = allowInAnd<Expression>(std::bind(&Parser::parseExpression, this));
parseExpected(SyntaxKind::CloseParenToken);
auto caseBlock = parseCaseBlock();
return finishNode(factory.createSwitchStatement(expression, caseBlock), pos);
}
auto parseThrowStatement() -> ThrowStatement
{
// ThrowStatement[Yield] :
// throw [no LineTerminator here]Expression[In, ?Yield];
auto pos = getNodePos();
parseExpected(SyntaxKind::ThrowKeyword);
// Because of automatic semicolon insertion, we need to report error if this
// throw could be terminated with a semicolon. we Note can't call 'parseExpression'
// directly.as<that>() might consume an expression on the following line.
// Instead, we create a "missing" identifier, but don't report an error. The actual error
// will be reported in the grammar walker.
auto expression = scanner.hasPrecedingLineBreak()
? undefined
: allowInAnd<Expression>(std::bind(&Parser::parseExpression, this));
if (expression == undefined)
{
identifierCount++;
expression = finishNode(factory.createIdentifier(string()), getNodePos());
}
parseSemicolon();
return finishNode(factory.createThrowStatement(expression), pos);
}
// Review TODO for error recovery
auto parseTryStatement() -> TryStatement
{
auto pos = getNodePos();
parseExpected(SyntaxKind::TryKeyword);
auto tryBlock = parseBlock(/*ignoreMissingOpenBrace*/ false);
auto catchClause = token() == SyntaxKind::CatchKeyword ? parseCatchClause() : undefined;
// If we don't have a catch clause, then we must have a finally clause. Try to parse
// one out no matter what.
Block finallyBlock;
if (!catchClause || token() == SyntaxKind::FinallyKeyword)
{
parseExpected(SyntaxKind::FinallyKeyword);
finallyBlock = parseBlock(/*ignoreMissingOpenBrace*/ false);
}
return finishNode(factory.createTryStatement(tryBlock, catchClause, finallyBlock), pos);
}
auto parseCatchClause() -> CatchClause
{
auto pos = getNodePos();
parseExpected(SyntaxKind::CatchKeyword);
VariableDeclaration variableDeclaration;
if (parseOptional(SyntaxKind::OpenParenToken))
{
variableDeclaration = parseVariableDeclaration();
parseExpected(SyntaxKind::CloseParenToken);
}
else
{
// Keep shape of node to avoid degrading performance.
variableDeclaration = undefined;
}
auto block = parseBlock(/*ignoreMissingOpenBrace*/ false);
return finishNode(factory.createCatchClause(variableDeclaration, block), pos);
}
auto parseDebuggerStatement() -> Statement
{
auto pos = getNodePos();
parseExpected(SyntaxKind::DebuggerKeyword);
parseSemicolon();
return finishNode(factory.createDebuggerStatement(), pos);
}
auto parseExpressionOrLabeledStatement() -> Node
{
// Avoiding having to do the lookahead for a labeled statement by just trying to parse
// out an expression, seeing if it is identifier and then seeing if it is followed by
// a colon.
auto pos = getNodePos();
auto hasJSDoc = hasPrecedingJSDocComment();
Node node;
auto hasParen = token() == SyntaxKind::OpenParenToken;
auto expression = allowInAnd<Expression>(std::bind(&Parser::parseExpression, this));
if (ts::isIdentifier(expression) && parseOptional(SyntaxKind::ColonToken))
{
node = factory.createLabeledStatement(expression, parseStatement());
}
else
{
parseSemicolon();
node = factory.createExpressionStatement(expression);
if (hasParen)
{
// do not parse the same jsdoc twice
hasJSDoc = false;
}
}
return withJSDoc(finishNode(node, pos), hasJSDoc);
}
auto nextTokenIsIdentifierOrKeywordOnSameLine() -> boolean
{
nextToken();
return scanner.tokenIsIdentifierOrKeyword(token()) && !scanner.hasPrecedingLineBreak();
}
auto nextTokenIsClassKeywordOnSameLine() -> boolean
{
nextToken();
return token() == SyntaxKind::ClassKeyword && !scanner.hasPrecedingLineBreak();
}
auto nextTokenIsFunctionKeywordOnSameLine() -> boolean
{
nextToken();
return token() == SyntaxKind::FunctionKeyword && !scanner.hasPrecedingLineBreak();
}
auto nextTokenIsIdentifierOrKeywordOrLiteralOnSameLine() -> boolean
{
nextToken();
return (scanner.tokenIsIdentifierOrKeyword(token()) || token() == SyntaxKind::NumericLiteral ||
token() == SyntaxKind::BigIntLiteral || token() == SyntaxKind::StringLiteral) &&
!scanner.hasPrecedingLineBreak();
}
auto isDeclaration() -> boolean
{
while (true)
{
switch (token())
{
case SyntaxKind::VarKeyword:
case SyntaxKind::LetKeyword:
case SyntaxKind::ConstKeyword:
case SyntaxKind::FunctionKeyword:
case SyntaxKind::ClassKeyword:
case SyntaxKind::EnumKeyword:
return true;
// 'declare', 'module', 'namespace', 'interface'* and 'type' are all legal JavaScript identifiers;
// however, an identifier cannot be followed by another identifier on the same line. This is what we
// count on to parse out the respective declarations. For instance, we exploit this to say that
//
// namespace n
//
// can be none other than the beginning of a namespace declaration, but need to respect that JavaScript sees
//
// namespace
// n
//
//.as<the>() identifier 'namespace' on one line followed by the identifier 'n' on another.
// We need to look one token ahead to see if it permissible to try parsing a declaration.
//
// *Note*: 'interface' is actually a strict mode reserved word. So while
//
// "use strict"
// interface
// I {}
//
// could be legal, it would add complexity for very little gain.
case SyntaxKind::InterfaceKeyword:
case SyntaxKind::TypeKeyword:
return nextTokenIsIdentifierOnSameLine();
case SyntaxKind::ModuleKeyword:
case SyntaxKind::NamespaceKeyword:
return nextTokenIsIdentifierOrStringLiteralOnSameLine();
case SyntaxKind::AbstractKeyword:
case SyntaxKind::AsyncKeyword:
case SyntaxKind::DeclareKeyword:
case SyntaxKind::PrivateKeyword:
case SyntaxKind::ProtectedKeyword:
case SyntaxKind::PublicKeyword:
case SyntaxKind::ReadonlyKeyword:
nextToken();
// ASI takes effect for this modifier.
if (scanner.hasPrecedingLineBreak())
{
return false;
}
continue;
case SyntaxKind::GlobalKeyword:
nextToken();
return token() == SyntaxKind::OpenBraceToken || token() == SyntaxKind::Identifier ||
token() == SyntaxKind::ExportKeyword;
case SyntaxKind::ImportKeyword:
nextToken();
return token() == SyntaxKind::StringLiteral || token() == SyntaxKind::AsteriskToken ||
token() == SyntaxKind::OpenBraceToken || scanner.tokenIsIdentifierOrKeyword(token());
case SyntaxKind::ExportKeyword: {
auto currentToken = nextToken();
if (currentToken == SyntaxKind::TypeKeyword)
{
currentToken = lookAhead<SyntaxKind>(std::bind(&Parser::nextToken, this));
}
if (currentToken == SyntaxKind::EqualsToken || currentToken == SyntaxKind::AsteriskToken ||
currentToken == SyntaxKind::OpenBraceToken || currentToken == SyntaxKind::DefaultKeyword ||
currentToken == SyntaxKind::AsKeyword)
{
return true;
}
continue;
}
case SyntaxKind::StaticKeyword:
nextToken();
continue;
default:
return false;
}
}
}
auto isStartOfDeclaration() -> boolean
{
return lookAhead<boolean>(std::bind(&Parser::isDeclaration, this));
}
auto isStartOfStatement() -> boolean
{
switch (token())
{
case SyntaxKind::AtToken:
case SyntaxKind::SemicolonToken:
case SyntaxKind::OpenBraceToken:
case SyntaxKind::VarKeyword:
case SyntaxKind::LetKeyword:
case SyntaxKind::FunctionKeyword:
case SyntaxKind::ClassKeyword:
case SyntaxKind::EnumKeyword:
case SyntaxKind::IfKeyword:
case SyntaxKind::DoKeyword:
case SyntaxKind::WhileKeyword:
case SyntaxKind::ForKeyword:
case SyntaxKind::ContinueKeyword:
case SyntaxKind::BreakKeyword:
case SyntaxKind::ReturnKeyword:
case SyntaxKind::WithKeyword:
case SyntaxKind::SwitchKeyword:
case SyntaxKind::ThrowKeyword:
case SyntaxKind::TryKeyword:
case SyntaxKind::DebuggerKeyword:
// 'catch' and 'finally' do not actually indicate that the code is part of a statement,
// however, we say they are here so that we may gracefully parse them and error later.
// falls through
case SyntaxKind::CatchKeyword:
case SyntaxKind::FinallyKeyword:
return true;
case SyntaxKind::ImportKeyword:
return isStartOfDeclaration() ||
lookAhead<boolean>(std::bind(&Parser::nextTokenIsOpenParenOrLessThanOrDot, this));
case SyntaxKind::ConstKeyword:
case SyntaxKind::ExportKeyword:
return isStartOfDeclaration();
case SyntaxKind::AsyncKeyword:
case SyntaxKind::DeclareKeyword:
case SyntaxKind::InterfaceKeyword:
case SyntaxKind::ModuleKeyword:
case SyntaxKind::NamespaceKeyword:
case SyntaxKind::TypeKeyword:
case SyntaxKind::GlobalKeyword:
// When these don't start a declaration, they're an identifier in an expression statement
return true;
case SyntaxKind::PublicKeyword:
case SyntaxKind::PrivateKeyword:
case SyntaxKind::ProtectedKeyword:
case SyntaxKind::StaticKeyword:
case SyntaxKind::ReadonlyKeyword:
// When these don't start a declaration, they may be the start of a class member if an identifier
// immediately follows. Otherwise they're an identifier in an expression statement.
return isStartOfDeclaration() ||
!lookAhead<boolean>(std::bind(&Parser::nextTokenIsIdentifierOrKeywordOnSameLine, this));
default:
return isStartOfExpression();
}
}
auto nextTokenIsIdentifierOrStartOfDestructuring()
{
nextToken();
return isIdentifier() || token() == SyntaxKind::OpenBraceToken || token() == SyntaxKind::OpenBracketToken;
}
auto isLetDeclaration()
{
// In ES6 'let' always starts a lexical declaration if followed by an identifier or {
// or [.
return lookAhead<boolean>(std::bind(&Parser::nextTokenIsIdentifierOrStartOfDestructuring, this));
}
auto parseStatement() -> Statement
{
switch (token())
{
case SyntaxKind::SemicolonToken:
return parseEmptyStatement();
case SyntaxKind::OpenBraceToken:
return parseBlock(/*ignoreMissingOpenBrace*/ false);
case SyntaxKind::VarKeyword:
return parseVariableStatement(getNodePos(), hasPrecedingJSDocComment(), /*decorators*/ undefined,
/*modifiers*/ undefined);
case SyntaxKind::LetKeyword:
if (isLetDeclaration())
{
return parseVariableStatement(getNodePos(), hasPrecedingJSDocComment(), /*decorators*/ undefined,
/*modifiers*/ undefined);
}
break;
case SyntaxKind::FunctionKeyword:
return parseFunctionDeclaration(getNodePos(), hasPrecedingJSDocComment(), /*decorators*/ undefined,
/*modifiers*/ undefined);
case SyntaxKind::ClassKeyword:
return parseClassDeclaration(getNodePos(), hasPrecedingJSDocComment(), /*decorators*/ undefined,
/*modifiers*/ undefined);
case SyntaxKind::IfKeyword:
return parseIfStatement();
case SyntaxKind::DoKeyword:
return parseDoStatement();
case SyntaxKind::WhileKeyword:
return parseWhileStatement();
case SyntaxKind::ForKeyword:
return parseForOrForInOrForOfStatement();
case SyntaxKind::ContinueKeyword:
return parseBreakOrContinueStatement(SyntaxKind::ContinueStatement);
case SyntaxKind::BreakKeyword:
return parseBreakOrContinueStatement(SyntaxKind::BreakStatement);
case SyntaxKind::ReturnKeyword:
return parseReturnStatement();
case SyntaxKind::WithKeyword:
return parseWithStatement();
case SyntaxKind::SwitchKeyword:
return parseSwitchStatement();
case SyntaxKind::ThrowKeyword:
return parseThrowStatement();
case SyntaxKind::TryKeyword:
// Include 'catch' and 'finally' for error recovery.
// falls through
case SyntaxKind::CatchKeyword:
case SyntaxKind::FinallyKeyword:
return parseTryStatement();
case SyntaxKind::DebuggerKeyword:
return parseDebuggerStatement();
case SyntaxKind::AtToken:
return parseDeclaration();
case SyntaxKind::AsyncKeyword:
case SyntaxKind::InterfaceKeyword:
case SyntaxKind::TypeKeyword:
case SyntaxKind::ModuleKeyword:
case SyntaxKind::NamespaceKeyword:
case SyntaxKind::DeclareKeyword:
case SyntaxKind::ConstKeyword:
case SyntaxKind::EnumKeyword:
case SyntaxKind::ExportKeyword:
case SyntaxKind::ImportKeyword:
case SyntaxKind::PrivateKeyword:
case SyntaxKind::ProtectedKeyword:
case SyntaxKind::PublicKeyword:
case SyntaxKind::AbstractKeyword:
case SyntaxKind::StaticKeyword:
case SyntaxKind::ReadonlyKeyword:
case SyntaxKind::GlobalKeyword:
if (isStartOfDeclaration())
{
return parseDeclaration();
}
break;
}
return parseExpressionOrLabeledStatement();
}
auto isDeclareModifier(Modifier modifier) -> boolean
{
return modifier == SyntaxKind::DeclareKeyword;
}
auto parseDeclaration() -> Statement
{
// Can TODO we hold onto the parsed decorators/modifiers and advance the scanner
// if we can't reuse the declaration, so that we don't do this work twice?
//
// `parseListElement` attempted to get the reused node at this position,
// but the ambient context flag was not yet set, so the node appeared
// not reusable in that context->
auto isAmbient = some(lookAhead<NodeArray<Modifier>>([&]() {
parseDecorators();
return parseModifiers();
}),
std::bind(&Parser::isDeclareModifier, this, std::placeholders::_1));
if (isAmbient)
{
auto node = tryReuseAmbientDeclaration();
if (node)
{
return node;
}
}
auto pos = getNodePos();
auto hasJSDoc = hasPrecedingJSDocComment();
auto decorators = parseDecorators();
auto modifiers = parseModifiers();
if (isAmbient)
{
for (auto &m : modifiers)
{
(m.asMutable<Node>())->flags |= NodeFlags::Ambient;
}
return doInsideOfContext<Node>(
NodeFlags::Ambient, [&]() { return parseDeclarationWorker(pos, hasJSDoc, decorators, modifiers); });
}
else
{
return parseDeclarationWorker(pos, hasJSDoc, decorators, modifiers);
}
}
auto tryReuseAmbientDeclaration() -> Statement
{
return doInsideOfContext<Statement>(NodeFlags::Ambient, [&]() {
auto node = currentNode(parsingContext);
if (node)
{
return consumeNode(node).as<Statement>();
}
return (Statement)undefined;
});
}
auto parseDeclarationWorker(pos_type pos, boolean hasJSDoc, NodeArray<Decorator> decorators,
NodeArray<Modifier> modifiers) -> Statement
{
switch (token())
{
case SyntaxKind::VarKeyword:
case SyntaxKind::LetKeyword:
case SyntaxKind::ConstKeyword:
return parseVariableStatement(pos, hasJSDoc, decorators, modifiers);
case SyntaxKind::FunctionKeyword:
return parseFunctionDeclaration(pos, hasJSDoc, decorators, modifiers);
case SyntaxKind::ClassKeyword:
return parseClassDeclaration(pos, hasJSDoc, decorators, modifiers);
case SyntaxKind::InterfaceKeyword:
return parseInterfaceDeclaration(pos, hasJSDoc, decorators, modifiers);
case SyntaxKind::TypeKeyword:
return parseTypeAliasDeclaration(pos, hasJSDoc, decorators, modifiers);
case SyntaxKind::EnumKeyword:
return parseEnumDeclaration(pos, hasJSDoc, decorators, modifiers);
case SyntaxKind::GlobalKeyword:
case SyntaxKind::ModuleKeyword:
case SyntaxKind::NamespaceKeyword:
return parseModuleDeclaration(pos, hasJSDoc, decorators, modifiers);
case SyntaxKind::ImportKeyword:
return parseImportDeclarationOrImportEqualsDeclaration(pos, hasJSDoc, decorators, modifiers);
case SyntaxKind::ExportKeyword:
nextToken();
switch (token())
{
case SyntaxKind::DefaultKeyword:
case SyntaxKind::EqualsToken:
return parseExportAssignment(pos, hasJSDoc, decorators, modifiers);
case SyntaxKind::AsKeyword:
return parseNamespaceExportDeclaration(pos, hasJSDoc, decorators, modifiers);
default:
return parseExportDeclaration(pos, hasJSDoc, decorators, modifiers);
}
default:
if (!!decorators || !!modifiers)
{
// We reached this point because we encountered decorators and/or modifiers and assumed a declaration
// would follow. For recovery and error reporting purposes, return an incomplete declaration.
auto missing = createMissingNode<MissingDeclaration>(
SyntaxKind::MissingDeclaration, /*reportAtCurrentPosition*/ true,
data::DiagnosticMessage(Diagnostics::Declaration_expected));
setTextRangePos(missing, pos);
missing->decorators = decorators;
copy(missing->modifiers, modifiers);
return missing;
}
return undefined; // GH TODO#18217
}
}
auto nextTokenIsIdentifierOrStringLiteralOnSameLine() -> boolean
{
nextToken();
return !scanner.hasPrecedingLineBreak() && (isIdentifier() || token() == SyntaxKind::StringLiteral);
}
auto parseFunctionBlockOrSemicolon(SignatureFlags flags, DiagnosticMessage diagnosticMessage = undefined) -> Block
{
if (token() != SyntaxKind::OpenBraceToken && canParseSemicolon())
{
parseSemicolon();
return undefined;
}
return parseFunctionBlock(flags, diagnosticMessage);
}
// DECLARATIONS
auto parseArrayBindingElement() -> ArrayBindingElement
{
auto pos = getNodePos();
if (token() == SyntaxKind::CommaToken)
{
return finishNode(factory.createOmittedExpression(), pos);
}
auto dotDotDotToken = parseOptionalToken(SyntaxKind::DotDotDotToken);
auto name = parseIdentifierOrPattern();
auto initializer = parseInitializer();
return finishNode(factory.createBindingElement(dotDotDotToken, /*propertyName*/ undefined, name, initializer),
pos);
}
auto parseObjectBindingElement() -> BindingElement
{
auto pos = getNodePos();
auto dotDotDotToken = parseOptionalToken(SyntaxKind::DotDotDotToken);
auto tokenIsIdentifier = isBindingIdentifier();
/*PropertyName*/ auto propertyName = parsePropertyName();
BindingName name;
if (tokenIsIdentifier && token() != SyntaxKind::ColonToken)
{
name = propertyName.as<Identifier>();
propertyName = undefined;
}
else
{
parseExpected(SyntaxKind::ColonToken);
name = parseIdentifierOrPattern();
}
auto initializer = parseInitializer();
return finishNode(factory.createBindingElement(dotDotDotToken, propertyName, name, initializer), pos);
}
auto parseObjectBindingPattern() -> ObjectBindingPattern
{
auto pos = getNodePos();
parseExpected(SyntaxKind::OpenBraceToken);
auto elements = parseDelimitedList<BindingElement>(ParsingContext::ObjectBindingElements,
std::bind(&Parser::parseObjectBindingElement, this));
parseExpected(SyntaxKind::CloseBraceToken);
return finishNode(factory.createObjectBindingPattern(elements), pos);
}
auto parseArrayBindingPattern() -> ArrayBindingPattern
{
auto pos = getNodePos();
parseExpected(SyntaxKind::OpenBracketToken);
auto elements = parseDelimitedList<ArrayBindingElement>(ParsingContext::ArrayBindingElements,
std::bind(&Parser::parseArrayBindingElement, this));
parseExpected(SyntaxKind::CloseBracketToken);
return finishNode(factory.createArrayBindingPattern(elements), pos);
}
auto isBindingIdentifierOrPrivateIdentifierOrPattern() -> boolean
{
return token() == SyntaxKind::OpenBraceToken || token() == SyntaxKind::OpenBracketToken ||
token() == SyntaxKind::PrivateIdentifier || isBindingIdentifier();
}
auto parseIdentifierOrPattern(DiagnosticMessage privateIdentifierDiagnosticMessage = undefined) -> Node
{
if (token() == SyntaxKind::OpenBracketToken)
{
return parseArrayBindingPattern();
}
if (token() == SyntaxKind::OpenBraceToken)
{
return parseObjectBindingPattern();
}
return parseBindingIdentifier(privateIdentifierDiagnosticMessage);
}
auto parseVariableDeclarationAllowExclamation()
{
return parseVariableDeclaration(/*allowExclamation*/ true);
}
auto parseVariableDeclaration0() -> VariableDeclaration
{
return parseVariableDeclaration();
}
auto parseVariableDeclaration(boolean allowExclamation = false) -> VariableDeclaration
{
auto pos = getNodePos();
auto hasJSDoc = hasPrecedingJSDocComment();
auto name = parseIdentifierOrPattern(
data::DiagnosticMessage(Diagnostics::Private_identifiers_are_not_allowed_in_variable_declarations));
ExclamationToken exclamationToken;
if (allowExclamation && name == SyntaxKind::Identifier && token() == SyntaxKind::ExclamationToken &&
!scanner.hasPrecedingLineBreak())
{
exclamationToken = parseTokenNode<Token<SyntaxKind::ExclamationToken>>();
}
auto type = parseTypeAnnotation();
auto initializer = isInOrOfKeyword(token()) ? undefined : parseInitializer();
auto node = factory.createVariableDeclaration(name, exclamationToken, type, initializer);
return withJSDoc(finishNode(node, pos), hasJSDoc);
}
auto parseVariableDeclarationList(boolean inForStatementInitializer) -> VariableDeclarationList
{
auto pos = getNodePos();
auto flags = NodeFlags::None;
switch (token())
{
case SyntaxKind::VarKeyword:
break;
case SyntaxKind::LetKeyword:
flags |= NodeFlags::Let;
break;
case SyntaxKind::ConstKeyword:
flags |= NodeFlags::Const;
break;
default:
Debug::fail<void>();
}
nextToken();
// The user may have written the following:
//
// for (auto of X) { }
//
// In this case, we want to parse an empty declaration list, and then parse 'of'
//.as<a>() keyword. The reason this is not automatic is that 'of' is a valid identifier.
// So we need to look ahead to determine if 'of' should be treated.as<a>() keyword in
// this context->
// The checker will then give an error that there is an empty declaration list.
NodeArray<VariableDeclaration> declarations;
if (token() == SyntaxKind::OfKeyword &&
lookAhead<boolean>(std::bind(&Parser::canFollowContextualOfKeyword, this)))
{
declarations = createMissingList<VariableDeclaration>();
}
else
{
auto savedDisallowIn = inDisallowInContext();
setDisallowInContext(inForStatementInitializer);
declarations = parseDelimitedList<VariableDeclaration>(
ParsingContext::VariableDeclarations,
inForStatementInitializer
? (std::function<VariableDeclaration()>)std::bind(&Parser::parseVariableDeclaration0, this)
: (std::function<VariableDeclaration()>)std::bind(&Parser::parseVariableDeclarationAllowExclamation,
this));
setDisallowInContext(savedDisallowIn);
}
return finishNode(factory.createVariableDeclarationList(declarations, flags), pos);
}
auto canFollowContextualOfKeyword() -> boolean
{
return nextTokenIsIdentifier() && nextToken() == SyntaxKind::CloseParenToken;
}
auto parseVariableStatement(pos_type pos, boolean hasJSDoc, NodeArray<Decorator> decorators,
NodeArray<Modifier> modifiers) -> VariableStatement
{
auto declarationList = parseVariableDeclarationList(/*inForStatementInitializer*/ false);
parseSemicolon();
auto node = factory.createVariableStatement(modifiers, declarationList);
// Decorators are not allowed on a variable statement, so we keep track of them to report them in the grammar
// checker.
node->decorators = decorators;
return withJSDoc(finishNode(node, pos), hasJSDoc);
}
auto parseFunctionDeclaration(pos_type pos, boolean hasJSDoc, NodeArray<Decorator> decorators,
NodeArray<Modifier> modifiers) -> FunctionDeclaration
{
auto savedAwaitContext = inAwaitContext();
auto modifierFlags = modifiersToFlags(modifiers);
parseExpected(SyntaxKind::FunctionKeyword);
auto asteriskToken = parseOptionalToken(SyntaxKind::AsteriskToken);
// We don't parse the name here in await context, instead we will report a grammar error in the checker.
auto name =
!!(modifierFlags & ModifierFlags::Default) ? parseOptionalBindingIdentifier() : parseBindingIdentifier();
auto isGenerator = asteriskToken ? SignatureFlags::Yield : SignatureFlags::None;
auto isAsync = !!(modifierFlags & ModifierFlags::Async) ? SignatureFlags::Await : SignatureFlags::None;
auto typeParameters = parseTypeParameters();
if (!!(modifierFlags & ModifierFlags::Export))
setAwaitContext(/*value*/ true);
auto parameters = parseParameters(isGenerator | isAsync);
auto type = parseReturnType(SyntaxKind::ColonToken, /*isType*/ false);
auto body =
parseFunctionBlockOrSemicolon(isGenerator | isAsync, data::DiagnosticMessage(Diagnostics::or_expected));
setAwaitContext(savedAwaitContext);
auto node = factory.createFunctionDeclaration(decorators, modifiers, asteriskToken, name, typeParameters,
parameters, type, body);
return withJSDoc(finishNode(node, pos), hasJSDoc);
}
auto parseConstructorName() -> boolean
{
if (token() == SyntaxKind::ConstructorKeyword)
{
return parseExpected(SyntaxKind::ConstructorKeyword);
}
if (token() == SyntaxKind::StringLiteral &&
lookAhead<SyntaxKind>(std::bind(&Parser::nextToken, this)) == SyntaxKind::OpenParenToken)
{
return tryParse<boolean>([&]() {
auto literalNode = parseLiteralNode();
return literalNode->text == S("constructor");
});
}
return false;
}
auto tryParseConstructorDeclaration(pos_type pos, boolean hasJSDoc, NodeArray<Decorator> decorators,
NodeArray<Modifier> modifiers) -> ConstructorDeclaration
{
return tryParse<ConstructorDeclaration>([&]() {
if (parseConstructorName())
{
auto typeParameters = parseTypeParameters();
auto parameters = parseParameters(SignatureFlags::None);
auto type = parseReturnType(SyntaxKind::ColonToken, /*isType*/ false);
auto body = parseFunctionBlockOrSemicolon(SignatureFlags::None,
data::DiagnosticMessage(Diagnostics::or_expected));
auto node = factory.createConstructorDeclaration(decorators, modifiers, parameters, body);
// Attach `typeParameters` and `type` if they exist so that we can report them in the grammar checker.
node->typeParameters = typeParameters;
node->type = type;
return withJSDoc(finishNode(node, pos), hasJSDoc);
}
return (Node)undefined;
});
return undefined;
}
auto parseMethodDeclaration(pos_type pos, boolean hasJSDoc, NodeArray<Decorator> decorators,
NodeArray<Modifier> modifiers, AsteriskToken asteriskToken, PropertyName name,
QuestionToken questionToken, ExclamationToken exclamationToken,
DiagnosticMessage diagnosticMessage = undefined) -> MethodDeclaration
{
auto isGenerator = asteriskToken == SyntaxKind::AsteriskToken ? SignatureFlags::Yield : SignatureFlags::None;
auto isAsync = some(modifiers, isAsyncModifier) ? SignatureFlags::Await : SignatureFlags::None;
auto typeParameters = parseTypeParameters();
auto parameters = parseParameters(isGenerator | isAsync);
auto type = parseReturnType(SyntaxKind::ColonToken, /*isType*/ false);
auto body = parseFunctionBlockOrSemicolon(isGenerator | isAsync, diagnosticMessage);
auto node = factory.createMethodDeclaration(decorators, modifiers, asteriskToken, name, questionToken,
typeParameters, parameters, type, body);
// An exclamation token on a method is invalid syntax and will be handled by the grammar checker
node->exclamationToken = exclamationToken;
return withJSDoc(finishNode(node, pos), hasJSDoc);
}
auto parsePropertyDeclaration(pos_type pos, boolean hasJSDoc, NodeArray<Decorator> decorators,
NodeArray<Modifier> modifiers, PropertyName name, QuestionToken questionToken)
-> PropertyDeclaration
{
auto exclamationToken = !questionToken && !scanner.hasPrecedingLineBreak()
? parseOptionalToken(SyntaxKind::ExclamationToken)
: undefined;
auto type = parseTypeAnnotation();
auto initializer = doOutsideOfContext<Expression>(NodeFlags::YieldContext | NodeFlags::AwaitContext |
NodeFlags::DisallowInContext,
std::bind(&Parser::parseInitializer, this));
parseSemicolon();
auto node = factory.createPropertyDeclaration(
decorators, modifiers, name, questionToken.as<Node>() || [&]() { return exclamationToken.as<Node>(); },
type, initializer);
return withJSDoc(finishNode(node, pos), hasJSDoc);
}
auto parsePropertyOrMethodDeclaration(pos_type pos, boolean hasJSDoc, NodeArray<Decorator> decorators,
NodeArray<Modifier> modifiers) -> Node
{
auto asteriskToken = parseOptionalToken(SyntaxKind::AsteriskToken);
auto name = parsePropertyName();
// this Note is not legal.as<per>() the grammar. But we allow it in the parser and
// report an error in the grammar checker.
auto questionToken = parseOptionalToken(SyntaxKind::QuestionToken);
if (asteriskToken || token() == SyntaxKind::OpenParenToken || token() == SyntaxKind::LessThanToken)
{
return parseMethodDeclaration(pos, hasJSDoc, decorators, modifiers, asteriskToken, name, questionToken,
/*exclamationToken*/ undefined,
data::DiagnosticMessage(Diagnostics::or_expected));
}
return parsePropertyDeclaration(pos, hasJSDoc, decorators, modifiers, name, questionToken);
}
auto parseAccessorDeclaration(pos_type pos, boolean hasJSDoc, NodeArray<Decorator> decorators,
NodeArray<Modifier> modifiers, SyntaxKind kind) -> AccessorDeclaration
{
auto name = parsePropertyName();
auto typeParameters = parseTypeParameters();
auto parameters = parseParameters(SignatureFlags::None);
auto type = parseReturnType(SyntaxKind::ColonToken, /*isType*/ false);
auto body = parseFunctionBlockOrSemicolon(SignatureFlags::None);
auto node = kind == SyntaxKind::GetAccessor
? factory.createGetAccessorDeclaration(decorators, modifiers, name, parameters, type, body)
.as<AccessorDeclaration>()
: factory.createSetAccessorDeclaration(decorators, modifiers, name, parameters, body)
.as<AccessorDeclaration>();
// Keep track of `typeParameters` (for both) and `type` (for setters) if they were parsed those indicate grammar
// errors
node->typeParameters = typeParameters;
if (!!type && node == SyntaxKind::SetAccessor)
(node.asMutable<SetAccessorDeclaration>())->type = type;
return withJSDoc(finishNode(node, pos), hasJSDoc);
}
auto isClassMemberStart() -> boolean
{
auto idToken = SyntaxKind::Unknown;
if (token() == SyntaxKind::AtToken)
{
return true;
}
// Eat up all modifiers, but hold on to the last one in case it is actually an identifier.
while (isModifierKind(token()))
{
idToken = token();
// If the idToken is a class modifier (protected, private, public, and static), it is
// certain that we are starting to parse class member. This allows better error recovery
// Example:
// public foo() ... // true
// public @dec blah ... // true; we will then report an error later
// public ... // true; we will then report an error later
if (isClassMemberModifier(idToken))
{
return true;
}
nextToken();
}
if (token() == SyntaxKind::AsteriskToken)
{
return true;
}
// Try to get the first property-like token following all modifiers.
// This can either be an identifier or the 'get' or 'set' keywords.
if (isLiteralPropertyName())
{
idToken = token();
nextToken();
}
// Index signatures and computed properties are class members; we can parse.
if (token() == SyntaxKind::OpenBracketToken)
{
return true;
}
// If we were able to get any potential identifier...
if (idToken != SyntaxKind::Unknown)
{
// If we have a non-keyword identifier, or if we have an accessor, then it's safe to parse.
if (!isKeyword(idToken) || idToken == SyntaxKind::SetKeyword || idToken == SyntaxKind::GetKeyword)
{
return true;
}
// If it *is* a keyword, but not an accessor, check a little farther along
// to see if it should actually be parsed.as<a>() class member.
switch (token())
{
case SyntaxKind::OpenParenToken: // Method declaration
case SyntaxKind::LessThanToken: // Generic Method declaration
case SyntaxKind::ExclamationToken: // Non-null assertion on property name
case SyntaxKind::ColonToken: // Type Annotation for declaration
case SyntaxKind::EqualsToken: // Initializer for declaration
case SyntaxKind::QuestionToken: // Not valid, but permitted so that it gets caught later on.
return true;
default:
// Covers
// - Semicolons (declaration termination)
// - Closing braces (end-of-class, must be declaration)
// - End-of-files (not valid, but permitted so that it gets caught later on)
// - Line-breaks (enabling *automatic semicolon insertion*)
return canParseSemicolon();
}
}
return false;
}
auto parseDecoratorExpression()
{
if (inAwaitContext() && token() == SyntaxKind::AwaitKeyword)
{
// `@await` is is disallowed in an [Await] context, but can cause parsing to go off the rails
// This simply parses the missing identifier and moves on.
auto pos = getNodePos();
auto awaitExpression = parseIdentifier(data::DiagnosticMessage(Diagnostics::Expression_expected));
nextToken();
auto memberExpression = parseMemberExpressionRest(pos, awaitExpression, /*allowOptionalChain*/ true);
return parseCallExpressionRest(pos, memberExpression);
}
return parseLeftHandSideExpressionOrHigher();
}
auto tryParseDecorator() -> Decorator
{
auto pos = getNodePos();
if (!parseOptional(SyntaxKind::AtToken))
{
return undefined;
}
auto expression =
doInDecoratorContext<LeftHandSideExpression>(std::bind(&Parser::parseDecoratorExpression, this));
return finishNode(factory.createDecorator(expression), pos);
}
auto parseDecorators() -> NodeArray<Decorator>
{
auto pos = getNodePos();
NodeArray<Decorator> list;
Decorator decorator;
while (!!(decorator = tryParseDecorator()))
{
list = append(list, decorator);
}
return !!list ? createNodeArray(list, pos) : undefined;
}
auto tryParseModifier(boolean permitInvalidConstAsModifier) -> Modifier
{
auto pos = getNodePos();
auto kind = token();
if (token() == SyntaxKind::ConstKeyword && permitInvalidConstAsModifier)
{
// We need to ensure that any subsequent modifiers appear on the same line
// so that when 'const' is a standalone declaration, we don't issue an error.
if (!tryParse<boolean>(std::bind(&Parser::nextTokenIsOnSameLineAndCanFollowModifier, this)))
{
return undefined;
}
}
else
{
if (!parseAnyContextualModifier())
{
return undefined;
}
}
return finishNode(factory.createToken(kind), pos);
}
/*
* There are situations in which a modifier like 'const' will appear unexpectedly, such.as<on>() a class member.
* In those situations, if we are entirely sure that 'const' is not valid on its own (such.as<when>() ASI takes
* effect and turns it into a standalone declaration), then it is better to parse it and report an error later.
*
* In such situations, 'permitInvalidConstAsModifier' should be set to true.
*/
auto parseModifiers(boolean permitInvalidConstAsModifier = false) -> NodeArray<Modifier>
{
auto pos = getNodePos();
NodeArray<Modifier> list;
Modifier modifier;
while (modifier = tryParseModifier(permitInvalidConstAsModifier))
{
list = append(list, modifier);
}
return !!list ? createNodeArray(list, pos) : undefined;
}
auto parseModifiersForArrowFunction() -> NodeArray<Modifier>
{
NodeArray<Modifier> modifiers;
if (token() == SyntaxKind::AsyncKeyword)
{
auto pos = getNodePos();
nextToken();
auto modifier = finishNode(factory.createToken(SyntaxKind::AsyncKeyword), pos);
modifiers = createNodeArray<Modifier>(NodeArray<Modifier>({modifier}), pos);
}
return modifiers;
}
auto parseClassElement() -> ClassElement
{
auto pos = getNodePos();
if (token() == SyntaxKind::SemicolonToken)
{
nextToken();
return finishNode(factory.createSemicolonClassElement(), pos);
}
auto hasJSDoc = hasPrecedingJSDocComment();
auto decorators = parseDecorators();
auto modifiers = parseModifiers(/*permitInvalidConstAsModifier*/ true);
if (parseContextualModifier(SyntaxKind::GetKeyword))
{
return parseAccessorDeclaration(pos, hasJSDoc, decorators, modifiers, SyntaxKind::GetAccessor);
}
if (parseContextualModifier(SyntaxKind::SetKeyword))
{
return parseAccessorDeclaration(pos, hasJSDoc, decorators, modifiers, SyntaxKind::SetAccessor);
}
if (token() == SyntaxKind::ConstructorKeyword || token() == SyntaxKind::StringLiteral)
{
auto constructorDeclaration = tryParseConstructorDeclaration(pos, hasJSDoc, decorators, modifiers);
if (!!constructorDeclaration)
{
return constructorDeclaration;
}
}
if (isIndexSignature())
{
return parseIndexSignatureDeclaration(pos, hasJSDoc, decorators, modifiers);
}
// It is very important that we check this *after* checking indexers because
// the [ token can start an index signature or a computed property name
if (scanner.tokenIsIdentifierOrKeyword(token()) || token() == SyntaxKind::StringLiteral ||
token() == SyntaxKind::NumericLiteral || token() == SyntaxKind::AsteriskToken ||
token() == SyntaxKind::OpenBracketToken)
{
auto isAmbient =
some<ModifiersArray>(modifiers, std::bind(&Parser::isDeclareModifier, this, std::placeholders::_1));
if (isAmbient)
{
for (auto m : modifiers)
{
(m.asMutable<Node>())->flags |= NodeFlags::Ambient;
}
return doInsideOfContext<Node>(NodeFlags::Ambient, [&]() {
return parsePropertyOrMethodDeclaration(pos, hasJSDoc, decorators, modifiers);
});
}
else
{
return parsePropertyOrMethodDeclaration(pos, hasJSDoc, decorators, modifiers);
}
}
if (!!decorators || !!modifiers)
{
// treat this.as<a>() property declaration with a missing name.
auto name = createMissingNode<Identifier>(SyntaxKind::Identifier, /*reportAtCurrentPosition*/ true,
data::DiagnosticMessage(Diagnostics::Declaration_expected));
return parsePropertyDeclaration(pos, hasJSDoc, decorators, modifiers, name, /*questionToken*/ undefined);
}
// 'isClassMemberStart' should have hinted not to attempt parsing.
return Debug::fail<ClassElement>(S("Should not have attempted to parse class member declaration."));
}
auto parseClassExpression() -> ClassExpression
{
return parseClassDeclarationOrExpression(getNodePos(), hasPrecedingJSDocComment(), /*decorators*/ undefined,
/*modifiers*/ undefined, SyntaxKind::ClassExpression);
}
auto parseClassDeclaration(pos_type pos, boolean hasJSDoc, NodeArray<Decorator> decorators,
NodeArray<Modifier> modifiers) -> ClassDeclaration
{
return parseClassDeclarationOrExpression(pos, hasJSDoc, decorators, modifiers, SyntaxKind::ClassDeclaration);
}
auto parseClassDeclarationOrExpression(pos_type pos, boolean hasJSDoc, NodeArray<Decorator> decorators,
NodeArray<Modifier> modifiers, SyntaxKind kind) -> ClassLikeDeclaration
{
auto savedAwaitContext = inAwaitContext();
parseExpected(SyntaxKind::ClassKeyword);
// We don't parse the name here in await context, instead we will report a grammar error in the checker.
auto name = parseNameOfClassDeclarationOrExpression();
auto typeParameters = parseTypeParameters();
if (some(modifiers, isExportModifier))
setAwaitContext(/*value*/ true);
auto heritageClauses = parseHeritageClauses();
NodeArray<ClassElement> members;
if (parseExpected(SyntaxKind::OpenBraceToken))
{
// ClassTail[Yield,Await] : (Modified) See 14.5
// ClassHeritage[?Yield,?Await]opt { ClassBody[?Yield,?Await]opt }
members = parseClassMembers();
parseExpected(SyntaxKind::CloseBraceToken);
}
else
{
members = createMissingList<ClassElement>();
}
setAwaitContext(savedAwaitContext);
auto node =
kind == SyntaxKind::ClassDeclaration
? factory.createClassDeclaration(decorators, modifiers, name, typeParameters, heritageClauses, members)
.as<ClassLikeDeclaration>()
: factory.createClassExpression(decorators, modifiers, name, typeParameters, heritageClauses, members)
.as<ClassLikeDeclaration>();
return withJSDoc(finishNode(node, pos), hasJSDoc);
}
auto parseNameOfClassDeclarationOrExpression() -> Identifier
{
// implements is a future reserved word so
// 'class implements' might mean either
// - class expression with omitted name, 'implements' starts heritage clause
// - class with name 'implements'
// 'isImplementsClause' helps to disambiguate between these two cases
return isBindingIdentifier() && !isImplementsClause() ? createIdentifier(isBindingIdentifier()) : undefined;
}
auto isImplementsClause() -> boolean
{
return token() == SyntaxKind::ImplementsKeyword &&
lookAhead<boolean>(std::bind(&Parser::nextTokenIsIdentifierOrKeyword, this));
}
auto parseHeritageClauses() -> NodeArray<HeritageClause>
{
// ClassTail[Yield,Await] : (Modified) See 14.5
// ClassHeritage[?Yield,?Await]opt { ClassBody[?Yield,?Await]opt }
if (isHeritageClause())
{
return parseList<HeritageClause>(ParsingContext::HeritageClauses,
std::bind(&Parser::parseHeritageClause, this));
}
return undefined;
}
auto parseHeritageClause() -> HeritageClause
{
auto pos = getNodePos();
auto tok = token();
Debug::_assert(tok == SyntaxKind::ExtendsKeyword ||
tok == SyntaxKind::ImplementsKeyword); // isListElement() should ensure this.
nextToken();
auto types = parseDelimitedList<ExpressionWithTypeArguments>(
ParsingContext::HeritageClauseElement, std::bind(&Parser::parseExpressionWithTypeArguments, this));
return finishNode(factory.createHeritageClause(tok, types), pos);
}
auto parseExpressionWithTypeArguments() -> ExpressionWithTypeArguments
{
auto pos = getNodePos();
auto expression = parseLeftHandSideExpressionOrHigher();
auto typeArguments = tryParseTypeArguments();
return finishNode(factory.createExpressionWithTypeArguments(expression, typeArguments), pos);
}
auto tryParseTypeArguments() -> NodeArray<TypeNode>
{
return token() == SyntaxKind::LessThanToken
? parseBracketedList<TypeNode>(ParsingContext::TypeArguments, std::bind(&Parser::parseType, this),
SyntaxKind::LessThanToken, SyntaxKind::GreaterThanToken)
: undefined;
}
auto isHeritageClause() -> boolean
{
return token() == SyntaxKind::ExtendsKeyword || token() == SyntaxKind::ImplementsKeyword;
}
auto parseClassMembers() -> NodeArray<ClassElement>
{
return parseList<ClassElement>(ParsingContext::ClassMembers, std::bind(&Parser::parseClassElement, this));
}
auto parseInterfaceDeclaration(pos_type pos, boolean hasJSDoc, NodeArray<Decorator> decorators,
NodeArray<Modifier> modifiers) -> InterfaceDeclaration
{
parseExpected(SyntaxKind::InterfaceKeyword);
auto name = parseIdentifier();
auto typeParameters = parseTypeParameters();
auto heritageClauses = parseHeritageClauses();
auto members = parseObjectTypeMembers();
auto node =
factory.createInterfaceDeclaration(decorators, modifiers, name, typeParameters, heritageClauses, members);
return withJSDoc(finishNode(node, pos), hasJSDoc);
}
auto parseTypeAliasDeclaration(pos_type pos, boolean hasJSDoc, NodeArray<Decorator> decorators,
NodeArray<Modifier> modifiers) -> TypeAliasDeclaration
{
parseExpected(SyntaxKind::TypeKeyword);
auto name = parseIdentifier();
auto typeParameters = parseTypeParameters();
parseExpected(SyntaxKind::EqualsToken);
auto type = (token() == SyntaxKind::IntrinsicKeyword
? tryParse<TypeNode>(std::bind(&Parser::parseKeywordAndNoDot, this))
: undefined) ||
[&]() { return parseType(); };
parseSemicolon();
auto node = factory.createTypeAliasDeclaration(decorators, modifiers, name, typeParameters, type);
return withJSDoc(finishNode(node, pos), hasJSDoc);
}
// In an ambient declaration, the grammar only allows integer literals.as<initializers>().
// In a non-ambient declaration, the grammar allows uninitialized members only in a
// ConstantEnumMemberSection, which starts at the beginning of an enum declaration
// or any time an integer literal initializer is encountered.
auto parseEnumMember() -> EnumMember
{
auto pos = getNodePos();
auto hasJSDoc = hasPrecedingJSDocComment();
auto name = parsePropertyName();
auto initializer = allowInAnd<Expression>(std::bind(&Parser::parseInitializer, this));
return withJSDoc(finishNode(factory.createEnumMember(name, initializer), pos), hasJSDoc);
}
auto parseEnumDeclaration(pos_type pos, boolean hasJSDoc, NodeArray<Decorator> decorators,
NodeArray<Modifier> modifiers) -> EnumDeclaration
{
parseExpected(SyntaxKind::EnumKeyword);
auto name = parseIdentifier();
NodeArray<EnumMember> members;
if (parseExpected(SyntaxKind::OpenBraceToken))
{
members = doOutsideOfYieldAndAwaitContext<NodeArray<EnumMember>>([&]() {
return parseDelimitedList<EnumMember>(ParsingContext::EnumMembers,
std::bind(&Parser::parseEnumMember, this));
});
parseExpected(SyntaxKind::CloseBraceToken);
}
else
{
members = createMissingList<EnumMember>();
}
auto node = factory.createEnumDeclaration(decorators, modifiers, name, members);
return withJSDoc(finishNode(node, pos), hasJSDoc);
}
auto parseModuleBlock() -> ModuleBlock
{
auto pos = getNodePos();
NodeArray<Statement> statements;
if (parseExpected(SyntaxKind::OpenBraceToken))
{
statements =
parseList<Statement>(ParsingContext::BlockStatements, std::bind(&Parser::parseStatement, this));
parseExpected(SyntaxKind::CloseBraceToken);
}
else
{
statements = createMissingList<Statement>();
}
return finishNode(factory.createModuleBlock(statements), pos);
}
auto parseModuleOrNamespaceDeclaration(pos_type pos, boolean hasJSDoc, NodeArray<Decorator> decorators,
NodeArray<Modifier> modifiers, NodeFlags flags) -> ModuleDeclaration
{
// If we are parsing a dotted namespace name, we want to
// propagate the 'Namespace' flag across the names if set.
auto namespaceFlag = flags & NodeFlags::Namespace;
auto name = parseIdentifier();
auto body =
parseOptional(SyntaxKind::DotToken)
? parseModuleOrNamespaceDeclaration(getNodePos(), /*hasJSDoc*/ false, /*decorators*/ undefined,
/*modifiers*/ undefined, NodeFlags::NestedNamespace | namespaceFlag)
.as<ModuleBody>()
: parseModuleBlock().as<ModuleBody>();
auto node = factory.createModuleDeclaration(decorators, modifiers, name, body, flags);
return withJSDoc(finishNode(node, pos), hasJSDoc);
}
auto parseAmbientExternalModuleDeclaration(pos_type pos, boolean hasJSDoc, NodeArray<Decorator> decorators,
NodeArray<Modifier> modifiers) -> ModuleDeclaration
{
auto flags = NodeFlags::None;
LiteralLikeNode name;
if (token() == SyntaxKind::GlobalKeyword)
{
// parse 'global'.as<name>() of global scope augmentation
name = parseIdentifier();
flags |= NodeFlags::GlobalAugmentation;
}
else
{
name = parseLiteralNode().as<StringLiteral>();
name->text = internIdentifier(name.as<LiteralLikeNode>()->text);
}
ModuleBlock body;
if (token() == SyntaxKind::OpenBraceToken)
{
body = parseModuleBlock();
}
else
{
parseSemicolon();
}
auto node = factory.createModuleDeclaration(decorators, modifiers, name, body, flags);
return withJSDoc(finishNode(node, pos), hasJSDoc);
}
auto parseModuleDeclaration(pos_type pos, boolean hasJSDoc, NodeArray<Decorator> decorators,
NodeArray<Modifier> modifiers) -> ModuleDeclaration
{
NodeFlags flags = NodeFlags::None;
if (token() == SyntaxKind::GlobalKeyword)
{
// global augmentation
return parseAmbientExternalModuleDeclaration(pos, hasJSDoc, decorators, modifiers);
}
else if (parseOptional(SyntaxKind::NamespaceKeyword))
{
flags |= NodeFlags::Namespace;
}
else
{
parseExpected(SyntaxKind::ModuleKeyword);
if (token() == SyntaxKind::StringLiteral)
{
return parseAmbientExternalModuleDeclaration(pos, hasJSDoc, decorators, modifiers);
}
}
return parseModuleOrNamespaceDeclaration(pos, hasJSDoc, decorators, modifiers, flags);
}
auto isExternalModuleReference() -> boolean
{
return token() == SyntaxKind::RequireKeyword &&
lookAhead<boolean>(std::bind(&Parser::nextTokenIsOpenParen, this));
}
auto nextTokenIsOpenParen() -> boolean
{
return nextToken() == SyntaxKind::OpenParenToken;
}
auto nextTokenIsSlash() -> boolean
{
return nextToken() == SyntaxKind::SlashToken;
}
auto parseNamespaceExportDeclaration(pos_type pos, boolean hasJSDoc, NodeArray<Decorator> decorators,
NodeArray<Modifier> modifiers) -> NamespaceExportDeclaration
{
parseExpected(SyntaxKind::AsKeyword);
parseExpected(SyntaxKind::NamespaceKeyword);
auto name = parseIdentifier();
parseSemicolon();
auto node = factory.createNamespaceExportDeclaration(name);
// NamespaceExportDeclaration nodes cannot have decorators or modifiers, so we attach them here so we can report
// them in the grammar checker
node->decorators = decorators;
copy(node->modifiers, modifiers);
return withJSDoc(finishNode(node, pos), hasJSDoc);
}
auto parseImportDeclarationOrImportEqualsDeclaration(pos_type pos, boolean hasJSDoc,
NodeArray<Decorator> decorators, NodeArray<Modifier> modifiers)
-> Node
{
parseExpected(SyntaxKind::ImportKeyword);
auto afterImportPos = scanner.getStartPos();
// We don't parse the identifier here in await context, instead we will report a grammar error in the checker.
Identifier identifier;
if (isIdentifier())
{
identifier = parseIdentifier();
}
auto isTypeOnly = false;
if (token() != SyntaxKind::FromKeyword && (!!identifier && identifier->escapedText == S("type")) &&
(isIdentifier() || tokenAfterImportDefinitelyProducesImportDeclaration()))
{
isTypeOnly = true;
identifier = isIdentifier() ? parseIdentifier() : undefined;
}
if (!!identifier && !tokenAfterImportedIdentifierDefinitelyProducesImportDeclaration())
{
return parseImportEqualsDeclaration(pos, hasJSDoc, decorators, modifiers, identifier, isTypeOnly);
}
// ImportDeclaration:
// import ImportClause from ModuleSpecifier ;
// import ModuleSpecifier;
ImportClause importClause;
if (!!identifier || // import id
token() == SyntaxKind::AsteriskToken || // import *
token() == SyntaxKind::OpenBraceToken // import {
)
{
importClause = parseImportClause(identifier, afterImportPos, isTypeOnly);
parseExpected(SyntaxKind::FromKeyword);
}
auto moduleSpecifier = parseModuleSpecifier();
parseSemicolon();
auto node = factory.createImportDeclaration(decorators, modifiers, importClause, moduleSpecifier);
return withJSDoc(finishNode(node, pos), hasJSDoc);
}
auto tokenAfterImportDefinitelyProducesImportDeclaration() -> boolean
{
return token() == SyntaxKind::AsteriskToken || token() == SyntaxKind::OpenBraceToken;
}
auto tokenAfterImportedIdentifierDefinitelyProducesImportDeclaration() -> boolean
{
// In `import id ___`, the current token decides whether to produce
// an ImportDeclaration or ImportEqualsDeclaration.
return token() == SyntaxKind::CommaToken || token() == SyntaxKind::FromKeyword;
}
auto parseImportEqualsDeclaration(pos_type pos, boolean hasJSDoc, NodeArray<Decorator> decorators,
NodeArray<Modifier> modifiers, Identifier identifier, boolean isTypeOnly)
-> ImportEqualsDeclaration
{
parseExpected(SyntaxKind::EqualsToken);
auto moduleReference = parseModuleReference();
parseSemicolon();
auto node =
factory.createImportEqualsDeclaration(decorators, modifiers, isTypeOnly, identifier, moduleReference);
auto finished = withJSDoc(finishNode(node, pos), hasJSDoc);
return finished;
}
auto parseImportClause(Identifier identifier, pos_type pos, boolean isTypeOnly) -> ImportClause
{
// ImportClause:
// ImportedDefaultBinding
// NameSpaceImport
// NamedImports
// ImportedDefaultBinding, NameSpaceImport
// ImportedDefaultBinding, NamedImports
// If there was no default import or if there is comma token after default import
// parse namespace or named imports
Node namedBindings;
if (!identifier || parseOptional(SyntaxKind::CommaToken))
{
namedBindings = token() == SyntaxKind::AsteriskToken
? parseNamespaceImport().as<Node>()
: parseNamedImportsOrExports(SyntaxKind::NamedImports).as<Node>();
}
return finishNode(factory.createImportClause(isTypeOnly, identifier, namedBindings), pos);
}
auto parseModuleReference() -> Node
{
return isExternalModuleReference() ? parseExternalModuleReference().as<Node>()
: parseEntityName(/*allowReservedWords*/ false).as<Node>();
}
auto parseExternalModuleReference() -> ExternalModuleReference
{
auto pos = getNodePos();
parseExpected(SyntaxKind::RequireKeyword);
parseExpected(SyntaxKind::OpenParenToken);
auto expression = parseModuleSpecifier();
parseExpected(SyntaxKind::CloseParenToken);
return finishNode(factory.createExternalModuleReference(expression), pos);
}
auto parseModuleSpecifier() -> Expression
{
if (token() == SyntaxKind::StringLiteral)
{
auto result = parseLiteralNode();
result->text = internIdentifier(result->text);
return result;
}
else
{
// We allow arbitrary expressions here, even though the grammar only allows string
// literals. We check to ensure that it is only a string literal later in the grammar
// check pass.
return parseExpression();
}
}
auto parseNamespaceImport() -> NamespaceImport
{
// NameSpaceImport:
// *.as<ImportedBinding>()
auto pos = getNodePos();
parseExpected(SyntaxKind::AsteriskToken);
parseExpected(SyntaxKind::AsKeyword);
auto name = parseIdentifier();
return finishNode(factory.createNamespaceImport(name), pos);
}
auto parseNamedImportsOrExports(SyntaxKind kind) -> NamedImportsOrExports
{
auto pos = getNodePos();
// NamedImports:
// { }
// { ImportsList }
// { ImportsList, }
// ImportsList:
// ImportSpecifier
// ImportsList, ImportSpecifier
auto node =
kind == SyntaxKind::NamedImports
? factory
.createNamedImports(parseBracketedList<ImportSpecifier>(
ParsingContext::ImportOrExportSpecifiers, std::bind(&Parser::parseImportSpecifier, this),
SyntaxKind::OpenBraceToken, SyntaxKind::CloseBraceToken))
.as<NamedImportsOrExports>()
: factory
.createNamedExports(parseBracketedList<ExportSpecifier>(
ParsingContext::ImportOrExportSpecifiers, std::bind(&Parser::parseExportSpecifier, this),
SyntaxKind::OpenBraceToken, SyntaxKind::CloseBraceToken))
.as<NamedImportsOrExports>();
return finishNode(node, pos);
}
auto parseExportSpecifier() -> ImportOrExportSpecifier
{
return parseImportOrExportSpecifier(SyntaxKind::ExportSpecifier).as<ExportSpecifier>();
}
auto parseImportSpecifier() -> ImportOrExportSpecifier
{
return parseImportOrExportSpecifier(SyntaxKind::ImportSpecifier).as<ImportSpecifier>();
}
auto parseImportOrExportSpecifier(SyntaxKind kind) -> ImportOrExportSpecifier
{
auto pos = getNodePos();
// ImportSpecifier:
// BindingIdentifier
// IdentifierName.as<BindingIdentifier>()
// ExportSpecifier:
// IdentifierName
// IdentifierName.as<IdentifierName>()
auto checkIdentifierIsKeyword = isKeyword(token()) && !isIdentifier();
auto checkIdentifierStart = scanner.getTokenPos();
auto checkIdentifierEnd = scanner.getTextPos();
auto identifierName = parseIdentifierName();
Identifier propertyName;
Identifier name;
if (token() == SyntaxKind::AsKeyword)
{
propertyName = identifierName;
parseExpected(SyntaxKind::AsKeyword);
checkIdentifierIsKeyword = isKeyword(token()) && !isIdentifier();
checkIdentifierStart = scanner.getTokenPos();
checkIdentifierEnd = scanner.getTextPos();
name = parseIdentifierName();
}
else
{
name = identifierName;
}
if (kind == SyntaxKind::ImportSpecifier && checkIdentifierIsKeyword)
{
parseErrorAt(checkIdentifierStart, checkIdentifierEnd,
data::DiagnosticMessage(Diagnostics::Identifier_expected));
}
auto node = kind == SyntaxKind::ImportSpecifier
? factory.createImportSpecifier(propertyName, name).as<ImportOrExportSpecifier>()
: factory.createExportSpecifier(propertyName, name).as<ImportOrExportSpecifier>();
return finishNode(node, pos);
}
auto parseNamespaceExport(pos_type pos) -> NamespaceExport
{
return finishNode(factory.createNamespaceExport(parseIdentifierName()), pos);
}
auto parseExportDeclaration(pos_type pos, boolean hasJSDoc, NodeArray<Decorator> decorators,
NodeArray<Modifier> modifiers) -> ExportDeclaration
{
auto savedAwaitContext = inAwaitContext();
setAwaitContext(/*value*/ true);
NamedExportBindings exportClause;
Expression moduleSpecifier;
auto isTypeOnly = parseOptional(SyntaxKind::TypeKeyword);
auto namespaceExportPos = getNodePos();
if (parseOptional(SyntaxKind::AsteriskToken))
{
if (parseOptional(SyntaxKind::AsKeyword))
{
exportClause = parseNamespaceExport(namespaceExportPos);
}
parseExpected(SyntaxKind::FromKeyword);
moduleSpecifier = parseModuleSpecifier();
}
else
{
exportClause = parseNamedImportsOrExports(SyntaxKind::NamedExports);
// It is not uncommon to accidentally omit the 'from' keyword. Additionally, in editing scenarios,
// the 'from' keyword can be parsed.as<a>() named when the clause is unterminated (i.e. `{ from
// "moduleName";`) If we don't have a 'from' keyword, see if we have a string literal such that ASI won't
// take effect.
if (token() == SyntaxKind::FromKeyword ||
(token() == SyntaxKind::StringLiteral && !scanner.hasPrecedingLineBreak()))
{
parseExpected(SyntaxKind::FromKeyword);
moduleSpecifier = parseModuleSpecifier();
}
}
parseSemicolon();
setAwaitContext(savedAwaitContext);
auto node = factory.createExportDeclaration(decorators, modifiers, isTypeOnly, exportClause, moduleSpecifier);
return withJSDoc(finishNode(node, pos), hasJSDoc);
}
auto parseExportAssignment(pos_type pos, boolean hasJSDoc, NodeArray<Decorator> decorators,
NodeArray<Modifier> modifiers) -> ExportAssignment
{
auto savedAwaitContext = inAwaitContext();
setAwaitContext(/*value*/ true);
auto isExportEquals = false;
if (parseOptional(SyntaxKind::EqualsToken))
{
isExportEquals = true;
}
else
{
parseExpected(SyntaxKind::DefaultKeyword);
}
auto expression = parseAssignmentExpressionOrHigher();
parseSemicolon();
setAwaitContext(savedAwaitContext);
auto node = factory.createExportAssignment(decorators, modifiers, isExportEquals, expression);
return withJSDoc(finishNode(node, pos), hasJSDoc);
}
auto setExternalModuleIndicator(SourceFile sourceFile) -> void
{
// Try to use the first top-level import/when available, then
// fall back to looking for an 'import.meta' somewhere in the tree if necessary.
sourceFile->externalModuleIndicator =
forEach<decltype(sourceFile->statements), Node>(
sourceFile->statements,
(FuncT<Node>)std::bind(&Parser::isAnExternalModuleIndicatorNode, this, std::placeholders::_1)) ||
[&]() { return getImportMetaIfNecessary(sourceFile); };
}
auto isAnExternalModuleIndicatorNode(Node node) -> Node
{
return hasModifierOfKind(node, SyntaxKind::ExportKeyword) ||
isImportEqualsDeclaration(node) &&
ts::isExternalModuleReference(node.as<ImportEqualsDeclaration>()->moduleReference) ||
isImportDeclaration(node) || isExportAssignment(node) || isExportDeclaration(node)
? node
: undefined;
}
auto getImportMetaIfNecessary(SourceFile sourceFile) -> Node
{
return !!(sourceFile->flags & NodeFlags::PossiblyContainsImportMeta)
? walkTreeForExternalModuleIndicators(sourceFile)
: undefined;
}
auto walkTreeForExternalModuleIndicators(Node node) -> Node
{
return isImportMeta(node)
? node
: forEachChild<Node, Node>(
node, std::bind(&Parser::walkTreeForExternalModuleIndicators, this, std::placeholders::_1));
}
/** Do not use hasModifier inside the parser; it relies on parent pointers. Use this instead. */
auto hasModifierOfKind(Node node, SyntaxKind kind) -> boolean
{
return some(node->modifiers, [=](auto m) { return m == kind; });
}
auto isImportMeta(Node node) -> boolean
{
return isMetaProperty(node) && node.as<MetaProperty>()->keywordToken == SyntaxKind::ImportKeyword &&
node.as<MetaProperty>()->name->escapedText == S("meta");
}
// [[[ namespace JSDocParser ]]]
auto parseJSDocTypeExpressionForTests(string content, number start, number length) -> NodeWithDiagnostics
{
initializeState(S("file.js"), content, ScriptTarget::Latest, /*_syntaxCursor:*/ undefined, ScriptKind::JS);
scanner.setText(content, start, length);
currentToken = scanner.scan();
auto jsDocTypeExpression = parseJSDocTypeExpression();
auto sourceFile =
createSourceFile(S("file.js"), ScriptTarget::Latest, ScriptKind::JS, /*isDeclarationFile*/ false,
NodeArray<Statement>(), factory.createToken(SyntaxKind::EndOfFileToken), NodeFlags::None);
auto diagnostics = attachFileToDiagnostics(parseDiagnostics, sourceFile);
if (!!jsDocDiagnostics)
{
copy(sourceFile->jsDocDiagnostics, attachFileToDiagnostics(jsDocDiagnostics, sourceFile));
}
clearState();
if (!!jsDocTypeExpression)
{
NodeWithDiagnostics nodeWithDiagnostics;
nodeWithDiagnostics->node = jsDocTypeExpression;
copy(nodeWithDiagnostics->diagnostics, diagnostics);
}
return undefined;
}
// Parses out a JSDoc type expression.
auto parseJSDocTypeExpression(boolean mayOmitBraces = false) -> JSDocTypeExpression
{
auto pos = getNodePos();
auto hasBrace =
mayOmitBraces ? parseOptional(SyntaxKind::OpenBraceToken) : parseExpected(SyntaxKind::OpenBraceToken);
auto type = doInsideOfContext<TypeNode>(NodeFlags::JSDoc, std::bind(&Parser::parseJSDocType, this));
if (!mayOmitBraces || hasBrace)
{
parseExpectedJSDoc(SyntaxKind::CloseBraceToken);
}
auto result = factory.createJSDocTypeExpression(type);
fixupParentReferences(result);
return finishNode(result, pos);
}
auto parseJSDocNameReference() -> JSDocNameReference
{
auto pos = getNodePos();
auto hasBrace = parseOptional(SyntaxKind::OpenBraceToken);
auto entityName = parseEntityName(/* allowReservedWords*/ false);
if (hasBrace)
{
parseExpectedJSDoc(SyntaxKind::CloseBraceToken);
}
auto result = factory.createJSDocNameReference(entityName);
fixupParentReferences(result);
return finishNode(result, pos);
}
auto parseIsolatedJSDocComment(string content, number start, number length) -> NodeWithDiagnostics
{
initializeState(string(), content, ScriptTarget::Latest, /*_syntaxCursor:*/ undefined, ScriptKind::JS);
auto jsDoc =
doInsideOfContext<JSDoc>(NodeFlags::JSDoc, [&]() { return parseJSDocCommentWorker(start, length); });
auto sourceFile = SourceFile();
sourceFile->text = content;
sourceFile->languageVariant = LanguageVariant::Standard;
auto diagnostics = attachFileToDiagnostics(parseDiagnostics, sourceFile);
clearState();
if (!!jsDoc)
{
auto nodeWithDiagnostics = NodeWithDiagnostics();
nodeWithDiagnostics->node = jsDoc;
copy(nodeWithDiagnostics->diagnostics, diagnostics);
}
return undefined;
}
auto parseJSDocComment(Node parent, number start, number length) -> JSDoc
{
auto saveToken = currentToken;
// TODO: does it make any sense
// auto saveParseDiagnosticsLength = parseDiagnostics.size();
auto saveParseErrorBeforeNextFinishedNode = parseErrorBeforeNextFinishedNode;
auto comment =
doInsideOfContext<JSDoc>(NodeFlags::JSDoc, [&]() { return parseJSDocCommentWorker(start, length); });
setParent(comment, parent);
if (!!(contextFlags & NodeFlags::JavaScriptFile))
{
if (!jsDocDiagnostics.empty())
{
jsDocDiagnostics.clear();
}
copy(jsDocDiagnostics, parseDiagnostics);
}
currentToken = saveToken;
// TODO: does it make any sense
// parseDiagnostics->length = saveParseDiagnosticsLength;
parseErrorBeforeNextFinishedNode = saveParseErrorBeforeNextFinishedNode;
return comment;
}
auto parseJSDocCommentWorker(number start = 0, number length = -1) -> JSDoc
{
// TODO: finish it
// ParseJSDocCommentClass p(scanner, this, sourceText);
// return p.parseJSDocCommentWorker(start, length);
return JSDoc();
} // end of parseJSDocCommentWorker
public:
auto createSourceFile(string fileName, string sourceText, ScriptTarget languageVersion,
boolean setParentNodes = false, ScriptKind scriptKind = ScriptKind::Unknown) -> SourceFile
{
SourceFile result;
if (languageVersion == ScriptTarget::JSON)
{
result = parseSourceFile(fileName, sourceText, languageVersion, undefined /*syntaxCursor*/, setParentNodes,
ScriptKind::JSON);
}
else
{
result = parseSourceFile(fileName, sourceText, languageVersion, undefined /*syntaxCursor*/, setParentNodes,
scriptKind);
}
return result;
}
/* @internal */
auto _parseIsolatedJSDocComment(string content, number start, number length) -> NodeWithDiagnostics
{
auto result = parseIsolatedJSDocComment(content, start, length);
if (!!result && !!result->jsDoc)
{
// because the jsDocComment was parsed out of the source file, it might
// not be covered by the fixupParentReferences.
fixupParentReferences(result->jsDoc);
}
return result;
}
/*@internal*/
struct Pair
{
string name;
string _args;
};
auto processCommentPragmas(SourceFile context, string sourceText) -> void
{
std::vector<ts::data::PragmaPseudoMapEntry> pragmas;
for (auto &range : scanner.getLeadingCommentRanges(sourceText, 0))
{
auto comment = safe_string(sourceText).substring(range->pos, range->_end);
extractPragmas(pragmas, range, comment);
}
context->pragmas.clear();
for (auto &pragma : pragmas)
{
context->pragmas[pragma.name].push_back(pragma._args);
}
}
/*@internal*/
auto processPragmasIntoFields(SourceFile context, PragmaDiagnosticReporter reportDiagnostic) -> void
{
context->checkJsDirective = undefined;
context->referencedFiles.clear();
context->typeReferenceDirectives.clear();
context->libReferenceDirectives.clear();
context->amdDependencies.clear();
context->hasNoDefaultLib = false;
for (auto &pair : context->pragmas)
{
auto key = pair.first;
auto entryOrList = pair.second;
static std::map<string, int> cases = {
{S("reference"), 1}, {S("amd-dependency"), 2}, {S("amd-module"), 3},
{S("ts-nocheck"), 4}, {S("ts-check"), 5}, {S("jsx"), 6},
{S("jsxfrag"), 7}, {S("jsximportsource"), 8}, {S("jsxruntime"), 9}};
/*JSDocTag*/ Node tag;
auto index = cases[key];
switch (index)
{
case 1: {
auto referencedFiles = context->referencedFiles;
auto typeReferenceDirectives = context->typeReferenceDirectives;
auto libReferenceDirectives = context->libReferenceDirectives;
for (auto _args : entryOrList)
{
if (_args.count(S("no-default-lib")))
{
context->hasNoDefaultLib = true;
}
else if (_args.count(S("path")))
{
auto path = _args[S("path")];
context->referencedFiles.push_back(
data::FileReference{{path.range->pos, path.range->_end}, path._arg.value});
}
}
break;
}
case 2: {
// TODO...
break;
}
case 3: {
// TODO...
break;
}
case 4:
case 5: {
// TODO...
break;
}
case 6:
case 7:
case 8:
case 9:
return; // Accessed directly
default:
Debug::fail<void>(S("Unhandled pragma kind")); // Can this be made into an assertNever in the future?
}
}
}
// std::map<string, regex> namedArgRegExCache;
// auto getNamedArgRegEx(string name) -> regex {
// if (namedArgRegExCache.find(name) != namedArgRegExCache.end()) {
// return namedArgRegExCache.at(name);
// }
// regex result(S("(\\s${name}\\s*=\\s*)('|\")(.+?)\\2"),
// std::regex_constants::extended|std::regex_constants::icase); namedArgRegExCache[name] = result; return
// result;
// }
regex tripleSlashXMLCommentStartRegEx = regex(S(R"(^///\s*<(\S+)\s(.*)?/>)"), std::regex_constants::ECMAScript);
regex singleLinePragmaRegEx = regex(S(R"(^///?\s*@(\S+)\s*(.*)\s*$)"), std::regex_constants::ECMAScript);
regex multiLinePragmaRegEx =
regex(S(R"(\s*@(\S+)\s*(.*)\s*$)"),
std::regex_constants::ECMAScript); // Defined inline since it uses the "g" flag,
// which keeps a persistent index (for iterating)
std::map<string, regex> namedArgRegExCache;
auto getNamedArgRegEx(string name) -> regex
{
if (namedArgRegExCache.count(name))
{
return namedArgRegExCache.at(name);
}
string r;
r.append(S(R"((\s)"));
r.append(name);
r.append(S(R"(\s*=\s*)('|")(.+?)\2)"));
auto result = regex(r, std::regex_constants::ECMAScript);
namedArgRegExCache.insert({name, result});
return result;
}
auto extractPragmas(std::vector<data::PragmaPseudoMapEntry> &pragmas, CommentRange range, string text) -> void
{
if (range->kind == SyntaxKind::SingleLineCommentTrivia)
{
auto tripleSlashXMLComment_begin =
sregex_iterator(text.begin(), text.end(), tripleSlashXMLCommentStartRegEx);
auto tripleSlashXMLComment_end = sregex_iterator();
// tripleSlash
if (tripleSlashXMLComment_begin != tripleSlashXMLComment_end)
{
for (sregex_iterator i = tripleSlashXMLComment_begin; i != tripleSlashXMLComment_end; ++i)
{
smatch match = *i;
string name = match[1].str();
if (name == S("reference"))
{
std::map<string, data::ArgumentWithCommentRange> _args;
for (auto arg : {S("types"), S("lib"), S("path"), S("no-default-lib")})
{
auto matcher = getNamedArgRegEx(arg);
auto matchResult_begin = sregex_iterator(text.begin(), text.end(), matcher);
auto matchResult_end = sregex_iterator();
if (matchResult_begin == matchResult_end)
{
continue;
}
smatch matchResult = *matchResult_begin;
if (arg == string(S("no-default-lib")))
{
_args[arg] = {{matchResult[3], 0, 0}, range};
}
else
{
// span
auto startPos = range->pos.pos + std::distance(matchResult_begin, matchResult_end) +
matchResult[1].length() + matchResult[2].length();
_args[arg] = {
{matchResult[3], (int)startPos, (int)startPos + (int)matchResult[3].length()},
range};
}
}
pragmas.push_back({name, _args});
}
}
}
}
// TODO: complete later
}
// auto addPragmaForMatch(std::vector<PragmaPseudoMapEntry> pragmas, CommentRange range, PragmaKindFlags kind,
// RegExpExecArray match) {
// if (!match) return;
// auto name = match[1].toLowerCase().as<keyof>() PragmaPseudoMap; // Technically unsafe cast, but we do it so
// they below check to make it safe typechecks auto pragma = commentPragmas[name].as<PragmaDefinition>(); if
// (!pragma || !(pragma->kind! & kind)) {
// return;
// }
// auto args = match[2]; // Split on spaces and match up positionally with definition
// auto argument = getNamedPragmaArguments(pragma, args);
// if (argument == "fail") return; // Missing required argument, fail to parse it
// pragmas.push({ name, args: { argument arguments, range } }.as<PragmaPseudoMapEntry>());
// return;
// }
// auto getNamedPragmaArguments(PragmaDefinition pragma, string text) -> std::map<string, string> {
// if (!text) return {};
// if (!pragma.args) return {};
// auto args = text.split(regex(S("\\s+")));
// auto argMap: {[string index]: string} = {};
// for (auto i = 0; i < pragma.args.size(); i++) {
// auto argument = pragma.args[i];
// if (!args[i] && !argument.optional) {
// return "fail";
// }
// if (argument.captureSpan) {
// return Debug::fail("Capture spans not yet implemented for non-xml pragmas");
// }
// argMap[argument.name] = args[i];
// }
// return argMap;
// }
/** @internal */
auto tagNamesAreEquivalent(JsxTagNameExpression lhs, JsxTagNameExpression rhs) -> boolean
{
if (lhs != rhs)
{
return false;
}
if (lhs == SyntaxKind::Identifier)
{
return lhs.as<Identifier>()->escapedText == rhs.as<Identifier>()->escapedText;
}
if (lhs == SyntaxKind::ThisKeyword)
{
return true;
}
// If we are at this statement then we must have PropertyAccessExpression and because tag name in Jsx element
// can only take forms of JsxTagNameExpression which includes an identifier, "this" expression, or another
// propertyAccessExpression it is safe to case the expression property.as<such>(). See parseJsxElementName for
// how we parse tag name in Jsx element
auto lhsName = ts::isIdentifier(lhs.as<PropertyAccessExpression>()->name)
? lhs.as<PropertyAccessExpression>()->name.as<Identifier>()->escapedText
: isPrivateIdentifier(lhs.as<PropertyAccessExpression>()->name)
? lhs.as<PropertyAccessExpression>()->name.as<PrivateIdentifier>()->escapedText
: string();
auto rhsName = ts::isIdentifier(rhs.as<PropertyAccessExpression>()->name)
? rhs.as<PropertyAccessExpression>()->name.as<Identifier>()->escapedText
: isPrivateIdentifier(rhs.as<PropertyAccessExpression>()->name)
? rhs.as<PropertyAccessExpression>()->name.as<PrivateIdentifier>()->escapedText
: string();
return lhsName == rhsName &&
tagNamesAreEquivalent(lhs.as<PropertyAccessExpression>()->expression.as<JsxTagNameExpression>(),
rhs.as<PropertyAccessExpression>()->expression.as<JsxTagNameExpression>());
}
}; // End of Scanner
// // Produces a new SourceFile for the 'newText' provided. The 'textChangeRange' parameter
// // indicates what changed between the 'text' that this SourceFile has and the 'newText'.
// // The SourceFile will be created with the compiler attempting to reuse.as<many>() nodes from
// // this file.as<possible>().
// //
// // this Note auto mutates nodes from this SourceFile. That means any existing nodes
// // from this SourceFile that are being held onto may change.as<a>() result (including
// // becoming detached from any SourceFile). It is recommended that this SourceFile not
// // be used once 'update' is called on it.
// auto updateSourceFile(SourceFile sourceFile, string newText, TextChangeRange textChangeRange, boolean
// aggressiveChecks = false) -> SourceFile {
// auto newSourceFile = IncrementalParser::updateSourceFile(sourceFile, newText, textChangeRange, aggressiveChecks);
// // Because new source file node is created, it may not have the flag PossiblyContainDynamicImport. This is the
// case if there is no new edit to add dynamic import.
// // We will manually port the flag to the new source file.
// newSourceFile->flags |= (sourceFile->flags & NodeFlags::PermanentlySetIncrementalFlags);
// return newSourceFile;
// }
} // namespace Impl
// See also `isExternalOrCommonJsModule` in utilities.ts
auto isExternalModule(SourceFile file) -> boolean
{
return !!file->externalModuleIndicator;
}
Parser::Parser()
{
impl = new ts::Impl::Parser();
}
auto Parser::parseSourceFile(string sourceText, ScriptTarget languageVersion) -> SourceFile
{
return impl->parseSourceFile(string(), sourceText, languageVersion, IncrementalParser::SyntaxCursor());
}
auto Parser::parseSourceFile(string fileName, string sourceText, ScriptTarget languageVersion) -> SourceFile
{
return impl->parseSourceFile(fileName, sourceText, languageVersion, IncrementalParser::SyntaxCursor());
}
auto Parser::parseSourceFile(string fileName, string sourceText, ScriptTarget languageVersion,
IncrementalParser::SyntaxCursor syntaxCursor, boolean setParentNodes,
ScriptKind scriptKind) -> SourceFile
{
return impl->parseSourceFile(fileName, sourceText, languageVersion, syntaxCursor, setParentNodes, scriptKind);
}
auto Parser::tokenToText(SyntaxKind kind) -> string
{
return impl->scanner.tokenToString(kind);
}
auto Parser::syntaxKindString(SyntaxKind kind) -> string
{
return impl->scanner.syntaxKindString(kind);
}
auto Parser::getLineAndCharacterOfPosition(SourceFileLike sourceFile, number position) -> LineAndCharacter
{
return impl->scanner.getLineAndCharacterOfPosition(sourceFile, position);
}
Parser::~Parser()
{
delete impl;
}
// TODO: temporary solution
namespace IncrementalParser
{
auto createSyntaxCursor(SourceFile sourceFile) -> SyntaxCursor
{
return SyntaxCursor();
}
} // namespace IncrementalParser
} // namespace ts
| 41.577147 | 187 | 0.606009 | SamuraiCrow |
0b499650ac92dc07d4078796ed0a30601cc66c19 | 424,220 | cpp | C++ | chipyard.TestHarness.LargeBoomAndRocketConfig/chipyard.TestHarness.LargeBoomAndRocketConfig/VTestHarness__151.cpp | vargandhi/ime-congs | 963be79b7b319d8e74edae09df7bdf3330371401 | [
"BSD-3-Clause"
] | null | null | null | chipyard.TestHarness.LargeBoomAndRocketConfig/chipyard.TestHarness.LargeBoomAndRocketConfig/VTestHarness__151.cpp | vargandhi/ime-congs | 963be79b7b319d8e74edae09df7bdf3330371401 | [
"BSD-3-Clause"
] | null | null | null | chipyard.TestHarness.LargeBoomAndRocketConfig/chipyard.TestHarness.LargeBoomAndRocketConfig/VTestHarness__151.cpp | vargandhi/ime-congs | 963be79b7b319d8e74edae09df7bdf3330371401 | [
"BSD-3-Clause"
] | null | null | null | // Verilated -*- C++ -*-
// DESCRIPTION: Verilator output: Design implementation internals
// See VTestHarness.h for the primary calling header
#include "VTestHarness.h"
#include "VTestHarness__Syms.h"
#include "verilated_dpi.h"
VL_INLINE_OPT void VTestHarness::_sequent__TOP__8712(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__8712\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_8__DOT___T_11
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu_io_core_ld_miss)
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_8__DOT__p1_poisoned)
| (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_8__DOT__p2_poisoned)));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT__slots_16__DOT___T_11
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu_io_core_ld_miss)
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT__slots_16__DOT__p1_poisoned)
| (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT__slots_16__DOT__p2_poisoned)));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT__slots_17__DOT___T_11
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu_io_core_ld_miss)
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT__slots_17__DOT__p1_poisoned)
| (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT__slots_17__DOT__p2_poisoned)));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT__slots_18__DOT___T_11
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu_io_core_ld_miss)
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT__slots_18__DOT__p1_poisoned)
| (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT__slots_18__DOT__p2_poisoned)));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT__slots_24__DOT___T_11
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu_io_core_ld_miss)
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT__slots_24__DOT__p1_poisoned)
| (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT__slots_24__DOT__p2_poisoned)));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT__slots_25__DOT___T_11
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu_io_core_ld_miss)
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT__slots_25__DOT__p1_poisoned)
| (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT__slots_25__DOT__p2_poisoned)));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT__slots_26__DOT___T_11
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu_io_core_ld_miss)
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT__slots_26__DOT__p1_poisoned)
| (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT__slots_26__DOT__p2_poisoned)));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT__slots_10__DOT___T_11
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu_io_core_ld_miss)
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT__slots_10__DOT__p1_poisoned)
| (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT__slots_10__DOT__p2_poisoned)));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT__slots_9__DOT___T_11
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu_io_core_ld_miss)
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT__slots_9__DOT__p1_poisoned)
| (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT__slots_9__DOT__p2_poisoned)));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT__slots_8__DOT___T_11
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu_io_core_ld_miss)
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT__slots_8__DOT__p1_poisoned)
| (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT__slots_8__DOT__p2_poisoned)));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66239
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_2324)
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66046)
: ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_2336)
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66046)
: ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_2351)
? ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_2356)
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66046)
: ((5U != (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__lcam_ldq_idx_0))
? ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_2367)
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_2370)
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66046))
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66046)))
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66046))));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66215
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_2324)
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66022)
: ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_2336)
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66022)
: ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_2351)
? ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_2356)
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66022)
: ((5U != (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__lcam_ldq_idx_0))
? ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_2367)
? ((0U != (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__lcam_ldq_idx_0))
& (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66022))
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66022))
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66022)))
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66022))));
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__8713(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__8713\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66216
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_2324)
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66023)
: ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_2336)
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66023)
: ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_2351)
? ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_2356)
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66023)
: ((5U != (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__lcam_ldq_idx_0))
? ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_2367)
? ((1U != (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__lcam_ldq_idx_0))
& (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66023))
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66023))
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66023)))
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66023))));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66217
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_2324)
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66024)
: ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_2336)
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66024)
: ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_2351)
? ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_2356)
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66024)
: ((5U != (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__lcam_ldq_idx_0))
? ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_2367)
? ((2U != (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__lcam_ldq_idx_0))
& (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66024))
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66024))
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66024)))
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66024))));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66218
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_2324)
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66025)
: ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_2336)
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66025)
: ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_2351)
? ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_2356)
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66025)
: ((5U != (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__lcam_ldq_idx_0))
? ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_2367)
? ((3U != (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__lcam_ldq_idx_0))
& (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66025))
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66025))
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66025)))
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66025))));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66219
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_2324)
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66026)
: ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_2336)
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66026)
: ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_2351)
? ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_2356)
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66026)
: ((5U != (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__lcam_ldq_idx_0))
? ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_2367)
? ((4U != (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__lcam_ldq_idx_0))
& (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66026))
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66026))
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66026)))
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66026))));
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__8714(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__8714\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66220
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_2324)
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66027)
: ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_2336)
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66027)
: ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_2351)
? ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_2356)
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66027)
: ((5U != (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__lcam_ldq_idx_0))
? ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_2367)
? ((5U != (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__lcam_ldq_idx_0))
& (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66027))
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66027))
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66027)))
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66027))));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66221
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_2324)
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66028)
: ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_2336)
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66028)
: ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_2351)
? ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_2356)
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66028)
: ((5U != (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__lcam_ldq_idx_0))
? ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_2367)
? ((6U != (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__lcam_ldq_idx_0))
& (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66028))
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66028))
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66028)))
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66028))));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66222
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_2324)
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66029)
: ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_2336)
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66029)
: ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_2351)
? ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_2356)
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66029)
: ((5U != (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__lcam_ldq_idx_0))
? ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_2367)
? ((7U != (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__lcam_ldq_idx_0))
& (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66029))
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66029))
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66029)))
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66029))));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66223
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_2324)
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66030)
: ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_2336)
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66030)
: ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_2351)
? ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_2356)
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66030)
: ((5U != (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__lcam_ldq_idx_0))
? ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_2367)
? ((8U != (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__lcam_ldq_idx_0))
& (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66030))
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66030))
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66030)))
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66030))));
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__8715(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__8715\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66224
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_2324)
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66031)
: ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_2336)
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66031)
: ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_2351)
? ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_2356)
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66031)
: ((5U != (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__lcam_ldq_idx_0))
? ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_2367)
? ((9U != (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__lcam_ldq_idx_0))
& (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66031))
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66031))
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66031)))
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66031))));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66225
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_2324)
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66032)
: ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_2336)
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66032)
: ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_2351)
? ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_2356)
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66032)
: ((5U != (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__lcam_ldq_idx_0))
? ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_2367)
? ((0xaU != (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__lcam_ldq_idx_0))
& (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66032))
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66032))
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66032)))
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66032))));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66226
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_2324)
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66033)
: ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_2336)
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66033)
: ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_2351)
? ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_2356)
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66033)
: ((5U != (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__lcam_ldq_idx_0))
? ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_2367)
? ((0xbU != (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__lcam_ldq_idx_0))
& (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66033))
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66033))
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66033)))
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66033))));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66227
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_2324)
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66034)
: ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_2336)
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66034)
: ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_2351)
? ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_2356)
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66034)
: ((5U != (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__lcam_ldq_idx_0))
? ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_2367)
? ((0xcU != (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__lcam_ldq_idx_0))
& (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66034))
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66034))
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66034)))
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66034))));
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__8716(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__8716\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66228
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_2324)
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66035)
: ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_2336)
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66035)
: ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_2351)
? ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_2356)
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66035)
: ((5U != (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__lcam_ldq_idx_0))
? ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_2367)
? ((0xdU != (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__lcam_ldq_idx_0))
& (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66035))
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66035))
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66035)))
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66035))));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66229
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_2324)
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66036)
: ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_2336)
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66036)
: ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_2351)
? ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_2356)
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66036)
: ((5U != (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__lcam_ldq_idx_0))
? ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_2367)
? ((0xeU != (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__lcam_ldq_idx_0))
& (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66036))
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66036))
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66036)))
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66036))));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66230
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_2324)
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66037)
: ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_2336)
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66037)
: ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_2351)
? ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_2356)
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66037)
: ((5U != (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__lcam_ldq_idx_0))
? ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_2367)
? ((0xfU != (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__lcam_ldq_idx_0))
& (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66037))
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66037))
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66037)))
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66037))));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66231
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_2324)
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66038)
: ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_2336)
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66038)
: ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_2351)
? ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_2356)
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66038)
: ((5U != (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__lcam_ldq_idx_0))
? ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_2367)
? ((0x10U != (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__lcam_ldq_idx_0))
& (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66038))
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66038))
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66038)))
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66038))));
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__8717(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__8717\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66232
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_2324)
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66039)
: ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_2336)
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66039)
: ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_2351)
? ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_2356)
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66039)
: ((5U != (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__lcam_ldq_idx_0))
? ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_2367)
? ((0x11U != (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__lcam_ldq_idx_0))
& (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66039))
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66039))
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66039)))
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66039))));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66233
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_2324)
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66040)
: ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_2336)
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66040)
: ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_2351)
? ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_2356)
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66040)
: ((5U != (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__lcam_ldq_idx_0))
? ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_2367)
? ((0x12U != (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__lcam_ldq_idx_0))
& (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66040))
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66040))
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66040)))
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66040))));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66234
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_2324)
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66041)
: ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_2336)
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66041)
: ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_2351)
? ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_2356)
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66041)
: ((5U != (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__lcam_ldq_idx_0))
? ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_2367)
? ((0x13U != (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__lcam_ldq_idx_0))
& (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66041))
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66041))
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66041)))
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66041))));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66235
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_2324)
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66042)
: ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_2336)
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66042)
: ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_2351)
? ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_2356)
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66042)
: ((5U != (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__lcam_ldq_idx_0))
? ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_2367)
? ((0x14U != (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__lcam_ldq_idx_0))
& (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66042))
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66042))
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66042)))
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66042))));
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__8718(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__8718\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66236
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_2324)
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66043)
: ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_2336)
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66043)
: ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_2351)
? ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_2356)
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66043)
: ((5U != (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__lcam_ldq_idx_0))
? ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_2367)
? ((0x15U != (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__lcam_ldq_idx_0))
& (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66043))
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66043))
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66043)))
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66043))));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66237
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_2324)
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66044)
: ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_2336)
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66044)
: ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_2351)
? ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_2356)
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66044)
: ((5U != (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__lcam_ldq_idx_0))
? ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_2367)
? ((0x16U != (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__lcam_ldq_idx_0))
& (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66044))
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66044))
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66044)))
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66044))));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66238
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_2324)
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66045)
: ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_2336)
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66045)
: ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_2351)
? ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_2356)
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66045)
: ((5U != (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__lcam_ldq_idx_0))
? ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_2367)
? ((0x17U != (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__lcam_ldq_idx_0))
& (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66045))
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66045))
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66045)))
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66045))));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66240
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_2324)
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66047)
: ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_2336)
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66047)
: ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_2351)
? ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_2356)
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66047)
: ((5U != (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__lcam_ldq_idx_0))
? ((~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_2367))
& (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66047))
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66047)))
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_66047))));
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__8719(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__8719\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_0__DOT__new_meta_dirty
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_0__DOT___T_778)
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_0__DOT__final_meta_writeback_dirty)
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__directory_io_result_bits_dirty));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_1__DOT__new_meta_dirty
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_1__DOT___T_778)
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_1__DOT__final_meta_writeback_dirty)
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__directory_io_result_bits_dirty));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_2__DOT__new_meta_dirty
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_2__DOT___T_778)
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_2__DOT__final_meta_writeback_dirty)
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__directory_io_result_bits_dirty));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_3__DOT__new_meta_dirty
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_3__DOT___T_778)
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_3__DOT__final_meta_writeback_dirty)
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__directory_io_result_bits_dirty));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_4__DOT__new_meta_dirty
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_4__DOT___T_778)
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_4__DOT__final_meta_writeback_dirty)
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__directory_io_result_bits_dirty));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_5__DOT__new_meta_dirty
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_5__DOT___T_778)
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_5__DOT__final_meta_writeback_dirty)
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__directory_io_result_bits_dirty));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_6__DOT__new_meta_dirty
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_6__DOT___T_778)
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_6__DOT__final_meta_writeback_dirty)
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__directory_io_result_bits_dirty));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_7__DOT__new_meta_dirty
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_7__DOT___T_778)
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_7__DOT__final_meta_writeback_dirty)
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__directory_io_result_bits_dirty));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_8__DOT__new_meta_dirty
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_8__DOT___T_778)
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_8__DOT__final_meta_writeback_dirty)
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__directory_io_result_bits_dirty));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_9__DOT__new_meta_dirty
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_9__DOT___T_778)
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_9__DOT__final_meta_writeback_dirty)
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__directory_io_result_bits_dirty));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__bc_mshr__DOT__new_meta_dirty
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__bc_mshr__DOT___T_778)
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__bc_mshr__DOT__final_meta_writeback_dirty)
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__directory_io_result_bits_dirty));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__c_mshr__DOT__new_meta_dirty
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__c_mshr__DOT___T_778)
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__c_mshr__DOT__final_meta_writeback_dirty)
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__directory_io_result_bits_dirty));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_0__DOT__new_meta_clients
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_0__DOT___T_778)
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_0__DOT__final_meta_writeback_clients)
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__directory_io_result_bits_clients));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_1__DOT__new_meta_clients
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_1__DOT___T_778)
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_1__DOT__final_meta_writeback_clients)
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__directory_io_result_bits_clients));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_2__DOT__new_meta_clients
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_2__DOT___T_778)
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_2__DOT__final_meta_writeback_clients)
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__directory_io_result_bits_clients));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_3__DOT__new_meta_clients
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_3__DOT___T_778)
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_3__DOT__final_meta_writeback_clients)
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__directory_io_result_bits_clients));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_4__DOT__new_meta_clients
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_4__DOT___T_778)
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_4__DOT__final_meta_writeback_clients)
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__directory_io_result_bits_clients));
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__8720(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__8720\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_5__DOT__new_meta_clients
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_5__DOT___T_778)
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_5__DOT__final_meta_writeback_clients)
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__directory_io_result_bits_clients));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_6__DOT__new_meta_clients
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_6__DOT___T_778)
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_6__DOT__final_meta_writeback_clients)
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__directory_io_result_bits_clients));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_7__DOT__new_meta_clients
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_7__DOT___T_778)
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_7__DOT__final_meta_writeback_clients)
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__directory_io_result_bits_clients));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_8__DOT__new_meta_clients
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_8__DOT___T_778)
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_8__DOT__final_meta_writeback_clients)
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__directory_io_result_bits_clients));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_9__DOT__new_meta_clients
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_9__DOT___T_778)
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_9__DOT__final_meta_writeback_clients)
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__directory_io_result_bits_clients));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__bc_mshr__DOT__new_meta_clients
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__bc_mshr__DOT___T_778)
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__bc_mshr__DOT__final_meta_writeback_clients)
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__directory_io_result_bits_clients));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__c_mshr__DOT__new_meta_clients
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__c_mshr__DOT___T_778)
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__c_mshr__DOT__final_meta_writeback_clients)
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__directory_io_result_bits_clients));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_0__DOT__new_meta_state
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_0__DOT___T_778)
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_0__DOT__final_meta_writeback_state)
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__directory_io_result_bits_state));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_1__DOT__new_meta_state
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_1__DOT___T_778)
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_1__DOT__final_meta_writeback_state)
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__directory_io_result_bits_state));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_2__DOT__new_meta_state
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_2__DOT___T_778)
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_2__DOT__final_meta_writeback_state)
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__directory_io_result_bits_state));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_3__DOT__new_meta_state
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_3__DOT___T_778)
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_3__DOT__final_meta_writeback_state)
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__directory_io_result_bits_state));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_4__DOT__new_meta_state
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_4__DOT___T_778)
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_4__DOT__final_meta_writeback_state)
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__directory_io_result_bits_state));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_5__DOT__new_meta_state
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_5__DOT___T_778)
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_5__DOT__final_meta_writeback_state)
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__directory_io_result_bits_state));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_6__DOT__new_meta_state
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_6__DOT___T_778)
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_6__DOT__final_meta_writeback_state)
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__directory_io_result_bits_state));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_7__DOT__new_meta_state
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_7__DOT___T_778)
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_7__DOT__final_meta_writeback_state)
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__directory_io_result_bits_state));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_8__DOT__new_meta_state
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_8__DOT___T_778)
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_8__DOT__final_meta_writeback_state)
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__directory_io_result_bits_state));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_9__DOT__new_meta_state
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_9__DOT___T_778)
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_9__DOT__final_meta_writeback_state)
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__directory_io_result_bits_state));
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__8721(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__8721\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__bc_mshr__DOT__new_meta_state
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__bc_mshr__DOT___T_778)
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__bc_mshr__DOT__final_meta_writeback_state)
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__directory_io_result_bits_state));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__c_mshr__DOT__new_meta_state
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__c_mshr__DOT___T_778)
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__c_mshr__DOT__final_meta_writeback_state)
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__directory_io_result_bits_state));
if (vlTOPp->reset) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_18__DOT__ppred = 0U;
} else {
if (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_18_io_in_uop_valid) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_18__DOT__ppred
= (1U & (~ ((4U == (7U & (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT___GEN_47)))
? (~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_21__DOT__ppred))
: ((2U == (7U & (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT___GEN_45)))
? (~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_20__DOT__ppred))
: (~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_19__DOT__ppred))))));
}
}
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__tlb__DOT___T_2355
= ((2U == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__tlb__DOT__state))
& (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__tlb_io_sfence_valid));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__tlb__DOT___T_2017
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__tlb_io_req_valid)
& (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__tlb__DOT__vm_enabled));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__tlb__DOT___T_2225
= (((0U == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__tlb__DOT__state))
& (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__tlb_io_req_valid))
& (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__tlb__DOT__tlb_miss));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__buffer__DOT__TLMonitor__DOT___T_1876
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__buffer__DOT__TLMonitor__DOT___T_1828)
& (0U == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__buffer__DOT__TLMonitor__DOT___T_1837)));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__tag_array_RW0_en
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__s0_clk_en)
| ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__metaArb_io_out_valid)
& (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__metaArb_io_out_bits_write)));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__ptw__DOT__package_Anon_io_x
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcacheArb_io_requestor_0_s2_nack)
? 1U : ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__ptw__DOT__mem_resp_valid)
? ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__ptw__DOT__traverse)
? 1U : 0U) : ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__ptw__DOT___T_1036)
? 0U : ((0U
== (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__ptw__DOT__state))
?
((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__ptw__DOT___T_55)
?
((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__ptw__DOT__arb_io_out_bits_valid)
? 1U
: 0U)
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__ptw__DOT__state))
:
((1U
== (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__ptw__DOT__state))
?
((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__ptw__DOT__pte_cache_hit)
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__ptw__DOT__state)
:
((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache_io_cpu_req_ready)
? 2U
: 1U))
:
((2U
== (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__ptw__DOT__state))
?
((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__ptw__DOT__s2_hit)
? 1U
: 4U)
:
((4U
== (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__ptw__DOT__state))
?
((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache_io_cpu_s2_xcpt_ae_ld)
? 0U
: 5U)
:
((7U
== (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__ptw__DOT__state))
? 0U
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__ptw__DOT__state)))))))));
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__8722(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__8722\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcacheArb_io_requestor_1_req_ready
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache_io_cpu_req_ready)
& (~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__ptw_io_mem_req_valid)));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sinkC__DOT__ListBuffer__DOT___T_70
= (0xffU & (((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sinkC__DOT__ListBuffer__DOT__used)
& (~ ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sinkC__DOT__ListBuffer_io_pop_valid)
? ((IData)(1U) << (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sinkC__DOT__ListBuffer__DOT__head_pop_head_data))
: 0U))) | ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sinkC__DOT__ListBuffer__DOT___T_32)
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sinkC__DOT__ListBuffer__DOT__freeOH)
: 0U)));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sinkC__DOT__ListBuffer__DOT___T_73
= (3U & (((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sinkC__DOT__ListBuffer__DOT__valid)
& (~ ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sinkC__DOT__ListBuffer_io_pop_valid)
? (((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sinkC__DOT__ListBuffer__DOT__head_pop_head_data)
== vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sinkC__DOT__ListBuffer__DOT__tail
[(1U & (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sourceD__DOT__s2_req_put))])
? ((IData)(1U) << (1U
& (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sourceD__DOT__s2_req_put)))
: 0U) : 0U))) | ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sinkC__DOT__ListBuffer__DOT___T_32)
? ((IData)(1U)
<<
(1U
& (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sinkC__DOT___GEN_6)))
: 0U)));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sinkA__DOT__putbuffer__DOT___T_51
= ((~ (IData)((VL_ULL(0xffffffffff) == vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sinkA__DOT__putbuffer__DOT__used)))
& (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sinkA__DOT__putbuffer_io_push_valid));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__InclusiveCache_inner_TLBuffer__DOT__Queue__DOT___GEN_14
= ((~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sinkA_io_a_ready))
& (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__InclusiveCache_inner_TLBuffer__DOT__Queue__DOT___T_1));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__TLMonitor__DOT___T_1365
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sinkA_io_a_ready)
& (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__InclusiveCache_inner_TLBuffer__DOT__Queue_io_deq_valid));
if ((1U & (~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core_io_ifu_redirect_flush)))) {
if ((1U & (~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__dis_stalls_2)))) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rename_stage__DOT__ren2_uops_2_mem_signed
= (1U & (~ (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__fb__DOT___T_3074[0x25U]
>> 0x15U)));
}
}
if ((1U & (~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core_io_ifu_redirect_flush)))) {
if ((1U & (~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__dis_stalls_2)))) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rename_stage__DOT__ren2_uops_1_mem_signed
= (1U & (~ (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__fb__DOT___T_3074[0x18U]
>> 0x1bU)));
}
}
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__8723(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__8723\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
if ((1U & (~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core_io_ifu_redirect_flush)))) {
if ((1U & (~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__dis_stalls_2)))) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rename_stage__DOT__ren2_uops_0_mem_signed
= (1U & (~ (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__fb__DOT___T_3074[0xcU]
>> 1U)));
}
}
if (vlTOPp->reset) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_15__DOT__slot_uop_fp_val = 0U;
} else {
if (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_15_io_in_uop_valid) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_15__DOT__slot_uop_fp_val
= ((4U == (7U & (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT___GEN_50)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rename_stage__DOT__ren2_uops_2_fp_val)
: ((2U == (7U & (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT___GEN_48)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rename_stage__DOT__ren2_uops_1_fp_val)
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rename_stage__DOT__ren2_uops_0_fp_val)));
}
}
if ((1U & (~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core_io_ifu_redirect_flush)))) {
if ((1U & (~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__dis_stalls_2)))) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rename_stage__DOT__ren2_uops_2_is_fence
= (8U == (0x3058U & ((vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__fb__DOT___T_3074[0x26U]
<< 0x19U) | (
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__fb__DOT___T_3074[0x25U]
>> 7U))));
}
}
if ((1U & (~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core_io_ifu_redirect_flush)))) {
if ((1U & (~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__dis_stalls_2)))) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rename_stage__DOT__ren2_uops_1_is_fence
= (8U == (0x3058U & ((vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__fb__DOT___T_3074[0x19U]
<< 0x13U) | (
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__fb__DOT___T_3074[0x18U]
>> 0xdU))));
}
}
if ((1U & (~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core_io_ifu_redirect_flush)))) {
if ((1U & (~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__dis_stalls_2)))) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rename_stage__DOT__ren2_uops_0_is_fence
= (8U == (0x3058U & ((vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__fb__DOT___T_3074[0xcU]
<< 0xdU) | (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__fb__DOT___T_3074[0xbU]
>> 0x13U))));
}
}
if (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_13_io_in_uop_valid) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_13__DOT__slot_uop_mem_size
= ((4U == (7U & (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT___GEN_46)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rename_stage__DOT__ren2_uops_0_mem_size)
: ((2U == (7U & (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT___GEN_44)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_15__DOT__slot_uop_mem_size)
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_14__DOT__slot_uop_mem_size)));
}
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__8724(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__8724\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
if (vlTOPp->reset) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT__slots_18__DOT__slot_uop_pdst = 0U;
} else {
if (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT__slots_18_io_in_uop_valid) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT__slots_18__DOT__slot_uop_pdst
= ((4U == (7U & (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT___GEN_56)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT__slots_21__DOT__slot_uop_pdst)
: ((2U == (7U & (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT___GEN_54)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT__slots_20__DOT__slot_uop_pdst)
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT__slots_19__DOT__slot_uop_pdst)));
}
}
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT___T_659
= (((1U == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_15__DOT__state))
? ((((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_15__DOT___T_118)
& (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_15__DOT__p3))
& (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_15__DOT__ppred))
& (~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT___T_916)))
: ((2U == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_15__DOT__state))
& ((((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_15__DOT__p1)
| (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_15__DOT__p2))
& (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_15__DOT__ppred))
& (~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT___T_916)))))
& (0U != ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_15__DOT__slot_uop_fu_code)
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__pause_mem)
? 0U : 4U))));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_15_io_out_uop_uopc
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT___T_1163)
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_15__DOT__slot_uop_uopc)
: ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_15__DOT___T_9)
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_15__DOT__slot_uop_uopc)
: ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_15__DOT___T_5)
? ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_15__DOT__p1)
? 3U : (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_15__DOT__slot_uop_uopc))
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_15__DOT__slot_uop_uopc))));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_15_io_out_uop_iw_state
= ((0U != (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_15__DOT___T_75))
? 0U : ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT___T_1163)
? 0U : ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_15__DOT___T_9)
? 0U : ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_15__DOT___T_5)
? 1U : (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_15__DOT__state)))));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_16__DOT___T_5
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_16_io_grant)
& (2U == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_16__DOT__state)));
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__8725(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__8725\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_16_io_will_be_valid
= ((0U != (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_16__DOT__state))
& (~ ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_16_io_grant)
& ((1U == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_16__DOT__state))
| ((((2U == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_16__DOT__state))
& (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_16__DOT__p1))
& (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_16__DOT__p2))
& (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_16__DOT__ppred))))));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT___T_844
= (((1U == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_17__DOT__state))
? ((((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_17__DOT___T_88)
& (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_17__DOT__p3))
& (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_17__DOT__ppred))
& (~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT___T_1163)))
: ((2U == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_17__DOT__state))
& ((((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_17__DOT__p1)
| (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_17__DOT__p2))
& (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_17__DOT__ppred))
& (~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT___T_1163)))))
& (0U != ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_17__DOT__slot_uop_fu_code)
& (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit_io_fu_types_0))));
if (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_18_io_in_uop_valid) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_18__DOT__slot_uop_fu_code
= ((4U == (7U & (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT___GEN_47)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_21__DOT__slot_uop_fu_code)
: ((2U == (7U & (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT___GEN_45)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_20__DOT__slot_uop_fu_code)
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_19__DOT__slot_uop_fu_code)));
}
if (vlTOPp->reset) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_12__DOT__slot_uop_fp_val = 0U;
} else {
if (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_12_io_in_uop_valid) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_12__DOT__slot_uop_fp_val
= ((4U == (7U & (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT___GEN_35)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_15__DOT__slot_uop_fp_val)
: ((2U == (7U & (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT___GEN_33)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_14__DOT__slot_uop_fp_val)
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_13__DOT__slot_uop_fp_val)));
}
}
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__8726(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__8726\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
if (vlTOPp->reset) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_12__DOT__slot_uop_uses_ldq = 0U;
} else {
if (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_12_io_in_uop_valid) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_12__DOT__slot_uop_uses_ldq
= ((4U == (7U & (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT___GEN_35)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_15__DOT__slot_uop_uses_ldq)
: ((2U == (7U & (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT___GEN_33)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_14__DOT__slot_uop_uses_ldq)
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_13__DOT__slot_uop_uses_ldq)));
}
}
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__bootrom__DOT___GEN_403
= ((0x193U == (0x1ffU & (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_bootrom__DOT__fragmenter_auto_out_a_bits_address
>> 3U))) ? VL_ULL(0x72656c6c6f7274)
: ((0x192U == (0x1ffU & (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_bootrom__DOT__fragmenter_auto_out_a_bits_address
>> 3U))) ? VL_ULL(0x6e6f632d74707572)
: ((0x191U == (0x1ffU & (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_bootrom__DOT__fragmenter_auto_out_a_bits_address
>> 3U))) ? VL_ULL(0x7265746e6900736c)
: ((0x190U == (0x1ffU & (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_bootrom__DOT__fragmenter_auto_out_a_bits_address
>> 3U)))
? VL_ULL(0x6c65632d74707572)
: ((0x18fU == (0x1ffU & (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_bootrom__DOT__fragmenter_auto_out_a_bits_address
>> 3U)))
? VL_ULL(0x7265746e69230074)
: ((0x18eU == (0x1ffU &
(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_bootrom__DOT__fragmenter_auto_out_a_bits_address
>> 3U)))
? VL_ULL(0x696c70732d626c74)
: ((0x18dU == (0x1ffU
& (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_bootrom__DOT__fragmenter_auto_out_a_bits_address
>> 3U)))
? VL_ULL(0x79636e65757165)
: ((0x18cU == (0x1ffU
& (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_bootrom__DOT__fragmenter_auto_out_a_bits_address
>> 3U)))
? VL_ULL(0x72662d6573616265)
: ((0x18bU
== (0x1ffU
& (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_bootrom__DOT__fragmenter_auto_out_a_bits_address
>> 3U)))
? VL_ULL(0x6d69740073757461)
: ((0x18aU
==
(0x1ffU
& (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_bootrom__DOT__fragmenter_auto_out_a_bits_address
>> 3U)))
? VL_ULL(0x747300736e6f6967)
: (
(0x189U
==
(0x1ffU
& (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_bootrom__DOT__fragmenter_auto_out_a_bits_address
>> 3U)))
? VL_ULL(0x6572706d702c7663)
:
((0x188U
==
(0x1ffU
& (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_bootrom__DOT__fragmenter_auto_out_a_bits_address
>> 3U)))
? VL_ULL(0x736972006173692c)
:
((0x187U
==
(0x1ffU
& (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_bootrom__DOT__fragmenter_auto_out_a_bits_address
>> 3U)))
? VL_ULL(0x7663736972006765)
: vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__bootrom__DOT___GEN_390)))))))))))));
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__8727(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__8727\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
if (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_12_io_in_uop_valid) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_12__DOT__slot_uop_imm_packed
= ((4U == (7U & (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT___GEN_35)))
? vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_15__DOT__slot_uop_imm_packed
: ((2U == (7U & (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT___GEN_33)))
? vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_14__DOT__slot_uop_imm_packed
: vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_13__DOT__slot_uop_imm_packed));
}
if (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_12_io_in_uop_valid) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_12__DOT__slot_uop_mem_cmd
= ((4U == (7U & (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT___GEN_35)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_15__DOT__slot_uop_mem_cmd)
: ((2U == (7U & (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT___GEN_33)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_14__DOT__slot_uop_mem_cmd)
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_13__DOT__slot_uop_mem_cmd)));
}
if (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT__slots_18_io_in_uop_valid) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT__slots_18__DOT__slot_uop_ldst_val
= ((4U == (7U & (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT___GEN_56)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT__slots_21__DOT__slot_uop_ldst_val)
: ((2U == (7U & (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT___GEN_54)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT__slots_20__DOT__slot_uop_ldst_val)
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT__slots_19__DOT__slot_uop_ldst_val)));
}
if (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT__slots_18_io_in_uop_valid) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT__slots_18__DOT__slot_uop_mem_cmd
= ((4U == (7U & (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT___GEN_56)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT__slots_21__DOT__slot_uop_mem_cmd)
: ((2U == (7U & (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT___GEN_54)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT__slots_20__DOT__slot_uop_mem_cmd)
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT__slots_19__DOT__slot_uop_mem_cmd)));
}
if (vlTOPp->reset) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT__slots_18__DOT__slot_uop_bypassable = 0U;
} else {
if (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT__slots_18_io_in_uop_valid) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT__slots_18__DOT__slot_uop_bypassable
= ((4U == (7U & (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT___GEN_56)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT__slots_21__DOT__slot_uop_bypassable)
: ((2U == (7U & (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT___GEN_54)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT__slots_20__DOT__slot_uop_bypassable)
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT__slots_19__DOT__slot_uop_bypassable)));
}
}
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__8728(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__8728\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
if (vlTOPp->reset) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT__slots_18__DOT__slot_uop_dst_rtype = 2U;
} else {
if (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT__slots_18_io_in_uop_valid) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT__slots_18__DOT__slot_uop_dst_rtype
= ((4U == (7U & (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT___GEN_56)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT__slots_21__DOT__slot_uop_dst_rtype)
: ((2U == (7U & (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT___GEN_54)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT__slots_20__DOT__slot_uop_dst_rtype)
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT__slots_19__DOT__slot_uop_dst_rtype)));
}
}
if (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT__slots_13_io_in_uop_valid) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT__slots_13__DOT__slot_uop_is_amo
= ((4U == (7U & (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT___GEN_46)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT__slots_16__DOT__slot_uop_is_amo)
: ((2U == (7U & (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT___GEN_44)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT__slots_15__DOT__slot_uop_is_amo)
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT__slots_14__DOT__slot_uop_is_amo)));
}
if (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT__slots_15_io_in_uop_valid) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT__slots_15__DOT__slot_uop_imm_packed
= ((4U == (7U & (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT___GEN_50)))
? vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT__slots_18__DOT__slot_uop_imm_packed
: ((2U == (7U & (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT___GEN_48)))
? vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT__slots_17__DOT__slot_uop_imm_packed
: vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT__slots_16__DOT__slot_uop_imm_packed));
}
if (vlTOPp->reset) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT__slots_13__DOT__slot_uop_uses_stq = 0U;
} else {
if (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT__slots_13_io_in_uop_valid) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT__slots_13__DOT__slot_uop_uses_stq
= ((4U == (7U & (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT___GEN_46)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT__slots_16__DOT__slot_uop_uses_stq)
: ((2U == (7U & (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT___GEN_44)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT__slots_15__DOT__slot_uop_uses_stq)
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT__slots_14__DOT__slot_uop_uses_stq)));
}
}
if (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT__slots_16_io_in_uop_valid) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT__slots_16__DOT__slot_uop_is_sfb
= ((4U == (7U & (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT___GEN_52)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT__slots_19__DOT__slot_uop_is_sfb)
: ((2U == (7U & (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT___GEN_50)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT__slots_18__DOT__slot_uop_is_sfb)
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT__slots_17__DOT__slot_uop_is_sfb)));
}
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__8729(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__8729\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
if (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT__slots_14_io_in_uop_valid) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT__slots_14__DOT__slot_uop_is_rvc
= ((4U == (7U & (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT___GEN_48)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT__slots_17__DOT__slot_uop_is_rvc)
: ((2U == (7U & (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT___GEN_46)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT__slots_16__DOT__slot_uop_is_rvc)
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT__slots_15__DOT__slot_uop_is_rvc)));
}
if (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT__slots_14_io_in_uop_valid) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT__slots_14__DOT__slot_uop_edge_inst
= ((4U == (7U & (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT___GEN_48)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT__slots_17__DOT__slot_uop_edge_inst)
: ((2U == (7U & (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT___GEN_46)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT__slots_16__DOT__slot_uop_edge_inst)
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT__slots_15__DOT__slot_uop_edge_inst)));
}
if (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT__slots_14_io_in_uop_valid) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT__slots_14__DOT__slot_uop_pc_lob
= ((4U == (7U & (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT___GEN_48)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT__slots_17__DOT__slot_uop_pc_lob)
: ((2U == (7U & (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT___GEN_46)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT__slots_16__DOT__slot_uop_pc_lob)
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT__slots_15__DOT__slot_uop_pc_lob)));
}
if (vlTOPp->reset) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT__slots_13__DOT__slot_uop_fp_val = 0U;
} else {
if (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT__slots_13_io_in_uop_valid) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT__slots_13__DOT__slot_uop_fp_val
= ((4U == (7U & (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT___GEN_46)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT__slots_16__DOT__slot_uop_fp_val)
: ((2U == (7U & (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT___GEN_44)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT__slots_15__DOT__slot_uop_fp_val)
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT__slots_14__DOT__slot_uop_fp_val)));
}
}
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT__slots_17__DOT___T_149
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT__slots_17__DOT__p2)
& (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT__slots_17__DOT__ppred));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT__slots_17__DOT___T_147
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT__slots_17__DOT___T_118)
& (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT__slots_17__DOT__ppred));
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__8730(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__8730\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT__slots_17__DOT___T_148
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT__slots_17__DOT__p1)
& (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT__slots_17__DOT__ppred));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT__slots_17_io_request
= ((1U == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT__slots_17__DOT__state))
? ((((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT__slots_17__DOT___T_118)
& (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT__slots_17__DOT__p3))
& (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT__slots_17__DOT__ppred))
& (~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT___T_917)))
: ((2U == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT__slots_17__DOT__state))
& ((((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT__slots_17__DOT__p1)
| (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT__slots_17__DOT__p2))
& (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT__slots_17__DOT__ppred))
& (~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT___T_917)))));
if (vlTOPp->reset) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT__slots_18__DOT__ppred = 0U;
} else {
if (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT__slots_18_io_in_uop_valid) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT__slots_18__DOT__ppred
= (1U & (~ ((4U == (7U & (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT___GEN_56)))
? (~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT__slots_21__DOT__ppred))
: ((2U == (7U & (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT___GEN_54)))
? (~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT__slots_20__DOT__ppred))
: (~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT__slots_19__DOT__ppred))))));
}
}
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT___T_1461
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT__slots_15__DOT__slot_uop_fu_code)
& (0x21U | ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__csr_exe_unit__DOT__BranchKillableQueue_io_empty)
? 0x100U : 0U)));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT___T_1457
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT__slots_15_io_request)
& (0U != ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT__slots_15__DOT__slot_uop_fu_code)
& (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit_io_fu_types_0))));
if (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT__slots_16_io_in_uop_valid) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT__slots_16__DOT__slot_uop_fu_code
= ((4U == (7U & (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT___GEN_52)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT__slots_19__DOT__slot_uop_fu_code)
: ((2U == (7U & (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT___GEN_50)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT__slots_18__DOT__slot_uop_fu_code)
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT__slots_17__DOT__slot_uop_fu_code)));
}
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__8731(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__8731\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__ras_io_write_addr
= (VL_ULL(0xffffffffff) & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__ftq__DOT___T_108)
? vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__ftq__DOT___T_109
: (((~ (VL_ULL(7)
| (~ vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__f3__DOT__ram_pc
[0U])))
+ (QData)((IData)(
((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__f3_fetch_bundle_cfi_idx_bits)
<< 1U))))
+ (QData)((IData)(
((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__f3_fetch_bundle_cfi_npc_plus4)
? 4U
: 2U))))));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT___GEN_200
= ((6U == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__f3_fetch_bundle_cfi_idx_bits))
? (((0x6fU == (0x7fU & vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__BranchDecode_9_io_inst))
| (0x67U == (0x707fU & vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__BranchDecode_9_io_inst)))
& (1U == (0x1fU & (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__BranchDecode_9_io_inst
>> 7U)))) : (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT___GEN_199));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT___GEN_208
= ((6U == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__f3_fetch_bundle_cfi_idx_bits))
? (((0x67U == (0x707fU & vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__BranchDecode_9_io_inst))
& (1U == (0x1bU & (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__BranchDecode_9_io_inst
>> 0xfU)))) & (0U
==
(0x1fU
& (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__BranchDecode_9_io_inst
>> 7U))))
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT___GEN_207));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT___T_1756
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT___T_1755)
| (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__f3_redirects_7));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__f3_fetch_bundle_br_mask
= (((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__f3_br_mask_7)
<< 7U) | (((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__f3_br_mask_6)
<< 6U) | (((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__f3_br_mask_5)
<< 5U) | (((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__f3_br_mask_4)
<< 4U)
| (((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__f3_br_mask_3)
<< 3U)
| (((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__f3_br_mask_2)
<< 2U)
| (((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__f3_br_mask_1)
<< 1U)
| (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__f3_br_mask_0))))))));
if (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_11_io_in_uop_valid) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_11__DOT__slot_uop_rob_idx
= ((4U == (7U & (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT___GEN_33)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_14__DOT__slot_uop_rob_idx)
: ((2U == (7U & (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT___GEN_31)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_13__DOT__slot_uop_rob_idx)
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_12__DOT__slot_uop_rob_idx)));
}
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__8732(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__8732\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
if (vlTOPp->reset) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_11__DOT__slot_uop_pdst = 0U;
} else {
if (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_11_io_in_uop_valid) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_11__DOT__slot_uop_pdst
= ((4U == (7U & (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT___GEN_33)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_14__DOT__slot_uop_pdst)
: ((2U == (7U & (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT___GEN_31)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_13__DOT__slot_uop_pdst)
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_12__DOT__slot_uop_pdst)));
}
}
if (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_11_io_in_uop_valid) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_11__DOT__slot_uop_is_amo
= ((4U == (7U & (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT___GEN_33)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_14__DOT__slot_uop_is_amo)
: ((2U == (7U & (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT___GEN_31)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_13__DOT__slot_uop_is_amo)
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_12__DOT__slot_uop_is_amo)));
}
if (vlTOPp->reset) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_11__DOT__slot_uop_dst_rtype = 2U;
} else {
if (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_11_io_in_uop_valid) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_11__DOT__slot_uop_dst_rtype
= ((4U == (7U & (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT___GEN_33)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_14__DOT__slot_uop_dst_rtype)
: ((2U == (7U & (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT___GEN_31)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_13__DOT__slot_uop_dst_rtype)
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_12__DOT__slot_uop_dst_rtype)));
}
}
if (vlTOPp->reset) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_11__DOT__slot_uop_uses_stq = 0U;
} else {
if (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_11_io_in_uop_valid) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_11__DOT__slot_uop_uses_stq
= ((4U == (7U & (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT___GEN_33)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_14__DOT__slot_uop_uses_stq)
: ((2U == (7U & (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT___GEN_31)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_13__DOT__slot_uop_uses_stq)
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_12__DOT__slot_uop_uses_stq)));
}
}
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__8733(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__8733\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_8__DOT___GEN_126
= (1U & (((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline_io_wakeups_1_valid)
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fpiu_unit_io_fresp_bits_uop_pdst)
== (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_8__DOT__next_uop_prs1)))
| (((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__ll_wbarb_io_out_valid)
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__ll_wbarb_io_out_bits_uop_pdst)
== (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_8__DOT__next_uop_prs1)))
| ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_8_io_in_uop_valid)
? (~ ((4U == (7U & (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT___GEN_27)))
? (~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_11__DOT__p1))
: ((2U == (7U & (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT___GEN_25)))
? (~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_10__DOT__p1))
: (~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_9__DOT__p1)))))
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_8__DOT__p1)))));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_8__DOT___GEN_127
= (1U & (((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline_io_wakeups_1_valid)
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fpiu_unit_io_fresp_bits_uop_pdst)
== (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_8__DOT__next_uop_prs2)))
| (((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__ll_wbarb_io_out_valid)
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__ll_wbarb_io_out_bits_uop_pdst)
== (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_8__DOT__next_uop_prs2)))
| ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_8_io_in_uop_valid)
? (~ ((4U == (7U & (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT___GEN_27)))
? (~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_11__DOT__p2))
: ((2U == (7U & (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT___GEN_25)))
? (~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_10__DOT__p2))
: (~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_9__DOT__p2)))))
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_8__DOT__p2)))));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_8__DOT___GEN_128
= (1U & (((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline_io_wakeups_1_valid)
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fpiu_unit_io_fresp_bits_uop_pdst)
== (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_8__DOT__next_uop_prs3)))
| (((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__ll_wbarb_io_out_valid)
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__ll_wbarb_io_out_bits_uop_pdst)
== (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_8__DOT__next_uop_prs3)))
| ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_8_io_in_uop_valid)
? (~ ((4U == (7U & (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT___GEN_27)))
? (~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_11__DOT__p3))
: ((2U == (7U & (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT___GEN_25)))
? (~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_10__DOT__p3))
: (~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_9__DOT__p3)))))
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_8__DOT__p3)))));
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__8734(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__8734\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_9_io_in_uop_bits_prs1
= ((4U == (7U & (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT___GEN_29)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_12__DOT__slot_uop_prs1)
: ((2U == (7U & (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT___GEN_27)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_11__DOT__slot_uop_prs1)
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_10__DOT__slot_uop_prs1)));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_9_io_in_uop_bits_prs2
= ((4U == (7U & (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT___GEN_29)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_12__DOT__slot_uop_prs2)
: ((2U == (7U & (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT___GEN_27)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_11__DOT__slot_uop_prs2)
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_10__DOT__slot_uop_prs2)));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_9_io_in_uop_bits_prs3
= ((4U == (7U & (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT___GEN_29)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_12__DOT__slot_uop_prs3)
: ((2U == (7U & (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT___GEN_27)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_11__DOT__slot_uop_prs3)
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_10__DOT__slot_uop_prs3)));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_9_io_in_uop_valid
= ((4U == (7U & (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT___GEN_29)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_12_io_will_be_valid)
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT___GEN_2298));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT___GEN_2538
= ((2U == (7U & (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT___GEN_29)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_12_io_will_be_valid)
: ((1U == (7U & (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT___GEN_27)))
& (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_11_io_will_be_valid)));
if (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_11_io_in_uop_valid) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_11__DOT__slot_uop_stq_idx
= ((4U == (7U & (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT___GEN_33)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_14__DOT__slot_uop_stq_idx)
: ((2U == (7U & (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT___GEN_31)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_13__DOT__slot_uop_stq_idx)
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_12__DOT__slot_uop_stq_idx)));
}
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__8735(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__8735\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
if (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT__slots_15_io_in_uop_valid) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT__slots_15__DOT__slot_uop_taken
= ((4U == (7U & (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT___GEN_50)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT__slots_18__DOT__slot_uop_taken)
: ((2U == (7U & (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT___GEN_48)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT__slots_17__DOT__slot_uop_taken)
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT__slots_16__DOT__slot_uop_taken)));
}
if (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT__slots_10_io_in_uop_valid) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT__slots_10__DOT__slot_uop_ftq_idx
= ((4U == (7U & (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT___GEN_40)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT__slots_13__DOT__slot_uop_ftq_idx)
: ((2U == (7U & (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT___GEN_38)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT__slots_12__DOT__slot_uop_ftq_idx)
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT__slots_11__DOT__slot_uop_ftq_idx)));
}
if (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_10_io_in_uop_valid) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_10__DOT__slot_uop_rob_idx
= ((4U == (7U & (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT___GEN_40)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_13__DOT__slot_uop_rob_idx)
: ((2U == (7U & (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT___GEN_38)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_12__DOT__slot_uop_rob_idx)
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_11__DOT__slot_uop_rob_idx)));
}
if (vlTOPp->reset) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_10__DOT__slot_uop_pdst = 0U;
} else {
if (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_10_io_in_uop_valid) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_10__DOT__slot_uop_pdst
= ((4U == (7U & (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT___GEN_40)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_13__DOT__slot_uop_pdst)
: ((2U == (7U & (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT___GEN_38)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_12__DOT__slot_uop_pdst)
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_11__DOT__slot_uop_pdst)));
}
}
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_13__DOT___T_9
= (((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_13_io_grant)
& (1U == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_13__DOT__state)))
| ((((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_13__DOT___T_5)
& (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_13__DOT__p1))
& (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_13__DOT__p2))
& (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_13__DOT__ppred)));
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__8736(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__8736\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_14__DOT___T_5
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_14_io_grant)
& (2U == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_14__DOT__state)));
if (vlTOPp->reset) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_10__DOT__slot_uop_uses_stq = 0U;
} else {
if (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_10_io_in_uop_valid) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_10__DOT__slot_uop_uses_stq
= ((4U == (7U & (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT___GEN_40)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_13__DOT__slot_uop_uses_stq)
: ((2U == (7U & (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT___GEN_38)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_12__DOT__slot_uop_uses_stq)
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_11__DOT__slot_uop_uses_stq)));
}
}
if (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_10_io_in_uop_valid) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_10__DOT__slot_uop_stq_idx
= ((4U == (7U & (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT___GEN_40)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_13__DOT__slot_uop_stq_idx)
: ((2U == (7U & (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT___GEN_38)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_12__DOT__slot_uop_stq_idx)
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_11__DOT__slot_uop_stq_idx)));
}
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_8_io_in_uop_bits_prs3
= ((4U == (7U & (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT___GEN_36)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_11__DOT__slot_uop_prs3)
: ((2U == (7U & (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT___GEN_34)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_10__DOT__slot_uop_prs3)
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_9__DOT__slot_uop_prs3)));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_8_io_in_uop_bits_prs1
= ((4U == (7U & (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT___GEN_36)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_11__DOT__slot_uop_prs1)
: ((2U == (7U & (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT___GEN_34)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_10__DOT__slot_uop_prs1)
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_9__DOT__slot_uop_prs1)));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_8_io_in_uop_bits_prs2
= ((4U == (7U & (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT___GEN_36)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_11__DOT__slot_uop_prs2)
: ((2U == (7U & (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT___GEN_34)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_10__DOT__slot_uop_prs2)
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_9__DOT__slot_uop_prs2)));
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__8737(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__8737\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
if (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_10_io_in_uop_valid) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_10__DOT__slot_uop_ldq_idx
= ((4U == (7U & (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT___GEN_40)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_13__DOT__slot_uop_ldq_idx)
: ((2U == (7U & (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT___GEN_38)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_12__DOT__slot_uop_ldq_idx)
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_11__DOT__slot_uop_ldq_idx)));
}
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_276
= (((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__ldq_0_bits_addr_valid)
& (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__ldq_0_bits_addr_is_virtual))
& (~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_273)));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_613
= (((((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__ldq_0_bits_addr_valid)
& (~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__ldq_0_bits_executed)))
& (~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__ldq_0_bits_succeeded)))
& (~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__ldq_0_bits_addr_is_virtual)))
& (~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_273)));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_280
= (((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__ldq_1_bits_addr_valid)
& (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__ldq_1_bits_addr_is_virtual))
& (~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_277)));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_622
= (((((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__ldq_1_bits_addr_valid)
& (~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__ldq_1_bits_executed)))
& (~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__ldq_1_bits_succeeded)))
& (~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__ldq_1_bits_addr_is_virtual)))
& (~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_277)));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_284
= (((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__ldq_2_bits_addr_valid)
& (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__ldq_2_bits_addr_is_virtual))
& (~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_281)));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_631
= (((((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__ldq_2_bits_addr_valid)
& (~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__ldq_2_bits_executed)))
& (~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__ldq_2_bits_succeeded)))
& (~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__ldq_2_bits_addr_is_virtual)))
& (~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_281)));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_288
= (((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__ldq_3_bits_addr_valid)
& (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__ldq_3_bits_addr_is_virtual))
& (~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_285)));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_640
= (((((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__ldq_3_bits_addr_valid)
& (~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__ldq_3_bits_executed)))
& (~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__ldq_3_bits_succeeded)))
& (~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__ldq_3_bits_addr_is_virtual)))
& (~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_285)));
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__8738(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__8738\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_292
= (((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__ldq_4_bits_addr_valid)
& (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__ldq_4_bits_addr_is_virtual))
& (~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_289)));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_649
= (((((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__ldq_4_bits_addr_valid)
& (~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__ldq_4_bits_executed)))
& (~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__ldq_4_bits_succeeded)))
& (~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__ldq_4_bits_addr_is_virtual)))
& (~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_289)));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_360
= (((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__ldq_21_bits_addr_valid)
& (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__ldq_21_bits_addr_is_virtual))
& (~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_357)));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_802
= (((((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__ldq_21_bits_addr_valid)
& (~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__ldq_21_bits_executed)))
& (~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__ldq_21_bits_succeeded)))
& (~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__ldq_21_bits_addr_is_virtual)))
& (~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_357)));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_364
= (((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__ldq_22_bits_addr_valid)
& (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__ldq_22_bits_addr_is_virtual))
& (~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_361)));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_811
= (((((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__ldq_22_bits_addr_valid)
& (~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__ldq_22_bits_executed)))
& (~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__ldq_22_bits_succeeded)))
& (~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__ldq_22_bits_addr_is_virtual)))
& (~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_361)));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_658
= (((((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__ldq_5_bits_addr_valid)
& (~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__ldq_5_bits_executed)))
& (~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__ldq_5_bits_succeeded)))
& (~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__ldq_5_bits_addr_is_virtual)))
& (~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_293)));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_296
= (((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__ldq_5_bits_addr_valid)
& (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__ldq_5_bits_addr_is_virtual))
& (~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_293)));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_356
= (((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__ldq_20_bits_addr_valid)
& (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__ldq_20_bits_addr_is_virtual))
& (~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_353)));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_793
= (((((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__ldq_20_bits_addr_valid)
& (~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__ldq_20_bits_executed)))
& (~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__ldq_20_bits_succeeded)))
& (~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__ldq_20_bits_addr_is_virtual)))
& (~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_353)));
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__8739(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__8739\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_300
= (((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__ldq_6_bits_addr_valid)
& (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__ldq_6_bits_addr_is_virtual))
& (~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_297)));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_667
= (((((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__ldq_6_bits_addr_valid)
& (~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__ldq_6_bits_executed)))
& (~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__ldq_6_bits_succeeded)))
& (~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__ldq_6_bits_addr_is_virtual)))
& (~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_297)));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_304
= (((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__ldq_7_bits_addr_valid)
& (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__ldq_7_bits_addr_is_virtual))
& (~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_301)));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_676
= (((((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__ldq_7_bits_addr_valid)
& (~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__ldq_7_bits_executed)))
& (~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__ldq_7_bits_succeeded)))
& (~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__ldq_7_bits_addr_is_virtual)))
& (~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_301)));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_308
= (((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__ldq_8_bits_addr_valid)
& (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__ldq_8_bits_addr_is_virtual))
& (~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_305)));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_685
= (((((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__ldq_8_bits_addr_valid)
& (~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__ldq_8_bits_executed)))
& (~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__ldq_8_bits_succeeded)))
& (~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__ldq_8_bits_addr_is_virtual)))
& (~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_305)));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_312
= (((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__ldq_9_bits_addr_valid)
& (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__ldq_9_bits_addr_is_virtual))
& (~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_309)));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_694
= (((((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__ldq_9_bits_addr_valid)
& (~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__ldq_9_bits_executed)))
& (~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__ldq_9_bits_succeeded)))
& (~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__ldq_9_bits_addr_is_virtual)))
& (~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_309)));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_316
= (((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__ldq_10_bits_addr_valid)
& (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__ldq_10_bits_addr_is_virtual))
& (~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_313)));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_703
= (((((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__ldq_10_bits_addr_valid)
& (~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__ldq_10_bits_executed)))
& (~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__ldq_10_bits_succeeded)))
& (~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__ldq_10_bits_addr_is_virtual)))
& (~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_313)));
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__8740(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__8740\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_320
= (((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__ldq_11_bits_addr_valid)
& (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__ldq_11_bits_addr_is_virtual))
& (~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_317)));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_712
= (((((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__ldq_11_bits_addr_valid)
& (~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__ldq_11_bits_executed)))
& (~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__ldq_11_bits_succeeded)))
& (~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__ldq_11_bits_addr_is_virtual)))
& (~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_317)));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_324
= (((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__ldq_12_bits_addr_valid)
& (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__ldq_12_bits_addr_is_virtual))
& (~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_321)));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_721
= (((((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__ldq_12_bits_addr_valid)
& (~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__ldq_12_bits_executed)))
& (~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__ldq_12_bits_succeeded)))
& (~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__ldq_12_bits_addr_is_virtual)))
& (~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_321)));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_328
= (((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__ldq_13_bits_addr_valid)
& (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__ldq_13_bits_addr_is_virtual))
& (~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_325)));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_730
= (((((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__ldq_13_bits_addr_valid)
& (~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__ldq_13_bits_executed)))
& (~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__ldq_13_bits_succeeded)))
& (~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__ldq_13_bits_addr_is_virtual)))
& (~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_325)));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_332
= (((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__ldq_14_bits_addr_valid)
& (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__ldq_14_bits_addr_is_virtual))
& (~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_329)));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_739
= (((((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__ldq_14_bits_addr_valid)
& (~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__ldq_14_bits_executed)))
& (~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__ldq_14_bits_succeeded)))
& (~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__ldq_14_bits_addr_is_virtual)))
& (~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_329)));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_336
= (((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__ldq_15_bits_addr_valid)
& (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__ldq_15_bits_addr_is_virtual))
& (~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_333)));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_748
= (((((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__ldq_15_bits_addr_valid)
& (~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__ldq_15_bits_executed)))
& (~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__ldq_15_bits_succeeded)))
& (~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__ldq_15_bits_addr_is_virtual)))
& (~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_333)));
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__8741(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__8741\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_340
= (((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__ldq_16_bits_addr_valid)
& (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__ldq_16_bits_addr_is_virtual))
& (~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_337)));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_757
= (((((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__ldq_16_bits_addr_valid)
& (~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__ldq_16_bits_executed)))
& (~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__ldq_16_bits_succeeded)))
& (~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__ldq_16_bits_addr_is_virtual)))
& (~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_337)));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_344
= (((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__ldq_17_bits_addr_valid)
& (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__ldq_17_bits_addr_is_virtual))
& (~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_341)));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_766
= (((((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__ldq_17_bits_addr_valid)
& (~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__ldq_17_bits_executed)))
& (~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__ldq_17_bits_succeeded)))
& (~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__ldq_17_bits_addr_is_virtual)))
& (~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_341)));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_348
= (((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__ldq_18_bits_addr_valid)
& (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__ldq_18_bits_addr_is_virtual))
& (~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_345)));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_775
= (((((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__ldq_18_bits_addr_valid)
& (~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__ldq_18_bits_executed)))
& (~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__ldq_18_bits_succeeded)))
& (~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__ldq_18_bits_addr_is_virtual)))
& (~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_345)));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_352
= (((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__ldq_19_bits_addr_valid)
& (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__ldq_19_bits_addr_is_virtual))
& (~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_349)));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_784
= (((((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__ldq_19_bits_addr_valid)
& (~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__ldq_19_bits_executed)))
& (~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__ldq_19_bits_succeeded)))
& (~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__ldq_19_bits_addr_is_virtual)))
& (~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_349)));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu_io_dmem_req_bits_0_bits_uop_uses_ldq
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__can_fire_load_incoming_0)
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__exe_tlb_uop_0_uses_ldq)
: ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__will_fire_load_retry_0)
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__exe_tlb_uop_0_uses_ldq)
: ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__will_fire_store_commit_0)
? ((0x17U == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__stq_execute_head))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__stq_23_bits_uop_uses_ldq)
: ((0x16U == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__stq_execute_head))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__stq_22_bits_uop_uses_ldq)
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_1904)))
: ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__will_fire_load_wakeup_0)
& ((0x17U == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__ldq_wakeup_idx))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__ldq_23_bits_uop_uses_ldq)
: ((0x16U == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__ldq_wakeup_idx))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__ldq_22_bits_uop_uses_ldq)
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_56900)))))));
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__8742(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__8742\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu_io_dmem_req_bits_0_bits_uop_uses_stq
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__can_fire_load_incoming_0)
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__exe_tlb_uop_0_uses_stq)
: ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__will_fire_load_retry_0)
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__exe_tlb_uop_0_uses_stq)
: ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__will_fire_store_commit_0)
? ((0x17U == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__stq_execute_head))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__stq_23_bits_uop_uses_stq)
: ((0x16U == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__stq_execute_head))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__stq_22_bits_uop_uses_stq)
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_1905)))
: ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__will_fire_load_wakeup_0)
& ((0x17U == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__ldq_wakeup_idx))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__ldq_23_bits_uop_uses_stq)
: ((0x16U == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__ldq_wakeup_idx))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__ldq_22_bits_uop_uses_stq)
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_56901)))))));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___GEN_104566
= (1U & (((~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__can_fire_load_incoming_0))
& (~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__will_fire_load_retry_0)))
& (~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__will_fire_store_commit_0))));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__dtlb__DOT__cmd_amo_arithmetic_0
= (((((8U == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__dtlb_io_req_0_bits_cmd))
| (0xcU == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__dtlb_io_req_0_bits_cmd)))
| (0xdU == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__dtlb_io_req_0_bits_cmd)))
| (0xeU == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__dtlb_io_req_0_bits_cmd)))
| (0xfU == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__dtlb_io_req_0_bits_cmd)));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__dtlb__DOT__cmd_amo_logical_0
= ((((4U == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__dtlb_io_req_0_bits_cmd))
| (9U == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__dtlb_io_req_0_bits_cmd)))
| (0xaU == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__dtlb_io_req_0_bits_cmd)))
| (0xbU == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__dtlb_io_req_0_bits_cmd)));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__dtlb__DOT___T_1542
= (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__dtlb_io_req_0_bits_vaddr
& (QData)((IData)((0xfU & (((IData)(1U)
<< (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__dtlb_io_req_0_bits_size))
- (IData)(1U))))));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__dtlb__DOT___GEN_19
= ((3U == (3U & (IData)((vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__dtlb_io_req_0_bits_vaddr
>> 0xcU)))) ? vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__dtlb__DOT__sectored_entries_0_data_3
: ((2U == (3U & (IData)((vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__dtlb_io_req_0_bits_vaddr
>> 0xcU)))) ? vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__dtlb__DOT__sectored_entries_0_data_2
: ((1U == (3U & (IData)((vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__dtlb_io_req_0_bits_vaddr
>> 0xcU))))
? vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__dtlb__DOT__sectored_entries_0_data_1
: vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__dtlb__DOT__sectored_entries_0_data_0)));
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__8743(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__8743\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__dtlb__DOT___GEN_23
= ((3U == (3U & (IData)((vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__dtlb_io_req_0_bits_vaddr
>> 0xcU)))) ? vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__dtlb__DOT__sectored_entries_1_data_3
: ((2U == (3U & (IData)((vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__dtlb_io_req_0_bits_vaddr
>> 0xcU)))) ? vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__dtlb__DOT__sectored_entries_1_data_2
: ((1U == (3U & (IData)((vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__dtlb_io_req_0_bits_vaddr
>> 0xcU))))
? vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__dtlb__DOT__sectored_entries_1_data_1
: vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__dtlb__DOT__sectored_entries_1_data_0)));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__dtlb__DOT___GEN_27
= ((3U == (3U & (IData)((vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__dtlb_io_req_0_bits_vaddr
>> 0xcU)))) ? vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__dtlb__DOT__sectored_entries_2_data_3
: ((2U == (3U & (IData)((vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__dtlb_io_req_0_bits_vaddr
>> 0xcU)))) ? vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__dtlb__DOT__sectored_entries_2_data_2
: ((1U == (3U & (IData)((vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__dtlb_io_req_0_bits_vaddr
>> 0xcU))))
? vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__dtlb__DOT__sectored_entries_2_data_1
: vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__dtlb__DOT__sectored_entries_2_data_0)));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__dtlb__DOT___GEN_31
= ((3U == (3U & (IData)((vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__dtlb_io_req_0_bits_vaddr
>> 0xcU)))) ? vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__dtlb__DOT__sectored_entries_3_data_3
: ((2U == (3U & (IData)((vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__dtlb_io_req_0_bits_vaddr
>> 0xcU)))) ? vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__dtlb__DOT__sectored_entries_3_data_2
: ((1U == (3U & (IData)((vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__dtlb_io_req_0_bits_vaddr
>> 0xcU))))
? vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__dtlb__DOT__sectored_entries_3_data_1
: vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__dtlb__DOT__sectored_entries_3_data_0)));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__dtlb__DOT__bad_va_0
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__dtlb__DOT__vm_enabled_0)
& (~ ((VL_ULL(0) == (VL_ULL(0xc000000000)
& vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__dtlb_io_req_0_bits_vaddr))
| (VL_ULL(0xc000000000) == (VL_ULL(0xc000000000)
& vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__dtlb_io_req_0_bits_vaddr)))));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__dtlb__DOT___T_29
= ((1U > (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__dtlb__DOT__special_entry_level))
? (0x7ffffffU & (IData)((vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__dtlb_io_req_0_bits_vaddr
>> 0xcU))) : 0U);
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__8744(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__8744\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__dtlb__DOT___T_35
= ((2U > (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__dtlb__DOT__special_entry_level))
? (0x7ffffffU & (IData)((vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__dtlb_io_req_0_bits_vaddr
>> 0xcU))) : 0U);
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__dtlb__DOT___T_631
= ((((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__dtlb__DOT__special_entry_valid_0)
& ((0x1ffU & (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__dtlb__DOT__special_entry_tag
>> 0x12U)) == (0x1ffU & (IData)(
(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__dtlb_io_req_0_bits_vaddr
>> 0x1eU)))))
& ((1U > (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__dtlb__DOT__special_entry_level))
| ((0x1ffU & (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__dtlb__DOT__special_entry_tag
>> 9U)) == (0x1ffU & (IData)(
(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__dtlb_io_req_0_bits_vaddr
>> 0x15U))))))
& ((2U > (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__dtlb__DOT__special_entry_level))
| ((0x1ffU & vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__dtlb__DOT__special_entry_tag)
== (0x1ffU & (IData)((vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__dtlb_io_req_0_bits_vaddr
>> 0xcU))))));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__dtlb__DOT__superpage_hits_0_2
= (((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__dtlb__DOT__superpage_entries_2_valid_0)
& ((0x1ffU & (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__dtlb__DOT__superpage_entries_2_tag
>> 0x12U)) == (0x1ffU & (IData)(
(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__dtlb_io_req_0_bits_vaddr
>> 0x1eU)))))
& ((1U > (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__dtlb__DOT__superpage_entries_2_level))
| ((0x1ffU & (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__dtlb__DOT__superpage_entries_2_tag
>> 9U)) == (0x1ffU & (IData)(
(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__dtlb_io_req_0_bits_vaddr
>> 0x15U))))));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__dtlb__DOT__superpage_hits_0_3
= (((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__dtlb__DOT__superpage_entries_3_valid_0)
& ((0x1ffU & (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__dtlb__DOT__superpage_entries_3_tag
>> 0x12U)) == (0x1ffU & (IData)(
(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__dtlb_io_req_0_bits_vaddr
>> 0x1eU)))))
& ((1U > (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__dtlb__DOT__superpage_entries_3_level))
| ((0x1ffU & (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__dtlb__DOT__superpage_entries_3_tag
>> 9U)) == (0x1ffU & (IData)(
(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__dtlb_io_req_0_bits_vaddr
>> 0x15U))))));
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__8745(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__8745\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__dtlb__DOT__superpage_hits_0_0
= (((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__dtlb__DOT__superpage_entries_0_valid_0)
& ((0x1ffU & (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__dtlb__DOT__superpage_entries_0_tag
>> 0x12U)) == (0x1ffU & (IData)(
(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__dtlb_io_req_0_bits_vaddr
>> 0x1eU)))))
& ((1U > (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__dtlb__DOT__superpage_entries_0_level))
| ((0x1ffU & (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__dtlb__DOT__superpage_entries_0_tag
>> 9U)) == (0x1ffU & (IData)(
(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__dtlb_io_req_0_bits_vaddr
>> 0x15U))))));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__dtlb__DOT__superpage_hits_0_1
= (((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__dtlb__DOT__superpage_entries_1_valid_0)
& ((0x1ffU & (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__dtlb__DOT__superpage_entries_1_tag
>> 0x12U)) == (0x1ffU & (IData)(
(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__dtlb_io_req_0_bits_vaddr
>> 0x1eU)))))
& ((1U > (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__dtlb__DOT__superpage_entries_1_level))
| ((0x1ffU & (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__dtlb__DOT__superpage_entries_1_tag
>> 9U)) == (0x1ffU & (IData)(
(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__dtlb_io_req_0_bits_vaddr
>> 0x15U))))));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__dtlb__DOT___T_388
= (0x7ffffffU & (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__dtlb__DOT__sectored_entries_0_tag
^ (IData)((vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__dtlb_io_req_0_bits_vaddr
>> 0xcU))));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__dtlb__DOT___T_395
= (0x7ffffffU & (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__dtlb__DOT__sectored_entries_1_tag
^ (IData)((vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__dtlb_io_req_0_bits_vaddr
>> 0xcU))));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__dtlb__DOT___T_402
= (0x7ffffffU & (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__dtlb__DOT__sectored_entries_2_tag
^ (IData)((vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__dtlb_io_req_0_bits_vaddr
>> 0xcU))));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__dtlb__DOT___T_409
= (0x7ffffffU & (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__dtlb__DOT__sectored_entries_3_tag
^ (IData)((vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__dtlb_io_req_0_bits_vaddr
>> 0xcU))));
if (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT__slots_12_io_in_uop_valid) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT__slots_12__DOT__slot_uop_is_jal
= ((4U == (7U & (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT___GEN_44)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT__slots_15__DOT__slot_uop_is_jal)
: ((2U == (7U & (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT___GEN_42)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT__slots_14__DOT__slot_uop_is_jal)
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT__slots_13__DOT__slot_uop_is_jal)));
}
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__8746(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__8746\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
if (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT__slots_12_io_in_uop_valid) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT__slots_12__DOT__slot_uop_is_jalr
= ((4U == (7U & (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT___GEN_44)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT__slots_15__DOT__slot_uop_is_jalr)
: ((2U == (7U & (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT___GEN_42)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT__slots_14__DOT__slot_uop_is_jalr)
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT__slots_13__DOT__slot_uop_is_jalr)));
}
if (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT__slots_12_io_in_uop_valid) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT__slots_12__DOT__slot_uop_is_br
= ((4U == (7U & (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT___GEN_44)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT__slots_15__DOT__slot_uop_is_br)
: ((2U == (7U & (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT___GEN_42)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT__slots_14__DOT__slot_uop_is_br)
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT__slots_13__DOT__slot_uop_is_br)));
}
if (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT__slots_11_io_in_uop_valid) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT__slots_11__DOT__slot_uop_rob_idx
= ((4U == (7U & (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT___GEN_42)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT__slots_14__DOT__slot_uop_rob_idx)
: ((2U == (7U & (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT___GEN_40)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT__slots_13__DOT__slot_uop_rob_idx)
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT__slots_12__DOT__slot_uop_rob_idx)));
}
if (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT__slots_10_io_in_uop_valid) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT__slots_10__DOT__slot_uop_br_tag
= ((4U == (7U & (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT___GEN_40)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT__slots_13__DOT__slot_uop_br_tag)
: ((2U == (7U & (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT___GEN_38)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT__slots_12__DOT__slot_uop_br_tag)
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__int_issue_unit__DOT__slots_11__DOT__slot_uop_br_tag)));
}
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT___T_199
= ((0x400000U & vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT___T_10[0U])
? 0U : ((0x200000U & vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT___T_10[0U])
? 1U : ((0x100000U & vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT___T_10[0U])
? 2U : ((0x80000U & vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT___T_10[0U])
? 3U : ((0x40000U
& vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT___T_10[0U])
? 4U
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT___T_194))))));
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__8747(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__8747\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT___T_101
= ((4U & vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT___T_10[1U])
? 0x11U : ((2U & vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT___T_10[1U])
? 0x12U : ((1U & vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT___T_10[1U])
? 0x13U : ((0x80000000U
& vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT___T_10[0U])
? 0x14U
: (
(0x40000000U
& vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT___T_10[0U])
? 0x15U
:
((0x20000000U
& vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT___T_10[0U])
? 0x16U
:
((0x10000000U
& vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT___T_10[0U])
? 0x17U
:
((0x8000000U
& vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT___T_10[0U])
? 0x18U
:
((0x4000000U
& vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT___T_10[0U])
? 0x19U
:
((0x2000000U
& vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT___T_10[0U])
? 0x1aU
:
((0x1000000U
& vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT___T_10[0U])
? 0x1bU
:
((0x800000U
& vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT___T_10[0U])
? 0x1cU
:
((0x400000U
& vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT___T_10[0U])
? 0x1dU
:
((0x200000U
& vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT___T_10[0U])
? 0x1eU
:
((0x100000U
& vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT___T_10[0U])
? 0x1fU
:
((0x80000U
& vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT___T_10[0U])
? 0x20U
:
((0x40000U
& vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT___T_10[0U])
? 0x21U
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT___T_84))))))))))))))))));
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__8748(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__8748\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT___GEN_23502
= ((0x1aU == (0x1fU & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U))) ? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_val___05F26)
: ((0x19U == (0x1fU & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U))) ? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_val___05F25)
: ((0x18U == (0x1fU & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U))) ? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_val___05F24)
: ((0x17U == (0x1fU & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_val___05F23)
: ((0x16U == (0x1fU & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_val___05F22)
: ((0x15U == (0x1fU & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_val___05F21)
: ((0x14U == (0x1fU
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_val___05F20)
: ((0x13U == (0x1fU
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_val___05F19)
: ((0x12U ==
(0x1fU
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_val___05F18)
: ((0x11U
==
(0x1fU
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_val___05F17)
: (
(0x10U
==
(0x1fU
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_val___05F16)
:
((0xfU
==
(0x1fU
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_val___05F15)
:
((0xeU
==
(0x1fU
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_val___05F14)
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT___GEN_23489))))))))))))));
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__8749(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__8749\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT___GEN_23534
= ((0x1aU == (0x1fU & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U))) ? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_bsy___05F26)
: ((0x19U == (0x1fU & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U))) ? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_bsy___05F25)
: ((0x18U == (0x1fU & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U))) ? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_bsy___05F24)
: ((0x17U == (0x1fU & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_bsy___05F23)
: ((0x16U == (0x1fU & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_bsy___05F22)
: ((0x15U == (0x1fU & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_bsy___05F21)
: ((0x14U == (0x1fU
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_bsy___05F20)
: ((0x13U == (0x1fU
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_bsy___05F19)
: ((0x12U ==
(0x1fU
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_bsy___05F18)
: ((0x11U
==
(0x1fU
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_bsy___05F17)
: (
(0x10U
==
(0x1fU
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_bsy___05F16)
:
((0xfU
==
(0x1fU
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_bsy___05F15)
:
((0xeU
==
(0x1fU
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_bsy___05F14)
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT___GEN_23521))))))))))))));
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__8750(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__8750\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT___GEN_52157
= ((0x1aU == (0x1fU & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U))) ? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_val_1_26)
: ((0x19U == (0x1fU & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U))) ? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_val_1_25)
: ((0x18U == (0x1fU & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U))) ? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_val_1_24)
: ((0x17U == (0x1fU & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_val_1_23)
: ((0x16U == (0x1fU & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_val_1_22)
: ((0x15U == (0x1fU & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_val_1_21)
: ((0x14U == (0x1fU
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_val_1_20)
: ((0x13U == (0x1fU
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_val_1_19)
: ((0x12U ==
(0x1fU
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_val_1_18)
: ((0x11U
==
(0x1fU
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_val_1_17)
: (
(0x10U
==
(0x1fU
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_val_1_16)
:
((0xfU
==
(0x1fU
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_val_1_15)
:
((0xeU
==
(0x1fU
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_val_1_14)
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT___GEN_52144))))))))))))));
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__8751(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__8751\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT___GEN_52189
= ((0x1aU == (0x1fU & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U))) ? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_bsy_1_26)
: ((0x19U == (0x1fU & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U))) ? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_bsy_1_25)
: ((0x18U == (0x1fU & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U))) ? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_bsy_1_24)
: ((0x17U == (0x1fU & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_bsy_1_23)
: ((0x16U == (0x1fU & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_bsy_1_22)
: ((0x15U == (0x1fU & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_bsy_1_21)
: ((0x14U == (0x1fU
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_bsy_1_20)
: ((0x13U == (0x1fU
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_bsy_1_19)
: ((0x12U ==
(0x1fU
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_bsy_1_18)
: ((0x11U
==
(0x1fU
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_bsy_1_17)
: (
(0x10U
==
(0x1fU
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_bsy_1_16)
:
((0xfU
==
(0x1fU
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_bsy_1_15)
:
((0xeU
==
(0x1fU
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_bsy_1_14)
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT___GEN_52176))))))))))))));
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__8752(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__8752\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT___GEN_80812
= ((0x1aU == (0x1fU & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U))) ? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_val_2_26)
: ((0x19U == (0x1fU & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U))) ? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_val_2_25)
: ((0x18U == (0x1fU & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U))) ? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_val_2_24)
: ((0x17U == (0x1fU & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_val_2_23)
: ((0x16U == (0x1fU & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_val_2_22)
: ((0x15U == (0x1fU & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_val_2_21)
: ((0x14U == (0x1fU
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_val_2_20)
: ((0x13U == (0x1fU
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_val_2_19)
: ((0x12U ==
(0x1fU
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_val_2_18)
: ((0x11U
==
(0x1fU
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_val_2_17)
: (
(0x10U
==
(0x1fU
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_val_2_16)
:
((0xfU
==
(0x1fU
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_val_2_15)
:
((0xeU
==
(0x1fU
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_val_2_14)
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT___GEN_80799))))))))))))));
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__8753(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__8753\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT___GEN_80844
= ((0x1aU == (0x1fU & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U))) ? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_bsy_2_26)
: ((0x19U == (0x1fU & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U))) ? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_bsy_2_25)
: ((0x18U == (0x1fU & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U))) ? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_bsy_2_24)
: ((0x17U == (0x1fU & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_bsy_2_23)
: ((0x16U == (0x1fU & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_bsy_2_22)
: ((0x15U == (0x1fU & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_bsy_2_21)
: ((0x14U == (0x1fU
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_bsy_2_20)
: ((0x13U == (0x1fU
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_bsy_2_19)
: ((0x12U ==
(0x1fU
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_bsy_2_18)
: ((0x11U
==
(0x1fU
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_bsy_2_17)
: (
(0x10U
==
(0x1fU
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_bsy_2_16)
:
((0xfU
==
(0x1fU
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_bsy_2_15)
:
((0xeU
==
(0x1fU
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_bsy_2_14)
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT___GEN_80831))))))))))))));
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__8754(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__8754\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT___GEN_25630
= ((0x1aU == (0x1fU & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U))) ? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_uop___05F26_pdst)
: ((0x19U == (0x1fU & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U))) ? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_uop___05F25_pdst)
: ((0x18U == (0x1fU & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U))) ? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_uop___05F24_pdst)
: ((0x17U == (0x1fU & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_uop___05F23_pdst)
: ((0x16U == (0x1fU & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_uop___05F22_pdst)
: ((0x15U == (0x1fU & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_uop___05F21_pdst)
: ((0x14U == (0x1fU
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_uop___05F20_pdst)
: ((0x13U == (0x1fU
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_uop___05F19_pdst)
: ((0x12U ==
(0x1fU
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_uop___05F18_pdst)
: ((0x11U
==
(0x1fU
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_uop___05F17_pdst)
: (
(0x10U
==
(0x1fU
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_uop___05F16_pdst)
:
((0xfU
==
(0x1fU
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_uop___05F15_pdst)
:
((0xeU
==
(0x1fU
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_uop___05F14_pdst)
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT___GEN_24603))))))))))))));
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__8755(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__8755\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT___GEN_25659
= ((0x1aU == (0x1fU & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U))) ? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_uop___05F26_ldst_val)
: ((0x19U == (0x1fU & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U))) ? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_uop___05F25_ldst_val)
: ((0x18U == (0x1fU & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U))) ? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_uop___05F24_ldst_val)
: ((0x17U == (0x1fU & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_uop___05F23_ldst_val)
: ((0x16U == (0x1fU & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_uop___05F22_ldst_val)
: ((0x15U == (0x1fU & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_uop___05F21_ldst_val)
: ((0x14U == (0x1fU
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_uop___05F20_ldst_val)
: ((0x13U == (0x1fU
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_uop___05F19_ldst_val)
: ((0x12U ==
(0x1fU
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_uop___05F18_ldst_val)
: ((0x11U
==
(0x1fU
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_uop___05F17_ldst_val)
: (
(0x10U
==
(0x1fU
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_uop___05F16_ldst_val)
:
((0xfU
==
(0x1fU
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_uop___05F15_ldst_val)
:
((0xeU
==
(0x1fU
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_uop___05F14_ldst_val)
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT___GEN_24632))))))))))))));
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__8756(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__8756\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT___GEN_54285
= ((0x1aU == (0x1fU & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U))) ? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_uop_1_26_pdst)
: ((0x19U == (0x1fU & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U))) ? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_uop_1_25_pdst)
: ((0x18U == (0x1fU & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U))) ? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_uop_1_24_pdst)
: ((0x17U == (0x1fU & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_uop_1_23_pdst)
: ((0x16U == (0x1fU & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_uop_1_22_pdst)
: ((0x15U == (0x1fU & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_uop_1_21_pdst)
: ((0x14U == (0x1fU
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_uop_1_20_pdst)
: ((0x13U == (0x1fU
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_uop_1_19_pdst)
: ((0x12U ==
(0x1fU
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_uop_1_18_pdst)
: ((0x11U
==
(0x1fU
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_uop_1_17_pdst)
: (
(0x10U
==
(0x1fU
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_uop_1_16_pdst)
:
((0xfU
==
(0x1fU
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_uop_1_15_pdst)
:
((0xeU
==
(0x1fU
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_uop_1_14_pdst)
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT___GEN_53258))))))))))))));
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__8757(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__8757\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT___GEN_54314
= ((0x1aU == (0x1fU & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U))) ? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_uop_1_26_ldst_val)
: ((0x19U == (0x1fU & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U))) ? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_uop_1_25_ldst_val)
: ((0x18U == (0x1fU & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U))) ? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_uop_1_24_ldst_val)
: ((0x17U == (0x1fU & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_uop_1_23_ldst_val)
: ((0x16U == (0x1fU & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_uop_1_22_ldst_val)
: ((0x15U == (0x1fU & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_uop_1_21_ldst_val)
: ((0x14U == (0x1fU
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_uop_1_20_ldst_val)
: ((0x13U == (0x1fU
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_uop_1_19_ldst_val)
: ((0x12U ==
(0x1fU
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_uop_1_18_ldst_val)
: ((0x11U
==
(0x1fU
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_uop_1_17_ldst_val)
: (
(0x10U
==
(0x1fU
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_uop_1_16_ldst_val)
:
((0xfU
==
(0x1fU
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_uop_1_15_ldst_val)
:
((0xeU
==
(0x1fU
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_uop_1_14_ldst_val)
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT___GEN_53287))))))))))))));
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__8758(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__8758\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT___GEN_82940
= ((0x1aU == (0x1fU & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U))) ? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_uop_2_26_pdst)
: ((0x19U == (0x1fU & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U))) ? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_uop_2_25_pdst)
: ((0x18U == (0x1fU & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U))) ? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_uop_2_24_pdst)
: ((0x17U == (0x1fU & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_uop_2_23_pdst)
: ((0x16U == (0x1fU & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_uop_2_22_pdst)
: ((0x15U == (0x1fU & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_uop_2_21_pdst)
: ((0x14U == (0x1fU
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_uop_2_20_pdst)
: ((0x13U == (0x1fU
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_uop_2_19_pdst)
: ((0x12U ==
(0x1fU
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_uop_2_18_pdst)
: ((0x11U
==
(0x1fU
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_uop_2_17_pdst)
: (
(0x10U
==
(0x1fU
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_uop_2_16_pdst)
:
((0xfU
==
(0x1fU
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_uop_2_15_pdst)
:
((0xeU
==
(0x1fU
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_uop_2_14_pdst)
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT___GEN_81913))))))))))))));
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__8759(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__8759\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT___GEN_82969
= ((0x1aU == (0x1fU & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U))) ? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_uop_2_26_ldst_val)
: ((0x19U == (0x1fU & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U))) ? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_uop_2_25_ldst_val)
: ((0x18U == (0x1fU & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U))) ? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_uop_2_24_ldst_val)
: ((0x17U == (0x1fU & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_uop_2_23_ldst_val)
: ((0x16U == (0x1fU & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_uop_2_22_ldst_val)
: ((0x15U == (0x1fU & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_uop_2_21_ldst_val)
: ((0x14U == (0x1fU
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_uop_2_20_ldst_val)
: ((0x13U == (0x1fU
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_uop_2_19_ldst_val)
: ((0x12U ==
(0x1fU
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_uop_2_18_ldst_val)
: ((0x11U
==
(0x1fU
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_uop_2_17_ldst_val)
: (
(0x10U
==
(0x1fU
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_uop_2_16_ldst_val)
:
((0xfU
==
(0x1fU
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_uop_2_15_ldst_val)
:
((0xeU
==
(0x1fU
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_uop_2_14_ldst_val)
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT___GEN_81942))))))))))))));
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__8760(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__8760\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT___GEN_13114
= ((0x1aU == (0x1fU & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U))) ? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_val___05F26)
: ((0x19U == (0x1fU & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U))) ? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_val___05F25)
: ((0x18U == (0x1fU & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U))) ? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_val___05F24)
: ((0x17U == (0x1fU & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_val___05F23)
: ((0x16U == (0x1fU & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_val___05F22)
: ((0x15U == (0x1fU & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_val___05F21)
: ((0x14U == (0x1fU
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_val___05F20)
: ((0x13U == (0x1fU
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_val___05F19)
: ((0x12U ==
(0x1fU
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_val___05F18)
: ((0x11U
==
(0x1fU
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_val___05F17)
: (
(0x10U
==
(0x1fU
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_val___05F16)
:
((0xfU
==
(0x1fU
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_val___05F15)
:
((0xeU
==
(0x1fU
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_val___05F14)
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT___GEN_13101))))))))))))));
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__8761(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__8761\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT___GEN_13146
= ((0x1aU == (0x1fU & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U))) ? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_bsy___05F26)
: ((0x19U == (0x1fU & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U))) ? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_bsy___05F25)
: ((0x18U == (0x1fU & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U))) ? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_bsy___05F24)
: ((0x17U == (0x1fU & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_bsy___05F23)
: ((0x16U == (0x1fU & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_bsy___05F22)
: ((0x15U == (0x1fU & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_bsy___05F21)
: ((0x14U == (0x1fU
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_bsy___05F20)
: ((0x13U == (0x1fU
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_bsy___05F19)
: ((0x12U ==
(0x1fU
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_bsy___05F18)
: ((0x11U
==
(0x1fU
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_bsy___05F17)
: (
(0x10U
==
(0x1fU
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_bsy___05F16)
:
((0xfU
==
(0x1fU
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_bsy___05F15)
:
((0xeU
==
(0x1fU
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_bsy___05F14)
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT___GEN_13133))))))))))))));
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__8762(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__8762\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT___GEN_41769
= ((0x1aU == (0x1fU & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U))) ? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_val_1_26)
: ((0x19U == (0x1fU & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U))) ? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_val_1_25)
: ((0x18U == (0x1fU & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U))) ? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_val_1_24)
: ((0x17U == (0x1fU & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_val_1_23)
: ((0x16U == (0x1fU & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_val_1_22)
: ((0x15U == (0x1fU & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_val_1_21)
: ((0x14U == (0x1fU
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_val_1_20)
: ((0x13U == (0x1fU
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_val_1_19)
: ((0x12U ==
(0x1fU
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_val_1_18)
: ((0x11U
==
(0x1fU
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_val_1_17)
: (
(0x10U
==
(0x1fU
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_val_1_16)
:
((0xfU
==
(0x1fU
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_val_1_15)
:
((0xeU
==
(0x1fU
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_val_1_14)
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT___GEN_41756))))))))))))));
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__8763(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__8763\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT___GEN_41801
= ((0x1aU == (0x1fU & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U))) ? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_bsy_1_26)
: ((0x19U == (0x1fU & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U))) ? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_bsy_1_25)
: ((0x18U == (0x1fU & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U))) ? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_bsy_1_24)
: ((0x17U == (0x1fU & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_bsy_1_23)
: ((0x16U == (0x1fU & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_bsy_1_22)
: ((0x15U == (0x1fU & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_bsy_1_21)
: ((0x14U == (0x1fU
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_bsy_1_20)
: ((0x13U == (0x1fU
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_bsy_1_19)
: ((0x12U ==
(0x1fU
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_bsy_1_18)
: ((0x11U
==
(0x1fU
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_bsy_1_17)
: (
(0x10U
==
(0x1fU
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_bsy_1_16)
:
((0xfU
==
(0x1fU
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_bsy_1_15)
:
((0xeU
==
(0x1fU
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_bsy_1_14)
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT___GEN_41788))))))))))))));
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__8764(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__8764\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT___GEN_70424
= ((0x1aU == (0x1fU & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U))) ? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_val_2_26)
: ((0x19U == (0x1fU & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U))) ? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_val_2_25)
: ((0x18U == (0x1fU & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U))) ? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_val_2_24)
: ((0x17U == (0x1fU & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_val_2_23)
: ((0x16U == (0x1fU & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_val_2_22)
: ((0x15U == (0x1fU & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_val_2_21)
: ((0x14U == (0x1fU
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_val_2_20)
: ((0x13U == (0x1fU
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_val_2_19)
: ((0x12U ==
(0x1fU
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_val_2_18)
: ((0x11U
==
(0x1fU
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_val_2_17)
: (
(0x10U
==
(0x1fU
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_val_2_16)
:
((0xfU
==
(0x1fU
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_val_2_15)
:
((0xeU
==
(0x1fU
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_val_2_14)
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT___GEN_70411))))))))))))));
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__8765(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__8765\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT___GEN_70456
= ((0x1aU == (0x1fU & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U))) ? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_bsy_2_26)
: ((0x19U == (0x1fU & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U))) ? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_bsy_2_25)
: ((0x18U == (0x1fU & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U))) ? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_bsy_2_24)
: ((0x17U == (0x1fU & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_bsy_2_23)
: ((0x16U == (0x1fU & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_bsy_2_22)
: ((0x15U == (0x1fU & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_bsy_2_21)
: ((0x14U == (0x1fU
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_bsy_2_20)
: ((0x13U == (0x1fU
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_bsy_2_19)
: ((0x12U ==
(0x1fU
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_bsy_2_18)
: ((0x11U
==
(0x1fU
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_bsy_2_17)
: (
(0x10U
==
(0x1fU
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_bsy_2_16)
:
((0xfU
==
(0x1fU
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_bsy_2_15)
:
((0xeU
==
(0x1fU
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_bsy_2_14)
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT___GEN_70443))))))))))))));
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__8766(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__8766\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT___GEN_15242
= ((0x1aU == (0x1fU & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U))) ? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_uop___05F26_pdst)
: ((0x19U == (0x1fU & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U))) ? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_uop___05F25_pdst)
: ((0x18U == (0x1fU & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U))) ? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_uop___05F24_pdst)
: ((0x17U == (0x1fU & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_uop___05F23_pdst)
: ((0x16U == (0x1fU & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_uop___05F22_pdst)
: ((0x15U == (0x1fU & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_uop___05F21_pdst)
: ((0x14U == (0x1fU
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_uop___05F20_pdst)
: ((0x13U == (0x1fU
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_uop___05F19_pdst)
: ((0x12U ==
(0x1fU
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_uop___05F18_pdst)
: ((0x11U
==
(0x1fU
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_uop___05F17_pdst)
: (
(0x10U
==
(0x1fU
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_uop___05F16_pdst)
:
((0xfU
==
(0x1fU
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_uop___05F15_pdst)
:
((0xeU
==
(0x1fU
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_uop___05F14_pdst)
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT___GEN_14215))))))))))))));
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__8767(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__8767\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT___GEN_15271
= ((0x1aU == (0x1fU & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U))) ? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_uop___05F26_ldst_val)
: ((0x19U == (0x1fU & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U))) ? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_uop___05F25_ldst_val)
: ((0x18U == (0x1fU & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U))) ? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_uop___05F24_ldst_val)
: ((0x17U == (0x1fU & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_uop___05F23_ldst_val)
: ((0x16U == (0x1fU & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_uop___05F22_ldst_val)
: ((0x15U == (0x1fU & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_uop___05F21_ldst_val)
: ((0x14U == (0x1fU
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_uop___05F20_ldst_val)
: ((0x13U == (0x1fU
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_uop___05F19_ldst_val)
: ((0x12U ==
(0x1fU
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_uop___05F18_ldst_val)
: ((0x11U
==
(0x1fU
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_uop___05F17_ldst_val)
: (
(0x10U
==
(0x1fU
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_uop___05F16_ldst_val)
:
((0xfU
==
(0x1fU
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_uop___05F15_ldst_val)
:
((0xeU
==
(0x1fU
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_uop___05F14_ldst_val)
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT___GEN_14244))))))))))))));
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__8768(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__8768\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT___GEN_43897
= ((0x1aU == (0x1fU & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U))) ? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_uop_1_26_pdst)
: ((0x19U == (0x1fU & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U))) ? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_uop_1_25_pdst)
: ((0x18U == (0x1fU & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U))) ? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_uop_1_24_pdst)
: ((0x17U == (0x1fU & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_uop_1_23_pdst)
: ((0x16U == (0x1fU & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_uop_1_22_pdst)
: ((0x15U == (0x1fU & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_uop_1_21_pdst)
: ((0x14U == (0x1fU
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_uop_1_20_pdst)
: ((0x13U == (0x1fU
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_uop_1_19_pdst)
: ((0x12U ==
(0x1fU
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_uop_1_18_pdst)
: ((0x11U
==
(0x1fU
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_uop_1_17_pdst)
: (
(0x10U
==
(0x1fU
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_uop_1_16_pdst)
:
((0xfU
==
(0x1fU
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_uop_1_15_pdst)
:
((0xeU
==
(0x1fU
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_uop_1_14_pdst)
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT___GEN_42870))))))))))))));
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__8769(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__8769\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT___GEN_43926
= ((0x1aU == (0x1fU & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U))) ? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_uop_1_26_ldst_val)
: ((0x19U == (0x1fU & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U))) ? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_uop_1_25_ldst_val)
: ((0x18U == (0x1fU & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U))) ? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_uop_1_24_ldst_val)
: ((0x17U == (0x1fU & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_uop_1_23_ldst_val)
: ((0x16U == (0x1fU & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_uop_1_22_ldst_val)
: ((0x15U == (0x1fU & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_uop_1_21_ldst_val)
: ((0x14U == (0x1fU
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_uop_1_20_ldst_val)
: ((0x13U == (0x1fU
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_uop_1_19_ldst_val)
: ((0x12U ==
(0x1fU
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_uop_1_18_ldst_val)
: ((0x11U
==
(0x1fU
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_uop_1_17_ldst_val)
: (
(0x10U
==
(0x1fU
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_uop_1_16_ldst_val)
:
((0xfU
==
(0x1fU
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_uop_1_15_ldst_val)
:
((0xeU
==
(0x1fU
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_uop_1_14_ldst_val)
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT___GEN_42899))))))))))))));
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__8770(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__8770\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT___GEN_72552
= ((0x1aU == (0x1fU & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U))) ? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_uop_2_26_pdst)
: ((0x19U == (0x1fU & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U))) ? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_uop_2_25_pdst)
: ((0x18U == (0x1fU & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U))) ? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_uop_2_24_pdst)
: ((0x17U == (0x1fU & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_uop_2_23_pdst)
: ((0x16U == (0x1fU & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_uop_2_22_pdst)
: ((0x15U == (0x1fU & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_uop_2_21_pdst)
: ((0x14U == (0x1fU
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_uop_2_20_pdst)
: ((0x13U == (0x1fU
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_uop_2_19_pdst)
: ((0x12U ==
(0x1fU
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_uop_2_18_pdst)
: ((0x11U
==
(0x1fU
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_uop_2_17_pdst)
: (
(0x10U
==
(0x1fU
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_uop_2_16_pdst)
:
((0xfU
==
(0x1fU
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_uop_2_15_pdst)
:
((0xeU
==
(0x1fU
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_uop_2_14_pdst)
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT___GEN_71525))))))))))))));
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__8771(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__8771\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT___GEN_72581
= ((0x1aU == (0x1fU & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U))) ? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_uop_2_26_ldst_val)
: ((0x19U == (0x1fU & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U))) ? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_uop_2_25_ldst_val)
: ((0x18U == (0x1fU & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U))) ? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_uop_2_24_ldst_val)
: ((0x17U == (0x1fU & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_uop_2_23_ldst_val)
: ((0x16U == (0x1fU & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_uop_2_22_ldst_val)
: ((0x15U == (0x1fU & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_uop_2_21_ldst_val)
: ((0x14U == (0x1fU
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_uop_2_20_ldst_val)
: ((0x13U == (0x1fU
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_uop_2_19_ldst_val)
: ((0x12U ==
(0x1fU
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_uop_2_18_ldst_val)
: ((0x11U
==
(0x1fU
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_uop_2_17_ldst_val)
: (
(0x10U
==
(0x1fU
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_uop_2_16_ldst_val)
:
((0xfU
==
(0x1fU
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_uop_2_15_ldst_val)
:
((0xeU
==
(0x1fU
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__ll_wbarb_io_out_bits_uop_rob_idx)
>> 2U)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__rob_uop_2_14_ldst_val)
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT___GEN_71554))))))))))))));
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__8772(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__8772\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fpiu_unit__DOT__BranchKillableQueue__DOT__do_enq
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fpiu_unit__DOT__BranchKillableQueue_io_empty)
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fpiu_unit__DOT__BranchKillableQueue__DOT___GEN_1879)
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fpiu_unit__DOT__BranchKillableQueue__DOT___T_3));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fpiu_unit__DOT__BranchKillableQueue_1__DOT__do_deq
= (1U & ((~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fpiu_unit__DOT__BranchKillableQueue_1_io_empty))
& (((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fpiu_unit__DOT__Arbiter_io_in_1_ready)
| (~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fpiu_unit__DOT__BranchKillableQueue_1__DOT___GEN_2)))
& (~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fpiu_unit__DOT__BranchKillableQueue_1_io_empty)))));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fpiu_unit__DOT__BranchKillableQueue_1__DOT___GEN_903
= ((~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fpiu_unit__DOT__Arbiter_io_in_1_ready))
& (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fpiu_unit__DOT__BranchKillableQueue_1__DOT___T_3));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_1631
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu_io_core_fp_stdata_ready)
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT___T_274)
& (2U == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fpiu_unit__DOT__Arbiter_io_out_bits_uop_uopc))));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__ll_wbarb_io_out_valid
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu_io_core_exe_0_iresp_valid)
| ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT___T_274)
& (2U != (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fpiu_unit__DOT__Arbiter_io_out_bits_uop_uopc))));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_1_io_will_be_valid
= ((0U != (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_1__DOT__state))
& (~ (((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_1_io_grant)
& ((1U == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_1__DOT__state))
| ((((2U == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_1__DOT__state))
& (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_1__DOT__p1))
& (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_1__DOT__p2))
& (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_1__DOT__ppred))))
& (~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_1__DOT___T_11)))));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_2_io_out_uop_uopc
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT___T_916)
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_2__DOT__slot_uop_uopc)
: ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_2__DOT___T_9)
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_2__DOT__slot_uop_uopc)
: ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_2__DOT___T_5)
? ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_2__DOT___T_11)
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_2__DOT__slot_uop_uopc)
: ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_2__DOT__p1)
? 3U : (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_2__DOT__slot_uop_uopc)))
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_2__DOT__slot_uop_uopc))));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_2_io_out_uop_iw_state
= ((0U != (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_2__DOT___T_105))
? 0U : ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT___T_916)
? 0U : ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_2__DOT___T_9)
? ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_2__DOT___T_11)
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_2__DOT__state)
: 0U) : ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_2__DOT___T_5)
? ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_2__DOT___T_11)
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_2__DOT__state)
: 1U)
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_2__DOT__state)))));
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__8773(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__8773\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_2_io_out_uop_lrs1_rtype
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT___T_916)
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_2__DOT__slot_uop_lrs1_rtype)
: ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_2__DOT___T_9)
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_2__DOT__slot_uop_lrs1_rtype)
: ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_2__DOT___T_5)
? ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_2__DOT___T_11)
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_2__DOT__slot_uop_lrs1_rtype)
: ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_2__DOT__p1)
? 2U : (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_2__DOT__slot_uop_lrs1_rtype)))
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_2__DOT__slot_uop_lrs1_rtype))));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_2_io_out_uop_lrs2_rtype
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT___T_916)
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_2__DOT__slot_uop_lrs2_rtype)
: ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_2__DOT___T_9)
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_2__DOT__slot_uop_lrs2_rtype)
: ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_2__DOT___T_5)
? ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_2__DOT___T_11)
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_2__DOT__slot_uop_lrs2_rtype)
: ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_2__DOT__p1)
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_2__DOT__slot_uop_lrs2_rtype)
: 2U)) : (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_2__DOT__slot_uop_lrs2_rtype))));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_2_io_will_be_valid
= ((0U != (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_2__DOT__state))
& (~ (((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_2_io_grant)
& ((1U == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_2__DOT__state))
| ((((2U == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_2__DOT__state))
& (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_2__DOT__p1))
& (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_2__DOT__p2))
& (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_2__DOT__ppred))))
& (~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_2__DOT___T_11)))));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_14_io_will_be_valid
= ((0U != (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_14__DOT__state))
& (~ (((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_14_io_grant)
& ((1U == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_14__DOT__state))
| ((((2U == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_14__DOT__state))
& (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_14__DOT__p1))
& (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_14__DOT__p2))
& (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_14__DOT__ppred))))
& (~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_14__DOT___T_11)))));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_11_io_out_uop_uopc
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT___T_916)
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_11__DOT__slot_uop_uopc)
: ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_11__DOT___T_9)
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_11__DOT__slot_uop_uopc)
: ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_11__DOT___T_5)
? ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_11__DOT___T_11)
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_11__DOT__slot_uop_uopc)
: ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_11__DOT__p1)
? 3U : (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_11__DOT__slot_uop_uopc)))
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_11__DOT__slot_uop_uopc))));
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__8774(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__8774\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_11_io_out_uop_iw_state
= ((0U != (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_11__DOT___T_105))
? 0U : ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT___T_916)
? 0U : ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_11__DOT___T_9)
? ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_11__DOT___T_11)
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_11__DOT__state)
: 0U) : ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_11__DOT___T_5)
? ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_11__DOT___T_11)
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_11__DOT__state)
: 1U)
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_11__DOT__state)))));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_11_io_out_uop_lrs1_rtype
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT___T_916)
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_11__DOT__slot_uop_lrs1_rtype)
: ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_11__DOT___T_9)
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_11__DOT__slot_uop_lrs1_rtype)
: ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_11__DOT___T_5)
? ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_11__DOT___T_11)
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_11__DOT__slot_uop_lrs1_rtype)
: ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_11__DOT__p1)
? 2U : (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_11__DOT__slot_uop_lrs1_rtype)))
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_11__DOT__slot_uop_lrs1_rtype))));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_11_io_out_uop_lrs2_rtype
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT___T_916)
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_11__DOT__slot_uop_lrs2_rtype)
: ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_11__DOT___T_9)
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_11__DOT__slot_uop_lrs2_rtype)
: ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_11__DOT___T_5)
? ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_11__DOT___T_11)
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_11__DOT__slot_uop_lrs2_rtype)
: ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_11__DOT__p1)
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_11__DOT__slot_uop_lrs2_rtype)
: 2U)) : (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_11__DOT__slot_uop_lrs2_rtype))));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_11_io_will_be_valid
= ((0U != (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_11__DOT__state))
& (~ (((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_11_io_grant)
& ((1U == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_11__DOT__state))
| ((((2U == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_11__DOT__state))
& (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_11__DOT__p1))
& (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_11__DOT__p2))
& (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_11__DOT__ppred))))
& (~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_11__DOT___T_11)))));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_12_io_out_uop_uopc
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT___T_916)
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_12__DOT__slot_uop_uopc)
: ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_12__DOT___T_9)
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_12__DOT__slot_uop_uopc)
: ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_12__DOT___T_5)
? ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_12__DOT___T_11)
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_12__DOT__slot_uop_uopc)
: ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_12__DOT__p1)
? 3U : (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_12__DOT__slot_uop_uopc)))
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_12__DOT__slot_uop_uopc))));
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__8775(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__8775\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_12_io_out_uop_iw_state
= ((0U != (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_12__DOT___T_105))
? 0U : ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT___T_916)
? 0U : ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_12__DOT___T_9)
? ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_12__DOT___T_11)
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_12__DOT__state)
: 0U) : ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_12__DOT___T_5)
? ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_12__DOT___T_11)
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_12__DOT__state)
: 1U)
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_12__DOT__state)))));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_12_io_out_uop_lrs1_rtype
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT___T_916)
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_12__DOT__slot_uop_lrs1_rtype)
: ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_12__DOT___T_9)
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_12__DOT__slot_uop_lrs1_rtype)
: ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_12__DOT___T_5)
? ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_12__DOT___T_11)
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_12__DOT__slot_uop_lrs1_rtype)
: ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_12__DOT__p1)
? 2U : (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_12__DOT__slot_uop_lrs1_rtype)))
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_12__DOT__slot_uop_lrs1_rtype))));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_12_io_out_uop_lrs2_rtype
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT___T_916)
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_12__DOT__slot_uop_lrs2_rtype)
: ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_12__DOT___T_9)
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_12__DOT__slot_uop_lrs2_rtype)
: ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_12__DOT___T_5)
? ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_12__DOT___T_11)
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_12__DOT__slot_uop_lrs2_rtype)
: ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_12__DOT__p1)
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_12__DOT__slot_uop_lrs2_rtype)
: 2U)) : (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_12__DOT__slot_uop_lrs2_rtype))));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_12_io_will_be_valid
= ((0U != (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_12__DOT__state))
& (~ (((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_12_io_grant)
& ((1U == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_12__DOT__state))
| ((((2U == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_12__DOT__state))
& (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_12__DOT__p1))
& (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_12__DOT__p2))
& (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_12__DOT__ppred))))
& (~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_12__DOT___T_11)))));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_13_io_will_be_valid
= ((0U != (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_13__DOT__state))
& (~ (((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_13_io_grant)
& ((1U == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_13__DOT__state))
| ((((2U == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_13__DOT__state))
& (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_13__DOT__p1))
& (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_13__DOT__p2))
& (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_13__DOT__ppred))))
& (~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_13__DOT___T_11)))));
}
| 110.90719 | 201 | 0.680517 | vargandhi |
0b506bcf56930496a297f5c4f2bac104da1c5553 | 602 | hpp | C++ | include/mtree.hpp | Aritzherrero4/fsCheckDaemon | 3cad10938ce0d14ff70490ca4bc3df742eb974c9 | [
"MIT"
] | null | null | null | include/mtree.hpp | Aritzherrero4/fsCheckDaemon | 3cad10938ce0d14ff70490ca4bc3df742eb974c9 | [
"MIT"
] | null | null | null | include/mtree.hpp | Aritzherrero4/fsCheckDaemon | 3cad10938ce0d14ff70490ca4bc3df742eb974c9 | [
"MIT"
] | null | null | null | #ifndef MTREE_HPP
#define MTREE_HPP
#include <iostream>
#include <vector>
#include <string>
#include <filesystem>
#include "../include/mnode.hpp"
class Mtree{
public:
int n_nodes; //Total number of files and dirs
Mnode *root_node; // Pointer of the top node
std::string root_hash;
int hashMode=_BLAKE3; //Default hash mode is blake3
Mtree();
~Mtree();
Mtree(int hashMode);
void populateTree(fs::path path);
void print();
void addNode(fs::path path);
void nodeChanged(fs::path path, int change);
};
#endif | 22.296296 | 59 | 0.621262 | Aritzherrero4 |
0b50f37553a1efbe3de59bcef9fd06ab73222598 | 2,713 | cpp | C++ | src/_leetcode/leet_84.cpp | turesnake/leetPractice | a87b9b90eb8016038d7e5d3ad8e50e4ceb54d69b | [
"MIT"
] | null | null | null | src/_leetcode/leet_84.cpp | turesnake/leetPractice | a87b9b90eb8016038d7e5d3ad8e50e4ceb54d69b | [
"MIT"
] | null | null | null | src/_leetcode/leet_84.cpp | turesnake/leetPractice | a87b9b90eb8016038d7e5d3ad8e50e4ceb54d69b | [
"MIT"
] | null | null | null | /*
* ====================== leet_84.cpp ==========================
* -- tpr --
* CREATE -- 2020.06.05
* MODIFY --
* ----------------------------------------------------------
* 84. 柱状图中最大的矩形
*/
#include "innLeet.h"
#include "TreeNode1.h"
#include "ListNode.h"
namespace leet_84 {//~
// 单调栈
// 需要单独抽出来练习
// 78%, 100% 看着教程还能一连错3次
// ----
// 此单调栈中记载的，是一组连续排列的元素的 最右那个
// 也就是说，当出现 {1,1,1,3} 这么一段时，
// 虽然一开始，会记录 [0]号的1，但是后面的紧挨着的相同的1，会改写这个 stk.top().idx
class S{
struct Elem{
int val {0};
int idx {0};
};
public:
int largestRectangleArea( std::vector<int>& heights ){
if(heights.empty()){ return 0; }
int N = static_cast<int>(heights.size());
int maxSum = 0;
// 单调栈，数据递增
std::stack<Elem> stk {};
stk.push( Elem{heights.at(0),0} );
for( int i=1; i<N; i++ ){
int curVal = heights.at(i);
if( curVal > stk.top().val ){
stk.push( Elem{heights.at(i),i} );
}else if( curVal < stk.top().val ){
// 将所有比 curVal 大的栈内元素，做一次清算
while( !stk.empty() && stk.top().val>curVal ){
auto &elem = stk.top();
stk.pop();
int l = stk.empty() ? -1 : stk.top().idx;
int rectH = elem.val;
int rectW = i-l-1; // l，新值，两者所在位，都不被算入矩形,
//cout<<"w:"<<rectW<<", h:"<<rectH<<endl;
maxSum = std::max(maxSum, rectW*rectH );
}
// 清算过后，还是要把剩余元素 塞入 栈中
stk.push( Elem{heights.at(i),i} );
}else{
// 当与上一值相等，将要 top.idx 改成自己
stk.top().idx = i;
}
}
//cout<<"---------"<<endl;
// 遍历完所有元素后，栈中还是存在剩余元素
while( !stk.empty() ){
auto &elem = stk.top();
stk.pop();
int l = stk.empty() ? -1 : stk.top().idx;
int rectH = elem.val;
int rectW = (N-1)-l;// l 所在 位，不被算入矩形
//cout<<"w:"<<rectW<<", h:"<<rectH<<endl;
maxSum = std::max(maxSum, rectW*rectH );
}
return maxSum;
}
};
//=========================================================//
void main_(){
//std::vector<int> v { 4,2,0,3,2,5 };
//std::vector<int> v { 2,1,5,6,2,3 };
//std::vector<int> v { 0,0,0,0,0,0,0,0,2147483647 };
//std::vector<int> v { 0,0,0,0,0,0,0,0,3 };
//cout<< S{}.largestRectangleArea(v) << endl;
//cout<<INT_MIN<<endl;
//cout<<INT_MAX<<endl;
debug::log( "\n~~~~ leet: 84 :end ~~~~\n" );
}
}//~
| 26.598039 | 64 | 0.402875 | turesnake |
0b56da83c0a8e058caa80169bb67015150bea1e5 | 2,131 | cpp | C++ | NfdcAppCore/AppView.cpp | Mason-Wmx/ViewFramework | d8117adc646c369ad29d64477788514c7a75a797 | [
"Apache-2.0"
] | 1 | 2021-10-03T16:47:04.000Z | 2021-10-03T16:47:04.000Z | NfdcAppCore/AppView.cpp | Mason-Wmx/ViewFramework | d8117adc646c369ad29d64477788514c7a75a797 | [
"Apache-2.0"
] | null | null | null | NfdcAppCore/AppView.cpp | Mason-Wmx/ViewFramework | d8117adc646c369ad29d64477788514c7a75a797 | [
"Apache-2.0"
] | null | null | null |
#include "stdafx.h"
#include "AppView.h"
#include "mainwindow.h"
#include "Application.h"
#include "ViewEvents.h"
#include "Document.h"
using namespace SIM;
AppView::AppView(Application& app,MainWindow& window) :
MVCItem<Application>(app),
_ribbon( window ),
_browser( window ),
_QATView(window),
_ICView(window),
_statusBar(window),
_progressView(window),
_mainWindow(window)
{
}
AppView::~AppView(void)
{
}
void AppView::Notify(Event& ev)
{
EventSwitch es(ev);
es.Case<AppViewModeChangedEvent>(std::bind(&AppView::OnSwitchMode, this, std::placeholders::_1));
es.Case<ModelSavedEvent>(std::bind(&AppView::OnModelSaved, this, std::placeholders::_1));
NotifyObservers(ev);
}
void AppView::OnSwitchMode(AppViewModeChangedEvent & ev)
{
_mainWindow.setUpdatesEnabled(false);
switch (ev.GetMode())
{
case DocModel::ViewMode::Explore:
_ribbon.GetRibbonTab()->hide();
_browser.hide();
_parent.GetController().HideActiveCommandsDialogs();
break;
case DocModel::ViewMode::Define:
default:
_ribbon.GetRibbonTab()->show();
_browser.show();
_parent.GetController().ShowActiveCommandsDialogs();
break;
}
_mainWindow.setUpdatesEnabled(true);
}
void AppView::OnModelSaved(ModelSavedEvent & ev)
{
DocModel* docModel = dynamic_cast<DocModel*>(&ev.GetSource());
if (docModel)
_parent.GetMainWindow().SetMainWindowTitle(docModel->GetProjectName(/*ifNotSetReturnProjectTemporaryName*/ true).c_str());
}
void SIM::AppView::Initialize()
{
_ribbon.Initialize();
_QATView.Initialize();
_ICView.Initialize();
_modeView.RegisterObserver(*this);
_ribbon.RegisterObserver(*this);
_browser.RegisterObserver(*this);
_QATView.RegisterObserver(*this);
_ICView.RegisterObserver(*this);
_progressView.RegisterObserver(*this);
RegisterObserver(_modeView);
RegisterObserver(_ribbon);
RegisterObserver(_browser);
RegisterObserver(_QATView);
RegisterObserver(_statusBar);
RegisterObserver(_ICView);
RegisterObserver(_progressView);
_parent.GetModel().RegisterObserver(*this);
}
| 24.215909 | 130 | 0.713749 | Mason-Wmx |
0b5bd642d3e9d17515e308d9075ed867a5c9c8b0 | 1,720 | cxx | C++ | vtkm/exec/internal/testing/UnitTestErrorMessageBuffer.cxx | yisyuanliou/VTK-m | cc483c8c2319a78b58b3ab849da8ca448e896220 | [
"BSD-3-Clause"
] | 14 | 2019-10-25T03:25:47.000Z | 2022-01-19T02:14:53.000Z | vtkm/exec/internal/testing/UnitTestErrorMessageBuffer.cxx | yisyuanliou/VTK-m | cc483c8c2319a78b58b3ab849da8ca448e896220 | [
"BSD-3-Clause"
] | 2 | 2020-11-18T16:50:34.000Z | 2022-01-21T13:31:47.000Z | vtkm/exec/internal/testing/UnitTestErrorMessageBuffer.cxx | yisyuanliou/VTK-m | cc483c8c2319a78b58b3ab849da8ca448e896220 | [
"BSD-3-Clause"
] | 5 | 2020-10-02T10:14:35.000Z | 2022-03-10T07:50:22.000Z | //============================================================================
// Copyright (c) Kitware, Inc.
// All rights reserved.
// See LICENSE.txt for details.
//
// This software is distributed WITHOUT ANY WARRANTY; without even
// the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
// PURPOSE. See the above copyright notice for more information.
//============================================================================
#include <vtkm/exec/internal/ErrorMessageBuffer.h>
#include <cstring>
#include <vtkm/testing/Testing.h>
namespace
{
void TestErrorMessageBuffer()
{
char messageBuffer[100];
std::cout << "Testing buffer large enough for message." << std::endl;
messageBuffer[0] = '\0';
vtkm::exec::internal::ErrorMessageBuffer largeBuffer(messageBuffer, 100);
VTKM_TEST_ASSERT(!largeBuffer.IsErrorRaised(), "Message created with error.");
largeBuffer.RaiseError("Hello World");
VTKM_TEST_ASSERT(largeBuffer.IsErrorRaised(), "Error not reported.");
VTKM_TEST_ASSERT(strcmp(messageBuffer, "Hello World") == 0, "Did not record error message.");
std::cout << "Testing truncated error message." << std::endl;
messageBuffer[0] = '\0';
vtkm::exec::internal::ErrorMessageBuffer smallBuffer(messageBuffer, 9);
VTKM_TEST_ASSERT(!smallBuffer.IsErrorRaised(), "Message created with error.");
smallBuffer.RaiseError("Hello World");
VTKM_TEST_ASSERT(smallBuffer.IsErrorRaised(), "Error not reported.");
VTKM_TEST_ASSERT(strcmp(messageBuffer, "Hello Wo") == 0, "Did not record error message.");
}
} // anonymous namespace
int UnitTestErrorMessageBuffer(int argc, char* argv[])
{
return vtkm::testing::Testing::Run(TestErrorMessageBuffer, argc, argv);
}
| 35.833333 | 95 | 0.672093 | yisyuanliou |
0b5f57c9aff3169ea11734ca33d254b1f456085d | 891 | cpp | C++ | 907-sum-of-subarray-minimums/907-sum-of-subarray-minimums.cpp | Ananyaas/LeetCodeDaily | e134e20ac02f26dc40881c376656d3294be0df2c | [
"MIT"
] | 2 | 2022-01-02T19:15:00.000Z | 2022-01-05T21:12:24.000Z | 907-sum-of-subarray-minimums/907-sum-of-subarray-minimums.cpp | Ananyaas/LeetCodeDaily | e134e20ac02f26dc40881c376656d3294be0df2c | [
"MIT"
] | null | null | null | 907-sum-of-subarray-minimums/907-sum-of-subarray-minimums.cpp | Ananyaas/LeetCodeDaily | e134e20ac02f26dc40881c376656d3294be0df2c | [
"MIT"
] | 1 | 2022-03-11T17:11:07.000Z | 2022-03-11T17:11:07.000Z | class Solution {
public:
int sumSubarrayMins(vector<int>& arr) {
vector<int>dp(arr.size());
dp[0]=arr[0];
stack<int>st;
st.push(0);
long long ans=arr[0];
int cv=1e9+7;
for(int i=1;i<arr.size();i++)
{
while(!st.empty() && arr[st.top()]>arr[i])
{
st.pop();
}
if(!st.empty())
{
long long tt = ((i-st.top()-1)*arr[i])%cv;
dp[i]+=tt;
dp[i]+=dp[st.top()];
dp[i]+=arr[i];
ans+=dp[i];
st.push(i);
}
else
{
long long y = (i*arr[i])%cv;
dp[i]+=y;
dp[i]+=arr[i];
ans+=dp[i];
st.push(i);
}
}
return ans%cv;
}
}; | 24.75 | 58 | 0.317621 | Ananyaas |
0b603922f73ff23a91f04bd356aa4d8f2885cbd3 | 843 | cpp | C++ | subtitans/disabledrawstackingpatch.cpp | UnknownException/SubTitans | 1502cb511ba3abfcec3d23f4345b309e300c8105 | [
"MIT"
] | 24 | 2020-05-18T09:17:46.000Z | 2022-03-12T12:02:02.000Z | subtitans/disabledrawstackingpatch.cpp | UnknownException/SubTitans | 1502cb511ba3abfcec3d23f4345b309e300c8105 | [
"MIT"
] | 4 | 2020-06-03T19:07:35.000Z | 2022-03-12T13:06:42.000Z | subtitans/disabledrawstackingpatch.cpp | UnknownException/SubTitans | 1502cb511ba3abfcec3d23f4345b309e300c8105 | [
"MIT"
] | null | null | null | #include "subtitans.h"
#include "disabledrawstackingpatch.h"
DisableDrawStackingPatch::DisableDrawStackingPatch()
{
GetLogger()->Informational("Constructing %s\n", __func__);
Address = 0;
}
DisableDrawStackingPatch::~DisableDrawStackingPatch()
{
GetLogger()->Informational("Destructing %s\n", __func__);
}
bool DisableDrawStackingPatch::Validate()
{
return Address != 0;
}
bool DisableDrawStackingPatch::Apply()
{
GetLogger()->Informational("%s\n", __FUNCTION__);
// This old optimization tanks the FPS
// Disabling it by overwriting the limit (100) with -1 (Jump Greater will ALWAYS execute)
unsigned char minusOne[] = { 0xFF };
if (!MemoryWriter::Write(Address, minusOne, 1))
return false;
return true;
}
const wchar_t* DisableDrawStackingPatch::ErrorMessage()
{
return L"Failed to apply Disable Draw Stacking patch";
}
| 22.184211 | 90 | 0.746145 | UnknownException |
0b65d1829d8da8698adb7f238f1fee52037fe456 | 15,178 | cpp | C++ | src/tvs/utils/variant.cpp | TastiiVegas/TestWP | 567c62117324b6649a54f23e1e332f6eb73e066a | [
"Apache-2.0"
] | 1 | 2017-09-14T09:59:56.000Z | 2017-09-14T09:59:56.000Z | src/tvs/utils/variant.cpp | TastiiVegas/TestWP | 567c62117324b6649a54f23e1e332f6eb73e066a | [
"Apache-2.0"
] | null | null | null | src/tvs/utils/variant.cpp | TastiiVegas/TestWP | 567c62117324b6649a54f23e1e332f6eb73e066a | [
"Apache-2.0"
] | null | null | null | /*
* Copyright (c) 2017 OFFIS Institute for Information Technology
* Oldenburg, Germany
*
* 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.
*/
/**
* @file variant.cpp
* @author Philipp A. Hartmann, OFFIS
*/
#include "tvs/utils/variant.h"
#include "tvs/utils/rapidjson.h"
#include <algorithm> // std::swap
#include <vector> // std::vector
namespace sysx {
namespace utils {
typedef rapidjson::CrtAllocator allocator_type;
typedef rapidjson::UTF8<> encoding_type;
typedef rapidjson::GenericValue<encoding_type, allocator_type> json_value;
typedef rapidjson::GenericDocument<encoding_type, allocator_type> json_document;
static allocator_type json_allocator;
// wrapper implementation is simply a RapidJSON value
typedef json_value impl_type;
// helper to convert to wrapper implementation
static inline impl_type*
impl_cast(void* p)
{
return static_cast<impl_type*>(p);
}
// ----------------------------------------------------------------------------
// variant_cache
/// internal helper to pool explicitly allocated RapidJSON value objects
struct variant_pool
{
typedef std::vector<impl_type*> free_list;
static impl_type* create() { return instance().do_create(); }
static void free(impl_type* obj) { instance().do_free(obj); }
~variant_pool()
{
for (free_list::iterator it = free_.begin(), end = free_.end(); it != end;
++it)
delete *it;
}
private:
variant_pool() {}
static variant_pool& instance()
{
static variant_pool instance_;
return instance_;
}
impl_type* do_create()
{
if (free_.empty())
return new impl_type();
impl_type* ret = free_.back();
free_.pop_back();
return ret;
}
void do_free(impl_type* obj) { free_.push_back(obj); }
free_list free_;
};
#define PIMPL(x) (impl_cast((x).pimpl_))
#define DEREF(x) (*PIMPL(x))
#define THIS (PIMPL(*this))
#define VALUE_ASSERT(Cond, Msg) \
do { \
if (!(Cond)) \
SYSX_REPORT_ERROR(report::variant_error) \
<< Msg << " (condition: " #Cond ")"; \
} while (false)
// ----------------------------------------------------------------------------
// variant_cref
bool
operator==(variant_cref const& left, variant_cref const& right)
{
if (PIMPL(left) == PIMPL(right))
return true;
if (!PIMPL(left) || !PIMPL(right))
return false;
return DEREF(left) == DEREF(right);
}
variant_category
variant_cref::category() const
{
if (!THIS)
return VARIANT_NULL;
switch (THIS->GetType()) {
case rapidjson::kFalseType:
case rapidjson::kTrueType:
return VARIANT_BOOL;
case rapidjson::kNumberType:
return VARIANT_NUMBER;
case rapidjson::kStringType:
return VARIANT_STRING;
case rapidjson::kArrayType:
return VARIANT_LIST;
case rapidjson::kObjectType:
return VARIANT_MAP;
case rapidjson::kNullType:
default:
return VARIANT_NULL;
}
}
bool
variant_cref::is_null() const
{
return !THIS || THIS->IsNull();
}
bool
variant_cref::is_bool() const
{
return THIS && THIS->IsBool();
}
bool
variant_cref::is_int() const
{
return THIS && THIS->IsInt();
}
bool
variant_cref::is_int64() const
{
return THIS && THIS->IsInt64();
}
bool
variant_cref::is_uint() const
{
return THIS && THIS->IsUint();
}
bool
variant_cref::is_uint64() const
{
return THIS && THIS->IsUint64();
}
bool
variant_cref::is_double() const
{
return THIS && THIS->IsDouble();
}
bool
variant_cref::is_string() const
{
return THIS && THIS->IsString();
}
bool
variant_cref::is_list() const
{
return THIS && THIS->IsArray();
}
bool
variant_cref::is_map() const
{
return THIS && THIS->IsObject();
}
bool
variant_cref::get_bool() const
{
(is_bool());
return THIS->GetBool();
}
#define ASSERT_TYPE(Cond) VALUE_ASSERT(Cond, "invalid type access")
int
variant_cref::get_int() const
{
ASSERT_TYPE(is_int());
return THIS->GetInt();
}
unsigned
variant_cref::get_uint() const
{
ASSERT_TYPE(is_uint());
return THIS->GetUint();
}
int64
variant_cref::get_int64() const
{
ASSERT_TYPE(is_int64());
return THIS->GetInt64();
}
uint64
variant_cref::get_uint64() const
{
ASSERT_TYPE(is_uint64());
return THIS->GetUint64();
}
double
variant_cref::get_double() const
{
ASSERT_TYPE(is_number());
return THIS->GetDouble();
}
variant_string_cref
variant_cref::get_string() const
{
ASSERT_TYPE(is_string());
return variant_string_cref(pimpl_);
}
variant_list_cref
variant_cref::get_list() const
{
ASSERT_TYPE(is_list());
return variant_list_cref(pimpl_);
}
variant_map_cref
variant_cref::get_map() const
{
ASSERT_TYPE(is_map());
return variant_map_cref(pimpl_);
}
// ----------------------------------------------------------------------------
// variant_ref
void
variant_ref::swap(variant_ref& that)
{
VALUE_ASSERT(pimpl_ && that.pimpl_, "swap with invalid value failed");
THIS->Swap(DEREF(that));
}
variant_ref
variant_ref::operator=(variant_cref const& that)
{
if (that.is_null())
set_null();
else {
sc_assert(THIS);
THIS->CopyFrom(DEREF(that), json_allocator);
}
return *this;
}
variant_ref
variant_ref::set_null()
{
if (THIS)
THIS->SetNull();
return this_type(THIS);
}
variant_ref
variant_ref::set_bool(bool v)
{
sc_assert(THIS);
THIS->SetBool(v);
return this_type(THIS);
}
variant_ref
variant_ref::set_int(int v)
{
sc_assert(THIS);
THIS->SetInt(v);
return this_type(THIS);
}
variant_ref
variant_ref::set_uint(unsigned v)
{
sc_assert(THIS);
THIS->SetUint(v);
return this_type(THIS);
}
variant_ref
variant_ref::set_int64(int64 v)
{
sc_assert(THIS);
THIS->SetInt64(v);
return this_type(THIS);
}
variant_ref
variant_ref::set_uint64(uint64 v)
{
sc_assert(THIS);
THIS->SetUint64(v);
return this_type(THIS);
}
variant_ref
variant_ref::set_double(double d)
{
sc_assert(THIS);
THIS->SetDouble(d);
return this_type(THIS);
}
variant_string_ref
variant_ref::set_string(const char* s, size_t len)
{
sc_assert(THIS);
THIS->SetString(s, len, json_allocator);
return variant_string_ref(THIS);
}
variant_list_ref
variant_ref::set_list()
{
sc_assert(THIS);
THIS->SetArray();
return variant_list_ref(THIS);
}
variant_map_ref
variant_ref::set_map()
{
sc_assert(THIS);
THIS->SetObject();
return variant_map_ref(THIS);
}
// ----------------------------------------------------------------------------
// variant_string_cref
variant_string_cref::size_type
variant_string_cref::size() const
{
return THIS->GetStringLength();
}
const char*
variant_string_cref::c_str() const
{
return THIS->GetString();
}
bool
operator==(variant_string_cref const& left, const char* right)
{
return !right ? false : DEREF(left) == right;
}
bool
operator==(variant_string_cref const& left, std::string const& right)
{
return DEREF(left) == rapidjson::StringRef(right.c_str(), right.size());
}
bool
operator==(const char* left, variant_string_cref const& right)
{
return !left ? false : DEREF(right) == left;
}
bool
operator==(std::string const& left, variant_string_cref const& right)
{
return DEREF(right) == rapidjson::StringRef(left.c_str(), left.size());
}
// ----------------------------------------------------------------------------
// variant_string_ref
void
variant_string_ref::swap(this_type& that)
{
VALUE_ASSERT(pimpl_ && that.pimpl_, "swap with invalid value failed");
THIS->Swap(DEREF(that));
}
// ----------------------------------------------------------------------------
// variant_list_cref
variant_list_cref::size_type
variant_list_cref::size() const
{
return THIS->Size();
}
variant_cref variant_list_cref::operator[](size_type index) const
{
return variant_cref(&(*THIS)[index]);
}
// ----------------------------------------------------------------------------
// variant_list_ref
void
variant_list_ref::swap(this_type& that)
{
VALUE_ASSERT(pimpl_ && that.pimpl_, "swap with invalid value failed");
THIS->Swap(DEREF(that));
}
variant_list_ref
variant_list_ref::clear()
{
THIS->Clear();
return *this;
}
variant_list_ref::size_type
variant_list_ref::capacity() const
{
return THIS->Capacity();
}
variant_list_ref
variant_list_ref::reserve(size_type new_capacity)
{
THIS->Reserve(new_capacity, json_allocator);
return *this;
}
variant_list_ref
variant_list_ref::push_back(const_reference value)
{
json_value v;
if (PIMPL(value))
v.CopyFrom(DEREF(value), json_allocator);
THIS->PushBack(v, json_allocator);
return *this;
}
// ----------------------------------------------------------------------------
// variant_map_cref
variant_map_cref::size_type
variant_map_cref::size() const
{
return THIS->MemberCount();
}
variant_cref::impl*
variant_map_cref::do_lookup(const char* key,
size_type keylen,
bool allow_fail /* = false */) const
{
json_value kv(rapidjson::StringRef(key, keylen));
json_value::ConstMemberIterator it = THIS->FindMember(kv);
if (it == THIS->MemberEnd()) {
if (allow_fail)
return NULL;
SYSX_REPORT_ERROR(report::variant_error)
<< "variant map has no element with key '" << key << "'";
return NULL;
}
return const_cast<json_value*>(&it->value);
}
// ----------------------------------------------------------------------------
// variant_map_ref
void
variant_map_ref::swap(this_type& that)
{
VALUE_ASSERT(pimpl_ && that.pimpl_, "swap with invalid value failed");
THIS->Swap(DEREF(that));
}
variant_map_ref
variant_map_ref::clear()
{
THIS->RemoveAllMembers();
return *this;
}
variant_map_ref
variant_map_ref::push_entry(const char* key,
variant::const_reference const& value)
{
json_value k(key, json_allocator);
json_value v;
if (PIMPL(value))
v.CopyFrom(DEREF(value), json_allocator);
THIS->AddMember(k, v, json_allocator);
return *this;
}
// ----------------------------------------------------------------------------
// variant(, _list, _map ) -- owning wrapper implementations
variant::variant(variant_category cat)
: variant_ref()
, own_pimpl_()
{
do_init();
switch (cat) {
case VARIANT_BOOL:
THIS->SetBool(false);
break;
case VARIANT_NUMBER:
THIS->SetUint(0u);
break;
case VARIANT_STRING:
THIS->SetString("");
break;
case VARIANT_LIST:
THIS->SetObject();
break;
case VARIANT_MAP:
THIS->SetObject();
break;
case VARIANT_NULL:
default:
/* do nothing */;
}
}
#define WRAPPER_ASSIGN_PRECOND_(Kind) WRAPPER_ASSIGN_PRECOND_FOR_##Kind
#define WRAPPER_ASSIGN_PRECOND_FOR_variant \
if (that.is_null()) { \
set_null(); \
return *this; \
} \
init()
#define WRAPPER_ASSIGN_PRECOND_FOR_variant_list \
sc_assert(is_list() && that.is_list())
#define WRAPPER_ASSIGN_PRECOND_FOR_variant_map \
sc_assert(is_map() && that.is_map())
#define WRAPPER_DO_INIT_(Kind) WRAPPER_DO_INIT_##Kind
#define WRAPPER_DO_INIT_variant ((void)0)
#define WRAPPER_DO_INIT_variant_list (THIS)->SetArray()
#define WRAPPER_DO_INIT_variant_map (THIS)->SetObject()
#define DEFINE_WRAPPER_(Kind) \
Kind::this_type& Kind::operator=(const_reference that) \
{ \
WRAPPER_ASSIGN_PRECOND_(Kind); \
reference::operator=(that); \
return *this; \
} \
\
void Kind::swap(this_type& that) \
{ \
using std::swap; \
swap(pimpl_, that.pimpl_); \
swap(own_pimpl_, that.own_pimpl_); \
} \
\
Kind::impl* Kind::do_init() \
{ \
sc_assert(!own_pimpl_); \
pimpl_ = own_pimpl_ = variant_pool::create(); \
WRAPPER_DO_INIT_(Kind); \
return THIS; \
} \
\
Kind::~Kind() { variant_pool::free(impl_cast(own_pimpl_)); }
DEFINE_WRAPPER_(variant)
DEFINE_WRAPPER_(variant_list)
DEFINE_WRAPPER_(variant_map)
// ----------------------------------------------------------------------------
// JSON (de)serialize
bool
variant_cref::json_serialize(std::string& dst) const
{
rapidjson::StringBuffer buf;
rapidjson::Writer<rapidjson::StringBuffer> writer(buf);
if (!THIS) {
writer.Null();
} else {
THIS->Accept(writer);
}
VALUE_ASSERT(writer.IsComplete(), "incomplete JSON sequence");
dst.assign(buf.GetString(), buf.GetSize());
return true;
}
bool
variant_ref::json_deserialize(std::string const& src)
{
json_document doc;
try {
doc.Parse(src.c_str());
} catch (rapidjson::ParseException const& e) {
SYSX_REPORT_ERROR(report::variant_error)
<< "JSON parsing failed: " << GetParseError_En(e.Code()) << "\n"
"\t'"
<< src << "' (offset: " << e.Offset() << ")";
return false;
}
THIS->Swap(doc);
return true;
}
} /* namespace utils */
} /* namespace sysx */
/* Taf!
* :tag: (variant,s)
*/
| 23.495356 | 80 | 0.558506 | TastiiVegas |
0b6b9455a8b5db56bed824b45b0c6fd651458f4d | 129 | cpp | C++ | Registration and Users/Source.cpp | Limitless-Rasul-Power/Registration-and-Users | 6b69942537a82dd66df7be645ec2132dbf618e38 | [
"MIT"
] | null | null | null | Registration and Users/Source.cpp | Limitless-Rasul-Power/Registration-and-Users | 6b69942537a82dd66df7be645ec2132dbf618e38 | [
"MIT"
] | null | null | null | Registration and Users/Source.cpp | Limitless-Rasul-Power/Registration-and-Users | 6b69942537a82dd66df7be645ec2132dbf618e38 | [
"MIT"
] | null | null | null | #include "System.h"
unsigned short User::id{ 0 };
int main()
{
System::Control();
system("pause");
return 0;
} | 10.75 | 30 | 0.55814 | Limitless-Rasul-Power |
0b6c790460eb54900b859e839f73275a0ead41ee | 3,298 | cpp | C++ | experimental/SkiaExamples/HelloSkiaExample.cpp | rgraebert/skia | 33a4b46e9f24be6268855478b5c895f883fb4ac5 | [
"BSD-3-Clause"
] | 1 | 2021-06-11T01:10:08.000Z | 2021-06-11T01:10:08.000Z | experimental/SkiaExamples/HelloSkiaExample.cpp | rgraebert/skia | 33a4b46e9f24be6268855478b5c895f883fb4ac5 | [
"BSD-3-Clause"
] | null | null | null | experimental/SkiaExamples/HelloSkiaExample.cpp | rgraebert/skia | 33a4b46e9f24be6268855478b5c895f883fb4ac5 | [
"BSD-3-Clause"
] | null | null | null | /*
* Copyright 2013 Google Inc.
*
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*
*/
#include "SkExample.h"
#include "SkApplication.h"
#include "SkDraw.h"
#include "SkGradientShader.h"
#include "SkGraphics.h"
#include "SkUnitMappers.h"
class HelloSkia : public SkExample {
public:
HelloSkia(SkExampleWindow* window) : SkExample(window) {
fName = "HelloSkia";
fBGColor = SK_ColorWHITE;
fRotationAngle = SkIntToScalar(0);
fWindow->setupBackend(SkExampleWindow::kGPU_DeviceType);
// Another option is software rendering:
// fWindow->setupBackend(SkExampleWindow::kRaster_DeviceType);
}
protected:
void draw(SkCanvas* canvas) {
// Clear background
canvas->drawColor(fBGColor);
SkPaint paint;
paint.setColor(SK_ColorRED);
// Draw a rectangle with blue paint
SkRect rect = {
SkIntToScalar(10), SkIntToScalar(10),
SkIntToScalar(128), SkIntToScalar(128)
};
canvas->drawRect(rect, paint);
// Set up a linear gradient and draw a circle
{
SkPoint linearPoints[] = {
{SkIntToScalar(0), SkIntToScalar(0)},
{SkIntToScalar(300), SkIntToScalar(300)}
};
SkColor linearColors[] = {SK_ColorGREEN, SK_ColorBLACK};
SkUnitMapper* linearMapper = new SkDiscreteMapper(100);
SkAutoUnref lm_deleter(linearMapper);
SkShader* shader = SkGradientShader::CreateLinear(
linearPoints, linearColors, NULL, 2,
SkShader::kMirror_TileMode, linearMapper);
SkAutoUnref shader_deleter(shader);
paint.setShader(shader);
paint.setFlags(SkPaint::kAntiAlias_Flag);
canvas->drawCircle(SkIntToScalar(200), SkIntToScalar(200),
SkIntToScalar(64), paint);
// Detach shader
paint.setShader(NULL);
}
// Draw a message with a nice black paint.
paint.setFlags(
SkPaint::kAntiAlias_Flag |
SkPaint::kSubpixelText_Flag | // ... avoid waggly text when rotating.
SkPaint::kUnderlineText_Flag);
paint.setColor(SK_ColorBLACK);
paint.setTextSize(SkIntToScalar(20));
canvas->save();
static const char message[] = "Hello Skia!!!";
// Translate and rotate
canvas->translate(SkIntToScalar(300), SkIntToScalar(300));
fRotationAngle += SkDoubleToScalar(0.2);
if (fRotationAngle > SkDoubleToScalar(360.0)) {
fRotationAngle -= SkDoubleToScalar(360.0);
}
canvas->rotate(fRotationAngle);
// Draw the text:
canvas->drawText(message, strlen(message), SkIntToScalar(0), SkIntToScalar(0), paint);
canvas->restore();
// Invalidate the window to force a redraw. Poor man's animation mechanism.
this->fWindow->inval(NULL);
}
private:
SkScalar fRotationAngle;
SkColor fBGColor;
};
static SkExample* MyFactory(SkExampleWindow* window) {
return new HelloSkia(window);
}
// Register this class as a Skia Example.
SkExample::Registry registry(MyFactory);
| 29.711712 | 94 | 0.614918 | rgraebert |
0b6d99ecba9287576888924794904cd1e6c84291 | 24,990 | cpp | C++ | tests/Widgets/ToggleButton.cpp | dmg103/TGUI | ed2ac830c399b8b579dc67493823551dbf966d63 | [
"Zlib"
] | null | null | null | tests/Widgets/ToggleButton.cpp | dmg103/TGUI | ed2ac830c399b8b579dc67493823551dbf966d63 | [
"Zlib"
] | null | null | null | tests/Widgets/ToggleButton.cpp | dmg103/TGUI | ed2ac830c399b8b579dc67493823551dbf966d63 | [
"Zlib"
] | null | null | null | /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//
// TGUI - Texus' Graphical User Interface
// Copyright (C) 2012-2022 Bruno Van de Velde ([email protected])
//
// This software is provided 'as-is', without any express or implied warranty.
// In no event will the authors be held liable for any damages arising from the use of this software.
//
// Permission is granted to anyone to use this software for any purpose,
// including commercial applications, and to alter it and redistribute it freely,
// subject to the following restrictions:
//
// 1. The origin of this software must not be misrepresented;
// you must not claim that you wrote the original software.
// If you use this software in a product, an acknowledgment
// in the product documentation would be appreciated but is not required.
//
// 2. Altered source versions must be plainly marked as such,
// and must not be misrepresented as being the original software.
//
// 3. This notice may not be removed or altered from any source distribution.
//
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
#include "Tests.hpp"
#include <TGUI/Widgets/ToggleButton.hpp>
TEST_CASE("[ToggleButton]")
{
tgui::ToggleButton::Ptr button = tgui::ToggleButton::create();
button->getRenderer()->setFont("resources/DejaVuSans.ttf");
SECTION("Signals")
{
button->onToggle([](){});
button->onToggle([](bool){});
}
SECTION("WidgetType")
{
REQUIRE(button->getWidgetType() == "ToggleButton");
}
SECTION("Position and Size")
{
button->setPosition(40, 30);
button->setSize(150, 100);
button->getRenderer()->setBorders(2);
REQUIRE(button->getPosition() == tgui::Vector2f(40, 30));
REQUIRE(button->getSize() == tgui::Vector2f(150, 100));
REQUIRE(button->getFullSize() == button->getSize());
REQUIRE(button->getWidgetOffset() == tgui::Vector2f(0, 0));
}
SECTION("Text")
{
REQUIRE(button->getText() == "");
button->setText("SomeText");
REQUIRE(button->getText() == "SomeText");
}
SECTION("Down")
{
REQUIRE(!button->isDown());
button->setDown(true);
REQUIRE(button->isDown());
button->setDown(false);
REQUIRE(!button->isDown());
}
SECTION("TextSize")
{
button->setTextSize(25);
REQUIRE(button->getTextSize() == 25);
}
SECTION("Events / Signals")
{
SECTION("ClickableWidget")
{
testClickableWidgetSignals(button);
}
// TODO: Toggled signal
}
testWidgetRenderer(button->getRenderer());
SECTION("Renderer")
{
auto renderer = button->getRenderer();
SECTION("colored")
{
SECTION("set serialized property")
{
REQUIRE_NOTHROW(renderer->setProperty("TextColor", "rgb(20, 30, 40)"));
REQUIRE_NOTHROW(renderer->setProperty("TextColorDown", "rgb(40, 50, 60)"));
REQUIRE_NOTHROW(renderer->setProperty("TextColorHover", "rgb(30, 40, 50)"));
REQUIRE_NOTHROW(renderer->setProperty("TextColorDownHover", "rgb(140, 150, 160)"));
REQUIRE_NOTHROW(renderer->setProperty("TextColorDisabled", "rgb(90, 100, 110)"));
REQUIRE_NOTHROW(renderer->setProperty("TextColorDownDisabled", "rgb(150, 160, 170)"));
REQUIRE_NOTHROW(renderer->setProperty("TextColorFocused", "rgb(160, 170, 180)"));
REQUIRE_NOTHROW(renderer->setProperty("TextColorDownFocused", "rgb(170, 180, 190)"));
REQUIRE_NOTHROW(renderer->setProperty("BackgroundColor", "rgb(50, 60, 70)"));
REQUIRE_NOTHROW(renderer->setProperty("BackgroundColorDown", "rgb(70, 80, 90)"));
REQUIRE_NOTHROW(renderer->setProperty("BackgroundColorHover", "rgb(60, 70, 80)"));
REQUIRE_NOTHROW(renderer->setProperty("BackgroundColorDownHover", "rgb(180, 190, 200)"));
REQUIRE_NOTHROW(renderer->setProperty("BackgroundColorDisabled", "rgb(100, 110, 120)"));
REQUIRE_NOTHROW(renderer->setProperty("BackgroundColorDownDisabled", "rgb(190, 200, 210)"));
REQUIRE_NOTHROW(renderer->setProperty("BackgroundColorFocused", "rgb(200, 210, 220)"));
REQUIRE_NOTHROW(renderer->setProperty("BackgroundColorDownFocused", "rgb(210, 220, 230)"));
REQUIRE_NOTHROW(renderer->setProperty("BorderColor", "rgb(80, 90, 100)"));
REQUIRE_NOTHROW(renderer->setProperty("BorderColorDown", "rgb(120, 130, 140)"));
REQUIRE_NOTHROW(renderer->setProperty("BorderColorHover", "rgb(110, 120, 130)"));
REQUIRE_NOTHROW(renderer->setProperty("BorderColorDownHover", "rgb(10, 20, 30)"));
REQUIRE_NOTHROW(renderer->setProperty("BorderColorDisabled", "rgb(130, 140, 150)"));
REQUIRE_NOTHROW(renderer->setProperty("BorderColorDownDisabled", "rgb(220, 230, 240)"));
REQUIRE_NOTHROW(renderer->setProperty("BorderColorFocused", "rgb(230, 240, 250)"));
REQUIRE_NOTHROW(renderer->setProperty("BorderColorDownFocused", "rgb(240, 250, 255)"));
REQUIRE_NOTHROW(renderer->setProperty("TextOutlineColor", "rgb(10, 20, 30)"));
REQUIRE_NOTHROW(renderer->setProperty("TextOutlineThickness", "2"));
REQUIRE_NOTHROW(renderer->setProperty("TextStyle", "Italic"));
REQUIRE_NOTHROW(renderer->setProperty("TextStyleDown", "Bold | Underlined"));
REQUIRE_NOTHROW(renderer->setProperty("TextStyleHover", "Underlined"));
REQUIRE_NOTHROW(renderer->setProperty("TextStyleDownHover", "Italic | StrikeThrough"));
REQUIRE_NOTHROW(renderer->setProperty("TextStyleDisabled", "StrikeThrough"));
REQUIRE_NOTHROW(renderer->setProperty("TextStyleDownDisabled", "Italic | Bold"));
REQUIRE_NOTHROW(renderer->setProperty("TextStyleFocused", "Bold | StrikeThrough"));
REQUIRE_NOTHROW(renderer->setProperty("TextStyleDownFocused", "Bold | Italic | Underlined | StrikeThrough"));
REQUIRE_NOTHROW(renderer->setProperty("Borders", "(1, 2, 3, 4)"));
}
SECTION("set object property")
{
REQUIRE_NOTHROW(renderer->setProperty("TextColor", tgui::Color{20, 30, 40}));
REQUIRE_NOTHROW(renderer->setProperty("TextColorDown", tgui::Color{40, 50, 60}));
REQUIRE_NOTHROW(renderer->setProperty("TextColorHover", tgui::Color{30, 40, 50}));
REQUIRE_NOTHROW(renderer->setProperty("TextColorDownHover", tgui::Color{140, 150, 160}));
REQUIRE_NOTHROW(renderer->setProperty("TextColorDisabled", tgui::Color{90, 100, 110}));
REQUIRE_NOTHROW(renderer->setProperty("TextColorDownDisabled", tgui::Color{150, 160, 170}));
REQUIRE_NOTHROW(renderer->setProperty("TextColorFocused", tgui::Color{160, 170, 180}));
REQUIRE_NOTHROW(renderer->setProperty("TextColorDownFocused", tgui::Color{170, 180, 190}));
REQUIRE_NOTHROW(renderer->setProperty("BackgroundColor", tgui::Color{50, 60, 70}));
REQUIRE_NOTHROW(renderer->setProperty("BackgroundColorDown", tgui::Color{70, 80, 90}));
REQUIRE_NOTHROW(renderer->setProperty("BackgroundColorHover", tgui::Color{60, 70, 80}));
REQUIRE_NOTHROW(renderer->setProperty("BackgroundColorDownHover", tgui::Color{180, 190, 200}));
REQUIRE_NOTHROW(renderer->setProperty("BackgroundColorDisabled", tgui::Color{100, 110, 120}));
REQUIRE_NOTHROW(renderer->setProperty("BackgroundColorDownDisabled", tgui::Color{190, 200, 210}));
REQUIRE_NOTHROW(renderer->setProperty("BackgroundColorFocused", tgui::Color{200, 210, 220}));
REQUIRE_NOTHROW(renderer->setProperty("BackgroundColorDownFocused", tgui::Color{210, 220, 230}));
REQUIRE_NOTHROW(renderer->setProperty("BorderColor", tgui::Color{80, 90, 100}));
REQUIRE_NOTHROW(renderer->setProperty("BorderColorDown", tgui::Color{120, 130, 140}));
REQUIRE_NOTHROW(renderer->setProperty("BorderColorHover", tgui::Color{110, 120, 130}));
REQUIRE_NOTHROW(renderer->setProperty("BorderColorDownHover", tgui::Color{10, 20, 30}));
REQUIRE_NOTHROW(renderer->setProperty("BorderColorDisabled", tgui::Color{130, 140, 150}));
REQUIRE_NOTHROW(renderer->setProperty("BorderColorDownDisabled", tgui::Color{220, 230, 240}));
REQUIRE_NOTHROW(renderer->setProperty("BorderColorFocused", tgui::Color{230, 240, 250}));
REQUIRE_NOTHROW(renderer->setProperty("BorderColorDownFocused", tgui::Color{240, 250, 255}));
REQUIRE_NOTHROW(renderer->setProperty("TextOutlineColor", tgui::Color{10, 20, 30}));
REQUIRE_NOTHROW(renderer->setProperty("TextOutlineThickness", 2));
REQUIRE_NOTHROW(renderer->setProperty("TextStyle", tgui::TextStyle::Italic));
REQUIRE_NOTHROW(renderer->setProperty("TextStyleDown", tgui::TextStyles(tgui::TextStyle::Bold | tgui::TextStyle::Underlined)));
REQUIRE_NOTHROW(renderer->setProperty("TextStyleHover", tgui::TextStyle::Underlined));
REQUIRE_NOTHROW(renderer->setProperty("TextStyleDownHover", tgui::TextStyles(tgui::TextStyle::Italic | tgui::TextStyle::StrikeThrough)));
REQUIRE_NOTHROW(renderer->setProperty("TextStyleDisabled", tgui::TextStyle::StrikeThrough));
REQUIRE_NOTHROW(renderer->setProperty("TextStyleDownDisabled", tgui::TextStyles(tgui::TextStyle::Italic | tgui::TextStyle::Bold)));
REQUIRE_NOTHROW(renderer->setProperty("TextStyleFocused", tgui::TextStyles(tgui::TextStyle::Bold | tgui::TextStyle::StrikeThrough)));
REQUIRE_NOTHROW(renderer->setProperty("TextStyleDownFocused", tgui::TextStyles(tgui::TextStyle::Bold |
tgui::TextStyles(tgui::TextStyle::Italic | tgui::TextStyle::Underlined | tgui::TextStyle::StrikeThrough))));
REQUIRE_NOTHROW(renderer->setProperty("Borders", tgui::Borders{1, 2, 3, 4}));
}
SECTION("functions")
{
renderer->setTextColor({20, 30, 40});
renderer->setTextColorDown({40, 50, 60});
renderer->setTextColorHover({30, 40, 50});
renderer->setTextColorDownHover({140, 150, 160});
renderer->setTextColorDisabled({90, 100, 110});
renderer->setTextColorDownDisabled({150, 160, 170});
renderer->setTextColorFocused({160, 170, 180});
renderer->setTextColorDownFocused({170, 180, 190});
renderer->setBackgroundColor({50, 60, 70});
renderer->setBackgroundColorDown({70, 80, 90});
renderer->setBackgroundColorHover({60, 70, 80});
renderer->setBackgroundColorDownHover({180, 190, 200});
renderer->setBackgroundColorDisabled({100, 110, 120});
renderer->setBackgroundColorDownDisabled({190, 200, 210});
renderer->setBackgroundColorFocused({200, 210, 220});
renderer->setBackgroundColorDownFocused({210, 220, 230});
renderer->setBorderColor({80, 90, 100});
renderer->setBorderColorDown({120, 130, 140});
renderer->setBorderColorHover({110, 120, 130});
renderer->setBorderColorDownHover({10, 20, 30});
renderer->setBorderColorDisabled({130, 140, 150});
renderer->setBorderColorDownDisabled({220, 230, 240});
renderer->setBorderColorFocused({230, 240, 250});
renderer->setBorderColorDownFocused({240, 250, 255});
renderer->setTextOutlineColor({10, 20, 30});
renderer->setTextOutlineThickness(2);
renderer->setTextStyle(tgui::TextStyle::Italic);
renderer->setTextStyleDown(tgui::TextStyle::Bold | tgui::TextStyle::Underlined);
renderer->setTextStyleHover(tgui::TextStyle::Underlined);
renderer->setTextStyleDownHover(tgui::TextStyle::Italic | tgui::TextStyle::StrikeThrough);
renderer->setTextStyleDisabled(tgui::TextStyle::StrikeThrough);
renderer->setTextStyleDownDisabled(tgui::TextStyle::Italic | tgui::TextStyle::Bold);
renderer->setTextStyleFocused(tgui::TextStyle::Bold | tgui::TextStyle::StrikeThrough);
renderer->setTextStyleDownFocused(tgui::TextStyle::Bold |
tgui::TextStyles(tgui::TextStyle::Italic | tgui::TextStyle::Underlined | tgui::TextStyle::StrikeThrough));
renderer->setBorders({1, 2, 3, 4});
}
REQUIRE(renderer->getProperty("TextColor").getColor() == tgui::Color(20, 30, 40));
REQUIRE(renderer->getProperty("TextColorDown").getColor() == tgui::Color(40, 50, 60));
REQUIRE(renderer->getProperty("TextColorHover").getColor() == tgui::Color(30, 40, 50));
REQUIRE(renderer->getProperty("TextColorDownHover").getColor() == tgui::Color(140, 150, 160));
REQUIRE(renderer->getProperty("TextColorDisabled").getColor() == tgui::Color(90, 100, 110));
REQUIRE(renderer->getProperty("TextColorDownDisabled").getColor() == tgui::Color(150, 160, 170));
REQUIRE(renderer->getProperty("TextColorFocused").getColor() == tgui::Color(160, 170, 180));
REQUIRE(renderer->getProperty("TextColorDownFocused").getColor() == tgui::Color(170, 180, 190));
REQUIRE(renderer->getProperty("BackgroundColor").getColor() == tgui::Color(50, 60, 70));
REQUIRE(renderer->getProperty("BackgroundColorDown").getColor() == tgui::Color(70, 80, 90));
REQUIRE(renderer->getProperty("BackgroundColorHover").getColor() == tgui::Color(60, 70, 80));
REQUIRE(renderer->getProperty("BackgroundColorDownHover").getColor() == tgui::Color(180, 190, 200));
REQUIRE(renderer->getProperty("BackgroundColorDisabled").getColor() == tgui::Color(100, 110, 120));
REQUIRE(renderer->getProperty("BackgroundColorDownDisabled").getColor() == tgui::Color(190, 200, 210));
REQUIRE(renderer->getProperty("BackgroundColorFocused").getColor() == tgui::Color(200, 210, 220));
REQUIRE(renderer->getProperty("BackgroundColorDownFocused").getColor() == tgui::Color(210, 220, 230));
REQUIRE(renderer->getProperty("BorderColor").getColor() == tgui::Color(80, 90, 100));
REQUIRE(renderer->getProperty("BorderColorDown").getColor() == tgui::Color(120, 130, 140));
REQUIRE(renderer->getProperty("BorderColorHover").getColor() == tgui::Color(110, 120, 130));
REQUIRE(renderer->getProperty("BorderColorDownHover").getColor() == tgui::Color(10, 20, 30));
REQUIRE(renderer->getProperty("BorderColorDisabled").getColor() == tgui::Color(130, 140, 150));
REQUIRE(renderer->getProperty("BorderColorDownDisabled").getColor() == tgui::Color(220, 230, 240));
REQUIRE(renderer->getProperty("BorderColorFocused").getColor() == tgui::Color(230, 240, 250));
REQUIRE(renderer->getProperty("BorderColorDownFocused").getColor() == tgui::Color(240, 250, 255));
REQUIRE(renderer->getProperty("TextOutlineColor").getColor() == tgui::Color(10, 20, 30));
REQUIRE(renderer->getProperty("TextOutlineThickness").getNumber() == 2);
REQUIRE(renderer->getProperty("TextStyle").getTextStyle() == tgui::TextStyle::Italic);
REQUIRE(renderer->getProperty("TextStyleDown").getTextStyle() == (tgui::TextStyle::Bold | tgui::TextStyle::Underlined));
REQUIRE(renderer->getProperty("TextStyleHover").getTextStyle() == tgui::TextStyle::Underlined);
REQUIRE(renderer->getProperty("TextStyleDownHover").getTextStyle() == (tgui::TextStyle::Italic | tgui::TextStyle::StrikeThrough));
REQUIRE(renderer->getProperty("TextStyleDisabled").getTextStyle() == tgui::TextStyle::StrikeThrough);
REQUIRE(renderer->getProperty("TextStyleDownDisabled").getTextStyle() == (tgui::TextStyle::Italic | tgui::TextStyle::Bold));
REQUIRE(renderer->getProperty("TextStyleFocused").getTextStyle() == (tgui::TextStyle::Bold | tgui::TextStyle::StrikeThrough));
REQUIRE(renderer->getProperty("TextStyleDownFocused").getTextStyle() == (tgui::TextStyle::Bold |
tgui::TextStyles(tgui::TextStyle::Italic | tgui::TextStyle::Underlined | tgui::TextStyle::StrikeThrough)));
REQUIRE(renderer->getProperty("Borders").getOutline() == tgui::Borders(1, 2, 3, 4));
REQUIRE(renderer->getTextColor() == tgui::Color(20, 30, 40));
REQUIRE(renderer->getTextColorDown() == tgui::Color(40, 50, 60));
REQUIRE(renderer->getTextColorHover() == tgui::Color(30, 40, 50));
REQUIRE(renderer->getTextColorDownHover() == tgui::Color(140, 150, 160));
REQUIRE(renderer->getTextColorDisabled() == tgui::Color(90, 100, 110));
REQUIRE(renderer->getTextColorDownDisabled() == tgui::Color(150, 160, 170));
REQUIRE(renderer->getTextColorFocused() == tgui::Color(160, 170, 180));
REQUIRE(renderer->getTextColorDownFocused() == tgui::Color(170, 180, 190));
REQUIRE(renderer->getBackgroundColor() == tgui::Color(50, 60, 70));
REQUIRE(renderer->getBackgroundColorDown() == tgui::Color(70, 80, 90));
REQUIRE(renderer->getBackgroundColorHover() == tgui::Color(60, 70, 80));
REQUIRE(renderer->getBackgroundColorDownHover() == tgui::Color(180, 190, 200));
REQUIRE(renderer->getBackgroundColorDisabled() == tgui::Color(100, 110, 120));
REQUIRE(renderer->getBackgroundColorDownDisabled() == tgui::Color(190, 200, 210));
REQUIRE(renderer->getBackgroundColorFocused() == tgui::Color(200, 210, 220));
REQUIRE(renderer->getBackgroundColorDownFocused() == tgui::Color(210, 220, 230));
REQUIRE(renderer->getBorderColor() == tgui::Color(80, 90, 100));
REQUIRE(renderer->getBorderColorDown() == tgui::Color(120, 130, 140));
REQUIRE(renderer->getBorderColorHover() == tgui::Color(110, 120, 130));
REQUIRE(renderer->getBorderColorDownHover() == tgui::Color(10, 20, 30));
REQUIRE(renderer->getBorderColorDisabled() == tgui::Color(130, 140, 150));
REQUIRE(renderer->getBorderColorDownDisabled() == tgui::Color(220, 230, 240));
REQUIRE(renderer->getBorderColorFocused() == tgui::Color(230, 240, 250));
REQUIRE(renderer->getBorderColorDownFocused() == tgui::Color(240, 250, 255));
REQUIRE(renderer->getTextOutlineColor() == tgui::Color(10, 20, 30));
REQUIRE(renderer->getTextOutlineThickness() == 2);
REQUIRE(renderer->getTextStyle() == tgui::TextStyle::Italic);
REQUIRE(renderer->getTextStyleDown() == (tgui::TextStyle::Bold | tgui::TextStyle::Underlined));
REQUIRE(renderer->getTextStyleHover() == tgui::TextStyle::Underlined);
REQUIRE(renderer->getTextStyleDownHover() == (tgui::TextStyle::Italic | tgui::TextStyle::StrikeThrough));
REQUIRE(renderer->getTextStyleDisabled() == tgui::TextStyle::StrikeThrough);
REQUIRE(renderer->getTextStyleDownDisabled() == (tgui::TextStyle::Italic | tgui::TextStyle::Bold));
REQUIRE(renderer->getTextStyleFocused() == (tgui::TextStyle::Bold | tgui::TextStyle::StrikeThrough));
REQUIRE(renderer->getTextStyleDownFocused() == (tgui::TextStyle::Bold |
tgui::TextStyles(tgui::TextStyle::Italic | tgui::TextStyle::Underlined | tgui::TextStyle::StrikeThrough)));
REQUIRE(renderer->getBorders() == tgui::Borders(1, 2, 3, 4));
}
SECTION("textured")
{
tgui::Texture textureNormal("resources/Texture1.png");
tgui::Texture textureDown("resources/Texture2.png");
tgui::Texture textureHover("resources/Texture3.png");
tgui::Texture textureDownHover("resources/Texture4.png");
tgui::Texture textureDisabled("resources/Texture5.png");
tgui::Texture textureDownDisabled("resources/Texture6.png");
tgui::Texture textureFocused("resources/Texture7.png");
tgui::Texture textureDownFocused("resources/Texture8.png");
SECTION("set serialized property")
{
REQUIRE_NOTHROW(renderer->setProperty("Texture", tgui::Serializer::serialize(textureNormal)));
REQUIRE_NOTHROW(renderer->setProperty("TextureDown", tgui::Serializer::serialize(textureDown)));
REQUIRE_NOTHROW(renderer->setProperty("TextureHover", tgui::Serializer::serialize(textureHover)));
REQUIRE_NOTHROW(renderer->setProperty("TextureDownHover", tgui::Serializer::serialize(textureDownHover)));
REQUIRE_NOTHROW(renderer->setProperty("TextureDisabled", tgui::Serializer::serialize(textureDisabled)));
REQUIRE_NOTHROW(renderer->setProperty("TextureDownDisabled", tgui::Serializer::serialize(textureDownDisabled)));
REQUIRE_NOTHROW(renderer->setProperty("TextureFocused", tgui::Serializer::serialize(textureFocused)));
REQUIRE_NOTHROW(renderer->setProperty("TextureDownFocused", tgui::Serializer::serialize(textureDownFocused)));
}
SECTION("set object property")
{
REQUIRE_NOTHROW(renderer->setProperty("Texture", textureNormal));
REQUIRE_NOTHROW(renderer->setProperty("TextureDown", textureDown));
REQUIRE_NOTHROW(renderer->setProperty("TextureHover", textureHover));
REQUIRE_NOTHROW(renderer->setProperty("TextureDownHover", textureDownHover));
REQUIRE_NOTHROW(renderer->setProperty("TextureDisabled", textureDisabled));
REQUIRE_NOTHROW(renderer->setProperty("TextureDownDisabled", textureDownDisabled));
REQUIRE_NOTHROW(renderer->setProperty("TextureFocused", textureFocused));
REQUIRE_NOTHROW(renderer->setProperty("TextureDownFocused", textureDownFocused));
}
SECTION("functions")
{
renderer->setTexture(textureNormal);
renderer->setTextureDown(textureDown);
renderer->setTextureHover(textureHover);
renderer->setTextureDownHover(textureDownHover);
renderer->setTextureDisabled(textureDisabled);
renderer->setTextureDownDisabled(textureDownDisabled);
renderer->setTextureFocused(textureFocused);
renderer->setTextureDownFocused(textureDownFocused);
}
REQUIRE(renderer->getProperty("Texture").getTexture().getData() != nullptr);
REQUIRE(renderer->getProperty("TextureDown").getTexture().getData() != nullptr);
REQUIRE(renderer->getProperty("TextureHover").getTexture().getData() != nullptr);
REQUIRE(renderer->getProperty("TextureDownHover").getTexture().getData() != nullptr);
REQUIRE(renderer->getProperty("TextureDisabled").getTexture().getData() != nullptr);
REQUIRE(renderer->getProperty("TextureDownDisabled").getTexture().getData() != nullptr);
REQUIRE(renderer->getProperty("TextureFocused").getTexture().getData() != nullptr);
REQUIRE(renderer->getProperty("TextureDownFocused").getTexture().getData() != nullptr);
REQUIRE(renderer->getTexture().getData() == textureNormal.getData());
REQUIRE(renderer->getTextureDown().getData() == textureDown.getData());
REQUIRE(renderer->getTextureHover().getData() == textureHover.getData());
REQUIRE(renderer->getTextureDownHover().getData() == textureDownHover.getData());
REQUIRE(renderer->getTextureDisabled().getData() == textureDisabled.getData());
REQUIRE(renderer->getTextureDownDisabled().getData() == textureDownDisabled.getData());
REQUIRE(renderer->getTextureFocused().getData() == textureFocused.getData());
REQUIRE(renderer->getTextureDownFocused().getData() == textureDownFocused.getData());
}
}
SECTION("Saving and loading from file")
{
button->setText(U"SomeText \u2190");
button->setTextSize(25);
button->setDown(true);
testSavingWidget("ToggleButton", button, false);
}
// TODO: Draw tests
}
| 68.092643 | 153 | 0.634654 | dmg103 |
0b6eb4cbbf42195b869375dac3586e6cc8046bde | 5,197 | hpp | C++ | Cons/tacka.hpp | matfija/GeoPaint | e4607221fb1c413619312cd0e7eebb679842e20f | [
"MIT"
] | null | null | null | Cons/tacka.hpp | matfija/GeoPaint | e4607221fb1c413619312cd0e7eebb679842e20f | [
"MIT"
] | null | null | null | Cons/tacka.hpp | matfija/GeoPaint | e4607221fb1c413619312cd0e7eebb679842e20f | [
"MIT"
] | 1 | 2020-01-27T23:00:31.000Z | 2020-01-27T23:00:31.000Z | #ifndef TACKA_HPP
#define TACKA_HPP
#include "geom.hpp"
// Imenski prostor za geometriju
namespace geom {
// Tacka afine ravni; dekorisana u smislu
// da implementira potpuno uredjenje
class tacka : public util::total_order<tacka>
{
public:
// Konstruktor bez argumenata
tacka();
// Destruktor; ne radi nista jer
// klasa nema dinamickih objekata
~tacka() = default;
// Konstruktor kopije; uzima se podrazumevani
// sablon zasnovan na idiomu zamene (copy-swap)
tacka(const tacka&) = default;
// Konstruktor kopije sa semantikom pomeranja;
// uzima se podrazumevani sablon pomeranja (move)
tacka(tacka&&) noexcept = default;
// Konstruktori od brojeva
tacka(const Element, const Element);
tacka(const Element, const Element, const Element);
// Konstruktori od vektora
tacka(const Matrica&);
tacka(Matrica&&);
tacka(const Vektor&);
tacka(Vektor&&);
// Dohvatac za vektor
const Vektor& mat() const;
// Dohvatac za velicinu
Velicina size() const;
// Dohvatac za toleranciju
Element tol() const;
// Kolekcijski metodi
auto begin() const noexcept;
auto cbegin() const noexcept;
auto end() const noexcept;
auto cend() const noexcept;
// Pretvaranje tacke u nisku
std::string str() const;
// Primena transformacije na tacku
void primeni(const geom&);
// Unarna potvrda
tacka operator+() const;
// Operator sabiranja
tacka operator+(const tacka&) const;
// Sabiranje sa numerickom vrednoscu
tacka operator+(const double) const;
// Operator sabiranja sa dodelom
tacka& operator+=(const tacka&);
// Sabiranje sa numerickom vrednoscu sa dodelom
tacka& operator+=(const double);
// Unarna negacija
tacka operator-() const;
// Operator oduzimanja
tacka operator-(const tacka&) const;
// Oduzimanje numericke vrednosti
tacka operator-(const double) const;
// Operator oduzimanja sa dodelom
tacka& operator-=(const tacka&);
// Oduzimanje numericke vrednosti sa dodelom
tacka& operator-=(const double);
// Mnozenje numerickom vrednoscu
tacka operator*(const double) const;
// Mnozenje numerickom vrednoscu sa dodelom
tacka& operator*=(const double);
// Deljenje numerickom vrednoscu
tacka operator/(const double) const;
// Deljenje numerickom vrednoscu sa dodelom
tacka& operator/=(const double);
// Operator jednakosti
bool operator==(const tacka&) const;
// Operator poretka
bool operator<(const tacka&) const;
// Operator dodele; podrazumevani
// sablon idioma zamene (copy-swap)
tacka& operator=(const tacka&) = default;
// Operator dodele sa semantikom pomeranja;
// podrazumevani sablon pomeranja (move)
tacka& operator=(tacka&&) noexcept = default;
// Operatori dodele vektora
tacka& operator=(const Matrica&);
tacka& operator=(Matrica&&);
tacka& operator=(const Vektor&);
tacka& operator=(Vektor&&);
// Operator indeksiranja za dohvatanje; eksplicitno
// oznacen da se ne sme odbaciti, kako bi se dodatno
// istaklo da je iskljucivo za dohvatanje, ne izmenu
[[nodiscard]]
const Element& operator[](const Velicina) const;
// Struktura koja sluzi za citanje
// toka razdvojenog zapetama
struct Citac{
// Objekat citaca
tacka& t;
// Indeks citaca
Velicina i;
// Konstruktor
Citac(tacka&, Velicina);
// Zapeta za upis
Citac operator,(const Element) const;
};
// Pocetni upis
Citac operator<<(const Element);
private:
// Provera korektnosti tacke
void proveri();
// Provera korektnosti matrice
void proverim(const Matrica&);
// Tacka u ravni predstavljena je homogenim
// vektorom duzine tri, a podrazumevano je
// u pitanju koordinatni pocetak; nije const
// zbog mogucnosti pomeranja (move)
Vektor _mat;
// Vektor je fiksne velicine,
// ali slicno nije const
Velicina _size = 3;
// Tolerancija u slucaju greske u racunu;
// nije const iz istog razloga kao dosad
Element _tol = 1e-5;
// Operator citanja sa ulaznog toka; mora
// prijateljski kako bi pristupao vektoru
friend std::istream& operator>>(std::istream&, tacka&);
};
// Operator ispisa na izlazni tok
std::ostream& operator<<(std::ostream&, const tacka&);
// Operator citanja sa ulaznog toka
std::istream& operator>>(std::istream&, tacka&);
// Operator za mnozenje matrice i tacke
tacka operator*(const geom&, const tacka&);
// Operator za sabiranje sa numerickom vrednoscu
tacka operator+(const double, const tacka&);
// Operator za oduzimanje numericke vrednosti
tacka operator-(const double, const tacka&);
// Operator za mnozenje numerickom vrednoscu
tacka operator*(const double, const tacka&);
// Operator za deljenje numerickom vrednoscu
tacka operator/(const double, const tacka&);
}
#endif // TACKA_HPP
| 26.380711 | 60 | 0.650183 | matfija |
0b6f6ef579c4be171e6a69c243a896cb1c743d19 | 4,702 | cpp | C++ | coding_exercise/btree_inorder_traversal.cpp | devastating/misc | f9922e14a9305808e668d8412b7a2443a7f45a0d | [
"MIT"
] | null | null | null | coding_exercise/btree_inorder_traversal.cpp | devastating/misc | f9922e14a9305808e668d8412b7a2443a7f45a0d | [
"MIT"
] | null | null | null | coding_exercise/btree_inorder_traversal.cpp | devastating/misc | f9922e14a9305808e668d8412b7a2443a7f45a0d | [
"MIT"
] | null | null | null | #include "basic_includes.hpp"
using namespace std;
/**
* Definition for a binary tree node.
*/
struct TreeNode {
int val;
TreeNode *left;
TreeNode *right;
TreeNode(int x) : val(x), left(NULL), right(NULL) {}
};
class binary_tree
{
public:
binary_tree(string serialized_str)
{
vector<string> tree_nodes;
tree_str_preprocessor(serialized_str, tree_nodes);
m_root = construct_tree(tree_nodes);
}
string deserialize_to_str()
{
list<TreeNode *> que;
string res;
stringstream ss;
que.push_back(m_root);
while (que.empty() != true)
{
auto node = que.front();
que.pop_front();
if (node != nullptr)
{
ss << node->val << "|";
}
else
{
ss << "#|";
}
if (node)
{
que.push_back(node->left);
que.push_back(node->right);
}
}
return ss.str();
}
private:
TreeNode *m_root = nullptr;
void tree_str_preprocessor(string serialized_str, vector<string> &out)
{
int idx = 0;
while (idx < serialized_str.length())
{
int stop_idx = serialized_str.find('|', idx);
if (stop_idx == string::npos) break;
out.push_back(serialized_str.substr(idx, stop_idx - idx));
idx = stop_idx + 1;
if (idx == serialized_str.length()) break;
}
}
public:
static TreeNode *construct_tree(vector<string> nodes)
{
stringstream ss(nodes[0]);
int root_val;
ss >> root_val;
auto root = new TreeNode(root_val);
list<TreeNode *> que;;
int iter = 0;
auto prev_node = root;
for (int i = 1; i < nodes.size(); i++)
{
iter++;
TreeNode *new_node = nullptr;
if (nodes[i] != "#")
{
stringstream ss(nodes[i]);
int new_val; ss >> new_val;
new_node = new TreeNode(new_val);
que.push_back(new_node);
}
if (iter == 1)
{
prev_node->left = new_node;
}
else if (iter == 2)
{
prev_node->right = new_node;
if (que.empty() == true)
{
assert(i == (nodes.size() - 1));
break;
}
prev_node = que.front();
que.pop_front();
iter = 0;
}
}
return root;
}
};
class Solution {
public:
vector<int> inorderTraversal(TreeNode* root)
{
list<TreeNode *> stack;
vector<int> res;
auto left_node = root;
while (left_node)
{
stack.push_back(left_node);
left_node = left_node->left;
}
// Begin process
while (stack.empty() != true)
{
auto stack_top = stack.back(); stack.pop_back();
res.push_back(stack_top->val);
if (stack_top->right)
{
auto left_node = stack_top->right;
while (left_node)
{
stack.push_back(left_node);
left_node = left_node->left;
}
}
}
return res;
}
};
void test(vector<int> &tree_values)
{
vector<string> tree_token;
for (auto tree_val: tree_values)
{
if (tree_val == INT_MAX)
{
tree_token.push_back("#");
continue;
}
stringstream ss; ss << tree_val;
tree_token.push_back(ss.str());
}
print_vector<string>(tree_token);
auto root = binary_tree::construct_tree(tree_token);
Solution sol;
auto res = sol.inorderTraversal(root);
print_vector<int>(res, "output");
}
int main()
{
vector<int> tree_val;
tree_val = {1,-2,-3,1,3,-2,INT_MAX,-1};
test(tree_val);
tree_val = {1,INT_MAX,2,3};
test(tree_val);
tree_val = {1,2,3};
test(tree_val);
tree_val = {-2,1};
test(tree_val);
return 0;
}
| 27.179191 | 78 | 0.429817 | devastating |
0b73ef4c0b58ef231128dea109d7ede39bb9ffbb | 4,943 | cc | C++ | src/core/fsnotify.cc | liubangchen/seastar | 5bf108406ae79a5f30383bf8e498dd9d4b51d1a5 | [
"Apache-2.0"
] | 6,526 | 2015-09-22T16:47:59.000Z | 2022-03-31T07:31:07.000Z | src/core/fsnotify.cc | liubangchen/seastar | 5bf108406ae79a5f30383bf8e498dd9d4b51d1a5 | [
"Apache-2.0"
] | 925 | 2015-09-23T13:52:53.000Z | 2022-03-31T21:33:25.000Z | src/core/fsnotify.cc | liubangchen/seastar | 5bf108406ae79a5f30383bf8e498dd9d4b51d1a5 | [
"Apache-2.0"
] | 1,473 | 2015-09-22T23:19:04.000Z | 2022-03-31T21:09:00.000Z | /*
* This file is open source software, licensed to you under the terms
* of the Apache License, Version 2.0 (the "License"). See the NOTICE file
* distributed with this work for additional information regarding copyright
* ownership. 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.
*/
/*
* Copyright 2020 ScyllaDB Ltd.
*/
#include <seastar/core/internal/pollable_fd.hh>
#include <seastar/core/posix.hh>
#include <seastar/core/reactor.hh>
#include "fsnotify.hh"
class seastar::fsnotifier::impl : public enable_shared_from_this<impl> {
class my_poll_fd : public pollable_fd {
public:
using pollable_fd::pollable_fd;
using pollable_fd::get_fd;
operator int() const {
return get_fd();
}
};
my_poll_fd _fd;
watch_token _close_dummy = -1;
public:
impl()
: _fd(file_desc::inotify_init(IN_NONBLOCK | IN_CLOEXEC))
{}
void remove_watch(watch_token);
future<watch_token> create_watch(const sstring& path, flags events);
future<std::vector<event>> wait();
void shutdown();
bool active() const {
return bool(_fd);
}
};
void seastar::fsnotifier::impl::remove_watch(watch_token token) {
if (active()) {
auto res = ::inotify_rm_watch(_fd, token);
// throw if any other error than EINVAL.
throw_system_error_on(res == -1 && errno != EINVAL, "could not remove inotify watch");
}
}
seastar::future<seastar::fsnotifier::watch_token> seastar::fsnotifier::impl::create_watch(const sstring& path, flags events) {
if (!active()) {
throw std::runtime_error("attempting to use closed notifier");
}
return engine().inotify_add_watch(_fd, path, uint32_t(events));
}
seastar::future<std::vector<seastar::fsnotifier::event>> seastar::fsnotifier::impl::wait() {
// be paranoid about buffer alignment
auto buf = temporary_buffer<char>::aligned(std::max(alignof(::inotify_event), alignof(int64_t)), 4096);
auto f = _fd.read_some(buf.get_write(), buf.size());
return f.then([me = shared_from_this(), buf = std::move(buf)](size_t n) {
auto p = buf.get();
auto e = buf.get() + n;
std::vector<event> events;
while (p < e) {
auto ev = reinterpret_cast<const ::inotify_event*>(p);
if (ev->wd == me->_close_dummy && me->_close_dummy != -1) {
me->_fd.close();
} else {
events.emplace_back(event {
ev->wd, flags(ev->mask), ev->cookie,
ev->len != 0 ? sstring(ev->name) : sstring{}
});
}
p += sizeof(::inotify_event) + ev->len;
}
return events;
});
}
void seastar::fsnotifier::impl::shutdown() {
// reactor does not yet have
// any means of "shutting down" a non-socket read,
// so we work around this by creating a watch for something ubiquitous,
// then removing the watch while adding a mark.
// This will cause any event waiter to wake up, but ignore the event for our
// dummy.
(void)create_watch("/", flags::delete_self).then([me = shared_from_this()](watch_token t) {
me->_close_dummy = t;
me->remove_watch(t);
});
}
seastar::fsnotifier::watch::~watch() {
if (_impl) {
_impl->remove_watch(_token);
}
}
seastar::fsnotifier::watch::watch(watch&&) noexcept = default;
seastar::fsnotifier::watch& seastar::fsnotifier::watch::operator=(watch&&) noexcept = default;
seastar::fsnotifier::watch_token seastar::fsnotifier::watch::release() {
_impl = {};
return _token;
}
seastar::fsnotifier::watch::watch(shared_ptr<impl> impl, watch_token token)
: _token(token)
, _impl(std::move(impl))
{}
seastar::fsnotifier::fsnotifier()
: _impl(make_shared<impl>())
{}
seastar::fsnotifier::~fsnotifier() = default;
seastar::fsnotifier::fsnotifier(fsnotifier&&) = default;
seastar::fsnotifier& seastar::fsnotifier::operator=(fsnotifier&&) = default;
seastar::future<seastar::fsnotifier::watch> seastar::fsnotifier::create_watch(const sstring& path, flags events) {
return _impl->create_watch(path, events).then([this](watch_token token) {
return watch(_impl, token);
});
}
seastar::future<std::vector<seastar::fsnotifier::event>> seastar::fsnotifier::wait() const {
return _impl->wait();
}
void seastar::fsnotifier::shutdown() {
_impl->shutdown();
}
bool seastar::fsnotifier::active() const {
return _impl->active();
}
| 32.519737 | 126 | 0.648594 | liubangchen |
0b74dd292c4a698a2353155ce514f1e5fbc6d6a7 | 3,715 | cpp | C++ | EfEfNet/Code/efefGeneral.cpp | Paideieitor/EfEfNet-Library | ad1d9c20c5d06d74785dcf9d93947d00c19f44f7 | [
"MIT"
] | null | null | null | EfEfNet/Code/efefGeneral.cpp | Paideieitor/EfEfNet-Library | ad1d9c20c5d06d74785dcf9d93947d00c19f44f7 | [
"MIT"
] | null | null | null | EfEfNet/Code/efefGeneral.cpp | Paideieitor/EfEfNet-Library | ad1d9c20c5d06d74785dcf9d93947d00c19f44f7 | [
"MIT"
] | null | null | null | #include "efefGeneral.h"
#include "efefPrivateGlobals.h"
#include "efefManager.h"
int efef::Init()
{
WORD version = MAKEWORD(2, 2);
WSADATA data;
if (WSAStartup(version, &data) == SOCKET_ERROR)
return efef::DebugError("Start Up Error");
if (data.wVersion != version)
{
if (WSACleanup() == SOCKET_ERROR)
return efef::DebugError("Version Clean Up Error");
return efef::DebugError("Version Error");
}
if (efef::manager::inst == nullptr)
efef::manager::inst = new manager();
return EFEF_NO_ERROR;
}
int efef::CleanUp()
{
if (WSACleanup() == SOCKET_ERROR)
return efef::DebugError("Clean Up Error");
delete efef::manager::inst;
efef::manager::inst = nullptr;
return EFEF_NO_ERROR;
}
int efef::GetLastError()
{
return WSAGetLastError();
}
efef::udp_socket efef::CreateUDPSocket(address_family family)
{
int af = 0;
switch (family)
{
case efef::IPv4:
af = AF_INET;
break;
case efef::IPv6:
af = AF_INET6;
break;
}
SOCKET newSocket = socket(af, SOCK_DGRAM, IPPROTO_UDP);
if (newSocket == INVALID_SOCKET)
return efef::DebugError("Create UDP Socket Error");
return udp_socket((uint)newSocket);
}
efef::tcp_socket efef::CreateTCPSocket(address_family family)
{
int af = 0;
switch (family)
{
case efef::IPv4:
af = AF_INET;
break;
case efef::IPv6:
af = AF_INET6;
break;
}
SOCKET newSocket = socket(af, SOCK_STREAM, IPPROTO_TCP);
if (newSocket == INVALID_SOCKET)
return efef::DebugError("Create TCP Socket Error");
return tcp_socket((uint)newSocket);
}
efef::fast_socket efef::CreateFastSocket(address_family family)
{
int af = 0;
switch (family)
{
case efef::IPv4:
af = AF_INET;
break;
case efef::IPv6:
af = AF_INET6;
break;
}
SOCKET newSocket = socket(af, SOCK_DGRAM, IPPROTO_UDP);
if (newSocket == INVALID_SOCKET)
return efef::DebugError("Create Fast Socket Error");
return fast_socket((uint)newSocket);
}
efef::fast_socket* efef::CreateDynmcFastSocket(address_family family)
{
int af = 0;
switch (family)
{
case efef::IPv4:
af = AF_INET;
break;
case efef::IPv6:
af = AF_INET6;
break;
}
SOCKET newSocket = socket(af, SOCK_DGRAM, IPPROTO_UDP);
if (newSocket == INVALID_SOCKET)
{
efef::DebugError("Create Fast Socket Error");
return nullptr;
}
return new fast_socket((uint)newSocket);
}
int efef::Poll(udp_socket* const socket, select_mode mode, long millisec)
{
udp_set set;
set.add(socket);
int error = priv_util::Select(&set, mode, millisec);
if (error < 0)
return EFEF_ERROR;
return set.size();
}
int efef::Select(udp_set* const sockets, select_mode mode, long millisec)
{
return priv_util::Select(sockets, mode, millisec);
}
int efef::Select(udp_set* const receive, udp_set* const send, udp_set* const except, long millisec)
{
return priv_util::Select(receive, send, except, millisec);
}
int efef::Poll(tcp_socket* const socket, select_mode mode, long millisec)
{
tcp_set set;
set.add(socket);
int error = priv_util::Select(&set, mode, millisec);
if (error != 0)
return EFEF_ERROR;
return set.size();
}
int efef::Select(tcp_set* const sockets, select_mode mode, long millisec)
{
return priv_util::Select(sockets, mode, millisec);
}
int efef::Select(tcp_set* const receive, tcp_set* const send, tcp_set* const except, long millisec)
{
return priv_util::Select(receive, send, except, millisec);
}
| 21.725146 | 99 | 0.635262 | Paideieitor |
0b8a34a3df4e179bfb6f7d524b16e1e2e6bd11c3 | 810 | cpp | C++ | Leetcode/Arrays/replace-elements-with-greatest-element-on-right-side.cpp | susantabiswas/competitive_coding | 49163ecdc81b68f5c1bd90988cc0dfac34ad5a31 | [
"MIT"
] | 2 | 2021-04-29T14:44:17.000Z | 2021-10-01T17:33:22.000Z | Leetcode/Arrays/replace-elements-with-greatest-element-on-right-side.cpp | adibyte95/competitive_coding | a6f084d71644606c21840875bad78d99f678a89d | [
"MIT"
] | null | null | null | Leetcode/Arrays/replace-elements-with-greatest-element-on-right-side.cpp | adibyte95/competitive_coding | a6f084d71644606c21840875bad78d99f678a89d | [
"MIT"
] | 1 | 2021-10-01T17:33:29.000Z | 2021-10-01T17:33:29.000Z | /*
https://leetcode.com/problems/replace-elements-with-greatest-element-on-right-side/submissions/
Start traversing from 2nd last element, write the max element seen so far there and check if the current
element is greater than max seen so far, if yes update that for next (i-1)th index
TC: O(N)
*/
class Solution {
public:
vector<int> replaceElements(vector<int>& arr) {
const int N = arr.size();
vector<int> result(N, -1);
// initial value for max right will be last element
int max_so_far = arr[arr.size() - 1];
for(int i = arr.size() - 2; i >= 0; i--) {
result[i] = max_so_far;
// update max
max_so_far = max(max_so_far, arr[i]);
}
return result;
}
};
| 30 | 108 | 0.576543 | susantabiswas |
0b8ba7ce05280c0b2caf323dda81dd6a8df384ed | 51,937 | cpp | C++ | unit_tests/source/XDateTupleTest.cpp | MultiSight/multisight-xsdk | 02268e1aeb1313cfb2f9515d08d131a4389e49f2 | [
"BSL-1.0"
] | null | null | null | unit_tests/source/XDateTupleTest.cpp | MultiSight/multisight-xsdk | 02268e1aeb1313cfb2f9515d08d131a4389e49f2 | [
"BSL-1.0"
] | null | null | null | unit_tests/source/XDateTupleTest.cpp | MultiSight/multisight-xsdk | 02268e1aeb1313cfb2f9515d08d131a4389e49f2 | [
"BSL-1.0"
] | null | null | null |
#include "XDateTupleTest.h"
#include <vector>
using namespace std;
using namespace XSDK;
REGISTER_TEST_FIXTURE(XDateTupleTest);
REGISTER_TEST_FIXTURE(XTimeTupleTest);
void XDateTupleTest::TestConstructor()
{
UT_ASSERT(XDateTuple(1) == XDateTuple(1, 1, 1));
UT_ASSERT(XDateTuple(2) == XDateTuple(1, 1, 2));
UT_ASSERT(XDateTuple(32) == XDateTuple(1, 2, 1));
UT_ASSERT(XDateTuple(365) == XDateTuple(1, 12, 31));
UT_ASSERT(XDateTuple(366) == XDateTuple(2, 1, 1));
UT_ASSERT(XDateTuple(731) == XDateTuple(3, 1, 1));
UT_ASSERT(XDateTuple(1096) == XDateTuple(4, 1, 1));
UT_ASSERT(XDateTuple(1097) == XDateTuple(4, 1, 2));
UT_ASSERT(XDateTuple(1460) == XDateTuple(4, 12, 30));
UT_ASSERT(XDateTuple(1461) == XDateTuple(4, 12, 31));
UT_ASSERT(XDateTuple(1462) == XDateTuple(5, 1, 1));
UT_ASSERT(XDateTuple(584023) == XDateTuple(1600, 1, 1));
UT_ASSERT(XDateTuple(584389) == XDateTuple(1601, 1, 1));
UT_ASSERT(XDateTuple(693596) == XDateTuple(1900, 1, 1));
UT_ASSERT(XDateTuple(693961) == XDateTuple(1901, 1, 1));
UT_ASSERT(XDateTuple(729755) == XDateTuple(1999, 1, 1));
UT_ASSERT(XDateTuple(730120) == XDateTuple(2000, 1, 1));
UT_ASSERT(XDateTuple(730121) == XDateTuple(2000, 1, 2));
UT_ASSERT(XDateTuple(730484) == XDateTuple(2000, 12, 30));
UT_ASSERT(XDateTuple(730485) == XDateTuple(2000, 12, 31));
UT_ASSERT(XDateTuple(730486) == XDateTuple(2001, 1, 1));
UT_ASSERT(XDateTuple(733773) == XDateTuple(2010, 1, 1));
UT_ASSERT(XDateTuple(733774) == XDateTuple(2010, 1, 2));
UT_ASSERT(XDateTuple(733803) == XDateTuple(2010, 1, 31));
UT_ASSERT(XDateTuple(733804) == XDateTuple(2010, 2, 1));
UT_ASSERT(XDateTuple(733831) == XDateTuple(2010, 2, 28));
UT_ASSERT(XDateTuple(733832) == XDateTuple(2010, 3, 1));
UT_ASSERT(XDateTuple(733862) == XDateTuple(2010, 3, 31));
UT_ASSERT(XDateTuple(733863) == XDateTuple(2010, 4, 1));
UT_ASSERT(XDateTuple(733892) == XDateTuple(2010, 4, 30));
UT_ASSERT(XDateTuple(733893) == XDateTuple(2010, 5, 1));
UT_ASSERT(XDateTuple(733923) == XDateTuple(2010, 5, 31));
UT_ASSERT(XDateTuple(733924) == XDateTuple(2010, 6, 1));
UT_ASSERT(XDateTuple(733953) == XDateTuple(2010, 6, 30));
UT_ASSERT(XDateTuple(733954) == XDateTuple(2010, 7, 1));
UT_ASSERT(XDateTuple(733984) == XDateTuple(2010, 7, 31));
UT_ASSERT(XDateTuple(733985) == XDateTuple(2010, 8, 1));
UT_ASSERT(XDateTuple(734015) == XDateTuple(2010, 8, 31));
UT_ASSERT(XDateTuple(734016) == XDateTuple(2010, 9, 1));
UT_ASSERT(XDateTuple(734045) == XDateTuple(2010, 9, 30));
UT_ASSERT(XDateTuple(734046) == XDateTuple(2010, 10, 1));
UT_ASSERT(XDateTuple(734076) == XDateTuple(2010, 10, 31));
UT_ASSERT(XDateTuple(734077) == XDateTuple(2010, 11, 1));
UT_ASSERT(XDateTuple(734106) == XDateTuple(2010, 11, 30));
UT_ASSERT(XDateTuple(734107) == XDateTuple(2010, 12, 1));
UT_ASSERT(XDateTuple(734136) == XDateTuple(2010, 12, 30));
UT_ASSERT(XDateTuple(734137) == XDateTuple(2010, 12, 31));
UT_ASSERT(XDateTuple(734169) == XDateTuple(2011, 2, 1));
UT_ASSERT(XDateTuple(734196) == XDateTuple(2011, 2, 28));
UT_ASSERT(XDateTuple(734197) == XDateTuple(2011, 3, 1));
UT_ASSERT(XDateTuple(734534) == XDateTuple(2012, 2, 1));
UT_ASSERT(XDateTuple(734561) == XDateTuple(2012, 2, 28));
UT_ASSERT(XDateTuple(734562) == XDateTuple(2012, 2, 29));
UT_ASSERT(XDateTuple(734563) == XDateTuple(2012, 3, 1));
UT_ASSERT_THROWS(XDateTuple(-1, 1, 1), XSDK::XException);
UT_ASSERT_THROWS(XDateTuple(0, 1, 1), XSDK::XException);
UT_ASSERT_THROWS(XDateTuple(1900, 2, 29), XSDK::XException);
UT_ASSERT_THROWS(XDateTuple(1999, 2, 29), XSDK::XException);
}
void XDateTupleTest::TestEquality()
{
vector<XDateTuple> dates;
dates.push_back(XDateTuple());
dates.push_back(XDateTuple(1, 1, 2));
dates.push_back(XDateTuple(1, 2, 1));
dates.push_back(XDateTuple(1, 2, 2));
dates.push_back(XDateTuple(2, 1, 1));
dates.push_back(XDateTuple(2, 2, 1));
dates.push_back(XDateTuple(2, 1, 2));
dates.push_back(XDateTuple(2, 2, 2));
dates.push_back(XDateTuple(1999, 7, 6));
dates.push_back(XDateTuple(2012, 12, 21));
for(size_t i = 0; i < dates.size(); ++i)
{
for(size_t j = 0; i < dates.size(); ++i)
{
try
{
if(i == j)
{
UT_ASSERT(dates[i] == dates[j]);
UT_ASSERT(!(dates[i] != dates[j]));
UT_ASSERT(!(dates[i] < dates[j]));
UT_ASSERT(dates[i] <= dates[j]);
UT_ASSERT(dates[i] >= dates[j]);
UT_ASSERT(!(dates[i] > dates[j]));
}
else
{
UT_ASSERT(!(dates[i] == dates[j]));
UT_ASSERT(dates[i] != dates[j]);
if(i < j)
{
UT_ASSERT(dates[i] < dates[j]);
UT_ASSERT(dates[i] <= dates[j]);
}
else if(i > j)
{
UT_ASSERT(dates[i] >= dates[j]);
UT_ASSERT(dates[i] > dates[j]);
}
}
}
catch(...)
{
printf("lhs [%s], rhs [%s]\n", dates[i].ToISOExtString().c_str(), dates[j].ToISOExtString().c_str());
throw;
}
}
}
}
void XDateTupleTest::TestDayOfGregorianCal()
{
UT_ASSERT(XDateTuple(1, 1, 1).DayOfGregorianCal() == 1);
UT_ASSERT(XDateTuple(1, 1, 2).DayOfGregorianCal() == 2);
UT_ASSERT(XDateTuple(1, 2, 1).DayOfGregorianCal() == 32);
UT_ASSERT(XDateTuple(2, 1, 1).DayOfGregorianCal() == 366);
UT_ASSERT(XDateTuple(1945, 11, 12).DayOfGregorianCal() == 710347);
UT_ASSERT(XDateTuple(1999, 1, 1).DayOfGregorianCal() == 729755);
UT_ASSERT(XDateTuple(2000, 1, 1).DayOfGregorianCal() == 730120);
UT_ASSERT(XDateTuple(2001, 1, 1).DayOfGregorianCal() == 730486);
UT_ASSERT(XDateTuple(2010, 1, 1).DayOfGregorianCal() == 733773);
UT_ASSERT(XDateTuple(2010, 1, 31).DayOfGregorianCal() == 733803);
UT_ASSERT(XDateTuple(2010, 2, 1).DayOfGregorianCal() == 733804);
UT_ASSERT(XDateTuple(2010, 2, 28).DayOfGregorianCal() == 733831);
UT_ASSERT(XDateTuple(2010, 3, 1).DayOfGregorianCal() == 733832);
UT_ASSERT(XDateTuple(2010, 3, 31).DayOfGregorianCal() == 733862);
UT_ASSERT(XDateTuple(2010, 4, 1).DayOfGregorianCal() == 733863);
UT_ASSERT(XDateTuple(2010, 4, 30).DayOfGregorianCal() == 733892);
UT_ASSERT(XDateTuple(2010, 5, 1).DayOfGregorianCal() == 733893);
UT_ASSERT(XDateTuple(2010, 5, 31).DayOfGregorianCal() == 733923);
UT_ASSERT(XDateTuple(2010, 6, 1).DayOfGregorianCal() == 733924);
UT_ASSERT(XDateTuple(2010, 6, 30).DayOfGregorianCal() == 733953);
UT_ASSERT(XDateTuple(2010, 7, 1).DayOfGregorianCal() == 733954);
UT_ASSERT(XDateTuple(2010, 7, 31).DayOfGregorianCal() == 733984);
UT_ASSERT(XDateTuple(2010, 8, 1).DayOfGregorianCal() == 733985);
UT_ASSERT(XDateTuple(2010, 8, 31).DayOfGregorianCal() == 734015);
UT_ASSERT(XDateTuple(2010, 9, 1).DayOfGregorianCal() == 734016);
UT_ASSERT(XDateTuple(2010, 9, 30).DayOfGregorianCal() == 734045);
UT_ASSERT(XDateTuple(2010, 10, 1).DayOfGregorianCal() == 734046);
UT_ASSERT(XDateTuple(2010, 10, 31).DayOfGregorianCal() == 734076);
UT_ASSERT(XDateTuple(2010, 11, 1).DayOfGregorianCal() == 734077);
UT_ASSERT(XDateTuple(2010, 11, 30).DayOfGregorianCal() == 734106);
UT_ASSERT(XDateTuple(2010, 12, 1).DayOfGregorianCal() == 734107);
UT_ASSERT(XDateTuple(2010, 12, 31).DayOfGregorianCal() == 734137);
UT_ASSERT(XDateTuple(2012, 2, 1).DayOfGregorianCal() == 734534);
UT_ASSERT(XDateTuple(2012, 2, 28).DayOfGregorianCal() == 734561);
UT_ASSERT(XDateTuple(2012, 2, 29).DayOfGregorianCal() == 734562);
UT_ASSERT(XDateTuple(2012, 3, 1).DayOfGregorianCal() == 734563);
}
void XDateTupleTest::TestDayOfYear()
{
UT_ASSERT(XDateTuple(1999, 1, 1).DayOfYear() == 1);
UT_ASSERT(XDateTuple(1999, 1, 2).DayOfYear() == 2);
UT_ASSERT(XDateTuple(1999, 1, 3).DayOfYear() == 3);
UT_ASSERT(XDateTuple(1999, 1, 31).DayOfYear() == 31);
UT_ASSERT(XDateTuple(1999, 2, 1).DayOfYear() == 32);
UT_ASSERT(XDateTuple(1999, 2, 28).DayOfYear() == 59);
UT_ASSERT(XDateTuple(1999, 3, 1).DayOfYear() == 60);
UT_ASSERT(XDateTuple(1999, 3, 31).DayOfYear() == 90);
UT_ASSERT(XDateTuple(1999, 4, 1).DayOfYear() == 91);
UT_ASSERT(XDateTuple(1999, 4, 30).DayOfYear() == 120);
UT_ASSERT(XDateTuple(1999, 5, 1).DayOfYear() == 121);
UT_ASSERT(XDateTuple(1999, 5, 31).DayOfYear() == 151);
UT_ASSERT(XDateTuple(1999, 6, 1).DayOfYear() == 152);
UT_ASSERT(XDateTuple(1999, 6, 30).DayOfYear() == 181);
UT_ASSERT(XDateTuple(1999, 7, 1).DayOfYear() == 182);
UT_ASSERT(XDateTuple(1999, 7, 31).DayOfYear() == 212);
UT_ASSERT(XDateTuple(1999, 8, 1).DayOfYear() == 213);
UT_ASSERT(XDateTuple(1999, 8, 31).DayOfYear() == 243);
UT_ASSERT(XDateTuple(1999, 9, 1).DayOfYear() == 244);
UT_ASSERT(XDateTuple(1999, 9, 30).DayOfYear() == 273);
UT_ASSERT(XDateTuple(1999, 10, 1).DayOfYear() == 274);
UT_ASSERT(XDateTuple(1999, 10, 31).DayOfYear() == 304);
UT_ASSERT(XDateTuple(1999, 11, 1).DayOfYear() == 305);
UT_ASSERT(XDateTuple(1999, 11, 30).DayOfYear() == 334);
UT_ASSERT(XDateTuple(1999, 12, 1).DayOfYear() == 335);
UT_ASSERT(XDateTuple(1999, 12, 31).DayOfYear() == 365);
UT_ASSERT(XDateTuple(2000, 1, 1).DayOfYear() == 1);
UT_ASSERT(XDateTuple(2000, 2, 1).DayOfYear() == 32);
UT_ASSERT(XDateTuple(2000, 2, 29).DayOfYear() == 60);
UT_ASSERT(XDateTuple(2000, 3, 1).DayOfYear() == 61);
UT_ASSERT(XDateTuple(2000, 3, 31).DayOfYear() == 91);
UT_ASSERT(XDateTuple(2000, 4, 1).DayOfYear() == 92);
UT_ASSERT(XDateTuple(2000, 4, 30).DayOfYear() == 121);
UT_ASSERT(XDateTuple(2000, 5, 1).DayOfYear() == 122);
UT_ASSERT(XDateTuple(2000, 5, 31).DayOfYear() == 152);
UT_ASSERT(XDateTuple(2000, 6, 1).DayOfYear() == 153);
UT_ASSERT(XDateTuple(2000, 6, 30).DayOfYear() == 182);
UT_ASSERT(XDateTuple(2000, 7, 1).DayOfYear() == 183);
UT_ASSERT(XDateTuple(2000, 7, 31).DayOfYear() == 213);
UT_ASSERT(XDateTuple(2000, 8, 1).DayOfYear() == 214);
UT_ASSERT(XDateTuple(2000, 8, 31).DayOfYear() == 244);
UT_ASSERT(XDateTuple(2000, 9, 1).DayOfYear() == 245);
UT_ASSERT(XDateTuple(2000, 9, 30).DayOfYear() == 274);
UT_ASSERT(XDateTuple(2000, 10, 1).DayOfYear() == 275);
UT_ASSERT(XDateTuple(2000, 10, 31).DayOfYear() == 305);
UT_ASSERT(XDateTuple(2000, 11, 1).DayOfYear() == 306);
UT_ASSERT(XDateTuple(2000, 11, 30).DayOfYear() == 335);
UT_ASSERT(XDateTuple(2000, 12, 1).DayOfYear() == 336);
UT_ASSERT(XDateTuple(2000, 12, 31).DayOfYear() == 366);
}
void XDateTupleTest::TestDayOfWeek_test(XDateTuple date, int day, int expectedMonth, int expectedDay)
{
try
{
date.SetDayOfYear(day);
UT_ASSERT(date.Month() == expectedMonth);
UT_ASSERT(date.Day() == expectedDay);
}
catch(...)
{
printf("orig date [%s], new day [%d]\n", date.ToISOExtString().c_str(), day);
throw;
}
}
void XDateTupleTest::TestDayOfWeek()
{
UT_ASSERT(XDateTuple(1, 1, 1).DayOfWeek() == 1);
UT_ASSERT(XDateTuple(1, 1, 2).DayOfWeek() == 2);
UT_ASSERT(XDateTuple(1, 1, 3).DayOfWeek() == 3);
UT_ASSERT(XDateTuple(1, 1, 4).DayOfWeek() == 4);
UT_ASSERT(XDateTuple(1, 1, 5).DayOfWeek() == 5);
UT_ASSERT(XDateTuple(1, 1, 6).DayOfWeek() == 6);
UT_ASSERT(XDateTuple(1, 1, 7).DayOfWeek() == 0);
UT_ASSERT(XDateTuple(1, 1, 8).DayOfWeek() == 1);
UT_ASSERT(XDateTuple(1, 1, 9).DayOfWeek() == 2);
UT_ASSERT(XDateTuple(2, 1, 1).DayOfWeek() == 2);
UT_ASSERT(XDateTuple(3, 1, 1).DayOfWeek() == 3);
UT_ASSERT(XDateTuple(4, 1, 1).DayOfWeek() == 4);
UT_ASSERT(XDateTuple(5, 1, 1).DayOfWeek() == 6);
UT_ASSERT(XDateTuple(2000, 1, 1).DayOfWeek() == 6);
UT_ASSERT(XDateTuple(2010, 8, 22).DayOfWeek() == 0);
UT_ASSERT(XDateTuple(2010, 8, 23).DayOfWeek() == 1);
UT_ASSERT(XDateTuple(2010, 8, 24).DayOfWeek() == 2);
UT_ASSERT(XDateTuple(2010, 8, 25).DayOfWeek() == 3);
UT_ASSERT(XDateTuple(2010, 8, 26).DayOfWeek() == 4);
UT_ASSERT(XDateTuple(2010, 8, 27).DayOfWeek() == 5);
UT_ASSERT(XDateTuple(2010, 8, 28).DayOfWeek() == 6);
UT_ASSERT(XDateTuple(2010, 8, 29).DayOfWeek() == 0);
TestDayOfWeek_test(XDateTuple(1999, 1, 9), 1, 1, 1);
TestDayOfWeek_test(XDateTuple(1999, 2, 8), 2, 1, 2);
TestDayOfWeek_test(XDateTuple(1999, 3, 7), 3, 1, 3);
TestDayOfWeek_test(XDateTuple(1999, 5, 6), 31, 1, 31);
TestDayOfWeek_test(XDateTuple(1999, 6, 5), 32, 2, 1);
TestDayOfWeek_test(XDateTuple(1999, 7, 4), 59, 2, 28);
TestDayOfWeek_test(XDateTuple(1999, 8, 3), 60, 3, 1);
TestDayOfWeek_test(XDateTuple(1999, 9, 2), 90, 3, 31);
TestDayOfWeek_test(XDateTuple(1999, 1, 1), 91, 4, 1);
TestDayOfWeek_test(XDateTuple(1999, 2, 1), 120, 4, 30);
TestDayOfWeek_test(XDateTuple(1999, 3, 2), 121, 5, 1);
TestDayOfWeek_test(XDateTuple(1999, 4, 2), 151, 5, 31);
TestDayOfWeek_test(XDateTuple(1999, 5, 3), 152, 6, 1);
TestDayOfWeek_test(XDateTuple(1999, 6, 3), 181, 6, 30);
TestDayOfWeek_test(XDateTuple(1999, 7, 4), 182, 7, 1);
TestDayOfWeek_test(XDateTuple(1999, 8, 4), 212, 7, 31);
TestDayOfWeek_test(XDateTuple(1999, 9, 5), 213, 8, 1);
TestDayOfWeek_test(XDateTuple(1999, 1, 5), 243, 8, 31);
TestDayOfWeek_test(XDateTuple(1999, 2, 6), 244, 9, 1);
TestDayOfWeek_test(XDateTuple(1999, 3, 6), 273, 9, 30);
TestDayOfWeek_test(XDateTuple(1999, 4, 7), 274, 10, 1);
TestDayOfWeek_test(XDateTuple(1999, 5, 7), 304, 10, 31);
TestDayOfWeek_test(XDateTuple(1999, 6, 8), 305, 11, 1);
TestDayOfWeek_test(XDateTuple(1999, 7, 8), 334, 11, 30);
TestDayOfWeek_test(XDateTuple(1999, 8, 9), 335, 12, 1);
TestDayOfWeek_test(XDateTuple(1999, 9, 9), 365, 12, 31);
TestDayOfWeek_test(XDateTuple(2000, 1, 1), 1, 1, 1);
TestDayOfWeek_test(XDateTuple(2000, 2, 2), 32, 2, 1);
TestDayOfWeek_test(XDateTuple(2000, 3, 3), 60, 2, 29);
TestDayOfWeek_test(XDateTuple(2000, 4, 4), 61, 3, 1);
TestDayOfWeek_test(XDateTuple(2000, 5, 5), 91, 3, 31);
TestDayOfWeek_test(XDateTuple(2000, 6, 6), 92, 4, 1);
TestDayOfWeek_test(XDateTuple(2000, 7, 7), 121, 4, 30);
TestDayOfWeek_test(XDateTuple(2000, 8, 8), 122, 5, 1);
TestDayOfWeek_test(XDateTuple(2000, 9, 9), 152, 5, 31);
TestDayOfWeek_test(XDateTuple(2000, 1, 9), 153, 6, 1);
TestDayOfWeek_test(XDateTuple(2000, 2, 8), 182, 6, 30);
TestDayOfWeek_test(XDateTuple(2000, 3, 7), 183, 7, 1);
TestDayOfWeek_test(XDateTuple(2000, 4, 6), 213, 7, 31);
TestDayOfWeek_test(XDateTuple(2000, 5, 5), 214, 8, 1);
TestDayOfWeek_test(XDateTuple(2000, 6, 4), 244, 8, 31);
TestDayOfWeek_test(XDateTuple(2000, 7, 3), 245, 9, 1);
TestDayOfWeek_test(XDateTuple(2000, 8, 2), 274, 9, 30);
TestDayOfWeek_test(XDateTuple(2000, 9, 1), 275, 10, 1);
TestDayOfWeek_test(XDateTuple(2000, 1, 2), 305, 10, 31);
TestDayOfWeek_test(XDateTuple(2000, 2, 3), 306, 11, 1);
TestDayOfWeek_test(XDateTuple(2000, 3, 4), 335, 11, 30);
TestDayOfWeek_test(XDateTuple(2000, 4, 5), 336, 12, 1);
TestDayOfWeek_test(XDateTuple(2000, 5, 6), 366, 12, 31);
}
void XDateTupleTest::TestSub()
{
UT_ASSERT(XDateTuple() - XDateTuple() == XDuration::Zero());
UT_ASSERT(XDateTuple(2012, 12, 21) - XDateTuple(2012, 12, 21) == XDuration::Zero());
UT_ASSERT(XDateTuple(2000, 7, 6) - XDateTuple(1998, 7, 6) == XDuration(DAYS, 731));
UT_ASSERT(XDateTuple(1998, 7, 6) - XDateTuple(2000, 7, 6) == XDuration(DAYS, -731));
UT_ASSERT(XDateTuple(1999, 7, 6) - XDateTuple(1998, 7, 6) == XDuration(DAYS, 365));
UT_ASSERT(XDateTuple(1998, 7, 6) - XDateTuple(1999, 7, 6) == XDuration(DAYS, -365));
UT_ASSERT(XDateTuple(1999, 6, 6) - XDateTuple(1999, 5, 6) == XDuration(DAYS, 31));
UT_ASSERT(XDateTuple(1999, 5, 6) - XDateTuple(1999, 6, 6) == XDuration(DAYS, -31));
}
void XDateTupleTest::TestYear()
{
UT_ASSERT(XDateTuple().Year() == 1);
UT_ASSERT(XDateTuple(1999, 1, 1).Year() == 1999);
UT_ASSERT(XDateTuple(1999, 12, 31).Year() == 1999);
UT_ASSERT(XDateTuple(2000, 1, 1).Year() == 2000);
UT_ASSERT(XDateTuple(2000, 12, 31).Year() == 2000);
UT_ASSERT(XDateTuple(2011, 3, 9).Year() == 2011);
{
XDateTuple xdt;
xdt.SetYear(1999);
UT_ASSERT(xdt == XDateTuple(1999, 1, 1));
xdt.SetYear(2012);
UT_ASSERT(xdt == XDateTuple(2012, 1, 1));
}
{
XDateTuple xdt;
xdt.SetYear(2012);
UT_ASSERT(xdt == XDateTuple(2012, 1, 1));
xdt.SetYear(1999);
UT_ASSERT(xdt == XDateTuple(1999, 1, 1));
}
{
XDateTuple xdt = XDateTuple(2000, 7, 4);
xdt.SetYear(1999);
UT_ASSERT(xdt == XDateTuple(1999, 7, 4));
}
{
XDateTuple xdt = XDateTuple(2000, 2, 29);
UT_ASSERT_THROWS(xdt.SetYear(1999), XSDK::XException);
UT_ASSERT(xdt == XDateTuple(2000, 2, 29));
xdt.SetYear(2012);
UT_ASSERT(xdt == XDateTuple(2012, 2, 29));
}
{
XDateTuple xdt = XDateTuple(2000, 2, 28);
xdt.SetYear(1999);
UT_ASSERT(xdt == XDateTuple(1999, 2, 28));
xdt.SetYear(2012);
UT_ASSERT(xdt == XDateTuple(2012, 2, 28));
}
{
XDateTuple xdt;
UT_ASSERT_THROWS(xdt.SetYear(0), XSDK::XException);
UT_ASSERT_THROWS(xdt.SetYear(-1), XSDK::XException);
}
}
void XDateTupleTest::TestMonth()
{
UT_ASSERT(XDateTuple().Month() == 1);
UT_ASSERT(XDateTuple(1999, 1, 1).Month() == 1);
UT_ASSERT(XDateTuple(1999, 1, 31).Month() == 1);
UT_ASSERT(XDateTuple(1999, 2, 28).Month() == 2);
UT_ASSERT(XDateTuple(1999, 3, 1).Month() == 3);
UT_ASSERT(XDateTuple(1999, 7, 4).Month() == 7);
UT_ASSERT(XDateTuple(1999, 12, 1).Month() == 12);
UT_ASSERT(XDateTuple(1999, 12, 31).Month() == 12);
UT_ASSERT(XDateTuple().Month() == 1);
UT_ASSERT(XDateTuple(2000, 1, 1).Month() == 1);
UT_ASSERT(XDateTuple(2000, 1, 31).Month() == 1);
UT_ASSERT(XDateTuple(2000, 2, 28).Month() == 2);
UT_ASSERT(XDateTuple(2000, 2, 29).Month() == 2);
UT_ASSERT(XDateTuple(2000, 3, 1).Month() == 3);
UT_ASSERT(XDateTuple(2000, 7, 4).Month() == 7);
UT_ASSERT(XDateTuple(2000, 12, 1).Month() == 12);
UT_ASSERT(XDateTuple(2000, 12, 31).Month() == 12);
{
XDateTuple xdt;
xdt.SetMonth(1);
UT_ASSERT(xdt == XDateTuple(1, 1, 1));
xdt.SetMonth(2);
UT_ASSERT(xdt == XDateTuple(1, 2, 1));
xdt.SetMonth(7);
UT_ASSERT(xdt == XDateTuple(1, 7, 1));
xdt.SetMonth(12);
UT_ASSERT(xdt == XDateTuple(1, 12, 1));
}
{
XDateTuple xdt = XDateTuple(1999, 7, 31);
xdt.SetMonth(7);
UT_ASSERT(xdt == XDateTuple(1999, 7, 31));
xdt.SetMonth(1);
UT_ASSERT(xdt == XDateTuple(1999, 1, 31));
xdt.SetMonth(12);
UT_ASSERT(xdt == XDateTuple(1999, 12, 31));
}
{
XDateTuple xdt = XDateTuple(2000, 1, 29);
xdt.SetMonth(1);
UT_ASSERT(xdt == XDateTuple(2000, 1, 29));
xdt.SetMonth(2);
UT_ASSERT(xdt == XDateTuple(2000, 2, 29));
xdt.SetMonth(3);
UT_ASSERT(xdt == XDateTuple(2000, 3, 29));
}
{
XDateTuple xdt = XDateTuple(1999, 3, 29);
UT_ASSERT_THROWS(xdt.SetMonth(2), XSDK::XException);
UT_ASSERT(xdt == XDateTuple(1999, 3, 29));
xdt.SetMonth(4);
UT_ASSERT(xdt == XDateTuple(1999, 4, 29));
}
{
XDateTuple xdt = XDateTuple(2000, 3, 30);
UT_ASSERT_THROWS(xdt.SetMonth(2), XSDK::XException);
UT_ASSERT(xdt == XDateTuple(2000, 3, 30));
xdt.SetMonth(4);
UT_ASSERT(xdt == XDateTuple(2000, 4, 30));
}
{
XDateTuple xdt = XDateTuple(2000, 3, 28);
xdt.SetMonth(2);
UT_ASSERT(xdt == XDateTuple(2000, 2, 28));
xdt.SetMonth(4);
UT_ASSERT(xdt == XDateTuple(2000, 4, 28));
}
{
XDateTuple xdt = XDateTuple(2011, 1, 31);
UT_ASSERT_THROWS(xdt.SetMonth(2), XSDK::XException);
UT_ASSERT_THROWS(xdt.SetMonth(4), XSDK::XException);
UT_ASSERT_THROWS(xdt.SetMonth(6), XSDK::XException);
UT_ASSERT_THROWS(xdt.SetMonth(9), XSDK::XException);
UT_ASSERT_THROWS(xdt.SetMonth(11), XSDK::XException);
UT_ASSERT(xdt == XDateTuple(2011, 1, 31));
}
}
void XDateTupleTest::TestDay()
{
UT_ASSERT(XDateTuple().Day() == 1);
UT_ASSERT(XDateTuple(1999, 1, 1).Day() == 1);
UT_ASSERT(XDateTuple(1999, 1, 4).Day() == 4);
UT_ASSERT(XDateTuple(1999, 1, 12).Day() == 12);
UT_ASSERT(XDateTuple(1999, 1, 31).Day() == 31);
UT_ASSERT(XDateTuple(1999, 2, 1).Day() == 1);
UT_ASSERT(XDateTuple(1999, 2, 28).Day() == 28);
UT_ASSERT(XDateTuple(1999, 3, 1).Day() == 1);
UT_ASSERT(XDateTuple(1999, 7, 4).Day() == 4);
UT_ASSERT(XDateTuple(1999, 12, 31).Day() == 31);
UT_ASSERT(XDateTuple(2000, 1, 1).Day() == 1);
UT_ASSERT(XDateTuple(2000, 1, 4).Day() == 4);
UT_ASSERT(XDateTuple(2000, 1, 12).Day() == 12);
UT_ASSERT(XDateTuple(2000, 1, 31).Day() == 31);
UT_ASSERT(XDateTuple(2000, 2, 1).Day() == 1);
UT_ASSERT(XDateTuple(2000, 2, 28).Day() == 28);
UT_ASSERT(XDateTuple(2000, 2, 29).Day() == 29);
UT_ASSERT(XDateTuple(2000, 3, 1).Day() == 1);
UT_ASSERT(XDateTuple(2000, 7, 4).Day() == 4);
UT_ASSERT(XDateTuple(2000, 12, 31).Day() == 31);
{
XDateTuple xdt;
xdt.SetDay(1);
UT_ASSERT(xdt == XDateTuple(1, 1, 1));
xdt.SetDay(2);
UT_ASSERT(xdt == XDateTuple(1, 1, 2));
xdt.SetDay(7);
UT_ASSERT(xdt == XDateTuple(1, 1, 7));
xdt.SetDay(31);
UT_ASSERT(xdt == XDateTuple(1, 1, 31));
}
{
XDateTuple xdt = XDateTuple(1999, 7, 31);
xdt.SetDay(31);
UT_ASSERT(xdt == XDateTuple(1999, 7, 31));
xdt.SetDay(1);
UT_ASSERT(xdt == XDateTuple(1999, 7, 1));
xdt.SetDay(12);
UT_ASSERT(xdt == XDateTuple(1999, 7, 12));
}
{
XDateTuple xdt = XDateTuple(2000, 2, 29);
xdt.SetDay(7);
UT_ASSERT(xdt == XDateTuple(2000, 2, 7));
xdt.SetDay(29);
UT_ASSERT(xdt == XDateTuple(2000, 2, 29));
xdt.SetDay(28);
UT_ASSERT(xdt == XDateTuple(2000, 2, 28));
}
{
XDateTuple xdt = XDateTuple(2011, 1, 31);
UT_ASSERT_THROWS(xdt.SetDay(32), XSDK::XException);
UT_ASSERT(xdt == XDateTuple(2011, 1, 31));
}
{
XDateTuple xdt = XDateTuple(1999, 2, 5);
UT_ASSERT_THROWS(xdt.SetDay(29), XSDK::XException);
UT_ASSERT(xdt == XDateTuple(1999, 2, 5));
xdt.SetDay(28);
UT_ASSERT(xdt == XDateTuple(1999, 2, 28));
}
{
XDateTuple xdt = XDateTuple(2000, 2, 5);
UT_ASSERT_THROWS(xdt.SetDay(30), XSDK::XException);
UT_ASSERT(xdt == XDateTuple(2000, 2, 5));
xdt.SetDay(29);
UT_ASSERT(xdt == XDateTuple(2000, 2, 29));
}
{
XDateTuple xdt = XDateTuple(2011, 3, 31);
UT_ASSERT_THROWS(xdt.SetDay(32), XSDK::XException);
}
{
XDateTuple xdt = XDateTuple(2011, 4, 30);
UT_ASSERT_THROWS(xdt.SetDay(31), XSDK::XException);
}
{
XDateTuple xdt = XDateTuple(2011, 5, 30);
UT_ASSERT_THROWS(xdt.SetDay(32), XSDK::XException);
}
{
XDateTuple xdt = XDateTuple(2011, 6, 7);
UT_ASSERT_THROWS(xdt.SetDay(31), XSDK::XException);
}
{
XDateTuple xdt = XDateTuple(2011, 7, 7);
UT_ASSERT_THROWS(xdt.SetDay(32), XSDK::XException);
}
{
XDateTuple xdt = XDateTuple(2011, 8, 7);
UT_ASSERT_THROWS(xdt.SetDay(32), XSDK::XException);
}
{
XDateTuple xdt = XDateTuple(2011, 9, 22);
UT_ASSERT_THROWS(xdt.SetDay(31), XSDK::XException);
}
{
XDateTuple xdt = XDateTuple(2011, 10, 22);
UT_ASSERT_THROWS(xdt.SetDay(32), XSDK::XException);
}
{
XDateTuple xdt = XDateTuple(2011, 11, 22);
UT_ASSERT_THROWS(xdt.SetDay(31), XSDK::XException);
}
{
XDateTuple xdt = XDateTuple(2011, 12, 31);
UT_ASSERT_THROWS(xdt.SetDay(32), XSDK::XException);
}
}
void XDateTupleTest::TestEndOfMonth()
{
UT_ASSERT(XDateTuple(1999, 1, 1).EndOfMonth() == XDateTuple(1999, 1, 31));
UT_ASSERT(XDateTuple(1999, 2, 1).EndOfMonth() == XDateTuple(1999, 2, 28));
UT_ASSERT(XDateTuple(2000, 2, 1).EndOfMonth() == XDateTuple(2000, 2, 29));
UT_ASSERT(XDateTuple(1999, 3, 1).EndOfMonth() == XDateTuple(1999, 3, 31));
UT_ASSERT(XDateTuple(1999, 4, 1).EndOfMonth() == XDateTuple(1999, 4, 30));
UT_ASSERT(XDateTuple(1999, 5, 1).EndOfMonth() == XDateTuple(1999, 5, 31));
UT_ASSERT(XDateTuple(1999, 6, 1).EndOfMonth() == XDateTuple(1999, 6, 30));
UT_ASSERT(XDateTuple(1999, 7, 1).EndOfMonth() == XDateTuple(1999, 7, 31));
UT_ASSERT(XDateTuple(1999, 8, 1).EndOfMonth() == XDateTuple(1999, 8, 31));
UT_ASSERT(XDateTuple(1999, 9, 1).EndOfMonth() == XDateTuple(1999, 9, 30));
UT_ASSERT(XDateTuple(1999, 10, 1).EndOfMonth() == XDateTuple(1999, 10, 31));
UT_ASSERT(XDateTuple(1999, 11, 1).EndOfMonth() == XDateTuple(1999, 11, 30));
UT_ASSERT(XDateTuple(1999, 12, 1).EndOfMonth() == XDateTuple(1999, 12, 31));
}
void XDateTupleTest::TestToISOExtString()
{
UT_ASSERT(XDateTuple().ToISOExtString() == "0001-01-01");
UT_ASSERT(XDateTuple(2, 3, 4).ToISOExtString() == "0002-03-04");
UT_ASSERT(XDateTuple(40, 7, 7).ToISOExtString() == "0040-07-07");
UT_ASSERT(XDateTuple(602, 9, 17).ToISOExtString() == "0602-09-17");
UT_ASSERT(XDateTuple(2012, 12, 21).ToISOExtString() == "2012-12-21");
UT_ASSERT(XDateTuple(12345, 12, 21).ToISOExtString() == "+12345-12-21");
}
void XDateTupleTest::TestToCustomString()
{
UT_ASSERT(XDateTuple().ToCustomString("YYYY-MM-DD") == "0001-01-01");
UT_ASSERT(XDateTuple(2, 3, 4).ToCustomString("YYYY-MM-DD") == "0002-03-04");
UT_ASSERT(XDateTuple(40, 7, 7).ToCustomString("YYYY-MM-DD") == "0040-07-07");
UT_ASSERT(XDateTuple(602, 9, 17).ToCustomString("YYYY-MM-DD") == "0602-09-17");
UT_ASSERT(XDateTuple(2012, 12, 21).ToCustomString("YYYY-MM-DD") == "2012-12-21");
UT_ASSERT(XDateTuple().ToCustomString("YYYYMMDD") == "00010101");
UT_ASSERT(XDateTuple(2, 3, 4).ToCustomString("YYYYMMDD") == "00020304");
UT_ASSERT(XDateTuple(40, 7, 7).ToCustomString("YYYYMMDD") == "00400707");
UT_ASSERT(XDateTuple(602, 9, 17).ToCustomString("YYYYMMDD") == "06020917");
UT_ASSERT(XDateTuple(2012, 12, 21).ToCustomString("YYYYMMDD") == "20121221");
UT_ASSERT(XDateTuple().ToCustomString("YY-MM-DD") == "01-01-01");
UT_ASSERT(XDateTuple(2, 3, 4).ToCustomString("YY-MM-DD") == "02-03-04");
UT_ASSERT(XDateTuple(40, 7, 7).ToCustomString("YY-MM-DD") == "40-07-07");
UT_ASSERT(XDateTuple(602, 9, 17).ToCustomString("YY-MM-DD") == "02-09-17");
UT_ASSERT(XDateTuple(2012, 12, 21).ToCustomString("YY-MM-DD") == "12-12-21");
UT_ASSERT(XDateTuple().ToCustomString("MM/DD/YYYY") == "01/01/0001");
UT_ASSERT(XDateTuple(2, 3, 4).ToCustomString("MM/DD/YYYY") == "03/04/0002");
UT_ASSERT(XDateTuple(40, 7, 7).ToCustomString("MM/DD/YYYY") == "07/07/0040");
UT_ASSERT(XDateTuple(602, 9, 17).ToCustomString("MM/DD/YYYY") == "09/17/0602");
UT_ASSERT(XDateTuple(2012, 12, 21).ToCustomString("MM/DD/YYYY") == "12/21/2012");
UT_ASSERT_THROWS(XDateTuple(12345, 12, 21).ToCustomString("YYYY-MM-DD"), XException);
}
void XDateTupleTest::TestFromISOExtString()
{
UT_ASSERT_THROWS(XDateTuple::FromISOExtString(""), XException);
UT_ASSERT_THROWS(XDateTuple::FromISOExtString("990704"), XException);
UT_ASSERT_THROWS(XDateTuple::FromISOExtString("0100704"), XException);
UT_ASSERT_THROWS(XDateTuple::FromISOExtString("2010070"), XException);
UT_ASSERT_THROWS(XDateTuple::FromISOExtString("2010070 "), XException);
UT_ASSERT_THROWS(XDateTuple::FromISOExtString("120100704"), XException);
UT_ASSERT_THROWS(XDateTuple::FromISOExtString("-0100704"), XException);
UT_ASSERT_THROWS(XDateTuple::FromISOExtString("+0100704"), XException);
UT_ASSERT_THROWS(XDateTuple::FromISOExtString("2010070a"), XException);
UT_ASSERT_THROWS(XDateTuple::FromISOExtString("20100a04"), XException);
UT_ASSERT_THROWS(XDateTuple::FromISOExtString("2010a704"), XException);
UT_ASSERT_THROWS(XDateTuple::FromISOExtString("99-07-04"), XException);
UT_ASSERT_THROWS(XDateTuple::FromISOExtString("010-07-04"), XException);
UT_ASSERT_THROWS(XDateTuple::FromISOExtString("2010-07-0"), XException);
UT_ASSERT_THROWS(XDateTuple::FromISOExtString("2010-07-0 "), XException);
UT_ASSERT_THROWS(XDateTuple::FromISOExtString("12010-07-04"), XException);
UT_ASSERT_THROWS(XDateTuple::FromISOExtString("-010-07-04"), XException);
UT_ASSERT_THROWS(XDateTuple::FromISOExtString("+010-07-04"), XException);
UT_ASSERT_THROWS(XDateTuple::FromISOExtString("2010-07-0a"), XException);
UT_ASSERT_THROWS(XDateTuple::FromISOExtString("2010-0a-04"), XException);
UT_ASSERT_THROWS(XDateTuple::FromISOExtString("2010-a7-04"), XException);
UT_ASSERT_THROWS(XDateTuple::FromISOExtString("2010/07/04"), XException);
UT_ASSERT_THROWS(XDateTuple::FromISOExtString("2010/7/04"), XException);
UT_ASSERT_THROWS(XDateTuple::FromISOExtString("2010/7/4"), XException);
UT_ASSERT_THROWS(XDateTuple::FromISOExtString("2010/07/4"), XException);
UT_ASSERT_THROWS(XDateTuple::FromISOExtString("2010-7-04"), XException);
UT_ASSERT_THROWS(XDateTuple::FromISOExtString("2010-7-4"), XException);
UT_ASSERT_THROWS(XDateTuple::FromISOExtString("2010-07-4"), XException);
UT_ASSERT_THROWS(XDateTuple::FromISOExtString("99-Jul-04"), XException);
UT_ASSERT_THROWS(XDateTuple::FromISOExtString("010-Jul-04"), XException);
UT_ASSERT_THROWS(XDateTuple::FromISOExtString("2010-Jul-0"), XException);
UT_ASSERT_THROWS(XDateTuple::FromISOExtString("2010Jul0 "), XException);
UT_ASSERT_THROWS(XDateTuple::FromISOExtString("12010-Jul-04"), XException);
UT_ASSERT_THROWS(XDateTuple::FromISOExtString("-010-Jul-04"), XException);
UT_ASSERT_THROWS(XDateTuple::FromISOExtString("+010-Jul-04"), XException);
UT_ASSERT_THROWS(XDateTuple::FromISOExtString("2010-Jul-0a"), XException);
UT_ASSERT_THROWS(XDateTuple::FromISOExtString("2010-Jua-04"), XException);
UT_ASSERT_THROWS(XDateTuple::FromISOExtString("2010-Jal-04"), XException);
UT_ASSERT_THROWS(XDateTuple::FromISOExtString("2010-aul-04"), XException);
UT_ASSERT(XDateTuple::FromISOExtString("1999-07-06") == XDateTuple(1999, 7, 6));
UT_ASSERT(XDateTuple::FromISOExtString("+01999-07-06") == XDateTuple(1999, 7, 6));
UT_ASSERT(XDateTuple::FromISOExtString("1999-07-06 ") == XDateTuple(1999, 7, 6));
UT_ASSERT(XDateTuple::FromISOExtString(" 1999-07-06") == XDateTuple(1999, 7, 6));
UT_ASSERT(XDateTuple::FromISOExtString(" 1999-07-06 ") == XDateTuple(1999, 7, 6));
}
void XTimeTupleTest::TestConstructor()
{
UT_ASSERT_THROWS(XTimeTuple(-1, 0, 0), XSDK::XException);
UT_ASSERT_THROWS(XTimeTuple(24, 0, 0), XSDK::XException);
UT_ASSERT_THROWS(XTimeTuple(0, -1, 0), XSDK::XException);
UT_ASSERT_THROWS(XTimeTuple(0, 60, 0), XSDK::XException);
UT_ASSERT_THROWS(XTimeTuple(0, 0, -1), XSDK::XException);
UT_ASSERT_THROWS(XTimeTuple(0, 0, 60), XSDK::XException);
}
void XTimeTupleTest::TestEquality()
{
vector<XTimeTuple> times;
times.push_back(XTimeTuple());
times.push_back(XTimeTuple(0, 0, 1));
times.push_back(XTimeTuple(0, 1, 0));
times.push_back(XTimeTuple(0, 1, 1));
times.push_back(XTimeTuple(1, 0, 0));
times.push_back(XTimeTuple(1, 1, 0));
times.push_back(XTimeTuple(1, 0, 1));
times.push_back(XTimeTuple(1, 1, 1));
times.push_back(XTimeTuple(12, 42, 3));
times.push_back(XTimeTuple(23, 59, 59));
for(size_t i = 0; i < times.size(); ++i)
{
for(size_t j = 0; i < times.size(); ++i)
{
try
{
if(i == j)
{
UT_ASSERT(times[i] == times[j]);
UT_ASSERT(!(times[i] != times[j]));
UT_ASSERT(!(times[i] < times[j]));
UT_ASSERT(times[i] <= times[j]);
UT_ASSERT(times[i] >= times[j]);
UT_ASSERT(!(times[i] > times[j]));
}
else
{
UT_ASSERT(!(times[i] == times[j]));
UT_ASSERT(times[i] != times[j]);
if(i < j)
{
UT_ASSERT(times[i] < times[j]);
UT_ASSERT(times[i] <= times[j]);
}
else if(i > j)
{
UT_ASSERT(times[i] >= times[j]);
UT_ASSERT(times[i] > times[j]);
}
}
}
catch(...)
{
printf("lhs [%s], rhs [%s]\n", times[i].ToISOExtString().c_str(), times[j].ToISOExtString().c_str());
throw;
}
}
}
}
void XTimeTupleTest::TestSub()
{
UT_ASSERT(XTimeTuple() - XTimeTuple() == XDuration::Zero());
UT_ASSERT(XTimeTuple(23, 59, 59) - XTimeTuple(23, 59, 59) == XDuration::Zero());
UT_ASSERT(XTimeTuple(23, 59, 59) - XTimeTuple(0, 0, 0) == XDuration(SECONDS, 86399));
UT_ASSERT(XTimeTuple(0, 0, 0) - XTimeTuple(23, 59, 59) == XDuration(SECONDS, -86399));
UT_ASSERT(XTimeTuple(7, 12, 52) - XTimeTuple(12, 30, 33) == XDuration(SECONDS, -19061));
UT_ASSERT(XTimeTuple(12, 30, 33) - XTimeTuple(7, 12, 52) == XDuration(SECONDS, 19061));
UT_ASSERT(XTimeTuple(12, 30, 33) - XTimeTuple(14, 30, 33) == XDuration(SECONDS, -7200));
UT_ASSERT(XTimeTuple(14, 30, 33) - XTimeTuple(12, 30, 33) == XDuration(SECONDS, 7200));
UT_ASSERT(XTimeTuple(12, 30, 33) - XTimeTuple(12, 34, 33) == XDuration(SECONDS, -240));
UT_ASSERT(XTimeTuple(12, 34, 33) - XTimeTuple(12, 30, 33) == XDuration(SECONDS, 240));
UT_ASSERT(XTimeTuple(12, 30, 33) - XTimeTuple(12, 30, 34) == XDuration(SECONDS, -1));
UT_ASSERT(XTimeTuple(12, 30, 34) - XTimeTuple(12, 30, 33) == XDuration(SECONDS, 1));
}
void XTimeTupleTest::TestHour()
{
UT_ASSERT(XTimeTuple().Hour() == 0);
UT_ASSERT(XTimeTuple(5, 0, 0).Hour() == 5);
UT_ASSERT(XTimeTuple(5, 59, 59).Hour() == 5);
UT_ASSERT(XTimeTuple(23, 0, 0).Hour() == 23);
UT_ASSERT(XTimeTuple(23, 59, 59).Hour() == 23);
{
XTimeTuple xtt;
xtt.SetHour(0);
UT_ASSERT(xtt == XTimeTuple(0, 0, 0));
}
{
XTimeTuple xtt;
xtt.SetHour(9);
UT_ASSERT(xtt == XTimeTuple(9, 0, 0));
}
{
XTimeTuple xtt;
xtt.SetHour(23);
UT_ASSERT(xtt == XTimeTuple(23, 0, 0));
}
{
XTimeTuple xtt = XTimeTuple(23, 59, 59);
xtt.SetHour(0);
UT_ASSERT(xtt == XTimeTuple(0, 59, 59));
}
{
XTimeTuple xtt = XTimeTuple(23, 59, 59);
xtt.SetHour(9);
UT_ASSERT(xtt == XTimeTuple(9, 59, 59));
}
{
XTimeTuple xtt = XTimeTuple(23, 59, 59);
xtt.SetHour(23);
UT_ASSERT(xtt == XTimeTuple(23, 59, 59));
}
{
XTimeTuple xtt;
UT_ASSERT_THROWS(xtt.SetHour(-1), XSDK::XException);
UT_ASSERT_THROWS(xtt.SetHour(24), XSDK::XException);
UT_ASSERT(xtt == XTimeTuple());
}
}
void XTimeTupleTest::TestMinute()
{
UT_ASSERT(XTimeTuple().Minute() == 0);
UT_ASSERT(XTimeTuple(0, 33, 0).Minute() == 33);
UT_ASSERT(XTimeTuple(23, 33, 59).Minute() == 33);
UT_ASSERT(XTimeTuple(0, 59, 0).Minute() == 59);
UT_ASSERT(XTimeTuple(23, 59, 59).Minute() == 59);
{
XTimeTuple xtt;
xtt.SetMinute(0);
UT_ASSERT(xtt == XTimeTuple(0, 0, 0));
}
{
XTimeTuple xtt;
xtt.SetMinute(17);
UT_ASSERT(xtt == XTimeTuple(0, 17, 0));
}
{
XTimeTuple xtt;
xtt.SetMinute(59);
UT_ASSERT(xtt == XTimeTuple(0, 59, 0));
}
{
XTimeTuple xtt = XTimeTuple(23, 59, 59);
xtt.SetMinute(0);
UT_ASSERT(xtt == XTimeTuple(23, 0, 59));
}
{
XTimeTuple xtt = XTimeTuple(23, 59, 59);
xtt.SetMinute(17);
UT_ASSERT(xtt == XTimeTuple(23, 17, 59));
}
{
XTimeTuple xtt = XTimeTuple(23, 59, 59);
xtt.SetMinute(59);
UT_ASSERT(xtt == XTimeTuple(23, 59, 59));
}
{
XTimeTuple xtt;
UT_ASSERT_THROWS(xtt.SetMinute(-1), XSDK::XException);
UT_ASSERT_THROWS(xtt.SetMinute(60), XSDK::XException);
UT_ASSERT(xtt == XTimeTuple());
}
}
void XTimeTupleTest::TestSecond()
{
UT_ASSERT(XTimeTuple().Second() == 0);
UT_ASSERT(XTimeTuple(0, 0, 33).Second() == 33);
UT_ASSERT(XTimeTuple(23, 59, 33).Second() == 33);
UT_ASSERT(XTimeTuple(0, 0, 59).Second() == 59);
UT_ASSERT(XTimeTuple(23, 59, 59).Second() == 59);
{
XTimeTuple xtt;
xtt.SetSecond(0);
UT_ASSERT(xtt == XTimeTuple(0, 0, 0));
}
{
XTimeTuple xtt;
xtt.SetSecond(17);
UT_ASSERT(xtt == XTimeTuple(0, 0, 17));
}
{
XTimeTuple xtt;
xtt.SetSecond(59);
UT_ASSERT(xtt == XTimeTuple(0, 0, 59));
}
{
XTimeTuple xtt = XTimeTuple(23, 59, 59);
xtt.SetSecond(0);
UT_ASSERT(xtt == XTimeTuple(23, 59, 0));
}
{
XTimeTuple xtt = XTimeTuple(23, 59, 59);
xtt.SetSecond(17);
UT_ASSERT(xtt == XTimeTuple(23, 59, 17));
}
{
XTimeTuple xtt = XTimeTuple(23, 59, 59);
xtt.SetSecond(59);
UT_ASSERT(xtt == XTimeTuple(23, 59, 59));
}
{
XTimeTuple xtt;
UT_ASSERT_THROWS(xtt.SetSecond(-1), XSDK::XException);
UT_ASSERT_THROWS(xtt.SetSecond(60), XSDK::XException);
UT_ASSERT(xtt == XTimeTuple());
}
}
void XTimeTupleTest::TestToISOExtString()
{
UT_ASSERT(XTimeTuple().ToISOExtString() == "00:00:00");
UT_ASSERT(XTimeTuple(1, 2, 3).ToISOExtString() == "01:02:03");
UT_ASSERT(XTimeTuple(23, 59, 59).ToISOExtString() == "23:59:59");
}
void XTimeTupleTest::TestToCustomString()
{
UT_ASSERT(XTimeTuple().ToCustomString("HH:MM:SS") == "00:00:00");
UT_ASSERT(XTimeTuple(1, 2, 3).ToCustomString("HH:MM:SS") == "01:02:03");
UT_ASSERT(XTimeTuple(23, 59, 59).ToCustomString("HH:MM:SS") == "23:59:59");
UT_ASSERT(XTimeTuple().ToCustomString("SS:MM:HH") == "00:00:00");
UT_ASSERT(XTimeTuple(1, 2, 3).ToCustomString("SS:MM:HH") == "03:02:01");
UT_ASSERT(XTimeTuple(23, 59, 59).ToCustomString("SS:MM:HH") == "59:59:23");
UT_ASSERT(XTimeTuple().ToCustomString("helloMMworld SSasnethae HHHH") == "hello00world 00asnethae 00HH");
UT_ASSERT(XTimeTuple(1, 2, 3).ToCustomString("helloMMworld SSasnethae HHHH") == "hello02world 03asnethae 01HH");
UT_ASSERT(XTimeTuple(23, 59, 59).ToCustomString("helloMMworld SSasnethae HHHH") == "hello59world 59asnethae 23HH");
}
void XTimeTupleTest::TestFromISOExtString()
{
UT_ASSERT_THROWS(XTimeTuple::FromISOExtString(""), XException);
UT_ASSERT_THROWS(XTimeTuple::FromISOExtString("0"), XException);
UT_ASSERT_THROWS(XTimeTuple::FromISOExtString("00"), XException);
UT_ASSERT_THROWS(XTimeTuple::FromISOExtString("000"), XException);
UT_ASSERT_THROWS(XTimeTuple::FromISOExtString("0000"), XException);
UT_ASSERT_THROWS(XTimeTuple::FromISOExtString("00000"), XException);
UT_ASSERT_THROWS(XTimeTuple::FromISOExtString("13033"), XException);
UT_ASSERT_THROWS(XTimeTuple::FromISOExtString("1277"), XException);
UT_ASSERT_THROWS(XTimeTuple::FromISOExtString("12707"), XException);
UT_ASSERT_THROWS(XTimeTuple::FromISOExtString("12070"), XException);
UT_ASSERT_THROWS(XTimeTuple::FromISOExtString("12303a"), XException);
UT_ASSERT_THROWS(XTimeTuple::FromISOExtString("1230a3"), XException);
UT_ASSERT_THROWS(XTimeTuple::FromISOExtString("123a33"), XException);
UT_ASSERT_THROWS(XTimeTuple::FromISOExtString("12a033"), XException);
UT_ASSERT_THROWS(XTimeTuple::FromISOExtString("1a0033"), XException);
UT_ASSERT_THROWS(XTimeTuple::FromISOExtString("a20033"), XException);
UT_ASSERT_THROWS(XTimeTuple::FromISOExtString("1200330"), XException);
UT_ASSERT_THROWS(XTimeTuple::FromISOExtString("0120033"), XException);
UT_ASSERT_THROWS(XTimeTuple::FromISOExtString("-120033"), XException);
UT_ASSERT_THROWS(XTimeTuple::FromISOExtString("+120033"), XException);
UT_ASSERT_THROWS(XTimeTuple::FromISOExtString("120033am"), XException);
UT_ASSERT_THROWS(XTimeTuple::FromISOExtString("120033pm"), XException);
UT_ASSERT_THROWS(XTimeTuple::FromISOExtString("0::"), XException);
UT_ASSERT_THROWS(XTimeTuple::FromISOExtString(":0:"), XException);
UT_ASSERT_THROWS(XTimeTuple::FromISOExtString("::0"), XException);
UT_ASSERT_THROWS(XTimeTuple::FromISOExtString("0:0:0"), XException);
UT_ASSERT_THROWS(XTimeTuple::FromISOExtString("0:0:00"), XException);
UT_ASSERT_THROWS(XTimeTuple::FromISOExtString("0:00:0"), XException);
UT_ASSERT_THROWS(XTimeTuple::FromISOExtString("00:0:0"), XException);
UT_ASSERT_THROWS(XTimeTuple::FromISOExtString("00:00:0"), XException);
UT_ASSERT_THROWS(XTimeTuple::FromISOExtString("00:0:00"), XException);
UT_ASSERT_THROWS(XTimeTuple::FromISOExtString("13:0:33"), XException);
UT_ASSERT_THROWS(XTimeTuple::FromISOExtString("12:7:7"), XException);
UT_ASSERT_THROWS(XTimeTuple::FromISOExtString("12:7:07"), XException);
UT_ASSERT_THROWS(XTimeTuple::FromISOExtString("12:07:0"), XException);
UT_ASSERT_THROWS(XTimeTuple::FromISOExtString("12:30:3a"), XException);
UT_ASSERT_THROWS(XTimeTuple::FromISOExtString("12:30:a3"), XException);
UT_ASSERT_THROWS(XTimeTuple::FromISOExtString("12:3a:33"), XException);
UT_ASSERT_THROWS(XTimeTuple::FromISOExtString("12:a0:33"), XException);
UT_ASSERT_THROWS(XTimeTuple::FromISOExtString("1a:00:33"), XException);
UT_ASSERT_THROWS(XTimeTuple::FromISOExtString("a2:00:33"), XException);
UT_ASSERT_THROWS(XTimeTuple::FromISOExtString("12:003:30"), XException);
UT_ASSERT_THROWS(XTimeTuple::FromISOExtString("120:03:30"), XException);
UT_ASSERT_THROWS(XTimeTuple::FromISOExtString("012:00:33"), XException);
UT_ASSERT_THROWS(XTimeTuple::FromISOExtString("01:200:33"), XException);
UT_ASSERT_THROWS(XTimeTuple::FromISOExtString("-12:00:33"), XException);
UT_ASSERT_THROWS(XTimeTuple::FromISOExtString("+12:00:33"), XException);
UT_ASSERT_THROWS(XTimeTuple::FromISOExtString("12:00:33am"), XException);
UT_ASSERT_THROWS(XTimeTuple::FromISOExtString("12:00:33pm"), XException);
UT_ASSERT_THROWS(XTimeTuple::FromISOExtString("120033"), XException);
UT_ASSERT(XTimeTuple::FromISOExtString("01:12:17") == XTimeTuple(1, 12, 17));
UT_ASSERT(XTimeTuple::FromISOExtString("00:14:12") == XTimeTuple(0, 14, 12));
UT_ASSERT(XTimeTuple::FromISOExtString("00:00:07") == XTimeTuple(0, 0, 7));
UT_ASSERT(XTimeTuple::FromISOExtString("01:12:17 ") == XTimeTuple(1, 12, 17));
UT_ASSERT(XTimeTuple::FromISOExtString(" 01:12:17") == XTimeTuple(1, 12, 17));
UT_ASSERT(XTimeTuple::FromISOExtString(" 01:12:17 ") == XTimeTuple(1, 12, 17));
}
void XTimeTupleTest::TestCmpDateTime()
{
UT_ASSERT(cmpDateTime(make_pair(XDateTuple(), XTimeTuple()),
make_pair(XDateTuple(), XTimeTuple())) == 0);
UT_ASSERT(cmpDateTime(make_pair(XDateTuple(2012, 12, 21), XTimeTuple(12, 13, 14)),
make_pair(XDateTuple(2012, 12, 21), XTimeTuple(12, 13, 14))) == 0);
UT_ASSERT(cmpDateTime(make_pair(XDateTuple(2012, 12, 22), XTimeTuple(12, 13, 14)),
make_pair(XDateTuple(2012, 12, 21), XTimeTuple(12, 13, 14))) > 0);
UT_ASSERT(cmpDateTime(make_pair(XDateTuple(2012, 12, 21), XTimeTuple(12, 13, 14)),
make_pair(XDateTuple(2012, 12, 22), XTimeTuple(12, 13, 14))) < 0);
UT_ASSERT(cmpDateTime(make_pair(XDateTuple(2012, 12, 21), XTimeTuple(12, 13, 15)),
make_pair(XDateTuple(2012, 12, 21), XTimeTuple(12, 13, 14))) > 0);
UT_ASSERT(cmpDateTime(make_pair(XDateTuple(2012, 12, 21), XTimeTuple(12, 13, 14)),
make_pair(XDateTuple(2012, 12, 21), XTimeTuple(12, 13, 15))) < 0);
UT_ASSERT(cmpDateTime(make_pair(XDateTuple(2012, 12, 22), XTimeTuple(12, 13, 14)),
make_pair(XDateTuple(2012, 12, 21), XTimeTuple(12, 13, 15))) > 0);
UT_ASSERT(cmpDateTime(make_pair(XDateTuple(2012, 12, 21), XTimeTuple(12, 13, 15)),
make_pair(XDateTuple(2012, 12, 22), XTimeTuple(12, 13, 14))) < 0);
UT_ASSERT(cmpDateTime(make_pair(XDateTuple(2012, 12, 22), XTimeTuple(12, 13, 15)),
make_pair(XDateTuple(2012, 12, 21), XTimeTuple(12, 13, 14))) > 0);
UT_ASSERT(cmpDateTime(make_pair(XDateTuple(2012, 12, 21), XTimeTuple(12, 13, 14)),
make_pair(XDateTuple(2012, 12, 22), XTimeTuple(12, 13, 15))) < 0);
}
static void testAdd(const pair<XDateTuple, XTimeTuple>& orig,
XDuration duration,
const pair<XDateTuple, XTimeTuple>& expected,
int line)
{
const pair<XDateTuple, XTimeTuple> result = addDuration(orig, duration);
UT_ASSERT_MESSAGE(XString::Format("Line# %d: [%s, %s] [%s, %s]\n",
line,
expected.first.ToISOExtString().c_str(),
expected.second.ToISOExtString().c_str(),
result.first.ToISOExtString().c_str(),
result.second.ToISOExtString().c_str()),
result == expected);
}
void XTimeTupleTest::TestAddDuration()
{
testAdd(make_pair(XDateTuple(1999, 1, 1), XTimeTuple(0, 0, 0)), XDuration::Zero(), make_pair(XDateTuple(1999, 1, 1), XTimeTuple(0, 0, 0)), __LINE__);
testAdd(make_pair(XDateTuple(1999, 1, 1), XTimeTuple(0, 0, 0)), XDuration(HNSECS, 1), make_pair(XDateTuple(1999, 1, 1), XTimeTuple(0, 0, 0)), __LINE__);
testAdd(make_pair(XDateTuple(1999, 1, 1), XTimeTuple(0, 0, 0)), XDuration(HNSECS, -1), make_pair(XDateTuple(1998, 12, 31), XTimeTuple(23, 59, 59)), __LINE__);
testAdd(make_pair(XDateTuple(1999, 1, 1), XTimeTuple(0, 0, 0)), XDuration(USECS, 1), make_pair(XDateTuple(1999, 1, 1), XTimeTuple(0, 0, 0)), __LINE__);
testAdd(make_pair(XDateTuple(1999, 1, 1), XTimeTuple(0, 0, 0)), XDuration(USECS, -1), make_pair(XDateTuple(1998, 12, 31), XTimeTuple(23, 59, 59)), __LINE__);
testAdd(make_pair(XDateTuple(1999, 1, 1), XTimeTuple(0, 0, 0)), XDuration(MSECS, 1), make_pair(XDateTuple(1999, 1, 1), XTimeTuple(0, 0, 0)), __LINE__);
testAdd(make_pair(XDateTuple(1999, 1, 1), XTimeTuple(0, 0, 0)), XDuration(MSECS, -1), make_pair(XDateTuple(1998, 12, 31), XTimeTuple(23, 59, 59)), __LINE__);
testAdd(make_pair(XDateTuple(1999, 1, 1), XTimeTuple(0, 0, 0)), XDuration(SECONDS, 1), make_pair(XDateTuple(1999, 1, 1), XTimeTuple(0, 0, 1)), __LINE__);
testAdd(make_pair(XDateTuple(1999, 1, 1), XTimeTuple(0, 0, 0)), XDuration(SECONDS, -1), make_pair(XDateTuple(1998, 12, 31), XTimeTuple(23, 59, 59)), __LINE__);
testAdd(make_pair(XDateTuple(1999, 1, 1), XTimeTuple(0, 0, 0)), XDuration(MINUTES, 1), make_pair(XDateTuple(1999, 1, 1), XTimeTuple(0, 1, 0)), __LINE__);
testAdd(make_pair(XDateTuple(1999, 1, 1), XTimeTuple(0, 0, 0)), XDuration(MINUTES, -1), make_pair(XDateTuple(1998, 12, 31), XTimeTuple(23, 59, 0)), __LINE__);
testAdd(make_pair(XDateTuple(1999, 1, 1), XTimeTuple(0, 0, 0)), XDuration(HOURS, 1), make_pair(XDateTuple(1999, 1, 1), XTimeTuple(1, 0, 0)), __LINE__);
testAdd(make_pair(XDateTuple(1999, 1, 1), XTimeTuple(0, 0, 0)), XDuration(HOURS, -1), make_pair(XDateTuple(1998, 12, 31), XTimeTuple(23, 0, 0)), __LINE__);
testAdd(make_pair(XDateTuple(1999, 1, 1), XTimeTuple(0, 0, 0)), XDuration(DAYS, 1), make_pair(XDateTuple(1999, 1, 2), XTimeTuple(0, 0, 0)), __LINE__);
testAdd(make_pair(XDateTuple(1999, 1, 1), XTimeTuple(0, 0, 0)), XDuration(DAYS, -1), make_pair(XDateTuple(1998, 12, 31), XTimeTuple(0, 0, 0)), __LINE__);
testAdd(make_pair(XDateTuple(1999, 1, 1), XTimeTuple(0, 0, 0)), XDuration(WEEKS, 1), make_pair(XDateTuple(1999, 1, 8), XTimeTuple(0, 0, 0)), __LINE__);
testAdd(make_pair(XDateTuple(1999, 1, 1), XTimeTuple(0, 0, 0)), XDuration(WEEKS, -1), make_pair(XDateTuple(1998, 12, 25), XTimeTuple(0, 0, 0)), __LINE__);
testAdd(make_pair(XDateTuple(1999, 12, 31), XTimeTuple(23, 59, 59)), XDuration(SECONDS, 1), make_pair(XDateTuple(2000, 1, 1), XTimeTuple(0, 0, 0)), __LINE__);
testAdd(make_pair(XDateTuple(1999, 12, 31), XTimeTuple(23, 59, 59)), XDuration(SECONDS, -1), make_pair(XDateTuple(1999, 12, 31), XTimeTuple(23, 59, 58)), __LINE__);
testAdd(make_pair(XDateTuple(1999, 12, 31), XTimeTuple(23, 59, 59)), XDuration(MINUTES, 1), make_pair(XDateTuple(2000, 1, 1), XTimeTuple(0, 0, 59)), __LINE__);
testAdd(make_pair(XDateTuple(1999, 12, 31), XTimeTuple(23, 59, 59)), XDuration(MINUTES, -1), make_pair(XDateTuple(1999, 12, 31), XTimeTuple(23, 58, 59)), __LINE__);
testAdd(make_pair(XDateTuple(1999, 12, 31), XTimeTuple(23, 59, 59)), XDuration(HOURS, 1), make_pair(XDateTuple(2000, 1, 1), XTimeTuple(0, 59, 59)), __LINE__);
testAdd(make_pair(XDateTuple(1999, 12, 31), XTimeTuple(23, 59, 59)), XDuration(HOURS, -1), make_pair(XDateTuple(1999, 12, 31), XTimeTuple(22, 59, 59)), __LINE__);
testAdd(make_pair(XDateTuple(1999, 12, 31), XTimeTuple(23, 59, 59)), XDuration(DAYS, 1), make_pair(XDateTuple(2000, 1, 1), XTimeTuple(23, 59, 59)), __LINE__);
testAdd(make_pair(XDateTuple(1999, 12, 31), XTimeTuple(23, 59, 59)), XDuration(DAYS, -1), make_pair(XDateTuple(1999, 12, 30), XTimeTuple(23, 59, 59)), __LINE__);
testAdd(make_pair(XDateTuple(1999, 12, 31), XTimeTuple(23, 59, 59)), XDuration(WEEKS, 1), make_pair(XDateTuple(2000, 1, 7), XTimeTuple(23, 59, 59)), __LINE__);
testAdd(make_pair(XDateTuple(1999, 12, 31), XTimeTuple(23, 59, 59)), XDuration(WEEKS, -1), make_pair(XDateTuple(1999, 12, 24), XTimeTuple(23, 59, 59)), __LINE__);
testAdd(make_pair(XDateTuple(1998, 12, 31), XTimeTuple(23, 59, 59)), XDuration(DAYS, 79) + XDuration(SECONDS, 512), make_pair(XDateTuple(1999, 3, 21), XTimeTuple(0, 8, 31)), __LINE__);
testAdd(make_pair(XDateTuple(1999, 12, 31), XTimeTuple(23, 59, 59)), XDuration(DAYS, 79) + XDuration(SECONDS, 512), make_pair(XDateTuple(2000, 3, 20), XTimeTuple(0, 8, 31)), __LINE__);
testAdd(make_pair(XDateTuple(1999, 3, 21), XTimeTuple(0, 8, 31)), -(XDuration(DAYS, 79) + XDuration(SECONDS, 512)), make_pair(XDateTuple(1998, 12, 31), XTimeTuple(23, 59, 59)), __LINE__);
testAdd(make_pair(XDateTuple(2000, 3, 20), XTimeTuple(0, 8, 31)), -(XDuration(DAYS, 79) + XDuration(SECONDS, 512)), make_pair(XDateTuple(1999, 12, 31), XTimeTuple(23, 59, 59)), __LINE__);
testAdd(make_pair(XDateTuple(1, 1, 1), XTimeTuple(0, 0, 0)), XDuration(SECONDS, 1), make_pair(XDateTuple(1, 1, 1), XTimeTuple(0, 0, 1)), __LINE__);
testAdd(make_pair(XDateTuple(1, 1, 1), XTimeTuple(0, 0, 0)), XDuration(SECONDS, -1), make_pair(XDateTuple(1, 1, 1), XTimeTuple(0, 0, 0)), __LINE__);
testAdd(make_pair(XDateTuple(2, 5, 12), XTimeTuple(7, 1, 5)), XDuration(DAYS, -5027), make_pair(XDateTuple(1, 1, 1), XTimeTuple(0, 0, 0)), __LINE__);
}
| 44.889369 | 191 | 0.630591 | MultiSight |
0b8d9fdad0ba1b34ec89e8bec996c31247d96ece | 5,027 | cpp | C++ | tests/testsType.cpp | markuspf/velocypack | 0cf8f21764f0336c32925ccd48f488cb8068a097 | [
"BSD-2-Clause",
"Apache-2.0"
] | 12,278 | 2015-01-29T17:11:33.000Z | 2022-03-31T21:12:00.000Z | tests/testsType.cpp | markuspf/velocypack | 0cf8f21764f0336c32925ccd48f488cb8068a097 | [
"BSD-2-Clause",
"Apache-2.0"
] | 9,469 | 2015-01-30T05:33:07.000Z | 2022-03-31T16:17:21.000Z | tests/testsType.cpp | markuspf/velocypack | 0cf8f21764f0336c32925ccd48f488cb8068a097 | [
"BSD-2-Clause",
"Apache-2.0"
] | 892 | 2015-01-29T16:26:19.000Z | 2022-03-20T07:44:30.000Z | ////////////////////////////////////////////////////////////////////////////////
/// @brief Library to build up VPack documents.
///
/// DISCLAIMER
///
/// Copyright 2015 ArangoDB GmbH, Cologne, Germany
///
/// 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.
///
/// Copyright holder is ArangoDB GmbH, Cologne, Germany
///
/// @author Max Neunhoeffer
/// @author Jan Steemann
/// @author Copyright 2015, ArangoDB GmbH, Cologne, Germany
////////////////////////////////////////////////////////////////////////////////
#include <ostream>
#include <string>
#include "tests-common.h"
TEST(TypesTest, TestGroups) {
ASSERT_EQ(ValueType::None, valueTypeGroup(ValueType::None));
ASSERT_EQ(ValueType::Null, valueTypeGroup(ValueType::Null));
ASSERT_EQ(ValueType::Bool, valueTypeGroup(ValueType::Bool));
ASSERT_EQ(ValueType::Double, valueTypeGroup(ValueType::Double));
ASSERT_EQ(ValueType::String, valueTypeGroup(ValueType::String));
ASSERT_EQ(ValueType::Array, valueTypeGroup(ValueType::Array));
ASSERT_EQ(ValueType::Object, valueTypeGroup(ValueType::Object));
ASSERT_EQ(ValueType::External, valueTypeGroup(ValueType::External));
ASSERT_EQ(ValueType::UTCDate, valueTypeGroup(ValueType::UTCDate));
ASSERT_EQ(ValueType::Double, valueTypeGroup(ValueType::Int));
ASSERT_EQ(ValueType::Double, valueTypeGroup(ValueType::UInt));
ASSERT_EQ(ValueType::Double, valueTypeGroup(ValueType::SmallInt));
ASSERT_EQ(ValueType::Binary, valueTypeGroup(ValueType::Binary));
ASSERT_EQ(ValueType::BCD, valueTypeGroup(ValueType::BCD));
ASSERT_EQ(ValueType::MinKey, valueTypeGroup(ValueType::MinKey));
ASSERT_EQ(ValueType::MaxKey, valueTypeGroup(ValueType::MaxKey));
ASSERT_EQ(ValueType::Custom, valueTypeGroup(ValueType::Custom));
}
TEST(TypesTest, TestNames) {
ASSERT_STREQ("none", valueTypeName(ValueType::None));
ASSERT_STREQ("null", valueTypeName(ValueType::Null));
ASSERT_STREQ("bool", valueTypeName(ValueType::Bool));
ASSERT_STREQ("double", valueTypeName(ValueType::Double));
ASSERT_STREQ("string", valueTypeName(ValueType::String));
ASSERT_STREQ("array", valueTypeName(ValueType::Array));
ASSERT_STREQ("object", valueTypeName(ValueType::Object));
ASSERT_STREQ("external", valueTypeName(ValueType::External));
ASSERT_STREQ("utc-date", valueTypeName(ValueType::UTCDate));
ASSERT_STREQ("int", valueTypeName(ValueType::Int));
ASSERT_STREQ("uint", valueTypeName(ValueType::UInt));
ASSERT_STREQ("smallint", valueTypeName(ValueType::SmallInt));
ASSERT_STREQ("binary", valueTypeName(ValueType::Binary));
ASSERT_STREQ("bcd", valueTypeName(ValueType::BCD));
ASSERT_STREQ("min-key", valueTypeName(ValueType::MinKey));
ASSERT_STREQ("max-key", valueTypeName(ValueType::MaxKey));
ASSERT_STREQ("custom", valueTypeName(ValueType::Custom));
}
TEST(TypesTest, TestNamesArrays) {
uint8_t const arrays[] = {0x01, 0x02, 0x03, 0x04, 0x05,
0x06, 0x07, 0x08, 0x9};
ASSERT_STREQ("array", valueTypeName(Slice(&arrays[0]).type()));
ASSERT_STREQ("array", valueTypeName(Slice(&arrays[1]).type()));
ASSERT_STREQ("array", valueTypeName(Slice(&arrays[2]).type()));
ASSERT_STREQ("array", valueTypeName(Slice(&arrays[3]).type()));
ASSERT_STREQ("array", valueTypeName(Slice(&arrays[4]).type()));
ASSERT_STREQ("array", valueTypeName(Slice(&arrays[5]).type()));
ASSERT_STREQ("array", valueTypeName(Slice(&arrays[6]).type()));
ASSERT_STREQ("array", valueTypeName(Slice(&arrays[7]).type()));
}
TEST(TypesTest, TestNamesObjects) {
uint8_t const objects[] = {0x0a, 0x0b, 0x0c, 0x0d, 0x0e};
ASSERT_STREQ("object", valueTypeName(Slice(&objects[0]).type()));
ASSERT_STREQ("object", valueTypeName(Slice(&objects[1]).type()));
ASSERT_STREQ("object", valueTypeName(Slice(&objects[2]).type()));
ASSERT_STREQ("object", valueTypeName(Slice(&objects[3]).type()));
ASSERT_STREQ("object", valueTypeName(Slice(&objects[4]).type()));
}
TEST(TypesTest, TestInvalidType) {
ASSERT_STREQ("unknown", valueTypeName(static_cast<ValueType>(0xff)));
}
TEST(TypesTest, TestStringifyObject) {
Builder b;
b.add(Value(ValueType::Object));
b.close();
Slice s(b.start());
std::ostringstream out;
out << s.type();
ASSERT_EQ("object", out.str());
}
TEST(TypesTest, TestStringifyArray) {
Builder b;
b.add(Value(ValueType::Array));
b.close();
Slice s(b.start());
std::ostringstream out;
out << s.type();
ASSERT_EQ("array", out.str());
}
int main(int argc, char* argv[]) {
::testing::InitGoogleTest(&argc, argv);
return RUN_ALL_TESTS();
}
| 39.582677 | 80 | 0.702208 | markuspf |
0b91c0ba01dd189d8fe58298364f21c8cfe4ab82 | 737 | cpp | C++ | Source/Graphics/GteSamplerState.cpp | vehsakul/gtl | 498bb20947e9ff21c08dd5a884ac3dc6f8313bb9 | [
"BSL-1.0"
] | null | null | null | Source/Graphics/GteSamplerState.cpp | vehsakul/gtl | 498bb20947e9ff21c08dd5a884ac3dc6f8313bb9 | [
"BSL-1.0"
] | null | null | null | Source/Graphics/GteSamplerState.cpp | vehsakul/gtl | 498bb20947e9ff21c08dd5a884ac3dc6f8313bb9 | [
"BSL-1.0"
] | null | null | null | // David Eberly, Geometric Tools, Redmond WA 98052
// Copyright (c) 1998-2016
// 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: 3.0.0 (2016/06/19)
#include <GTEnginePCH.h>
#include <Graphics/GteSamplerState.h>
using namespace gte;
SamplerState::SamplerState()
:
filter(MIN_P_MAG_P_MIP_P),
mipLODBias(0.0f),
maxAnisotropy(1),
comparison(NEVER),
borderColor({ 1.0f, 1.0f, 1.0f, 1.0f }),
minLOD(-std::numeric_limits<float>::max()),
maxLOD(std::numeric_limits<float>::max())
{
mType = GT_SAMPLER_STATE;
mode[0] = CLAMP;
mode[1] = CLAMP;
mode[2] = CLAMP;
}
| 24.566667 | 62 | 0.675712 | vehsakul |
0b97328fb46ad8f79b0555132af8e5b1f6625b9e | 215 | cc | C++ | cores/pico/picorv32/demo/src/decode_riscv_JALR.cc | yuex1994/iw_imdb | 946ce12d1b28075bfc513b2baf0f30601d36558c | [
"MIT"
] | 1 | 2020-05-30T17:34:03.000Z | 2020-05-30T17:34:03.000Z | cores/pico/picorv32/demo/src/decode_riscv_JALR.cc | yuex1994/iw_imdb | 946ce12d1b28075bfc513b2baf0f30601d36558c | [
"MIT"
] | null | null | null | cores/pico/picorv32/demo/src/decode_riscv_JALR.cc | yuex1994/iw_imdb | 946ce12d1b28075bfc513b2baf0f30601d36558c | [
"MIT"
] | 1 | 2020-02-26T03:35:51.000Z | 2020-02-26T03:35:51.000Z | #include "riscv.h"
bool riscv::decode_riscv_JALR() {
if (!1) {
return false;
}
uint7_t tmp_15 = 0 - 1;
c_15 = static_cast<uint7_t> ((riscv_inst >> 0) & tmp_15);
c_768 = c_15 == 103;
return c_768;
};
| 19.545455 | 59 | 0.604651 | yuex1994 |
0b9a50a4f6724669a76fe08028073b17c20054fb | 4,059 | cpp | C++ | api/autoware_iv_internal_api_adaptor/src/initial_pose.cpp | KevinXie86/AutowareArchitectureProposal.iv | 28c8c367652bcc5c2548abdab732e0fea7302653 | [
"Apache-2.0"
] | 88 | 2021-01-16T20:05:40.000Z | 2022-03-21T05:40:35.000Z | api/autoware_iv_internal_api_adaptor/src/initial_pose.cpp | KevinXie86/AutowareArchitectureProposal.iv | 28c8c367652bcc5c2548abdab732e0fea7302653 | [
"Apache-2.0"
] | 271 | 2021-01-13T16:54:09.000Z | 2022-02-25T16:26:07.000Z | api/autoware_iv_internal_api_adaptor/src/initial_pose.cpp | KevinXie86/AutowareArchitectureProposal.iv | 28c8c367652bcc5c2548abdab732e0fea7302653 | [
"Apache-2.0"
] | 68 | 2021-01-14T09:16:40.000Z | 2022-03-29T02:15:36.000Z | // Copyright 2021 Tier IV, Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
#include "initial_pose.hpp"
#include <memory>
namespace internal_api
{
InitialPose::InitialPose(const rclcpp::NodeOptions & options)
: Node("internal_api_initial_pose", options)
{
using namespace std::placeholders;
autoware_api_utils::ServiceProxyNodeInterface proxy(this);
init_simulator_pose_ = declare_parameter("init_simulator_pose", false);
init_localization_pose_ = declare_parameter("init_localization_pose", false);
group_ = create_callback_group(rclcpp::CallbackGroupType::MutuallyExclusive);
srv_set_initialize_pose_ = proxy.create_service<InitializePose>(
"/api/autoware/set/initialize_pose",
std::bind(&InitialPose::setInitializePose, this, _1, _2),
rmw_qos_profile_services_default, group_);
srv_set_initialize_pose_auto_ = proxy.create_service<InitializePoseAuto>(
"/api/autoware/set/initialize_pose_auto",
std::bind(&InitialPose::setInitializePoseAuto, this, _1, _2),
rmw_qos_profile_services_default, group_);
if (init_localization_pose_) {
cli_set_initialize_pose_ = proxy.create_client<PoseWithCovarianceStampedSrv>(
"/localization/util/initialize_pose",
rmw_qos_profile_services_default);
cli_set_initialize_pose_auto_ = proxy.create_client<InitializePoseAuto>(
"/localization/util/initialize_pose_auto",
rmw_qos_profile_services_default);
}
if (init_simulator_pose_) {
cli_set_simulator_pose_ = proxy.create_client<InitializePose>(
"/api/simulator/set/pose",
rmw_qos_profile_services_default);
pub_initialpose2d_ = create_publisher<geometry_msgs::msg::PoseWithCovarianceStamped>(
"/initialpose2d", rclcpp::QoS(1));
}
}
void InitialPose::setInitializePose(
const autoware_external_api_msgs::srv::InitializePose::Request::SharedPtr request,
const autoware_external_api_msgs::srv::InitializePose::Response::SharedPtr response)
{
response->status = autoware_api_utils::response_ignored("No processing.");
if (init_simulator_pose_) {
const auto [status, resp] = cli_set_simulator_pose_->call(request);
if (!autoware_api_utils::is_success(status)) {
response->status = status;
return;
}
pub_initialpose2d_->publish(request->pose);
response->status = resp->status;
}
if (init_localization_pose_) {
const auto req = std::make_shared<PoseWithCovarianceStampedSrv::Request>();
req->pose_with_cov = request->pose;
const auto [status, resp] = cli_set_initialize_pose_->call(req);
if (!autoware_api_utils::is_success(status)) {
response->status = status;
return;
}
if (resp->success) {
response->status = autoware_api_utils::response_success();
} else {
response->status = autoware_api_utils::response_error("Internal service failed.");
}
}
}
void InitialPose::setInitializePoseAuto(
const autoware_external_api_msgs::srv::InitializePoseAuto::Request::SharedPtr request,
const autoware_external_api_msgs::srv::InitializePoseAuto::Response::SharedPtr response)
{
response->status = autoware_api_utils::response_ignored("No processing.");
if (init_localization_pose_) {
const auto [status, resp] = cli_set_initialize_pose_auto_->call(request);
if (!autoware_api_utils::is_success(status)) {
response->status = status;
return;
}
response->status = resp->status;
}
}
} // namespace internal_api
#include "rclcpp_components/register_node_macro.hpp"
RCLCPP_COMPONENTS_REGISTER_NODE(internal_api::InitialPose)
| 36.9 | 90 | 0.752648 | KevinXie86 |
0b9ab9fcbbdd6e8d1c97ce245b01e71b34a27318 | 7,190 | cpp | C++ | src/FileUtils.cpp | omi-lab/tp_utils | cb4fa24f418b7a9cc95f7f574ed724d9ed378528 | [
"MIT"
] | null | null | null | src/FileUtils.cpp | omi-lab/tp_utils | cb4fa24f418b7a9cc95f7f574ed724d9ed378528 | [
"MIT"
] | null | null | null | src/FileUtils.cpp | omi-lab/tp_utils | cb4fa24f418b7a9cc95f7f574ed724d9ed378528 | [
"MIT"
] | null | null | null | #include "tp_utils/FileUtils.h"
#include <fstream>
#include <streambuf>
namespace tp_utils
{
//##################################################################################################
std::string TP_UTILS_SHARED_EXPORT readTextFile(const std::string& fileName)
{
try
{
std::ifstream in(fileName);
return std::string((std::istreambuf_iterator<char>(in)), std::istreambuf_iterator<char>());
}
catch(...)
{
return std::string();
}
}
//##################################################################################################
std::string TP_UTILS_SHARED_EXPORT readBinaryFile(const std::string& fileName)
{
try
{
std::ifstream in(fileName, std::ios::binary | std::ios::ate);
std::string results;
auto size = in.tellg();
if(size>0)
{
results.resize(size_t(size));
in.seekg(0);
int64_t read=0;
while(read<size && !in.eof())
{
in.read(&results[size_t(read)], ptrdiff_t(size)-ptrdiff_t(read));
read += int64_t(in.gcount());
}
if(size_t(read)!=results.size())
results.resize(size_t(read));
}
return results;
}
catch(...)
{
return std::string();
}
}
//##################################################################################################
bool TP_UTILS_SHARED_EXPORT writeTextFile(const std::string& fileName, const std::string& textOutput, bool append)
{
try
{
std::ofstream out;
if(append)
out.open(fileName, std::ios_base::out | std::ios_base::app);
else
out.open(fileName, std::ios_base::out | std::ios_base::trunc);
out << textOutput;
return true;
}
catch(...)
{
return false;
}
}
//##################################################################################################
bool TP_UTILS_SHARED_EXPORT writeBinaryFile(const std::string& fileName, const std::string& textOutput)
{
try
{
std::ofstream out(fileName, std::ios::binary);
out << textOutput;
return true;
}
catch(...)
{
return false;
}
}
//##################################################################################################
nlohmann::json TP_UTILS_SHARED_EXPORT readJSONFile(const std::string& fileName)
{
try
{
std::string str = readTextFile(fileName);
return nlohmann::json::parse(str);
}
catch(...)
{
return nlohmann::json();
}
}
//##################################################################################################
bool writeJSONFile(const std::string& fileName, const nlohmann::json& j, int indent)
{
try
{
std::string s = j.dump(indent);
return writeTextFile(fileName, s);
}
catch(...)
{
return false;
}
}
//##################################################################################################
bool writePrettyJSONFile(const std::string& fileName, const nlohmann::json& j)
{
try
{
std::string s = j.dump(2);
return writeTextFile(fileName, s);
}
catch(...)
{
return false;
}
}
//##################################################################################################
std::vector<std::string> (*listFilesCallback)(const std::string& path, const std::unordered_set<std::string>& extensions)=nullptr;
std::vector<std::string> (*listDirectoriesCallback)(const std::string& path)=nullptr;
int64_t (*fileTimeMSCallback)(const std::string& path)=nullptr;
bool (*copyFileCallback)(const std::string& pathFrom, const std::string& pathTo)=nullptr;
bool (*mkdirCallback)(const std::string& path, CreateFullPath createFullPath)=nullptr;
bool (*rmCallback)(const std::string& path, bool recursive)=nullptr;
bool (*existsCallback)(const std::string& path)=nullptr;
size_t (*fileSizeCallback)(const std::string& path)=nullptr;
bool (*setCWDCallback)(const std::string& path)=nullptr;
bool (*setPermissionsCallback)(const std::string& path, unsigned permissionsh)=nullptr;
//##################################################################################################
std::vector<std::string> listFiles(const std::string& path, const std::unordered_set<std::string>& extensions)
{
return listFilesCallback?listFilesCallback(path, extensions):std::vector<std::string>();
}
//##################################################################################################
std::vector<std::string> listDirectories(const std::string& path)
{
return listDirectoriesCallback?listDirectoriesCallback(path):std::vector<std::string>();
}
//##################################################################################################
int64_t fileTimeMS(const std::string& path)
{
return fileTimeMSCallback?fileTimeMSCallback(path):0;
}
//##################################################################################################
bool copyFile(const std::string& pathFrom, const std::string& pathTo)
{
return copyFileCallback?copyFileCallback(pathFrom, pathTo):false;
}
//##################################################################################################
bool mkdir(const std::string& path, CreateFullPath createFullPath)
{
return mkdirCallback?mkdirCallback(path, createFullPath):false;
}
//##################################################################################################
bool rm(const std::string& path, bool recursive)
{
return rmCallback?rmCallback(path, recursive):false;
}
//##################################################################################################
bool exists(const std::string& path)
{
return existsCallback?existsCallback(path):false;
}
//##################################################################################################
size_t fileSize(const std::string& path)
{
return fileSizeCallback?fileSizeCallback(path):0;
}
//##################################################################################################
bool setCWD(const std::string& path)
{
return setCWDCallback?setCWDCallback(path):false;
}
namespace
{
#ifdef TP_WIN32
char del = '\\';
#else
char del = '/';
#endif
}
//##################################################################################################
bool setPermissions(const std::string& path, unsigned permissions)
{
return setPermissionsCallback?setPermissionsCallback(path, permissions):false;
}
//##################################################################################################
std::string fileName(const std::string& path)
{
std::vector<std::string> results;
tpSplit(results, path, del, SplitBehavior::SkipEmptyParts);
return results.empty()?"":results.back();
}
//##################################################################################################
std::string directoryName(const std::string& path)
{
auto i = path.find_last_of("\\/");
if(i != std::string::npos)
return path.substr(0, i);
return "";
}
//##################################################################################################
std::string pathAppend(const std::string& path, const std::string& part)
{
auto result = path;
if(!result.empty())
if(!tpEndsWith(result, std::string(1, del)))
result.push_back(del);
return result + part;
}
}
| 29.588477 | 130 | 0.484423 | omi-lab |
0b9eefd450416d7fbd226a21f513e742c6e6cf8a | 4,466 | cpp | C++ | tc 160+/CubeRoll.cpp | ibudiselic/contest-problem-solutions | 88082981b4d87da843472e3ca9ed5f4c42b3f0aa | [
"BSD-2-Clause"
] | 3 | 2015-05-25T06:24:37.000Z | 2016-09-10T07:58:00.000Z | tc 160+/CubeRoll.cpp | ibudiselic/contest-problem-solutions | 88082981b4d87da843472e3ca9ed5f4c42b3f0aa | [
"BSD-2-Clause"
] | null | null | null | tc 160+/CubeRoll.cpp | ibudiselic/contest-problem-solutions | 88082981b4d87da843472e3ca9ed5f4c42b3f0aa | [
"BSD-2-Clause"
] | 5 | 2015-05-25T06:24:40.000Z | 2021-08-19T19:22:29.000Z | #include <algorithm>
#include <cassert>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <sstream>
#include <string>
#include <vector>
#include <set>
#include <queue>
using namespace std;
bool done[100001];
int solve(int a, int b, int x, int y) {
memset(done, 0, sizeof done);
queue<int> Q;
Q.push(a);
int dist = 0;
int sz = 0;
done[a] = true;
while (!Q.empty()) {
if (sz == 0) {
++dist;
sz = Q.size();
}
a = Q.front();
Q.pop();
--sz;
for (int i=1; i<1000; ++i) {
int move = i*i;
if (a-move>x && !done[a-move]) {
if (a-move == b) {
return dist;
}
done[a-move] = true;
Q.push(a-move);
}
if (a+move<y && !done[a+move]) {
if (a+move == b) {
return dist;
}
done[a+move] = true;
Q.push(a+move);
}
}
}
return -1;
}
int solve(int a, int b) {
set<long long> squares;
for (long long i=1; i<50001; ++i) {
squares.insert(i*i);
}
int d = abs(a-b);
if (squares.count(d)) {
return 1;
}
for (set<long long>::const_iterator it=squares.begin(); it!=squares.end(); ++it) {
if (*it<d && squares.count(d-*it)) {
return 2;
} else if (*it>d && squares.count(*it-d)) {
return 2;
}
}
return 3;
}
class CubeRoll {
public:
int getMinimumSteps(int a, int b, vector <int> P) {
sort(P.begin(), P.end());
if (a < P[0]) {
if (b < P[0]) {
return solve(a, b);
} else {
return -1;
}
} else if (a > P.back()) {
if (b > P.back()) {
return solve(a, b);
} else {
return -1;
}
} else {
int p = lower_bound(P.begin(), P.end(), a) - P.begin();
if (P[p-1]<b && b<P[p]) {
return solve(a, b, P[p-1], P[p]);
} else {
return -1;
}
}
}
// BEGIN CUT HERE
public:
void run_test(int Case) { if ((Case == -1) || (Case == 0)) test_case_0(); if ((Case == -1) || (Case == 1)) test_case_1(); if ((Case == -1) || (Case == 2)) test_case_2(); if ((Case == -1) || (Case == 3)) test_case_3(); if ((Case == -1) || (Case == 4)) test_case_4(); }
private:
template <typename T> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
void verify_case(int Case, const int &Expected, const int &Received) { cerr << "Test Case #" << Case << "..."; if (Expected == Received) cerr << "PASSED" << endl; else { cerr << "FAILED" << endl; cerr << "\tExpected: \"" << Expected << '\"' << endl; cerr << "\tReceived: \"" << Received << '\"' << endl; } }
void test_case_0() { int Arg0 = 5; int Arg1 = 1; int Arr2[] = {3}; vector <int> Arg2(Arr2, Arr2 + (sizeof(Arr2) / sizeof(Arr2[0]))); int Arg3 = -1; verify_case(0, Arg3, getMinimumSteps(Arg0, Arg1, Arg2)); }
void test_case_1() { int Arg0 = 36; int Arg1 = 72; int Arr2[] = {300, 100, 200, 400}; vector <int> Arg2(Arr2, Arr2 + (sizeof(Arr2) / sizeof(Arr2[0]))); int Arg3 = 1; verify_case(1, Arg3, getMinimumSteps(Arg0, Arg1, Arg2)); }
void test_case_2() { int Arg0 = 10; int Arg1 = 21; int Arr2[] = {38,45}; vector <int> Arg2(Arr2, Arr2 + (sizeof(Arr2) / sizeof(Arr2[0]))); int Arg3 = 2; verify_case(2, Arg3, getMinimumSteps(Arg0, Arg1, Arg2)); }
void test_case_3() { int Arg0 = 98765; int Arg1 = 4963; int Arr2[] = {10,20,40,30}; vector <int> Arg2(Arr2, Arr2 + (sizeof(Arr2) / sizeof(Arr2[0]))); int Arg3 = 2; verify_case(3, Arg3, getMinimumSteps(Arg0, Arg1, Arg2)); }
void test_case_4() { int Arg0 = 68332; int Arg1 = 825; int Arr2[] = {99726,371,67,89210}; vector <int> Arg2(Arr2, Arr2 + (sizeof(Arr2) / sizeof(Arr2[0]))); int Arg3 = 2; verify_case(4, Arg3, getMinimumSteps(Arg0, Arg1, Arg2)); }
// END CUT HERE
};
// BEGIN CUT HERE
int main()
{
CubeRoll ___test;
___test.run_test(-1);
}
// END CUT HERE
| 34.890625 | 309 | 0.478728 | ibudiselic |
0ba43aeceb5658d59f6183f177c35b23db44dd80 | 2,455 | cpp | C++ | tests/AllegroFlare/RandomTest.cpp | MarkOates/allegro_flare | b454cb85eb5e43d19c23c0c6fd2dc11b96666ce7 | [
"MIT"
] | 25 | 2015-03-30T02:02:43.000Z | 2019-03-04T22:29:12.000Z | tests/AllegroFlare/RandomTest.cpp | MarkOates/allegro_flare | b454cb85eb5e43d19c23c0c6fd2dc11b96666ce7 | [
"MIT"
] | 122 | 2015-04-01T08:15:26.000Z | 2019-10-16T20:31:22.000Z | tests/AllegroFlare/RandomTest.cpp | MarkOates/allegro_flare | b454cb85eb5e43d19c23c0c6fd2dc11b96666ce7 | [
"MIT"
] | 4 | 2016-09-02T12:14:09.000Z | 2018-11-23T20:38:49.000Z |
#include <gtest/gtest.h>
#include <AllegroFlare/Random.hpp>
TEST(AllegroFlare_RandomTest, gets_the_current_seed)
{
AllegroFlare::Random number_generator = AllegroFlare::Random(123);
ASSERT_EQ(123, number_generator.get_seed());
}
TEST(AllegroFlare_RandomTest, sets_the_current_seed)
{
AllegroFlare::Random number_generator = AllegroFlare::Random(123);
number_generator.set_seed(456);
ASSERT_EQ(456, number_generator.get_seed());
}
TEST(AllegroFlare_RandomTest, only_returns_integers_within_the_bounds_inclusive)
{
AllegroFlare::Random number_generator = AllegroFlare::Random(123);
const int min_random_num = 1;
const int max_random_num = 3;
for (int i=0; i<1000; i++)
{
int val = number_generator.get_random_int(min_random_num, max_random_num);
ASSERT_TRUE(val <= max_random_num);
ASSERT_TRUE(val >= min_random_num);
}
}
TEST(AllegroFlare_RandomTest, only_returns_doubles_within_the_bounds_inclusive)
{
AllegroFlare::Random number_generator = AllegroFlare::Random(123);
const double min_random_num = 1.0;
const double max_random_num = 3.0;
for (int i=0; i<1000; i++)
{
double val = number_generator.get_random_double(min_random_num, max_random_num);
ASSERT_TRUE(val <= max_random_num);
ASSERT_TRUE(val >= min_random_num);
}
}
TEST(AllegroFlare_RandomTest, only_returns_floats_within_the_bounds_inclusive)
{
AllegroFlare::Random number_generator = AllegroFlare::Random(123);
const float min_random_num = 1.0;
const float max_random_num = 3.0;
for (int i=0; i<1000; i++)
{
float val = number_generator.get_random_float(min_random_num, max_random_num);
ASSERT_TRUE(val <= max_random_num);
ASSERT_TRUE(val >= min_random_num);
}
}
TEST(RandomTest, DISABLED_returns_an_expected_sequence_of_random_numbers_given_a_seed)
{
// TODO, these results are different, depending on platform (MacOS, Win).
// It's *possible* the results could be different on different devices of the
// same OS, too, (but this has not been tested)
AllegroFlare::Random number_generator = AllegroFlare::Random(123456);
const int min_random_num = 0;
const int max_random_num = 10;
std::vector<int> expected_numbers = {1, 10, 2, 1, 8};
for (int i=0; i<expected_numbers.size(); i++)
{
int val = number_generator.get_random_int(min_random_num, max_random_num);
ASSERT_EQ(expected_numbers[i], val);
}
}
| 26.684783 | 86 | 0.731568 | MarkOates |
24392ec5778dc52e78bd8d93517094c6e0a92d22 | 18,609 | cc | C++ | wrappers/7.0.0/vtkCylinderSourceWrap.cc | axkibe/node-vtk | 900ad7b5500f672519da5aa24c99aa5a96466ef3 | [
"BSD-3-Clause"
] | 6 | 2016-02-03T12:48:36.000Z | 2020-09-16T15:07:51.000Z | wrappers/7.0.0/vtkCylinderSourceWrap.cc | axkibe/node-vtk | 900ad7b5500f672519da5aa24c99aa5a96466ef3 | [
"BSD-3-Clause"
] | 4 | 2016-02-13T01:30:43.000Z | 2020-03-30T16:59:32.000Z | wrappers/7.0.0/vtkCylinderSourceWrap.cc | axkibe/node-vtk | 900ad7b5500f672519da5aa24c99aa5a96466ef3 | [
"BSD-3-Clause"
] | null | null | null | /* this file has been autogenerated by vtkNodeJsWrap */
/* editing this might proof futile */
#define VTK_WRAPPING_CXX
#define VTK_STREAMS_FWD_ONLY
#include <nan.h>
#include "vtkPolyDataAlgorithmWrap.h"
#include "vtkCylinderSourceWrap.h"
#include "vtkObjectWrap.h"
#include "../../plus/plus.h"
using namespace v8;
extern Nan::Persistent<v8::Object> vtkNodeJsNoWrap;
Nan::Persistent<v8::FunctionTemplate> VtkCylinderSourceWrap::ptpl;
VtkCylinderSourceWrap::VtkCylinderSourceWrap()
{ }
VtkCylinderSourceWrap::VtkCylinderSourceWrap(vtkSmartPointer<vtkCylinderSource> _native)
{ native = _native; }
VtkCylinderSourceWrap::~VtkCylinderSourceWrap()
{ }
void VtkCylinderSourceWrap::Init(v8::Local<v8::Object> exports)
{
Nan::SetAccessor(exports, Nan::New("vtkCylinderSource").ToLocalChecked(), ConstructorGetter);
Nan::SetAccessor(exports, Nan::New("CylinderSource").ToLocalChecked(), ConstructorGetter);
}
void VtkCylinderSourceWrap::ConstructorGetter(
v8::Local<v8::String> property,
const Nan::PropertyCallbackInfo<v8::Value>& info)
{
InitPtpl();
info.GetReturnValue().Set(Nan::New(ptpl)->GetFunction());
}
void VtkCylinderSourceWrap::InitPtpl()
{
if (!ptpl.IsEmpty()) return;
v8::Local<v8::FunctionTemplate> tpl = Nan::New<v8::FunctionTemplate>(New);
VtkPolyDataAlgorithmWrap::InitPtpl( );
tpl->Inherit(Nan::New<FunctionTemplate>(VtkPolyDataAlgorithmWrap::ptpl));
tpl->SetClassName(Nan::New("VtkCylinderSourceWrap").ToLocalChecked());
tpl->InstanceTemplate()->SetInternalFieldCount(1);
Nan::SetPrototypeMethod(tpl, "CappingOff", CappingOff);
Nan::SetPrototypeMethod(tpl, "cappingOff", CappingOff);
Nan::SetPrototypeMethod(tpl, "CappingOn", CappingOn);
Nan::SetPrototypeMethod(tpl, "cappingOn", CappingOn);
Nan::SetPrototypeMethod(tpl, "GetCapping", GetCapping);
Nan::SetPrototypeMethod(tpl, "getCapping", GetCapping);
Nan::SetPrototypeMethod(tpl, "GetCenter", GetCenter);
Nan::SetPrototypeMethod(tpl, "getCenter", GetCenter);
Nan::SetPrototypeMethod(tpl, "GetClassName", GetClassName);
Nan::SetPrototypeMethod(tpl, "getClassName", GetClassName);
Nan::SetPrototypeMethod(tpl, "GetHeight", GetHeight);
Nan::SetPrototypeMethod(tpl, "getHeight", GetHeight);
Nan::SetPrototypeMethod(tpl, "GetHeightMaxValue", GetHeightMaxValue);
Nan::SetPrototypeMethod(tpl, "getHeightMaxValue", GetHeightMaxValue);
Nan::SetPrototypeMethod(tpl, "GetHeightMinValue", GetHeightMinValue);
Nan::SetPrototypeMethod(tpl, "getHeightMinValue", GetHeightMinValue);
Nan::SetPrototypeMethod(tpl, "GetOutputPointsPrecision", GetOutputPointsPrecision);
Nan::SetPrototypeMethod(tpl, "getOutputPointsPrecision", GetOutputPointsPrecision);
Nan::SetPrototypeMethod(tpl, "GetRadius", GetRadius);
Nan::SetPrototypeMethod(tpl, "getRadius", GetRadius);
Nan::SetPrototypeMethod(tpl, "GetRadiusMaxValue", GetRadiusMaxValue);
Nan::SetPrototypeMethod(tpl, "getRadiusMaxValue", GetRadiusMaxValue);
Nan::SetPrototypeMethod(tpl, "GetRadiusMinValue", GetRadiusMinValue);
Nan::SetPrototypeMethod(tpl, "getRadiusMinValue", GetRadiusMinValue);
Nan::SetPrototypeMethod(tpl, "GetResolution", GetResolution);
Nan::SetPrototypeMethod(tpl, "getResolution", GetResolution);
Nan::SetPrototypeMethod(tpl, "GetResolutionMaxValue", GetResolutionMaxValue);
Nan::SetPrototypeMethod(tpl, "getResolutionMaxValue", GetResolutionMaxValue);
Nan::SetPrototypeMethod(tpl, "GetResolutionMinValue", GetResolutionMinValue);
Nan::SetPrototypeMethod(tpl, "getResolutionMinValue", GetResolutionMinValue);
Nan::SetPrototypeMethod(tpl, "IsA", IsA);
Nan::SetPrototypeMethod(tpl, "isA", IsA);
Nan::SetPrototypeMethod(tpl, "NewInstance", NewInstance);
Nan::SetPrototypeMethod(tpl, "newInstance", NewInstance);
Nan::SetPrototypeMethod(tpl, "SafeDownCast", SafeDownCast);
Nan::SetPrototypeMethod(tpl, "safeDownCast", SafeDownCast);
Nan::SetPrototypeMethod(tpl, "SetCapping", SetCapping);
Nan::SetPrototypeMethod(tpl, "setCapping", SetCapping);
Nan::SetPrototypeMethod(tpl, "SetCenter", SetCenter);
Nan::SetPrototypeMethod(tpl, "setCenter", SetCenter);
Nan::SetPrototypeMethod(tpl, "SetHeight", SetHeight);
Nan::SetPrototypeMethod(tpl, "setHeight", SetHeight);
Nan::SetPrototypeMethod(tpl, "SetOutputPointsPrecision", SetOutputPointsPrecision);
Nan::SetPrototypeMethod(tpl, "setOutputPointsPrecision", SetOutputPointsPrecision);
Nan::SetPrototypeMethod(tpl, "SetRadius", SetRadius);
Nan::SetPrototypeMethod(tpl, "setRadius", SetRadius);
Nan::SetPrototypeMethod(tpl, "SetResolution", SetResolution);
Nan::SetPrototypeMethod(tpl, "setResolution", SetResolution);
#ifdef VTK_NODE_PLUS_VTKCYLINDERSOURCEWRAP_INITPTPL
VTK_NODE_PLUS_VTKCYLINDERSOURCEWRAP_INITPTPL
#endif
ptpl.Reset( tpl );
}
void VtkCylinderSourceWrap::New(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
if(!info.IsConstructCall())
{
Nan::ThrowError("Constructor not called in a construct call.");
return;
}
if(info.Length() == 0)
{
vtkSmartPointer<vtkCylinderSource> native = vtkSmartPointer<vtkCylinderSource>::New();
VtkCylinderSourceWrap* obj = new VtkCylinderSourceWrap(native);
obj->Wrap(info.This());
}
else
{
if(info[0]->ToObject() != vtkNodeJsNoWrap )
{
Nan::ThrowError("Parameter Error");
return;
}
}
info.GetReturnValue().Set(info.This());
}
void VtkCylinderSourceWrap::CappingOff(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
VtkCylinderSourceWrap *wrapper = ObjectWrap::Unwrap<VtkCylinderSourceWrap>(info.Holder());
vtkCylinderSource *native = (vtkCylinderSource *)wrapper->native.GetPointer();
if(info.Length() != 0)
{
Nan::ThrowError("Too many parameters.");
return;
}
native->CappingOff();
}
void VtkCylinderSourceWrap::CappingOn(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
VtkCylinderSourceWrap *wrapper = ObjectWrap::Unwrap<VtkCylinderSourceWrap>(info.Holder());
vtkCylinderSource *native = (vtkCylinderSource *)wrapper->native.GetPointer();
if(info.Length() != 0)
{
Nan::ThrowError("Too many parameters.");
return;
}
native->CappingOn();
}
void VtkCylinderSourceWrap::GetCapping(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
VtkCylinderSourceWrap *wrapper = ObjectWrap::Unwrap<VtkCylinderSourceWrap>(info.Holder());
vtkCylinderSource *native = (vtkCylinderSource *)wrapper->native.GetPointer();
int r;
if(info.Length() != 0)
{
Nan::ThrowError("Too many parameters.");
return;
}
r = native->GetCapping();
info.GetReturnValue().Set(Nan::New(r));
}
void VtkCylinderSourceWrap::GetCenter(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
VtkCylinderSourceWrap *wrapper = ObjectWrap::Unwrap<VtkCylinderSourceWrap>(info.Holder());
vtkCylinderSource *native = (vtkCylinderSource *)wrapper->native.GetPointer();
double const * r;
if(info.Length() != 0)
{
Nan::ThrowError("Too many parameters.");
return;
}
r = native->GetCenter();
Local<v8::ArrayBuffer> ab = v8::ArrayBuffer::New(v8::Isolate::GetCurrent(), 3 * sizeof(double));
Local<v8::Float64Array> at = v8::Float64Array::New(ab, 0, 3);
memcpy(ab->GetContents().Data(), r, 3 * sizeof(double));
info.GetReturnValue().Set(at);
}
void VtkCylinderSourceWrap::GetClassName(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
VtkCylinderSourceWrap *wrapper = ObjectWrap::Unwrap<VtkCylinderSourceWrap>(info.Holder());
vtkCylinderSource *native = (vtkCylinderSource *)wrapper->native.GetPointer();
char const * r;
if(info.Length() != 0)
{
Nan::ThrowError("Too many parameters.");
return;
}
r = native->GetClassName();
info.GetReturnValue().Set(Nan::New(r).ToLocalChecked());
}
void VtkCylinderSourceWrap::GetHeight(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
VtkCylinderSourceWrap *wrapper = ObjectWrap::Unwrap<VtkCylinderSourceWrap>(info.Holder());
vtkCylinderSource *native = (vtkCylinderSource *)wrapper->native.GetPointer();
double r;
if(info.Length() != 0)
{
Nan::ThrowError("Too many parameters.");
return;
}
r = native->GetHeight();
info.GetReturnValue().Set(Nan::New(r));
}
void VtkCylinderSourceWrap::GetHeightMaxValue(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
VtkCylinderSourceWrap *wrapper = ObjectWrap::Unwrap<VtkCylinderSourceWrap>(info.Holder());
vtkCylinderSource *native = (vtkCylinderSource *)wrapper->native.GetPointer();
double r;
if(info.Length() != 0)
{
Nan::ThrowError("Too many parameters.");
return;
}
r = native->GetHeightMaxValue();
info.GetReturnValue().Set(Nan::New(r));
}
void VtkCylinderSourceWrap::GetHeightMinValue(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
VtkCylinderSourceWrap *wrapper = ObjectWrap::Unwrap<VtkCylinderSourceWrap>(info.Holder());
vtkCylinderSource *native = (vtkCylinderSource *)wrapper->native.GetPointer();
double r;
if(info.Length() != 0)
{
Nan::ThrowError("Too many parameters.");
return;
}
r = native->GetHeightMinValue();
info.GetReturnValue().Set(Nan::New(r));
}
void VtkCylinderSourceWrap::GetOutputPointsPrecision(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
VtkCylinderSourceWrap *wrapper = ObjectWrap::Unwrap<VtkCylinderSourceWrap>(info.Holder());
vtkCylinderSource *native = (vtkCylinderSource *)wrapper->native.GetPointer();
int r;
if(info.Length() != 0)
{
Nan::ThrowError("Too many parameters.");
return;
}
r = native->GetOutputPointsPrecision();
info.GetReturnValue().Set(Nan::New(r));
}
void VtkCylinderSourceWrap::GetRadius(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
VtkCylinderSourceWrap *wrapper = ObjectWrap::Unwrap<VtkCylinderSourceWrap>(info.Holder());
vtkCylinderSource *native = (vtkCylinderSource *)wrapper->native.GetPointer();
double r;
if(info.Length() != 0)
{
Nan::ThrowError("Too many parameters.");
return;
}
r = native->GetRadius();
info.GetReturnValue().Set(Nan::New(r));
}
void VtkCylinderSourceWrap::GetRadiusMaxValue(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
VtkCylinderSourceWrap *wrapper = ObjectWrap::Unwrap<VtkCylinderSourceWrap>(info.Holder());
vtkCylinderSource *native = (vtkCylinderSource *)wrapper->native.GetPointer();
double r;
if(info.Length() != 0)
{
Nan::ThrowError("Too many parameters.");
return;
}
r = native->GetRadiusMaxValue();
info.GetReturnValue().Set(Nan::New(r));
}
void VtkCylinderSourceWrap::GetRadiusMinValue(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
VtkCylinderSourceWrap *wrapper = ObjectWrap::Unwrap<VtkCylinderSourceWrap>(info.Holder());
vtkCylinderSource *native = (vtkCylinderSource *)wrapper->native.GetPointer();
double r;
if(info.Length() != 0)
{
Nan::ThrowError("Too many parameters.");
return;
}
r = native->GetRadiusMinValue();
info.GetReturnValue().Set(Nan::New(r));
}
void VtkCylinderSourceWrap::GetResolution(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
VtkCylinderSourceWrap *wrapper = ObjectWrap::Unwrap<VtkCylinderSourceWrap>(info.Holder());
vtkCylinderSource *native = (vtkCylinderSource *)wrapper->native.GetPointer();
int r;
if(info.Length() != 0)
{
Nan::ThrowError("Too many parameters.");
return;
}
r = native->GetResolution();
info.GetReturnValue().Set(Nan::New(r));
}
void VtkCylinderSourceWrap::GetResolutionMaxValue(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
VtkCylinderSourceWrap *wrapper = ObjectWrap::Unwrap<VtkCylinderSourceWrap>(info.Holder());
vtkCylinderSource *native = (vtkCylinderSource *)wrapper->native.GetPointer();
int r;
if(info.Length() != 0)
{
Nan::ThrowError("Too many parameters.");
return;
}
r = native->GetResolutionMaxValue();
info.GetReturnValue().Set(Nan::New(r));
}
void VtkCylinderSourceWrap::GetResolutionMinValue(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
VtkCylinderSourceWrap *wrapper = ObjectWrap::Unwrap<VtkCylinderSourceWrap>(info.Holder());
vtkCylinderSource *native = (vtkCylinderSource *)wrapper->native.GetPointer();
int r;
if(info.Length() != 0)
{
Nan::ThrowError("Too many parameters.");
return;
}
r = native->GetResolutionMinValue();
info.GetReturnValue().Set(Nan::New(r));
}
void VtkCylinderSourceWrap::IsA(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
VtkCylinderSourceWrap *wrapper = ObjectWrap::Unwrap<VtkCylinderSourceWrap>(info.Holder());
vtkCylinderSource *native = (vtkCylinderSource *)wrapper->native.GetPointer();
if(info.Length() > 0 && info[0]->IsString())
{
Nan::Utf8String a0(info[0]);
int r;
if(info.Length() != 1)
{
Nan::ThrowError("Too many parameters.");
return;
}
r = native->IsA(
*a0
);
info.GetReturnValue().Set(Nan::New(r));
return;
}
Nan::ThrowError("Parameter mismatch");
}
void VtkCylinderSourceWrap::NewInstance(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
VtkCylinderSourceWrap *wrapper = ObjectWrap::Unwrap<VtkCylinderSourceWrap>(info.Holder());
vtkCylinderSource *native = (vtkCylinderSource *)wrapper->native.GetPointer();
vtkCylinderSource * r;
if(info.Length() != 0)
{
Nan::ThrowError("Too many parameters.");
return;
}
r = native->NewInstance();
VtkCylinderSourceWrap::InitPtpl();
v8::Local<v8::Value> argv[1] =
{ Nan::New(vtkNodeJsNoWrap) };
v8::Local<v8::Function> cons =
Nan::New<v8::FunctionTemplate>(VtkCylinderSourceWrap::ptpl)->GetFunction();
v8::Local<v8::Object> wo = cons->NewInstance(1, argv);
VtkCylinderSourceWrap *w = new VtkCylinderSourceWrap();
w->native = r;
w->Wrap(wo);
info.GetReturnValue().Set(wo);
}
void VtkCylinderSourceWrap::SafeDownCast(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
VtkCylinderSourceWrap *wrapper = ObjectWrap::Unwrap<VtkCylinderSourceWrap>(info.Holder());
vtkCylinderSource *native = (vtkCylinderSource *)wrapper->native.GetPointer();
if(info.Length() > 0 && info[0]->IsObject() && (Nan::New(VtkObjectWrap::ptpl))->HasInstance(info[0]))
{
VtkObjectWrap *a0 = ObjectWrap::Unwrap<VtkObjectWrap>(info[0]->ToObject());
vtkCylinderSource * r;
if(info.Length() != 1)
{
Nan::ThrowError("Too many parameters.");
return;
}
r = native->SafeDownCast(
(vtkObject *) a0->native.GetPointer()
);
VtkCylinderSourceWrap::InitPtpl();
v8::Local<v8::Value> argv[1] =
{ Nan::New(vtkNodeJsNoWrap) };
v8::Local<v8::Function> cons =
Nan::New<v8::FunctionTemplate>(VtkCylinderSourceWrap::ptpl)->GetFunction();
v8::Local<v8::Object> wo = cons->NewInstance(1, argv);
VtkCylinderSourceWrap *w = new VtkCylinderSourceWrap();
w->native = r;
w->Wrap(wo);
info.GetReturnValue().Set(wo);
return;
}
Nan::ThrowError("Parameter mismatch");
}
void VtkCylinderSourceWrap::SetCapping(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
VtkCylinderSourceWrap *wrapper = ObjectWrap::Unwrap<VtkCylinderSourceWrap>(info.Holder());
vtkCylinderSource *native = (vtkCylinderSource *)wrapper->native.GetPointer();
if(info.Length() > 0 && info[0]->IsInt32())
{
if(info.Length() != 1)
{
Nan::ThrowError("Too many parameters.");
return;
}
native->SetCapping(
info[0]->Int32Value()
);
return;
}
Nan::ThrowError("Parameter mismatch");
}
void VtkCylinderSourceWrap::SetCenter(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
VtkCylinderSourceWrap *wrapper = ObjectWrap::Unwrap<VtkCylinderSourceWrap>(info.Holder());
vtkCylinderSource *native = (vtkCylinderSource *)wrapper->native.GetPointer();
size_t i;
if(info.Length() > 0 && info[0]->IsFloat64Array())
{
v8::Local<v8::Float64Array>a0(v8::Local<v8::Float64Array>::Cast(info[0]->ToObject()));
if( a0->Length() < 3 )
{
Nan::ThrowError("Array too short.");
return;
}
if(info.Length() != 1)
{
Nan::ThrowError("Too many parameters.");
return;
}
native->SetCenter(
(double *)(a0->Buffer()->GetContents().Data())
);
return;
}
else if(info.Length() > 0 && info[0]->IsArray())
{
v8::Local<v8::Array>a0(v8::Local<v8::Array>::Cast(info[0]->ToObject()));
double b0[3];
if( a0->Length() < 3 )
{
Nan::ThrowError("Array too short.");
return;
}
for( i = 0; i < 3; i++ )
{
if( !a0->Get(i)->IsNumber() )
{
Nan::ThrowError("Array contents invalid.");
return;
}
b0[i] = a0->Get(i)->NumberValue();
}
if(info.Length() != 1)
{
Nan::ThrowError("Too many parameters.");
return;
}
native->SetCenter(
b0
);
return;
}
else if(info.Length() > 0 && info[0]->IsNumber())
{
if(info.Length() > 1 && info[1]->IsNumber())
{
if(info.Length() > 2 && info[2]->IsNumber())
{
if(info.Length() != 3)
{
Nan::ThrowError("Too many parameters.");
return;
}
native->SetCenter(
info[0]->NumberValue(),
info[1]->NumberValue(),
info[2]->NumberValue()
);
return;
}
}
}
Nan::ThrowError("Parameter mismatch");
}
void VtkCylinderSourceWrap::SetHeight(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
VtkCylinderSourceWrap *wrapper = ObjectWrap::Unwrap<VtkCylinderSourceWrap>(info.Holder());
vtkCylinderSource *native = (vtkCylinderSource *)wrapper->native.GetPointer();
if(info.Length() > 0 && info[0]->IsNumber())
{
if(info.Length() != 1)
{
Nan::ThrowError("Too many parameters.");
return;
}
native->SetHeight(
info[0]->NumberValue()
);
return;
}
Nan::ThrowError("Parameter mismatch");
}
void VtkCylinderSourceWrap::SetOutputPointsPrecision(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
VtkCylinderSourceWrap *wrapper = ObjectWrap::Unwrap<VtkCylinderSourceWrap>(info.Holder());
vtkCylinderSource *native = (vtkCylinderSource *)wrapper->native.GetPointer();
if(info.Length() > 0 && info[0]->IsInt32())
{
if(info.Length() != 1)
{
Nan::ThrowError("Too many parameters.");
return;
}
native->SetOutputPointsPrecision(
info[0]->Int32Value()
);
return;
}
Nan::ThrowError("Parameter mismatch");
}
void VtkCylinderSourceWrap::SetRadius(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
VtkCylinderSourceWrap *wrapper = ObjectWrap::Unwrap<VtkCylinderSourceWrap>(info.Holder());
vtkCylinderSource *native = (vtkCylinderSource *)wrapper->native.GetPointer();
if(info.Length() > 0 && info[0]->IsNumber())
{
if(info.Length() != 1)
{
Nan::ThrowError("Too many parameters.");
return;
}
native->SetRadius(
info[0]->NumberValue()
);
return;
}
Nan::ThrowError("Parameter mismatch");
}
void VtkCylinderSourceWrap::SetResolution(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
VtkCylinderSourceWrap *wrapper = ObjectWrap::Unwrap<VtkCylinderSourceWrap>(info.Holder());
vtkCylinderSource *native = (vtkCylinderSource *)wrapper->native.GetPointer();
if(info.Length() > 0 && info[0]->IsInt32())
{
if(info.Length() != 1)
{
Nan::ThrowError("Too many parameters.");
return;
}
native->SetResolution(
info[0]->Int32Value()
);
return;
}
Nan::ThrowError("Parameter mismatch");
}
| 30.506557 | 102 | 0.723037 | axkibe |
243a4125ec0e4aff0607b782bb2619c443a15db1 | 993 | cpp | C++ | class/app/juego/rompible.cpp | TheMarlboroMan/winter-fgj5 | 28cd4bd4ae37230e51c1a9963bcd293e674cdc3c | [
"Beerware"
] | null | null | null | class/app/juego/rompible.cpp | TheMarlboroMan/winter-fgj5 | 28cd4bd4ae37230e51c1a9963bcd293e674cdc3c | [
"Beerware"
] | null | null | null | class/app/juego/rompible.cpp | TheMarlboroMan/winter-fgj5 | 28cd4bd4ae37230e51c1a9963bcd293e674cdc3c | [
"Beerware"
] | null | null | null | #include "rompible.h"
using namespace App_Juego;
Rompible::Rompible(float x, float y)
:Actor(x, y, W, H)
{
}
unsigned int Rompible::obtener_ciclos_representable()const
{
return 1;
}
unsigned short int Rompible::obtener_profundidad_ordenacion() const
{
return 30;
}
void Rompible::transformar_bloque(App_Graficos::Bloque_transformacion_representable &b) const
{
const auto& a=b.obtener_animacion(App_Definiciones::animaciones::sprites, App_Definiciones::animaciones_sprites::rompible);
const auto& f=a.obtener_para_tiempo_animacion(App_Graficos::Animaciones::obtener_tiempo(), a.acc_duracion_total()).frame;
b.establecer_tipo(App_Graficos::Bloque_transformacion_representable::tipos::tr_bitmap);
b.establecer_alpha(255);
b.establecer_recurso(App::Recursos_graficos::rt_sprites);
b.establecer_recorte(f.x, f.y, f.w, f.h);
b.establecer_posicion(acc_espaciable_x()+f.desp_x, acc_espaciable_y()+f.desp_y, f.w, f.h);
}
void Rompible::recibir_disparo(int v)
{
mut_borrar(true);
}
| 26.131579 | 124 | 0.784491 | TheMarlboroMan |
243adbb232eafea79221ffa8f9fd869b0a1c9014 | 16,115 | cpp | C++ | PhantomEngine/PhantomFont.cpp | DexianZhao/PhantomGameEngine | cf8e341d21e3973856d9f23ad0b1af9db831bac7 | [
"MIT"
] | 4 | 2019-11-08T00:15:13.000Z | 2021-03-26T13:34:50.000Z | PhantomEngine/PhantomFont.cpp | DexianZhao/PhantomGameEngine | cf8e341d21e3973856d9f23ad0b1af9db831bac7 | [
"MIT"
] | 4 | 2021-03-13T10:26:09.000Z | 2021-03-13T10:45:35.000Z | PhantomEngine/PhantomFont.cpp | DexianZhao/PhantomGameEngine | cf8e341d21e3973856d9f23ad0b1af9db831bac7 | [
"MIT"
] | 3 | 2020-06-01T01:53:05.000Z | 2021-03-21T03:51:33.000Z | //////////////////////////////////////////////////////////////////////////////////////////////////////
/*
幻影游戏引擎, 2009-2016, Phantom Game Engine, http://www.aixspace.com
Design Writer : 赵德贤 Dexian Zhao
Email: [email protected]
*/
//////////////////////////////////////////////////////////////////////////////////////////////////////
#include "PhantomFont.h"
#include "PhantomManager.h"
namespace Phantom{
Font::Font()
{
m_fPixelSize = 16.0f;
m_fFontSize = 16.0f;
m_fFontItalic = 0;
m_bFullRGB = false;
m_textColor = color4(1,1,1,1);
m_fFontScale = 1.0f;
m_fontSpaceW = 0;
}
Font::~Font()
{
}
BOOL Font::LoadFont(const char* szFigFile)
{CPUTime(Font);
CFileHelperR r;
if(!r.open(szFigFile))
{
LogInfo("error:load font %s failure\n", szFigFile);
return false;
}
char head[4];
r.read(head, 4);
if(stricmp(head, "fig") != 0)
{
LogInfo("error:load font %s failure, not fig file\n", szFigFile);
return false;
}
int pixelSize = 12;
int version = 1;
r >> version;
r >> pixelSize;
r >> m_bFullRGB;
m_fPixelSize = (float)pixelSize;
int nCount = 0;
r >> nCount;
if(nCount > 65536)//不超过65536个
{
LogInfo("error:load font %s failure, data error\n", szFigFile);
return false;
}
unsigned short maxcode = 0;
r >> maxcode;
unsigned short other = 0;
r >> other;
r.seek(other, StreamBase::Seek_Cur);
//
this->m_texts.SetArrayCount(nCount);
r.read(m_texts.GetPtr(), sizeof(FontTextInfo) * nCount);
//
LFileName fig = szFigFile;
fig.setIsFile();
//
LFileName dir, file;
fig.splitpath(&dir, &file, 0);
dir += file;
for(int i=0;i<MAX_FONT_IMAGES;i++)
{
LFileName path;
path = dir;
if(i == 0)
path += ".png";
else
{
char buf[128];
sprintf(buf, "%d.png", i);
path += buf;
}
//如果找到了就载入
if(!fexist(path))
break;
TexturePtr ret;
if(g_manager.LoadTexture(ret, path, 0, Phantom::TextureFilter_Point|0x00030000))
{
m_fontImgs[i] = ret.GetPtr();
}
}
m_charsetMap.SetArrayCount(maxcode + 1);
for(int i=0;i<m_charsetMap.size();i++)
m_charsetMap[i] = -1;
for(int i=0;i<nCount;i++)
{
assert(m_texts[i].unicode <= maxcode);
m_charsetMap[m_texts[i].unicode] = (unsigned short)i;
}
this->m_fontName = file;
return true;
}
BOOL Font::DrawTexts(const char* szUTF8, Rect& destRect, unsigned int len, unsigned dtFormat, const matrix4x4* world)
{CPUTime(Font);
if(len == 0)
len = strlen(szUTF8);
if(len <= 0)return false;
m_tempBuffer.SetArrayCount(len * 2, false);
if(g_manager.GetIsUtf8())
{
int index = 0;
for(int i=0;i<len;i++)
{
int n = 0;
m_tempBuffer[index++] = utf8ToUnicode((const unsigned char*)szUTF8 + i, &n);
i += (n - 1);
}
m_tempBuffer.SetArrayCount(index);
}
else
{
int l = Utf8ToW(szUTF8, m_tempBuffer.GetPtr(), len * 2);
m_tempBuffer.SetArrayCount(l);
}
DrawTexts(m_tempBuffer.GetPtr(), destRect, m_tempBuffer.size(), dtFormat, world);
return true;
}
BOOL Font::DrawTextClip(const short_t* szU, Rect& destRect, unsigned int len, unsigned dtFormat, const matrix4x4* world, const Rect* clip, BOOL bIsUI)
{CPUTime(Font);
if(!InitDrawText(destRect, &m_textColor, world, 0))
return false;
if(len == 0)
len = u_strlen(szU);
//
rect_f destIO((float)destRect.left, (float)destRect.top, (float)destRect.right, (float)destRect.bottom);
rect_f rc = destIO;
float maxLineHeight = 0;
float2 topSpace(destIO.bottom, 0);
{
unsigned int nLength = len;
const short_t* szUnicode = szU;
float maxHeight = 0;
while(*szUnicode && nLength > 0)
{
nLength--;
if(!DrawUnicode(*szUnicode, rc, maxHeight, destRect, false, maxLineHeight, &topSpace, bIsUI, clip))
break;
szUnicode++;
}
if(dtFormat & DrawTextAlign_RIGHT)
destIO.left = destIO.right - (rc.right - destIO.left);
else if(dtFormat & DrawTextAlign_CENTER)
destIO.left += (destIO.GetWidth() - (rc.right - destIO.left)) / 2.0f;
if(dtFormat & DrawTextAlign_BOTTOM)
destIO.top = destIO.bottom - maxLineHeight;//(rc.bottom - destIO.top);
else if(dtFormat & DrawTextAlign_VCENTER)
destIO.top += (destIO.GetHeight() - maxLineHeight) / 2.0f;//(rc.bottom - destIO.top)) / 2.0f;
if(dtFormat & DrawTextAlign_CALCRECT)
return true;
}
{
unsigned int nLength = len;
const short_t* szUnicode = szU;
float maxHeight = 0;
while(*szUnicode && nLength > 0)
{
nLength--;
if(!DrawUnicode(*szUnicode, destIO, maxHeight, destRect, true, maxLineHeight, &topSpace, bIsUI, clip))
break;
szUnicode++;
}
}
return true;
}
BOOL Font::DrawTexts(const short_t* szU, Rect& destRect, unsigned int len, unsigned dtFormat, const matrix4x4* world, const rect_f* scale, BOOL bIsUI)
{CPUTime(Font);
if(!InitDrawText(destRect, &m_textColor, world, scale))
return false;
if(len == 0)
len = -1;
//
rect_f destIO((float)destRect.left, (float)destRect.top, (float)destRect.right, (float)destRect.bottom);
rect_f rc = destIO;
float maxLineHeight = 0;
float2 topSpace(destIO.bottom, 0);
//if(dtFormat > 0)
{
unsigned int nLength = len;
const short_t* szUnicode = szU;
float maxHeight = 0;
while(*szUnicode && nLength > 0)
{
nLength--;
if(!DrawUnicode(*szUnicode, rc, maxHeight, destRect, false, maxLineHeight, &topSpace, bIsUI))
break;
szUnicode++;
}
//maxLineHeight = topSpace.y - topSpace.x;
if(dtFormat & DrawTextAlign_RIGHT)
destIO.left = destIO.right - (rc.right - destIO.left);
else if(dtFormat & DrawTextAlign_CENTER)
destIO.left += (destIO.GetWidth() - (rc.right - destIO.left)) / 2.0f;
if(dtFormat & DrawTextAlign_BOTTOM)
destIO.top = destIO.bottom - maxLineHeight;//(rc.bottom - destIO.top);
else if(dtFormat & DrawTextAlign_VCENTER)
destIO.top += (destIO.GetHeight() - maxLineHeight) / 2.0f;//(rc.bottom - destIO.top)) / 2.0f;
if(dtFormat & DrawTextAlign_CALCRECT)
return true;
}
{
unsigned int nLength = len;
const short_t* szUnicode = szU;
float maxHeight = 0;
while(*szUnicode && nLength > 0)
{
nLength--;
if(!DrawUnicode(*szUnicode, destIO, maxHeight, destRect, true, maxLineHeight, &topSpace, bIsUI))
break;
szUnicode++;
}
}
return true;
}
Font::FontTextInfo* Font::GetTextInfo(unsigned short u)
{CPUTime(Font);
if(u >= m_charsetMap.size() || m_charsetMap[u] == 65535)
return 0;
FontTextInfo* info = &m_texts[m_charsetMap[u]];
if(info->unicode != u)
return 0;
return info;
}
int Font::GetTextDrawCount(const short_t* szUnicode, int textCount, unsigned int nPixelWidth)
{CPUTime(Font);
Rect destRect(0, 0, g_manager.GetBufferWidth(), g_manager.GetBufferHeight());
rect_f destIO(0, 0, g_manager.GetBufferWidth(), g_manager.GetBufferHeight());
unsigned int nLength = textCount;
float maxHeight = 0;
int nCount = 0;
float maxLineHeight = 0;
while(*szUnicode && nLength > 0)
{
nLength--;
if(!DrawUnicode(*szUnicode, destIO, maxHeight, destRect, false, maxLineHeight))
break;
if(destIO.right >= nPixelWidth)
return nCount;
nCount++;
szUnicode++;
}
return nCount;
}
VOID Font::SetFontSize(float f)
{CPUTime(Font);
m_fFontSize = f;
if(m_fFontSize < 0)
m_fFontSize = -m_fFontSize;
m_fFontScale = m_fFontSize / m_fPixelSize;
int nScale = (int)(m_fFontScale * 10);
if((nScale%2) > 0)
nScale = (nScale / 2 + 1) * 2;
else
nScale = (nScale / 2) * 2;
m_fFontScale = (float)nScale / 10.0f;
}
Size Font::GetTextDrawSize(const short_t* szUnicode, int textCount)
{CPUTime(Font);
Rect destRect(0, 0, g_manager.GetBufferWidth(), g_manager.GetBufferHeight());
rect_f destIO(0, 0, m_fFontSize, m_fFontSize);
unsigned int nLength = textCount;
float maxHeight = 0;
float maxLineHeight = 0;
float2 topSpace(1000, 0);
while(*szUnicode && nLength > 0)
{
nLength--;
if(!DrawUnicode(*szUnicode, destIO, maxHeight, destRect, false, maxLineHeight, &topSpace))
{
maxLineHeight = m_fFontSize;
destIO.right = maxLineHeight;
break;
}
szUnicode++;
}
return Size(destIO.right, maxLineHeight);
}
BOOL ClipRect(Rect& dest, Rect& tex, const Rect& clip)
{
if(dest.bottom < clip.top || dest.top > clip.bottom || dest.left > clip.right || dest.right < clip.left)
return false;
int dh = dest.GetHeight();
int dw = dest.GetWidth();
int th = tex.GetHeight();
int tw = tex.GetWidth();
if(dest.top < clip.top)
{
int ch = clip.top - dest.top;
dest.top = clip.top;
tex.top += ch * th / dh;
}
if(dest.bottom > clip.bottom)
{
int ch = dest.bottom - clip.bottom;
dest.bottom = clip.bottom;
tex.bottom -= ch * th / dh;
}
if(dest.left < clip.left)
{
int cw = clip.left - dest.left;
dest.left = clip.left;
tex.left += cw * tw / dw;
}
if(dest.right > clip.right)
{
int cw = dest.right - clip.right;
dest.right = clip.right;
tex.right -= cw * tw / dw;
}
return true;
}
BOOL Font::DrawUnicode(short_t u, rect_f& dio, float& maxHeight, const Rect& destRc, BOOL bDraw, float& maxLineHeight, float2* topSpace, BOOL bIsUI, const Rect* clip)
{CPUTime(Font);
if(u == ' ')
{
u = '_';
bDraw = false;
}
Font* font = this;
FontTextInfo* info = GetTextInfo(u);
if(!info || u < 128)
{
font = g_manager.GetDefaultENFont();
if(!font)
return false;
info = font->GetTextInfo(u);
}
if(!info)
{
for(int i=0;i<g_manager.m_fonts.size();i++)
{
if(g_manager.m_fonts[i] == font)
continue;
font = g_manager.m_fonts[i];
info = g_manager.m_fonts[i]->GetTextInfo(u);
if(info)
break;
}
}
float screenWidth = (float)g_manager.GetBufferWidth();
float screenHeight = (float)g_manager.GetBufferHeight();
float scale = 1;//(float)m_fFontSize / (float)info->rh;//m_fFontScale;
if(bDraw)
scale *= ((float)maxLineHeight / (float)font->m_fPixelSize);
float width,height;
float offX = 0;
float offY = 0;
float realW = 0;
float realH = 0;
if(info)
{
//scale *= (float)m_fFontSize / (float)info->h;//
width = (float)info->w * scale;
height = (float)info->h * scale;
realW = (float)info->rw * scale;
realH = (float)info->rh * scale;
offX = (float)info->offX * scale;
offY = (float)info->offY * scale;
}
else
{
realW = m_fFontSize;
realH = m_fFontSize;
width = m_fFontSize;
height = m_fFontSize;
}
dio.right = dio.left + width;
if(dio.right > destRc.right)
{
dio.left = destRc.left;
dio.right = dio.left + width;
dio.top += maxLineHeight;//maxHeight;
maxHeight = 0;
}
float top = dio.top + offY;// + realH;
dio.bottom = top + height;//realH;
if(!bDraw)
{
maxLineHeight = getmax(maxLineHeight, height);
}
else
{
float fSaveB = dio.bottom - dio.top;
}
rect_f rc(dio.left, top , dio.right, dio.bottom);
//dio.bottom += height * 0.5f;
if(dio.bottom > maxHeight)
maxHeight = dio.bottom;
//
if((int)dio.top > destRc.bottom)
return false;
if(info)
{
Texture* t = font->m_fontImgs[info->imageIndex].t;
float fTexWidth = (float)t->GetWidth();
float fTexHeight = (float)t->GetHeight();
if(bDraw)
{
if(clip){
Rect rcd(rc.left, rc.top, rc.right, rc.bottom);
Rect rct(info->x, info->y, info->x + info->w, info->y + info->h);
if(ClipRect(rcd, rct, *clip))
DrawUnicode(font->m_fontImgs[info->imageIndex].t, info->channel, rect_f(rcd.left, rcd.top, rcd.right, rcd.bottom), rect_f((float)rct.left / fTexWidth,
(float)rct.top / fTexHeight, (float)rct.right / fTexWidth, (float)rct.bottom / fTexHeight), bIsUI);
}
else
{
rect_f texr((float)(info->x) / fTexWidth, (float)(info->y) / fTexHeight, (float)(info->x + info->w) / fTexWidth, (float)(info->y + info->h) / fTexHeight);
rc.right = rc.left + (float)info->w;
rc.bottom = rc.top + (float)info->h;
DrawUnicode(font->m_fontImgs[info->imageIndex].t, info->channel, rc, texr, bIsUI);
}
}
}
if(info && u > 256)
{
if((info->w + 2) == info->rw)
{
width += width * 0.2f;
}
}
dio.left += (width-m_fontSpaceW);
return true;
}
BOOL Font::InitDrawText(const Rect& rc, const color4* c, const matrix4x4* world, const rect_f* scale)
{CPUTime(Font);
//if(rc.right <= rc.left || rc.bottom <= rc.top)
// return false;
//if(m_bFullRGB)
//{
// if(!g_manager.SetRenderMode(RenderMode_TextFull))
// return false;
//}
//else if(!g_manager.SetRenderMode(RenderMode_TextChannel))
// return false;
//m_screenRect.set(rc.left, rc.top, rc.right, rc.bottom);
//float fov = tanf(g_manager.Get2DProjectionFov() / 2.0f) * 2.0f;
//float fovY = fov;
//float fovX = fovY * (float)g_manager.GetBufferWidth() / (float)g_manager.GetBufferHeight();
////
//m_drawPos[0].setxyz(m_screenRect.left, m_screenRect.top, 0);
//m_drawPos[1].setxyz(m_screenRect.right, m_screenRect.top, 0);
//m_drawPos[2].setxyz(m_screenRect.right, m_screenRect.bottom, 0);
//m_drawPos[3].setxyz(m_screenRect.left, m_screenRect.bottom, 0);
//for(int i=0;i<4;i++)
//{
// float3& p = m_drawPos[i];
// if(world)
// p.transform(p, *world);
// else if(scale)
// {
// p.x = p.x * scale->left + scale->right;
// p.y = p.y * scale->top + scale->bottom;
// }
//}
//m_drawPosBegin = m_drawPos[0];
//m_drawPosDirL = m_drawPos[1] - m_drawPos[0];
//m_drawPosDirT = m_drawPos[3] - m_drawPos[0];
//m_drawPosDirL.normalize();
//m_drawPosDirT.normalize();
////
//g_manager.SetWorldMatrix2D(0);
//unsigned int temp = 0xffffffff;
//if(c)
// temp = *c;
//for(int i=0;i<4;i++)
// m_drawColor[i] = temp;
//g_manager->SetCullVisible(CullMode_CW);
//g_manager->SetAlphaMode(AlphaMode_Blend);
return true;
}
VOID Font::DrawUnicode(Texture* tex, int channel, const rect_f& screen, const rect_f& texRc, BOOL bIsUI) //渲染2D图片
{CPUTime(Font);
assert(channel < 3);
static float3 texChannel[3] = {float3(1,0,0), float3(0,1,0), float3(0,0,1)};
float fWidth = m_screenRect.GetWidth();
float fHeight = m_screenRect.GetHeight();
float left = screen.left - m_screenRect.left;
float top = screen.top - m_screenRect.top;
float right = screen.right - m_screenRect.left;
float bottom = screen.bottom - m_screenRect.top;
float l2 = left + m_fFontItalic * this->m_fFontSize;
float r2 = right + m_fFontItalic * this->m_fFontSize;
m_drawPos[0] = m_drawPosBegin + m_drawPosDirL * l2 + m_drawPosDirT * top;
m_drawPos[1] = m_drawPosBegin + m_drawPosDirL * r2 + m_drawPosDirT * top;
m_drawPos[2] = m_drawPosBegin + m_drawPosDirL * right + m_drawPosDirT * bottom;
m_drawPos[3] = m_drawPosBegin + m_drawPosDirL * left + m_drawPosDirT * bottom;
float fov = tanf(g_manager.Get2DProjectionFov() / 2.0f) * 2.0f;
float fovY = fov;
float fovX = fovY * (float)g_manager.GetBufferWidth() / (float)g_manager.GetBufferHeight();
for(int i=0;i<4;i++)
{
if(bIsUI)
{
m_drawPos[i].x *= g_manager.GetUIScale().x;
m_drawPos[i].y *= g_manager.GetUIScale().y;
m_drawPos[i].x += g_manager.GetUIOffset().x;
m_drawPos[i].y += g_manager.GetUIOffset().y;
}
m_drawPos[i].x = ((m_drawPos[i].x / (float)g_manager.GetBufferWidth()) - 0.5f) * fovX;
m_drawPos[i].y = (0.5f - (m_drawPos[i].y / (float)g_manager.GetBufferHeight())) * fovY;
m_drawPos[i].z = 0;
}
//
m_drawUV[0] = float2(texRc.left, texRc.top);
m_drawUV[1] = float2(texRc.right, texRc.top);
m_drawUV[2] = float2(texRc.right, texRc.bottom);
m_drawUV[3] = float2(texRc.left, texRc.bottom);
g_manager.GetCurrProgram()->SetTexture(TextureIndex_0, tex);
if(!m_bFullRGB)
{
if(this->m_varTextChannel.is_findFail())
this->m_varTextChannel.reset_handle();
g_manager.GetCurrProgram()->SetFloat3(this->m_varTextChannel, texChannel[channel], "textChannel");
}
static unsigned short indexBuffer[] ={3,1,0,3,2,1, 0,1,3,1,2,3};
int numIndices = 6;
g_manager->DrawIndexed(g_manager.GetCurrProgram(), DrawVInfos(4, m_drawPos, m_drawColor, m_drawUV), indexBuffer, numIndices, DrawMode_Triangles);
}
};
| 30.348399 | 173 | 0.634998 | DexianZhao |
243c884e7bac4f400e8f268fe9e546622882ffe6 | 944 | cpp | C++ | test/tests/memcached/regression/lp_000-583-031.cpp | topilski/libmemcached | 7a10166fbc4e718a3392ff744eb5bc499defd952 | [
"BSD-3-Clause"
] | 18 | 2021-06-23T15:20:25.000Z | 2022-03-25T22:51:09.000Z | test/tests/memcached/regression/lp_000-583-031.cpp | topilski/libmemcached | 7a10166fbc4e718a3392ff744eb5bc499defd952 | [
"BSD-3-Clause"
] | 108 | 2020-01-20T09:25:47.000Z | 2021-05-18T06:45:30.000Z | test/tests/memcached/regression/lp_000-583-031.cpp | topilski/libmemcached | 7a10166fbc4e718a3392ff744eb5bc499defd952 | [
"BSD-3-Clause"
] | 4 | 2021-06-25T07:49:31.000Z | 2022-02-07T21:30:45.000Z | #include "test/lib/common.hpp"
#include "test/lib/ReturnMatcher.hpp"
TEST_CASE("memcached_regression_lp583031") {
MemcachedPtr memc;
LoneReturnMatcher test{*memc};
REQUIRE_SUCCESS(memcached_server_add(*memc, "192.0.2.1", 11211));
REQUIRE_SUCCESS(memcached_behavior_set(*memc, MEMCACHED_BEHAVIOR_CONNECT_TIMEOUT, 3000));
REQUIRE_SUCCESS(memcached_behavior_set(*memc, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT, 1000));
REQUIRE_SUCCESS(memcached_behavior_set(*memc, MEMCACHED_BEHAVIOR_SND_TIMEOUT, 1000));
REQUIRE_SUCCESS(memcached_behavior_set(*memc, MEMCACHED_BEHAVIOR_RCV_TIMEOUT, 1000));
REQUIRE_SUCCESS(memcached_behavior_set(*memc, MEMCACHED_BEHAVIOR_POLL_TIMEOUT, 1000));
REQUIRE_SUCCESS(memcached_behavior_set(*memc, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT, 3));
memcached_return_t rc;
Malloced val(memcached_get(*memc, S("not-found"), nullptr, nullptr, &rc));
REQUIRE_RC(MEMCACHED_TIMEOUT, rc);
REQUIRE_FALSE(*val);
}
| 44.952381 | 93 | 0.808263 | topilski |
2441f77a6976761118737787ae981b45238b81e3 | 3,260 | cpp | C++ | tests/integral.cpp | steven-varga/h5cpp11 | 9b322fe381608cb277817a993999d03753d356be | [
"MIT"
] | 6 | 2019-03-07T23:40:16.000Z | 2021-09-22T17:31:32.000Z | tests/integral.cpp | steven-varga/h5cpp11 | 9b322fe381608cb277817a993999d03753d356be | [
"MIT"
] | null | null | null | tests/integral.cpp | steven-varga/h5cpp11 | 9b322fe381608cb277817a993999d03753d356be | [
"MIT"
] | 1 | 2021-03-18T04:34:47.000Z | 2021-03-18T04:34:47.000Z | /*
* Copyright (c) 2017 vargaconsulting, Toronto,ON Canada
* Author: Varga, Steven <[email protected]>
*
* 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 <gtest/gtest.h>
#include <armadillo>
#include <h5cpp/core>
#include <h5cpp/mock.hpp>
#include <h5cpp/create.hpp>
#include <h5cpp/read.hpp>
#include <h5cpp/write.hpp>
#include "event_listener.hpp"
#include "abstract.h"
template <typename T> class IntegralTest : public AbstractTest<T>{};
typedef ::testing::Types<H5CPP_TEST_PRIMITIVE_TYPES> PrimitiveTypes;
TYPED_TEST_CASE(IntegralTest, PrimitiveTypes);
TYPED_TEST(IntegralTest,IntegralCreate) {
// PLAIN
if( h5::create<TypeParam>(this->fd,this->name + " 1d",{3}) < 0 ) ADD_FAILURE();
if( h5::create<TypeParam>(this->fd,this->name + " 2d",{2,3} ) < 0 ) ADD_FAILURE();
if( h5::create<TypeParam>(this->fd,this->name + " 3d",{1,2,3}) < 0 ) ADD_FAILURE();
// CHUNKED
if( h5::create<TypeParam>(this->fd,this->name + " 1d chunk",{3000},{100} ) < 0 ) ADD_FAILURE();
if( h5::create<TypeParam>(this->fd,this->name + " 2d chunk",{2000,3},{100,1} ) < 0 ) ADD_FAILURE();
if( h5::create<TypeParam>(this->fd,this->name + " 3d chunk",{1000,2,3},{100,1,1} ) < 0 ) ADD_FAILURE();
// CHUNKED COMPRESSION: GZIP 9
if( h5::create<TypeParam>(this->fd,this->name + " 1d chunk gzip",{3000},{100},9 ) < 0 ) ADD_FAILURE();
if( h5::create<TypeParam>(this->fd,this->name + " 2d chunk gzip",{2000,3},{100,1},9 ) < 0 ) ADD_FAILURE();
if( h5::create<TypeParam>(this->fd,this->name + " 3d chunk gzip",{1000,2,3},{100,1,1},9 ) < 0 ) ADD_FAILURE();
}
TYPED_TEST(IntegralTest,IntegralPointerWrite) {
TypeParam data[100]={0};
hid_t ds = h5::create<TypeParam>(this->fd, this->name+".ptr",{100},{} );
h5::write(ds, data,{0},{100} );
H5Dclose(ds);
}
TYPED_TEST(IntegralTest,IntegralPointerRead) {
TypeParam data[100]={0};
hid_t ds = h5::create<TypeParam>(this->fd, this->name+".ptr",{100},{} );
h5::write(ds, data,{0},{100} );
h5::read<TypeParam>(ds,data,{5},{20} );
H5Dclose(ds);
h5::read<TypeParam>(this->fd,this->name+".ptr",data,{5},{20} );
}
/*----------- BEGIN TEST RUNNER ---------------*/
H5CPP_TEST_RUNNER( int argc, char** argv );
/*----------------- END -----------------------*/
| 44.657534 | 111 | 0.675767 | steven-varga |
24457fd301b53435389d8c4e4ca692145557a1f1 | 416 | cpp | C++ | source/pso/function/Easom.cpp | Nothrax/pso_visualisation | 96f9453643c49f0b94b5d9f0462274f74a29388f | [
"MIT"
] | null | null | null | source/pso/function/Easom.cpp | Nothrax/pso_visualisation | 96f9453643c49f0b94b5d9f0462274f74a29388f | [
"MIT"
] | null | null | null | source/pso/function/Easom.cpp | Nothrax/pso_visualisation | 96f9453643c49f0b94b5d9f0462274f74a29388f | [
"MIT"
] | null | null | null | #include <pso/function/Easom.h>
double Easom::calculateFitness(Point point) {
return -cos(point.x) * cos(point.y) *
exp(-(point.x - _pi) * (point.x - _pi) - (point.y - _pi) * (point.y - _pi));
}
double Easom::getMinFitness() {
return -1.0;
}
Point Easom::getBoundary() {
Point point = {80.0, 80.0};
return point;
}
std::string Easom::getMinPoint() {
return "[3.14159,\n3.14159]";
} | 21.894737 | 87 | 0.596154 | Nothrax |
244761738fccc8a11616eb2eccb6938685186722 | 7,679 | cpp | C++ | test/test_complex.cpp | pruthvistony/rocThrust | c986b97395d4a6cbacc7a4600d11bdf389de639a | [
"Apache-2.0"
] | null | null | null | test/test_complex.cpp | pruthvistony/rocThrust | c986b97395d4a6cbacc7a4600d11bdf389de639a | [
"Apache-2.0"
] | null | null | null | test/test_complex.cpp | pruthvistony/rocThrust | c986b97395d4a6cbacc7a4600d11bdf389de639a | [
"Apache-2.0"
] | null | null | null | /*
* Copyright 2008-2013 NVIDIA Corporation
* Modifications Copyright© 2019 Advanced Micro Devices, 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.
*/
#include <thrust/complex.h>
#include "test_header.hpp"
TESTS_DEFINE(ComplexTests, FloatTestsParams);
TYPED_TEST(ComplexTests, TestComplexConstructors)
{
using T = typename TestFixture::input_type;
thrust::host_vector<T> data = get_random_data<T>(2, T(-1000), T(1000));
thrust::complex<T> a(data[0], data[1]);
thrust::complex<T> b(a);
thrust::complex<float> float_b(a);
a = thrust::complex<T>(data[0], data[1]);
ASSERT_NEAR_COMPLEX(a, b);
a = thrust::complex<T>(data[0]);
ASSERT_EQ(data[0], a.real());
ASSERT_EQ(T(0), a.imag());
a = thrust::complex<T>();
ASSERT_NEAR_COMPLEX(a, std::complex<T>(0));
a = thrust::complex<T>(
thrust::complex<float>(static_cast<float>(data[0]), static_cast<float>(data[1])));
ASSERT_NEAR_COMPLEX(a, float_b);
a = thrust::complex<T>(
thrust::complex<double>(static_cast<double>(data[0]), static_cast<double>(data[1])));
ASSERT_NEAR_COMPLEX(a, b);
a = thrust::complex<T>(
std::complex<float>(static_cast<float>(data[0]), static_cast<float>(data[1])));
ASSERT_NEAR_COMPLEX(a, float_b);
a = thrust::complex<T>(
std::complex<double>(static_cast<double>(data[0]), static_cast<double>(data[1])));
ASSERT_NEAR_COMPLEX(a, b);
}
TYPED_TEST(ComplexTests, TestComplexGetters)
{
using T = typename TestFixture::input_type;
thrust::host_vector<T> data
= get_random_data<T>(2, std::numeric_limits<T>::min(), std::numeric_limits<T>::max());
thrust::complex<T> z(data[0], data[1]);
ASSERT_EQ(data[0], z.real());
ASSERT_EQ(data[1], z.imag());
z.real(data[1]);
z.imag(data[0]);
ASSERT_EQ(data[1], z.real());
ASSERT_EQ(data[0], z.imag());
volatile thrust::complex<T> v(data[0], data[1]);
ASSERT_EQ(data[0], v.real());
ASSERT_EQ(data[1], v.imag());
v.real(data[1]);
v.imag(data[0]);
ASSERT_EQ(data[1], v.real());
ASSERT_EQ(data[0], v.imag());
}
TYPED_TEST(ComplexTests, TestComplexMemberOperators)
{
using T = typename TestFixture::input_type;
thrust::host_vector<T> data_a = get_random_data<T>(2, 10000, 10000);
thrust::host_vector<T> data_b = get_random_data<T>(2, 10000, 10000);
thrust::complex<T> a(data_a[0], data_a[1]);
thrust::complex<T> b(data_b[0], data_b[1]);
std::complex<T> c(a);
std::complex<T> d(b);
a += b;
c += d;
ASSERT_NEAR_COMPLEX(a, c);
a -= b;
c -= d;
ASSERT_NEAR_COMPLEX(a, c);
a *= b;
c *= d;
ASSERT_NEAR_COMPLEX(a, c);
a /= b;
c /= d;
ASSERT_NEAR_COMPLEX(a, c);
// casting operator
c = (std::complex<T>)a;
}
TYPED_TEST(ComplexTests, TestComplexBasicArithmetic)
{
using T = typename TestFixture::input_type;
thrust::host_vector<T> data = get_random_data<T>(2, T(-100), T(100));
thrust::complex<T> a(data[0], data[1]);
std::complex<T> b(a);
// Test the basic arithmetic functions against std
ASSERT_NEAR(abs(a), abs(b), T(0.01));
ASSERT_NEAR(arg(a), arg(b), T(0.01));
ASSERT_NEAR(norm(a), norm(b), T(0.01));
ASSERT_EQ(conj(a), conj(b));
ASSERT_NEAR_COMPLEX(thrust::polar(data[0], data[1]), std::polar(data[0], data[1]));
// random_samples does not seem to produce infinities so proj(z) == z
ASSERT_EQ(proj(a), a);
}
TYPED_TEST(ComplexTests, TestComplexBinaryArithmetic)
{
using T = typename TestFixture::input_type;
thrust::host_vector<T> data_a = get_random_data<T>(2, -10000, 10000);
thrust::host_vector<T> data_b = get_random_data<T>(2, -10000, 10000);
thrust::complex<T> a(data_a[0], data_a[1]);
thrust::complex<T> b(data_b[0], data_b[1]);
ASSERT_NEAR_COMPLEX(a * b, std::complex<T>(a) * std::complex<T>(b));
ASSERT_NEAR_COMPLEX(a * data_b[0], std::complex<T>(a) * data_b[0]);
ASSERT_NEAR_COMPLEX(data_a[0] * b, data_a[0] * std::complex<T>(b));
ASSERT_NEAR_COMPLEX(a / b, std::complex<T>(a) / std::complex<T>(b));
ASSERT_NEAR_COMPLEX(a / data_b[0], std::complex<T>(a) / data_b[0]);
ASSERT_NEAR_COMPLEX(data_a[0] / b, data_a[0] / std::complex<T>(b));
ASSERT_EQ(a + b, std::complex<T>(a) + std::complex<T>(b));
ASSERT_EQ(a + data_b[0], std::complex<T>(a) + data_b[0]);
ASSERT_EQ(data_a[0] + b, data_a[0] + std::complex<T>(b));
ASSERT_EQ(a - b, std::complex<T>(a) - std::complex<T>(b));
ASSERT_EQ(a - data_b[0], std::complex<T>(a) - data_b[0]);
ASSERT_EQ(data_a[0] - b, data_a[0] - std::complex<T>(b));
}
TYPED_TEST(ComplexTests, TestComplexUnaryArithmetic)
{
using T = typename TestFixture::input_type;
thrust::host_vector<T> data_a
= get_random_data<T>(2, std::numeric_limits<T>::min(), std::numeric_limits<T>::max());
thrust::complex<T> a(data_a[0], data_a[1]);
ASSERT_EQ(+a, +std::complex<T>(a));
ASSERT_EQ(-a, -std::complex<T>(a));
}
TYPED_TEST(ComplexTests, TestComplexExponentialFunctions)
{
using T = typename TestFixture::input_type;
thrust::host_vector<T> data_a = get_random_data<T>(2, -100, 100);
thrust::complex<T> a(data_a[0], data_a[1]);
std::complex<T> b(a);
ASSERT_NEAR_COMPLEX(exp(a), exp(b));
ASSERT_NEAR_COMPLEX(log(a), log(b));
ASSERT_NEAR_COMPLEX(log10(a), log10(b));
}
TYPED_TEST(ComplexTests, TestComplexPowerFunctions)
{
using T = typename TestFixture::input_type;
thrust::host_vector<T> data_a = get_random_data<T>(2, -100, 100);
thrust::host_vector<T> data_b = get_random_data<T>(2, -100, 100);
thrust::complex<T> a(data_a[0], data_a[1]);
thrust::complex<T> b(data_b[0], data_b[1]);
std::complex<T> c(a);
std::complex<T> d(b);
ASSERT_NEAR_COMPLEX(pow(a, b), pow(c, d));
ASSERT_NEAR_COMPLEX(pow(a, b.real()), pow(c, d.real()));
ASSERT_NEAR_COMPLEX(pow(a.real(), b), pow(c.real(), d));
ASSERT_NEAR_COMPLEX(sqrt(a), sqrt(c));
}
TYPED_TEST(ComplexTests, TestComplexTrigonometricFunctions)
{
using T = typename TestFixture::input_type;
thrust::host_vector<T> data_a = get_random_data<T>(2, T(-1), T(1));
thrust::complex<T> a(data_a[0], data_a[1]);
std::complex<T> c(a);
ASSERT_NEAR_COMPLEX(cos(a), cos(c));
ASSERT_NEAR_COMPLEX(sin(a), sin(c));
ASSERT_NEAR_COMPLEX(tan(a), tan(c));
ASSERT_NEAR_COMPLEX(cosh(a), cosh(c));
ASSERT_NEAR_COMPLEX(sinh(a), sinh(c));
ASSERT_NEAR_COMPLEX(tanh(a), tanh(c));
ASSERT_NEAR_COMPLEX(acos(a), acos(c));
ASSERT_NEAR_COMPLEX(asin(a), asin(c));
ASSERT_NEAR_COMPLEX(atan(a), atan(c));
ASSERT_NEAR_COMPLEX(acosh(a), acosh(c));
ASSERT_NEAR_COMPLEX(asinh(a), asinh(c));
ASSERT_NEAR_COMPLEX(atanh(a), atanh(c));
}
TYPED_TEST(ComplexTests, TestComplexStreamOperators)
{
using T = typename TestFixture::input_type;
thrust::host_vector<T> data_a = get_random_data<T>(2, T(-1000), T(1000));
thrust::complex<T> a(data_a[0], data_a[1]);
std::stringstream out;
out << a;
thrust::complex<T> b;
out >> b;
ASSERT_NEAR_COMPLEX(a, b);
}
| 29.648649 | 94 | 0.643313 | pruthvistony |
244d67f3a543162ec8841d0659c81427b0abcf37 | 10,823 | cc | C++ | runtime/vm/resolver.cc | annagrin/sdk | dfce72bbf9bf359ecd810964259978e24c55e237 | [
"BSD-3-Clause"
] | 2 | 2020-03-09T11:45:05.000Z | 2021-06-08T12:06:05.000Z | runtime/vm/resolver.cc | annagrin/sdk | dfce72bbf9bf359ecd810964259978e24c55e237 | [
"BSD-3-Clause"
] | null | null | null | runtime/vm/resolver.cc | annagrin/sdk | dfce72bbf9bf359ecd810964259978e24c55e237 | [
"BSD-3-Clause"
] | null | null | null | // Copyright (c) 2011, the Dart project authors. Please see the AUTHORS file
// for details. All rights reserved. Use of this source code is governed by a
// BSD-style license that can be found in the LICENSE file.
#include "vm/resolver.h"
#include "vm/dart_entry.h"
#include "vm/flags.h"
#include "vm/isolate.h"
#include "vm/log.h"
#include "vm/object.h"
#include "vm/object_store.h"
#include "vm/symbols.h"
namespace dart {
DEFINE_FLAG(bool, trace_resolving, false, "Trace resolving.");
// The actual names of named arguments are not checked by the dynamic resolver,
// but by the method entry code. It is important that the dynamic resolver
// checks that no named arguments are passed to a method that does not accept
// them, since the entry code of such a method does not check for named
// arguments. The dynamic resolver actually checks that a valid number of named
// arguments is passed in.
RawFunction* Resolver::ResolveDynamic(const Instance& receiver,
const String& function_name,
const ArgumentsDescriptor& args_desc) {
// Figure out type of receiver first.
const Class& cls = Class::Handle(receiver.clazz());
return ResolveDynamicForReceiverClass(cls, function_name, args_desc);
}
RawFunction* Resolver::ResolveDynamicForReceiverClass(
const Class& receiver_class,
const String& function_name,
const ArgumentsDescriptor& args_desc,
bool allow_add) {
Thread* thread = Thread::Current();
Zone* zone = thread->zone();
Function& function = Function::Handle(
zone,
ResolveDynamicAnyArgs(zone, receiver_class, function_name, allow_add));
if (function.IsNull() ||
!function.AreValidArguments(NNBDMode::kLegacyLib, args_desc, NULL)) {
// Return a null function to signal to the upper levels to dispatch to
// "noSuchMethod" function.
if (FLAG_trace_resolving) {
String& error_message =
String::Handle(zone, Symbols::New(thread, "function not found"));
if (!function.IsNull()) {
// Obtain more detailed error message.
function.AreValidArguments(NNBDMode::kLegacyLib, args_desc,
&error_message);
}
THR_Print("ResolveDynamic error '%s': %s.\n", function_name.ToCString(),
error_message.ToCString());
}
return Function::null();
}
return function.raw();
}
RawFunction* Resolver::ResolveDynamicAnyArgs(Zone* zone,
const Class& receiver_class,
const String& function_name,
bool allow_add) {
Class& cls = Class::Handle(zone, receiver_class.raw());
if (FLAG_trace_resolving) {
THR_Print("ResolveDynamic '%s' for class %s\n", function_name.ToCString(),
String::Handle(zone, cls.Name()).ToCString());
}
Function& function = Function::Handle(zone);
String& demangled = String::Handle(zone);
const bool is_getter = Field::IsGetterName(function_name);
if (is_getter) {
demangled = Field::NameFromGetter(function_name);
}
if (Function::IsDynamicInvocationForwarderName(function_name)) {
demangled = Function::DemangleDynamicInvocationForwarderName(function_name);
#ifdef DART_PRECOMPILED_RUNTIME
// In precompiled mode, the non-dynamic version of the function may be
// tree-shaken away, so can't necessarily resolve the demanged name.
while (!cls.IsNull()) {
function = cls.GetInvocationDispatcher(
function_name, Array::null_array(),
RawFunction::kDynamicInvocationForwarder, /*create_if_absent=*/false);
if (!function.IsNull()) break;
cls = cls.SuperClass();
}
// Some functions don't require dynamic invocation forwarders, for example
// if there are no parameters or all the parameters are marked
// `generic-covariant` (meaning there's no work for the dynamic invocation
// forwarder to do, see `kernel::DynamicInvocationForwarder`). For these
// functions, we won't have built a `dyn:` version, but it's safe to just
// return the original version directly.
return !function.IsNull() ? function.raw()
: ResolveDynamicAnyArgs(zone, receiver_class,
demangled, allow_add);
#else
function =
ResolveDynamicAnyArgs(zone, receiver_class, demangled, allow_add);
return function.IsNull() ? function.raw()
: function.GetDynamicInvocationForwarder(
function_name, allow_add);
#endif
}
// Now look for an instance function whose name matches function_name
// in the class.
while (!cls.IsNull()) {
function = cls.LookupDynamicFunction(function_name);
if (!function.IsNull()) {
return function.raw();
}
// Getter invocation might actually be a method extraction.
if (is_getter && function.IsNull()) {
function = cls.LookupDynamicFunction(demangled);
if (!function.IsNull()) {
if (allow_add && FLAG_lazy_dispatchers) {
// We were looking for the getter but found a method with the same
// name. Create a method extractor and return it.
// The extractor does not exist yet, so using GetMethodExtractor is
// not necessary here.
function = function.CreateMethodExtractor(function_name);
return function.raw();
} else {
return Function::null();
}
}
}
cls = cls.SuperClass();
}
return function.raw();
}
RawFunction* Resolver::ResolveStatic(const Library& library,
const String& class_name,
const String& function_name,
intptr_t type_args_len,
intptr_t num_arguments,
const Array& argument_names) {
ASSERT(!library.IsNull());
Function& function = Function::Handle();
if (class_name.IsNull() || (class_name.Length() == 0)) {
// Check if we are referring to a top level function.
const Object& object = Object::Handle(library.ResolveName(function_name));
if (!object.IsNull() && object.IsFunction()) {
function ^= object.raw();
if (!function.AreValidArguments(NNBDMode::kLegacyLib, type_args_len,
num_arguments, argument_names, NULL)) {
if (FLAG_trace_resolving) {
String& error_message = String::Handle();
// Obtain more detailed error message.
function.AreValidArguments(NNBDMode::kLegacyLib, type_args_len,
num_arguments, argument_names,
&error_message);
THR_Print("ResolveStatic error '%s': %s.\n",
function_name.ToCString(), error_message.ToCString());
}
function = Function::null();
}
} else {
if (FLAG_trace_resolving) {
THR_Print("ResolveStatic error: function '%s' not found.\n",
function_name.ToCString());
}
}
} else {
// Lookup class_name in the library's class dictionary to get at
// the dart class object. If class_name is not found in the dictionary
// ResolveStatic will return a NULL function object.
const Class& cls = Class::Handle(library.LookupClass(class_name));
if (!cls.IsNull()) {
function = ResolveStatic(cls, function_name, type_args_len, num_arguments,
argument_names);
}
if (FLAG_trace_resolving && function.IsNull()) {
THR_Print("ResolveStatic error: function '%s.%s' not found.\n",
class_name.ToCString(), function_name.ToCString());
}
}
return function.raw();
}
RawFunction* Resolver::ResolveStatic(const Class& cls,
const String& function_name,
intptr_t type_args_len,
intptr_t num_arguments,
const Array& argument_names) {
ASSERT(!cls.IsNull());
if (FLAG_trace_resolving) {
THR_Print("ResolveStatic '%s'\n", function_name.ToCString());
}
const Function& function =
Function::Handle(cls.LookupStaticFunction(function_name));
if (function.IsNull() ||
!function.AreValidArguments(NNBDMode::kLegacyLib, type_args_len,
num_arguments, argument_names, NULL)) {
// Return a null function to signal to the upper levels to throw a
// resolution error or maybe throw the error right here.
if (FLAG_trace_resolving) {
String& error_message = String::Handle(String::New("function not found"));
if (!function.IsNull()) {
// Obtain more detailed error message.
function.AreValidArguments(NNBDMode::kLegacyLib, type_args_len,
num_arguments, argument_names,
&error_message);
}
THR_Print("ResolveStatic error '%s': %s.\n", function_name.ToCString(),
error_message.ToCString());
}
return Function::null();
}
return function.raw();
}
RawFunction* Resolver::ResolveStaticAllowPrivate(const Class& cls,
const String& function_name,
intptr_t type_args_len,
intptr_t num_arguments,
const Array& argument_names) {
ASSERT(!cls.IsNull());
if (FLAG_trace_resolving) {
THR_Print("ResolveStaticAllowPrivate '%s'\n", function_name.ToCString());
}
const Function& function =
Function::Handle(cls.LookupStaticFunctionAllowPrivate(function_name));
if (function.IsNull() ||
!function.AreValidArguments(NNBDMode::kLegacyLib, type_args_len,
num_arguments, argument_names, NULL)) {
// Return a null function to signal to the upper levels to throw a
// resolution error or maybe throw the error right here.
if (FLAG_trace_resolving) {
String& error_message = String::Handle(String::New("function not found"));
if (!function.IsNull()) {
// Obtain more detailed error message.
function.AreValidArguments(NNBDMode::kLegacyLib, type_args_len,
num_arguments, argument_names,
&error_message);
}
THR_Print("ResolveStaticAllowPrivate error '%s': %s.\n",
function_name.ToCString(), error_message.ToCString());
}
return Function::null();
}
return function.raw();
}
} // namespace dart
| 42.443137 | 80 | 0.61397 | annagrin |
244da09164ff9cfabb3cb29e67832566c39f0107 | 1,039 | cpp | C++ | src/3D/Face3D.cpp | FloydATC/Deep | 856914d7e99778df094541361e8d98b9f3ce8a06 | [
"CC0-1.0"
] | null | null | null | src/3D/Face3D.cpp | FloydATC/Deep | 856914d7e99778df094541361e8d98b9f3ce8a06 | [
"CC0-1.0"
] | null | null | null | src/3D/Face3D.cpp | FloydATC/Deep | 856914d7e99778df094541361e8d98b9f3ce8a06 | [
"CC0-1.0"
] | null | null | null |
#include "Face3D.h"
Face3D::Face3D(Vertex3D* v1, Vertex3D* v2, Vertex3D* v3)
{
//ctor
vertices.push_back(v1);
vertices.push_back(v2);
vertices.push_back(v3);
calc_normal();
calc_center();
adjacent = { -1, -1, -1 };
}
Face3D::~Face3D()
{
//dtor
}
Vector3 Face3D::calc_normal()
{
// Compute vertex normals for a flat surface
//For each triangle ABC
// n := normalize(cross(B-A, C-A))
// A.n := n
// B.n := n
// C.n := n
Vector3 ba = vertices[1]->v - vertices[0]->v;
Vector3 ca = vertices[2]->v - vertices[0]->v;
this->normal = ba.cross(ca).normalize();
return this->normal;
}
Vector3 Face3D::calc_center()
{
// Compute average position of the three vertices
this->center = (vertices[0]->v + vertices[1]->v + vertices[2]->v) / 3.0;
return this->center;
}
Edge3D Face3D::getEdge(uint8_t edge_no)
{
return Edge3D(this->vertices[edge_no]->v, this->vertices[(edge_no+1)%3]->v);
}
void Face3D::setAdjacentFace(uint8_t edge_no, uint32_t face_id)
{
this->adjacent[edge_no] = face_id;
}
| 18.553571 | 78 | 0.637151 | FloydATC |
245322917e3c4ac189437cfcc7ebda7edc618771 | 2,165 | cpp | C++ | logdevice/common/SlowStorageTasksTracer.cpp | SimonKinds/LogDevice | fc9ac2fccb6faa3292b2b0a610a9eb77fd445824 | [
"BSD-3-Clause"
] | 1 | 2018-10-17T06:49:04.000Z | 2018-10-17T06:49:04.000Z | logdevice/common/SlowStorageTasksTracer.cpp | msdgwzhy6/LogDevice | bc2491b7dfcd129e25490c7d5321d3d701f53ac4 | [
"BSD-3-Clause"
] | null | null | null | logdevice/common/SlowStorageTasksTracer.cpp | msdgwzhy6/LogDevice | bc2491b7dfcd129e25490c7d5321d3d701f53ac4 | [
"BSD-3-Clause"
] | null | null | null | /**
* Copyright (c) 2017-present, Facebook, Inc. and its affiliates.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree.
*/
#include "logdevice/common/SlowStorageTasksTracer.h"
#include "logdevice/common/configuration/Log.h"
#include <algorithm>
namespace facebook { namespace logdevice {
SlowStorageTasksTracer::SlowStorageTasksTracer(
std::shared_ptr<TraceLogger> logger)
: SampledTracer(std::move(logger)) {}
void SlowStorageTasksTracer::traceStorageTask(
const StorageTaskDebugInfo& info) {
auto sample_builder = [&]() {
auto sample = std::make_unique<TraceSample>();
sample->addIntValue("shard_id", info.shard_id);
sample->addNormalValue("task_priority", info.priority);
sample->addNormalValue("thread_type", info.thread_type);
sample->addNormalValue("task_type", info.task_type);
sample->addIntValue("enqueue_time", info.enqueue_time.count());
sample->addNormalValue("durability", info.durability);
if (info.log_id) {
sample->addNormalValue(
"log_id", folly::to<std::string>(info.log_id.value().val()));
}
if (info.lsn) {
sample->addNormalValue("lsn", folly::to<std::string>(info.lsn.value()));
}
if (info.client_address) {
sample->addNormalValue(
"client_address", info.client_address.value().toStringNoPort());
}
if (info.execution_start_time) {
sample->addIntValue(
"execution_start_time", info.execution_start_time.value().count());
}
if (info.execution_end_time) {
sample->addIntValue(
"execution_end_time", info.execution_end_time.value().count());
}
if (info.client_id) {
sample->addNormalValue("client_id", info.client_id.value().toString());
}
if (info.node_id) {
sample->addNormalValue("node_id", info.node_id.value().toString());
}
if (info.extra_info) {
sample->addNormalValue("extra_info", info.extra_info.value());
}
return sample;
};
publish(SLOW_STORAGE_TASKS_TRACER, sample_builder);
}
}} // namespace facebook::logdevice
| 32.313433 | 78 | 0.68545 | SimonKinds |
245a974abe43b18a78fbf27cbd469476071daf5f | 304 | hpp | C++ | include/mod/sequences.hpp | rationalis-petra/modulus | 194e4029b3085e89b7e35bb925fcba079905ef80 | [
"MIT"
] | 1 | 2021-09-24T19:45:18.000Z | 2021-09-24T19:45:18.000Z | include/mod/sequences.hpp | rationalis-petra/modulus | 194e4029b3085e89b7e35bb925fcba079905ef80 | [
"MIT"
] | null | null | null | include/mod/sequences.hpp | rationalis-petra/modulus | 194e4029b3085e89b7e35bb925fcba079905ef80 | [
"MIT"
] | null | null | null | #ifndef __MODULUS_MOD_OPTIONAL_HPP
#define __MODULUS_MOD_OPTIONAL_HPP
#include <functional>
namespace mod {
template <typename Seq, typename B>
B fold(Seq s, std::function<B(B, B)> func, B val) {
for (auto it = s.begin(); it < s.end(); it++) {
val = func(*it, val);
}
return val;
}
}
#endif
| 17.882353 | 51 | 0.661184 | rationalis-petra |
246011e5d6908b4bbd4919d5f4b5a558ad96daa5 | 31,996 | cpp | C++ | unit-tests/hdr/test-hdr.cpp | rocket-kaya/librealsense | 4663fe85b5177b5ac19834f115400fb1d5368e14 | [
"Apache-2.0"
] | 1 | 2021-05-05T17:46:11.000Z | 2021-05-05T17:46:11.000Z | unit-tests/hdr/test-hdr.cpp | rocket-kaya/librealsense | 4663fe85b5177b5ac19834f115400fb1d5368e14 | [
"Apache-2.0"
] | null | null | null | unit-tests/hdr/test-hdr.cpp | rocket-kaya/librealsense | 4663fe85b5177b5ac19834f115400fb1d5368e14 | [
"Apache-2.0"
] | 2 | 2021-01-25T01:18:47.000Z | 2021-03-18T06:44:07.000Z | // License: Apache 2.0. See LICENSE file in root directory.
// Copyright(c) 2021 Intel Corporation. All Rights Reserved.
/////////////////////////////////////////////////////////////////////////////
// This set of tests is valid for any device that supports the HDR feature //
/////////////////////////////////////////////////////////////////////////////
//#cmake:add-file ../unit-tests-common.h
//#cmake:add-file ../approx.h
#define CATCH_CONFIG_MAIN
#include "../catch.h"
#include "../unit-tests-common.h"
#include <easylogging++.h>
#ifdef BUILD_SHARED_LIBS
// With static linkage, ELPP is initialized by librealsense, so doing it here will
// create errors. When we're using the shared .so/.dll, the two are separate and we have
// to initialize ours if we want to use the APIs!
INITIALIZE_EASYLOGGINGPP
#endif
using namespace rs2;
// HDR CONFIGURATION TESTS
TEST_CASE("HDR Config - default config", "[hdr][live]")
{
rs2::context ctx;
if (make_context(SECTION_FROM_TEST_NAME, &ctx, "2.39.0"))
{
rs2::device_list devices_list = ctx.query_devices();
size_t device_count = devices_list.size();
if (devices_list.size() != 0)
{
rs2::depth_sensor depth_sensor = restart_first_device_and_return_depth_sensor(ctx, devices_list);
if (depth_sensor && depth_sensor.supports(RS2_OPTION_HDR_ENABLED))
{
auto exposure_range = depth_sensor.get_option_range(RS2_OPTION_EXPOSURE);
auto gain_range = depth_sensor.get_option_range(RS2_OPTION_GAIN);
depth_sensor.set_option(RS2_OPTION_HDR_ENABLED, 1);
REQUIRE(depth_sensor.get_option(RS2_OPTION_HDR_ENABLED) == 1.f);
depth_sensor.set_option(RS2_OPTION_SEQUENCE_ID, 1);
REQUIRE(depth_sensor.get_option(RS2_OPTION_SEQUENCE_ID) == 1.f);
auto exp = depth_sensor.get_option(RS2_OPTION_EXPOSURE);
REQUIRE(depth_sensor.get_option(RS2_OPTION_EXPOSURE) == exposure_range.def - 1000); //w/a
REQUIRE(depth_sensor.get_option(RS2_OPTION_GAIN) == gain_range.def);
depth_sensor.set_option(RS2_OPTION_SEQUENCE_ID, 2);
REQUIRE(depth_sensor.get_option(RS2_OPTION_SEQUENCE_ID) == 2.f);
REQUIRE(depth_sensor.get_option(RS2_OPTION_EXPOSURE) == exposure_range.min);
REQUIRE(depth_sensor.get_option(RS2_OPTION_GAIN) == gain_range.min);
depth_sensor.set_option(RS2_OPTION_HDR_ENABLED, 0);
auto enabled = depth_sensor.get_option(RS2_OPTION_HDR_ENABLED);
REQUIRE(depth_sensor.get_option(RS2_OPTION_HDR_ENABLED) == 0.f);
}
}
else
{
std::cout << "No device was found - skipping test" << std::endl;
}
}
}
TEST_CASE("HDR Config - custom config", "[hdr][live]")
{
// Require at least one device to be plugged in
rs2::context ctx;
if (make_context(SECTION_FROM_TEST_NAME, &ctx, "2.39.0"))
{
rs2::device_list devices_list = ctx.query_devices();
size_t device_count = devices_list.size();
if (devices_list.size() != 0)
{
rs2::depth_sensor depth_sensor = restart_first_device_and_return_depth_sensor(ctx, devices_list);
if (depth_sensor && depth_sensor.supports(RS2_OPTION_HDR_ENABLED))
{
depth_sensor.set_option(RS2_OPTION_SEQUENCE_SIZE, 2);
REQUIRE(depth_sensor.get_option(RS2_OPTION_SEQUENCE_SIZE) == 2.f);
depth_sensor.set_option(RS2_OPTION_SEQUENCE_ID, 1);
REQUIRE(depth_sensor.get_option(RS2_OPTION_SEQUENCE_ID) == 1.f);
depth_sensor.set_option(RS2_OPTION_EXPOSURE, 120.f);
REQUIRE(depth_sensor.get_option(RS2_OPTION_EXPOSURE) == 120.f);
depth_sensor.set_option(RS2_OPTION_GAIN, 90.f);
REQUIRE(depth_sensor.get_option(RS2_OPTION_GAIN) == 90.f);
depth_sensor.set_option(RS2_OPTION_SEQUENCE_ID, 2);
REQUIRE(depth_sensor.get_option(RS2_OPTION_SEQUENCE_ID) == 2.f);
depth_sensor.set_option(RS2_OPTION_EXPOSURE, 1200.f);
REQUIRE(depth_sensor.get_option(RS2_OPTION_EXPOSURE) == 1200.f);
depth_sensor.set_option(RS2_OPTION_GAIN, 20.f);
REQUIRE(depth_sensor.get_option(RS2_OPTION_GAIN) == 20.f);
depth_sensor.set_option(RS2_OPTION_HDR_ENABLED, 1);
REQUIRE(depth_sensor.get_option(RS2_OPTION_HDR_ENABLED) == 1.f);
depth_sensor.set_option(RS2_OPTION_HDR_ENABLED, 0);
REQUIRE(depth_sensor.get_option(RS2_OPTION_HDR_ENABLED) == 0.f);
}
}
else
{
std::cout << "No device was found - skipping test" << std::endl;
}
}
}
// HDR STREAMING TESTS
TEST_CASE("HDR Streaming - default config", "[hdr][live][using_pipeline]")
{
rs2::context ctx;
if (make_context(SECTION_FROM_TEST_NAME, &ctx, "2.39.0"))
{
rs2::device_list devices_list = ctx.query_devices();
size_t device_count = devices_list.size();
if (devices_list.size() != 0)
{
rs2::depth_sensor depth_sensor = restart_first_device_and_return_depth_sensor(ctx, devices_list);
if (depth_sensor && depth_sensor.supports(RS2_OPTION_HDR_ENABLED))
{
auto exposure_range = depth_sensor.get_option_range(RS2_OPTION_EXPOSURE);
auto gain_range = depth_sensor.get_option_range(RS2_OPTION_GAIN);
depth_sensor.set_option(RS2_OPTION_HDR_ENABLED, 1);
REQUIRE(depth_sensor.get_option(RS2_OPTION_HDR_ENABLED) == 1.f);
rs2::config cfg;
cfg.enable_stream(RS2_STREAM_DEPTH);
cfg.enable_stream(RS2_STREAM_INFRARED, 1);
rs2::pipeline pipe;
pipe.start(cfg);
int iteration = 0;
while (++iteration < 100)
{
rs2::frameset data;
REQUIRE_NOTHROW(data = pipe.wait_for_frames());
rs2::depth_frame out_depth_frame = data.get_depth_frame();
if (iteration < 3)
continue;
if (out_depth_frame.supports_frame_metadata(RS2_FRAME_METADATA_SEQUENCE_ID))
{
long long frame_exposure = out_depth_frame.get_frame_metadata(RS2_FRAME_METADATA_ACTUAL_EXPOSURE);
long long frame_gain = out_depth_frame.get_frame_metadata(RS2_FRAME_METADATA_GAIN_LEVEL);
auto seq_id = out_depth_frame.get_frame_metadata(RS2_FRAME_METADATA_SEQUENCE_ID);
if (seq_id == 0)
{
REQUIRE(frame_exposure == exposure_range.def - 1000.f); // w/a
REQUIRE(frame_gain == gain_range.def);
}
else
{
REQUIRE(frame_exposure == exposure_range.min);
REQUIRE(frame_gain == gain_range.min);
}
}
}
}
}
else
{
std::cout << "No device was found - skipping test" << std::endl;
}
}
}
TEST_CASE("HDR Streaming - custom config", "[hdr][live][using_pipeline]")
{
rs2::context ctx;
if (make_context(SECTION_FROM_TEST_NAME, &ctx, "2.39.0"))
{
rs2::device_list devices_list = ctx.query_devices();
size_t device_count = devices_list.size();
if (devices_list.size() != 0)
{
rs2::depth_sensor depth_sensor = restart_first_device_and_return_depth_sensor(ctx, devices_list);
if (depth_sensor && depth_sensor.supports(RS2_OPTION_HDR_ENABLED))
{
depth_sensor.set_option(RS2_OPTION_SEQUENCE_SIZE, 2);
REQUIRE(depth_sensor.get_option(RS2_OPTION_SEQUENCE_SIZE) == 2.f);
auto first_exposure = 120.f;
auto first_gain = 90.f;
depth_sensor.set_option(RS2_OPTION_SEQUENCE_ID, 1);
REQUIRE(depth_sensor.get_option(RS2_OPTION_SEQUENCE_ID) == 1.f);
depth_sensor.set_option(RS2_OPTION_EXPOSURE, first_exposure);
REQUIRE(depth_sensor.get_option(RS2_OPTION_EXPOSURE) == first_exposure);
depth_sensor.set_option(RS2_OPTION_GAIN, first_gain);
REQUIRE(depth_sensor.get_option(RS2_OPTION_GAIN) == first_gain);
auto second_exposure = 1200.f;
auto second_gain = 20.f;
depth_sensor.set_option(RS2_OPTION_SEQUENCE_ID, 2);
REQUIRE(depth_sensor.get_option(RS2_OPTION_SEQUENCE_ID) == 2.f);
depth_sensor.set_option(RS2_OPTION_EXPOSURE, second_exposure);
REQUIRE(depth_sensor.get_option(RS2_OPTION_EXPOSURE) == second_exposure);
depth_sensor.set_option(RS2_OPTION_GAIN, second_gain);
REQUIRE(depth_sensor.get_option(RS2_OPTION_GAIN) == second_gain);
depth_sensor.set_option(RS2_OPTION_HDR_ENABLED, 1);
REQUIRE(depth_sensor.get_option(RS2_OPTION_HDR_ENABLED) == 1.f);
rs2::config cfg;
cfg.enable_stream(RS2_STREAM_DEPTH);
cfg.enable_stream(RS2_STREAM_INFRARED, 1);
rs2::pipeline pipe;
pipe.start(cfg);
int iteration = 0;
while (++iteration < 100)
{
rs2::frameset data;
REQUIRE_NOTHROW(data = pipe.wait_for_frames());
rs2::depth_frame out_depth_frame = data.get_depth_frame();
if (iteration < 3)
continue;
if (out_depth_frame.supports_frame_metadata(RS2_FRAME_METADATA_SEQUENCE_ID))
{
long long frame_exposure = out_depth_frame.get_frame_metadata(RS2_FRAME_METADATA_ACTUAL_EXPOSURE);
long long frame_gain = out_depth_frame.get_frame_metadata(RS2_FRAME_METADATA_GAIN_LEVEL);
auto seq_id = out_depth_frame.get_frame_metadata(RS2_FRAME_METADATA_SEQUENCE_ID);
if (seq_id == 0)
{
REQUIRE(frame_exposure == first_exposure);
REQUIRE(frame_gain == first_gain);
}
else
{
REQUIRE(frame_exposure == second_exposure);
REQUIRE(frame_gain == second_gain);
}
}
}
}
}
else
{
std::cout << "No device was found - skipping test" << std::endl;
}
}
}
// HDR CHANGING CONFIG WHILE STREAMING TESTS
TEST_CASE("HDR Config while Streaming", "[hdr][live][using_pipeline]")
{
rs2::context ctx;
if (make_context(SECTION_FROM_TEST_NAME, &ctx, "2.39.0"))
{
rs2::device_list devices_list = ctx.query_devices();
size_t device_count = devices_list.size();
if (devices_list.size() != 0)
{
rs2::depth_sensor depth_sensor = restart_first_device_and_return_depth_sensor(ctx, devices_list);
if (depth_sensor && depth_sensor.supports(RS2_OPTION_HDR_ENABLED))
{
auto exposure_range = depth_sensor.get_option_range(RS2_OPTION_EXPOSURE);
auto gain_range = depth_sensor.get_option_range(RS2_OPTION_GAIN);
depth_sensor.set_option(RS2_OPTION_HDR_ENABLED, 1);
REQUIRE(depth_sensor.get_option(RS2_OPTION_HDR_ENABLED) == 1.f);
rs2::config cfg;
cfg.enable_stream(RS2_STREAM_DEPTH);
cfg.enable_stream(RS2_STREAM_INFRARED, 1);
rs2::pipeline pipe;
pipe.start(cfg);
auto required_exposure = exposure_range.def - 1000; // w/a
auto required_gain = gain_range.def;
auto changed_exposure = 33000.f;
auto changed_gain = 150.f;
int iteration = 0;
while (++iteration < 100)
{
rs2::frameset data;
REQUIRE_NOTHROW(data = pipe.wait_for_frames());
rs2::depth_frame out_depth_frame = data.get_depth_frame();
if (iteration < 3 || (iteration > 30 && iteration < 36))
continue;
if (iteration == 30)
{
depth_sensor.set_option(RS2_OPTION_SEQUENCE_ID, 1);
REQUIRE(depth_sensor.get_option(RS2_OPTION_SEQUENCE_ID) == 1.f);
depth_sensor.set_option(RS2_OPTION_EXPOSURE, changed_exposure);
REQUIRE(depth_sensor.get_option(RS2_OPTION_EXPOSURE) == changed_exposure);
depth_sensor.set_option(RS2_OPTION_GAIN, changed_gain);
REQUIRE(depth_sensor.get_option(RS2_OPTION_GAIN) == changed_gain);
required_exposure = changed_exposure;
required_gain = changed_gain;
continue;
}
if (out_depth_frame.supports_frame_metadata(RS2_FRAME_METADATA_SEQUENCE_ID))
{
long long frame_exposure = out_depth_frame.get_frame_metadata(RS2_FRAME_METADATA_ACTUAL_EXPOSURE);
long long frame_gain = out_depth_frame.get_frame_metadata(RS2_FRAME_METADATA_GAIN_LEVEL);
auto seq_id = out_depth_frame.get_frame_metadata(RS2_FRAME_METADATA_SEQUENCE_ID);
if (seq_id == 0)
{
REQUIRE(frame_exposure == required_exposure);
REQUIRE(frame_gain == required_gain);
}
else
{
REQUIRE(frame_exposure == exposure_range.min);
REQUIRE(frame_gain == gain_range.min);
}
}
}
}
}
else
{
std::cout << "No device was found - skipping test" << std::endl;
}
}
}
// CHECKING HDR AFTER PIPE RESTART
TEST_CASE("HDR Running - restart hdr at restream", "[hdr][live][using_pipeline]")
{
rs2::context ctx;
if (make_context(SECTION_FROM_TEST_NAME, &ctx, "2.39.0"))
{
rs2::device_list devices_list = ctx.query_devices();
size_t device_count = devices_list.size();
if (devices_list.size() != 0)
{
rs2::depth_sensor depth_sensor = restart_first_device_and_return_depth_sensor(ctx, devices_list);
if (depth_sensor && depth_sensor.supports(RS2_OPTION_HDR_ENABLED))
{
rs2::config cfg;
cfg.enable_stream(RS2_STREAM_DEPTH);
rs2::pipeline pipe;
pipe.start(cfg);
depth_sensor.set_option(RS2_OPTION_HDR_ENABLED, 1);
REQUIRE(depth_sensor.get_option(RS2_OPTION_HDR_ENABLED) == 1.f);
for (int i = 0; i < 10; ++i)
{
rs2::frameset data;
REQUIRE_NOTHROW(data = pipe.wait_for_frames());
}
REQUIRE(depth_sensor.get_option(RS2_OPTION_HDR_ENABLED) == 1.f);
pipe.stop();
pipe.start(cfg);
REQUIRE(depth_sensor.get_option(RS2_OPTION_HDR_ENABLED) == 1.f);
pipe.stop();
}
}
else
{
std::cout << "No device was found - skipping test" << std::endl;
}
}
}
// CHECKING SEQUENCE ID WHILE STREAMING
TEST_CASE("HDR Streaming - checking sequence id", "[hdr][live][using_pipeline]")
{
rs2::context ctx;
if (make_context(SECTION_FROM_TEST_NAME, &ctx, "2.39.0"))
{
rs2::device_list devices_list = ctx.query_devices();
size_t device_count = devices_list.size();
if (devices_list.size() != 0)
{
rs2::depth_sensor depth_sensor = restart_first_device_and_return_depth_sensor(ctx, devices_list);
if (depth_sensor && depth_sensor.supports(RS2_OPTION_HDR_ENABLED))
{
rs2::config cfg;
cfg.enable_stream(RS2_STREAM_DEPTH);
cfg.enable_stream(RS2_STREAM_INFRARED, 1);
rs2::pipeline pipe;
pipe.start(cfg);
depth_sensor.set_option(RS2_OPTION_HDR_ENABLED, 1.f);
REQUIRE(depth_sensor.get_option(RS2_OPTION_HDR_ENABLED) == 1.f);
int iteration = 0;
int sequence_id = -1;
int iterations_for_preparation = 6;
while (++iteration < 50) // Application still alive?
{
rs2::frameset data;
REQUIRE_NOTHROW(data = pipe.wait_for_frames());
if (iteration < iterations_for_preparation)
continue;
auto depth_frame = data.get_depth_frame();
if (depth_frame.supports_frame_metadata(RS2_FRAME_METADATA_SEQUENCE_ID))
{
auto depth_seq_id = depth_frame.get_frame_metadata(RS2_FRAME_METADATA_SEQUENCE_ID);
auto ir_frame = data.get_infrared_frame(1);
auto ir_seq_id = ir_frame.get_frame_metadata(RS2_FRAME_METADATA_SEQUENCE_ID);
if (iteration == iterations_for_preparation)
{
REQUIRE(depth_seq_id == ir_seq_id);
sequence_id = depth_seq_id;
}
else
{
sequence_id = (sequence_id == 0) ? 1 : 0;
REQUIRE(sequence_id == depth_seq_id);
REQUIRE(sequence_id == ir_seq_id);
}
}
}
pipe.stop();
}
}
else
{
std::cout << "No device was found - skipping test" << std::endl;
}
}
}
TEST_CASE("Emitter on/off - checking sequence id", "[hdr][live][using_pipeline]")
{
rs2::context ctx;
if (make_context(SECTION_FROM_TEST_NAME, &ctx, "2.39.0"))
{
rs2::device_list devices_list = ctx.query_devices();
size_t device_count = devices_list.size();
if (devices_list.size() != 0)
{
rs2::depth_sensor depth_sensor = restart_first_device_and_return_depth_sensor(ctx, devices_list);
if (depth_sensor && depth_sensor.supports(RS2_OPTION_HDR_ENABLED))
{
rs2::config cfg;
cfg.enable_stream(RS2_STREAM_DEPTH);
cfg.enable_stream(RS2_STREAM_INFRARED, 1);
rs2::pipeline pipe;
pipe.start(cfg);
depth_sensor.set_option(RS2_OPTION_EMITTER_ON_OFF, 1);
REQUIRE(depth_sensor.get_option(RS2_OPTION_EMITTER_ON_OFF) == 1.f);
int iteration = 0;
int sequence_id = -1;
int iterations_for_preparation = 6;
while (++iteration < 50) // Application still alive?
{
rs2::frameset data;
REQUIRE_NOTHROW(data = pipe.wait_for_frames());
if (iteration < iterations_for_preparation)
continue;
auto depth_frame = data.get_depth_frame();
if (depth_frame.supports_frame_metadata(RS2_FRAME_METADATA_SEQUENCE_ID))
{
auto depth_seq_id = depth_frame.get_frame_metadata(RS2_FRAME_METADATA_SEQUENCE_ID);
auto ir_frame = data.get_infrared_frame(1);
auto ir_seq_id = ir_frame.get_frame_metadata(RS2_FRAME_METADATA_SEQUENCE_ID);
if (iteration == iterations_for_preparation)
{
REQUIRE(depth_seq_id == ir_seq_id);
sequence_id = depth_seq_id;
}
else
{
sequence_id = (sequence_id == 0) ? 1 : 0;
REQUIRE(sequence_id == depth_seq_id);
REQUIRE(sequence_id == ir_seq_id);
}
}
}
pipe.stop();
}
}
else
{
std::cout << "No device was found - skipping test" << std::endl;
}
}
}
//This tests checks that the previously saved merged frame is discarded after a pipe restart
TEST_CASE("HDR Merge - discard merged frame", "[hdr][live][using_pipeline]") {
rs2::context ctx;
if (make_context(SECTION_FROM_TEST_NAME, &ctx, "2.39.0"))
{
rs2::device_list devices_list = ctx.query_devices();
size_t device_count = devices_list.size();
if (devices_list.size() != 0)
{
rs2::depth_sensor depth_sensor = restart_first_device_and_return_depth_sensor(ctx, devices_list);
if (depth_sensor && depth_sensor.supports(RS2_OPTION_HDR_ENABLED))
{
depth_sensor.set_option(RS2_OPTION_HDR_ENABLED, 1);
REQUIRE(depth_sensor.get_option(RS2_OPTION_HDR_ENABLED) == 1.f);
rs2::config cfg;
cfg.enable_stream(RS2_STREAM_DEPTH);
rs2::pipeline pipe;
pipe.start(cfg);
// initializing the merging filter
rs2::hdr_merge merging_filter;
int num_of_iterations_in_serie = 10;
int first_series_last_merged_ts = -1;
for (int i = 0; i < num_of_iterations_in_serie; ++i)
{
rs2::frameset data;
REQUIRE_NOTHROW(data = pipe.wait_for_frames());
rs2::depth_frame out_depth_frame = data.get_depth_frame();
if (out_depth_frame.supports_frame_metadata(RS2_FRAME_METADATA_SEQUENCE_ID))
{
// merging the frames from the different HDR sequence IDs
auto merged_frameset = merging_filter.process(data);
auto merged_depth_frame = merged_frameset.as<rs2::frameset>().get_depth_frame();
long long frame_ts = merged_depth_frame.get_frame_metadata(RS2_FRAME_METADATA_FRAME_TIMESTAMP);
if (i == (num_of_iterations_in_serie - 1))
first_series_last_merged_ts = frame_ts;
}
}
REQUIRE(first_series_last_merged_ts != -1);
pipe.stop();
REQUIRE(depth_sensor.get_option(RS2_OPTION_HDR_ENABLED) == 1.f);
pipe.start(cfg);
for (int i = 0; i < 10; ++i)
{
rs2::frameset data;
REQUIRE_NOTHROW(data = pipe.wait_for_frames());
rs2::depth_frame out_depth_frame = data.get_depth_frame();
if (out_depth_frame.supports_frame_metadata(RS2_FRAME_METADATA_SEQUENCE_ID))
{
// merging the frames from the different HDR sequence IDs
auto merged_frameset = merging_filter.process(data);
auto merged_depth_frame = merged_frameset.as<rs2::frameset>().get_depth_frame();
long long frame_ts = merged_depth_frame.get_frame_metadata(RS2_FRAME_METADATA_FRAME_TIMESTAMP);
REQUIRE(frame_ts > first_series_last_merged_ts);
}
}
pipe.stop();
}
}
else
{
std::cout << "No device was found - skipping test" << std::endl;
}
}
}
TEST_CASE("HDR Start Stop - recover manual exposure and gain", "[HDR]")
{
rs2::context ctx;
if (make_context(SECTION_FROM_TEST_NAME, &ctx, "2.39.0"))
{
rs2::device_list devices_list = ctx.query_devices();
size_t device_count = devices_list.size();
if (devices_list.size() != 0)
{
rs2::depth_sensor depth_sensor = restart_first_device_and_return_depth_sensor(ctx, devices_list);
if (depth_sensor && depth_sensor.supports(RS2_OPTION_HDR_ENABLED))
{
float gain_before_hdr = 50.f;
depth_sensor.set_option(RS2_OPTION_GAIN, gain_before_hdr);
REQUIRE(depth_sensor.get_option(RS2_OPTION_GAIN) == gain_before_hdr);
float exposure_before_hdr = 5000.f;
depth_sensor.set_option(RS2_OPTION_EXPOSURE, exposure_before_hdr);
REQUIRE(depth_sensor.get_option(RS2_OPTION_EXPOSURE) == exposure_before_hdr);
depth_sensor.set_option(RS2_OPTION_HDR_ENABLED, 1);
REQUIRE(depth_sensor.get_option(RS2_OPTION_HDR_ENABLED) == 1.f);
rs2::config cfg;
cfg.enable_stream(RS2_STREAM_DEPTH);
rs2::pipeline pipe;
pipe.start(cfg);
int iteration = 0;
int iteration_for_disable = 50;
int iteration_to_check_after_disable = iteration_for_disable + 2;
while (++iteration < 70)
{
rs2::frameset data;
REQUIRE_NOTHROW(data = pipe.wait_for_frames());
rs2::depth_frame out_depth_frame = data.get_depth_frame();
if (out_depth_frame.supports_frame_metadata(RS2_FRAME_METADATA_SEQUENCE_ID))
{
long long frame_gain = out_depth_frame.get_frame_metadata(RS2_FRAME_METADATA_GAIN_LEVEL);
long long frame_exposure = out_depth_frame.get_frame_metadata(RS2_FRAME_METADATA_ACTUAL_EXPOSURE);
if (iteration > iteration_for_disable && iteration < iteration_to_check_after_disable)
continue;
if (iteration == iteration_for_disable)
{
depth_sensor.set_option(RS2_OPTION_HDR_ENABLED, 0);
REQUIRE(depth_sensor.get_option(RS2_OPTION_HDR_ENABLED) == 0.f);
}
else if (iteration >= iteration_to_check_after_disable)
{
REQUIRE(frame_gain == gain_before_hdr);
REQUIRE(frame_exposure == exposure_before_hdr);
}
}
}
}
}
else
{
std::cout << "No device was found - skipping test" << std::endl;
}
}
}
// CONTROLS STABILITY WHILE HDR ACTIVE
TEST_CASE("HDR Active - set locked options", "[hdr][live]") {
rs2::context ctx;
if (make_context(SECTION_FROM_TEST_NAME, &ctx, "2.39.0"))
{
rs2::device_list devices_list = ctx.query_devices();
size_t device_count = devices_list.size();
if (devices_list.size() != 0)
{
rs2::depth_sensor depth_sensor = restart_first_device_and_return_depth_sensor(ctx, devices_list);
if (depth_sensor && depth_sensor.supports(RS2_OPTION_HDR_ENABLED))
{
//setting laser ON
REQUIRE_NOTHROW(depth_sensor.set_option(RS2_OPTION_EMITTER_ENABLED, 1.f));
auto laser_power_before_hdr = depth_sensor.get_option(RS2_OPTION_LASER_POWER);
std::this_thread::sleep_for((std::chrono::milliseconds)(1500));
REQUIRE_NOTHROW(depth_sensor.set_option(RS2_OPTION_HDR_ENABLED, 1.f));
REQUIRE(depth_sensor.get_option(RS2_OPTION_HDR_ENABLED) == 1.f);
// the following calls should not be performed and should send a LOG_WARNING
REQUIRE_NOTHROW(depth_sensor.set_option(RS2_OPTION_ENABLE_AUTO_EXPOSURE, 1.f));
REQUIRE(depth_sensor.get_option(RS2_OPTION_ENABLE_AUTO_EXPOSURE) == 0.f);
REQUIRE_NOTHROW(depth_sensor.set_option(RS2_OPTION_EMITTER_ENABLED, 0.f));
REQUIRE(depth_sensor.get_option(RS2_OPTION_EMITTER_ENABLED) == 1.f);
REQUIRE_NOTHROW(depth_sensor.set_option(RS2_OPTION_EMITTER_ON_OFF, 1.f));
REQUIRE(depth_sensor.get_option(RS2_OPTION_EMITTER_ON_OFF) == 0.f);
REQUIRE_NOTHROW(depth_sensor.set_option(RS2_OPTION_LASER_POWER, laser_power_before_hdr - 30.f));
REQUIRE(depth_sensor.get_option(RS2_OPTION_LASER_POWER) == laser_power_before_hdr);
}
}
else
{
std::cout << "No device was found - skipping test" << std::endl;
}
}
}
TEST_CASE("HDR Streaming - set locked options", "[hdr][live][using_pipeline]") {
rs2::context ctx;
if (make_context(SECTION_FROM_TEST_NAME, &ctx, "2.39.0"))
{
rs2::device_list devices_list = ctx.query_devices();
size_t device_count = devices_list.size();
if (devices_list.size() != 0)
{
rs2::depth_sensor depth_sensor = restart_first_device_and_return_depth_sensor(ctx, devices_list);
if (depth_sensor && depth_sensor.supports(RS2_OPTION_HDR_ENABLED))
{
//setting laser ON
REQUIRE_NOTHROW(depth_sensor.set_option(RS2_OPTION_EMITTER_ENABLED, 1.f));
auto laser_power_before_hdr = depth_sensor.get_option(RS2_OPTION_LASER_POWER);
std::this_thread::sleep_for((std::chrono::milliseconds)(1500));
REQUIRE_NOTHROW(depth_sensor.set_option(RS2_OPTION_HDR_ENABLED, 1.f));
REQUIRE(depth_sensor.get_option(RS2_OPTION_HDR_ENABLED) == 1.f);
rs2::config cfg;
cfg.enable_stream(RS2_STREAM_DEPTH);
rs2::pipeline pipe;
pipe.start(cfg);
int iteration = 0;
while (++iteration < 50)
{
rs2::frameset data;
REQUIRE_NOTHROW(data = pipe.wait_for_frames());
if (iteration == 20)
{
// the following calls should not be performed and should send a LOG_WARNING
REQUIRE_NOTHROW(depth_sensor.set_option(RS2_OPTION_ENABLE_AUTO_EXPOSURE, 1.f));
REQUIRE(depth_sensor.get_option(RS2_OPTION_ENABLE_AUTO_EXPOSURE) == 0.f);
REQUIRE_NOTHROW(depth_sensor.set_option(RS2_OPTION_EMITTER_ENABLED, 0.f));
REQUIRE(depth_sensor.get_option(RS2_OPTION_EMITTER_ENABLED) == 1.f);
REQUIRE_NOTHROW(depth_sensor.set_option(RS2_OPTION_EMITTER_ON_OFF, 1.f));
REQUIRE(depth_sensor.get_option(RS2_OPTION_EMITTER_ON_OFF) == 0.f);
REQUIRE_NOTHROW(depth_sensor.set_option(RS2_OPTION_LASER_POWER, laser_power_before_hdr - 30.f));
REQUIRE(depth_sensor.get_option(RS2_OPTION_LASER_POWER) == laser_power_before_hdr);
}
}
}
}
else
{
std::cout << "No device was found - skipping test" << std::endl;
}
}
} | 42.322751 | 122 | 0.561039 | rocket-kaya |
2463b1d1f84cb6068161203df82beb4d4fd58407 | 3,272 | cc | C++ | test/static_test/test_strings.cc | vvchernov/onnxruntime-extensions | cc858e831b719d31e4f34ee9adb391105b4ce26b | [
"MIT"
] | 59 | 2021-04-29T07:39:42.000Z | 2022-03-29T21:12:05.000Z | test/static_test/test_strings.cc | vvchernov/onnxruntime-extensions | cc858e831b719d31e4f34ee9adb391105b4ce26b | [
"MIT"
] | 45 | 2021-05-12T08:32:58.000Z | 2022-03-29T21:11:59.000Z | test/static_test/test_strings.cc | vvchernov/onnxruntime-extensions | cc858e831b719d31e4f34ee9adb391105b4ce26b | [
"MIT"
] | 18 | 2021-05-10T10:15:46.000Z | 2022-03-22T10:46:36.000Z | // Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT License.
#include "gtest/gtest.h"
#include "string_utils.h"
#include "text/re2_strings/string_regex_split_re.hpp"
#include "text/string_ecmaregex_split.hpp"
TEST(strings, std_regex_test) {
std::regex regex("[\u2700-\u27bf\U0001f650-\U0001f67f\U0001f600-\U0001f64f\u2600-\u26ff"
"\U0001f300-\U0001f5ff\U0001f900-\U0001f9ff\U0001fa70-\U0001faff"
"\U0001f680-\U0001f6ff]");
std::string test =u8"abcde😀🔍🦑😁🔍🎉😂🤣";
auto result = std::regex_replace(test, regex, "");
std::cout << test << std::endl;
std::cout << result << std::endl;
}
TEST(strings, regex_split) {
std::string input = "hello world";
re2::RE2 reg("(\\s)");
re2::RE2 keep_reg("\\s");
std::vector<std::string_view> tokens;
std::vector<int64_t> begin_offsets;
std::vector<int64_t> end_offsets;
RegexSplitImpl(input, reg, true, keep_reg, tokens, begin_offsets, end_offsets);
std::vector<std::string_view> expected_tokens{"hello", " ", " ", "world"};
std::vector<int64_t> expected_begin_offsets{0, 5, 6, 7};
std::vector<int64_t> expected_end_offsets{5, 6, 7, 12};
EXPECT_EQ(expected_tokens, tokens);
EXPECT_EQ(expected_begin_offsets, begin_offsets);
EXPECT_EQ(expected_end_offsets, end_offsets);
}
TEST(strings, regex_split_skip) {
std::string input = "hello world";
re2::RE2 reg("(\\s)");
re2::RE2 keep_reg("");
std::vector<std::string_view> tokens;
std::vector<int64_t> begin_offsets;
std::vector<int64_t> end_offsets;
RegexSplitImpl(input, reg, true, keep_reg, tokens, begin_offsets, end_offsets);
std::vector<std::string_view> expected_tokens{"hello", "world"};
std::vector<int64_t> expected_begin_offsets{0, 6};
std::vector<int64_t> expected_end_offsets{5, 11};
EXPECT_EQ(expected_tokens, tokens);
EXPECT_EQ(expected_begin_offsets, begin_offsets);
EXPECT_EQ(expected_end_offsets, end_offsets);
}
TEST(strings, regex_split_no_matched) {
std::string input = "helloworld";
std::regex reg("(\\s)");
std::regex keep_reg("");
std::vector<std::string_view> tokens;
std::vector<int64_t> begin_offsets;
std::vector<int64_t> end_offsets;
ECMARegexSplitImpl(input, reg, true, keep_reg, tokens, begin_offsets, end_offsets);
std::vector<std::string_view> expected_tokens{"helloworld"};
std::vector<int64_t> expected_begin_offsets{0};
std::vector<int64_t> expected_end_offsets{10};
EXPECT_EQ(expected_tokens, tokens);
EXPECT_EQ(expected_begin_offsets, begin_offsets);
EXPECT_EQ(expected_end_offsets, end_offsets);
}
TEST(strings, regex_split_begin_end_delim) {
std::string input = " hello world ";
std::regex reg("(\\s)");
std::regex keep_reg("\\s");
std::vector<std::string_view> tokens;
std::vector<int64_t> begin_offsets;
std::vector<int64_t> end_offsets;
ECMARegexSplitImpl(input, reg, true, keep_reg, tokens, begin_offsets, end_offsets);
std::vector<std::string_view> expected_tokens{" ", "hello"," ", "world", " "};
std::vector<int64_t> expected_begin_offsets{0, 1, 6, 7, 12};
std::vector<int64_t> expected_end_offsets{1, 6, 7, 12, 13};
EXPECT_EQ(expected_tokens, tokens);
EXPECT_EQ(expected_begin_offsets, begin_offsets);
EXPECT_EQ(expected_end_offsets, end_offsets);
}
| 38.494118 | 90 | 0.718826 | vvchernov |
2463d4d986c95bf2155c21f51c379c6e05df10ea | 2,512 | cpp | C++ | src/modules/m_setagent.cpp | BerilBBJ/beryldb | 6569b568796e4cea64fe7f42785b0319541a0284 | [
"BSD-3-Clause"
] | 206 | 2021-04-27T21:44:24.000Z | 2022-02-23T12:01:20.000Z | src/modules/m_setagent.cpp | BerilBBJ/beryldb | 6569b568796e4cea64fe7f42785b0319541a0284 | [
"BSD-3-Clause"
] | 10 | 2021-05-04T19:46:59.000Z | 2021-10-01T23:43:07.000Z | src/modules/m_setagent.cpp | berylcorp/beryl | 6569b568796e4cea64fe7f42785b0319541a0284 | [
"BSD-3-Clause"
] | 7 | 2021-04-28T16:17:56.000Z | 2021-12-10T01:14:42.000Z | /*
* BerylDB - A lightweight database.
* http://www.beryldb.com
*
* Copyright (C) 2021 - Carlos F. Ferry <[email protected]>
*
* This file is part of BerylDB. BerylDB is free software: you can
* redistribute it and/or modify it under the terms of the BSD License
* version 3.
*
* More information about our licensing can be found at https://docs.beryl.dev
*/
#include "beryl.h"
#include "engine.h"
class CommandSetAgent : public Command
{
public:
CommandSetAgent(Module* Creator) : Command(Creator, "SETAGENT", 2)
{
last_empty_ok = false;
flags = 'e';
syntax = "[<instance>] <channel>[,<channel>]+";
INTERPRET2(TR_INSTANCE, TR_TEXT);
}
COMMAND_RESULT Handle(User* user, const Params& parameters)
{
const std::string& instance = parameters[0];
const std::string& agent = parameters[1];
User* target = Kernel->Clients->FindInstance(instance);
if ((!target) || (target->registered != REG_OK))
{
user->SendProtocol(Protocols::NoInstance(instance));
return FAILED;
}
if (agent.empty() || agent.length() < 3 || agent.length() > 15)
{
user->SendProtocol(ERR_INPUT2, ERR_BAD_FORMAT, VALID_AGENT);
return FAILED;
}
if (!Kernel->Engine->IsAgent(agent))
{
user->SendProtocol(ERR_INPUT2, ERR_BAD_FORMAT, WRONG_AGENT);
return FAILED;
}
if (IS_LOCAL(target))
{
target->SetAgent(parameters[1]);
user->SendProtocol(BRLD_OK, PROCESS_OK);
}
return SUCCESS;
}
RouteParams GetRouting(User* user, const Params& parameters)
{
return ROUTE_OPT_UCAST(parameters[0]);
}
};
class ModuleSetAgent : public Module
{
private:
CommandSetAgent cmd;
public:
ModuleSetAgent() : cmd(this)
{
}
Version GetDescription()
{
return Version("Adds SETAGENT command.", VF_BERYLDB|VF_OPTCOMMON);
}
};
MODULE_LOAD(ModuleSetAgent)
| 27.911111 | 84 | 0.492834 | BerilBBJ |
246d1122b2586189924fae88f550ba68460df271 | 4,061 | hpp | C++ | include/common_robotics_utilities/simple_dtw.hpp | EricCousineau-TRI/common_robotics_utilities | df2f0c68d92d93c919bb7401abe5e12bd5ca2345 | [
"BSD-3-Clause"
] | null | null | null | include/common_robotics_utilities/simple_dtw.hpp | EricCousineau-TRI/common_robotics_utilities | df2f0c68d92d93c919bb7401abe5e12bd5ca2345 | [
"BSD-3-Clause"
] | null | null | null | include/common_robotics_utilities/simple_dtw.hpp | EricCousineau-TRI/common_robotics_utilities | df2f0c68d92d93c919bb7401abe5e12bd5ca2345 | [
"BSD-3-Clause"
] | null | null | null | #pragma once
#include <cstdint>
#include <functional>
#include <limits>
#include <stdexcept>
#include <vector>
#include <Eigen/Geometry>
namespace common_robotics_utilities
{
namespace simple_dtw
{
template<typename FirstDatatype, typename SecondDatatype,
typename FirstContainer=std::vector<FirstDatatype>,
typename SecondContainer=std::vector<SecondDatatype>>
class SimpleDTW
{
protected:
void InitializeMatrix(const ssize_t first_sequence_size,
const ssize_t second_sequence_size)
{
const ssize_t rows = first_sequence_size + 1;
const ssize_t cols = second_sequence_size + 1;
if (dtw_matrix_.rows() < rows || dtw_matrix_.cols() < cols)
{
dtw_matrix_ = Eigen::MatrixXd::Zero(rows, cols);
if (rows > 1 && cols > 1)
{
for (ssize_t row = 1; row < rows; row++)
{
dtw_matrix_(row, 0) = std::numeric_limits<double>::infinity();
}
for (ssize_t col = 1; col < cols; col++)
{
dtw_matrix_(0, col) = std::numeric_limits<double>::infinity();
}
}
}
}
Eigen::MatrixXd dtw_matrix_;
public:
SimpleDTW()
{
InitializeMatrix(0, 0);
}
SimpleDTW(const ssize_t first_sequence_size,
const ssize_t second_sequence_size)
{
InitializeMatrix(first_sequence_size, second_sequence_size);
}
double EvaluateWarpingCost(
const FirstContainer& first_sequence,
const SecondContainer& second_sequence,
const std::function<double(const FirstDatatype&,
const SecondDatatype&)>& distance_fn)
{
if (first_sequence.empty())
{
throw std::invalid_argument("first_sequence is empty");
}
if (second_sequence.empty())
{
throw std::invalid_argument("second_sequence is empty");
}
const ssize_t first_sequence_size
= static_cast<ssize_t>(first_sequence.size());
const ssize_t second_sequence_size
= static_cast<ssize_t>(second_sequence.size());
InitializeMatrix(first_sequence_size, second_sequence_size);
//Compute DTW cost for the two sequences
for (ssize_t i = 1; i <= first_sequence_size; i++)
{
const FirstDatatype& first_item
= first_sequence[static_cast<size_t>(i) - 1];
for (ssize_t j = 1; j <= second_sequence_size; j++)
{
const SecondDatatype& second_item
= second_sequence[static_cast<size_t>(j) - 1];
const double index_cost = distance_fn(first_item, second_item);
double prev_cost = 0.0;
// Get the next neighboring values from the matrix to use for the update
double im1j = dtw_matrix_(i - 1, j);
double im1jm1 = dtw_matrix_(i - 1, j - 1);
double ijm1 = dtw_matrix_(i, j - 1);
// Start the update step
if (im1j < im1jm1 && im1j < ijm1)
{
prev_cost = im1j;
}
else if (ijm1 < im1j && ijm1 < im1jm1)
{
prev_cost = ijm1;
}
else
{
prev_cost = im1jm1;
}
// Update the value in the matrix
const double new_cost = index_cost + prev_cost;
dtw_matrix_(i, j) = new_cost;
}
}
//Return total path cost
const double warping_cost
= dtw_matrix_(first_sequence_size, second_sequence_size);
return warping_cost;
}
};
template<typename FirstDatatype, typename SecondDatatype,
typename FirstContainer=std::vector<FirstDatatype>,
typename SecondContainer=std::vector<SecondDatatype>>
inline double EvaluateWarpingCost(
const FirstContainer& first_sequence,
const SecondContainer& second_sequence,
const std::function<double(const FirstDatatype&,
const SecondDatatype&)>& distance_fn)
{
SimpleDTW<FirstDatatype, SecondDatatype,
FirstContainer, SecondContainer> dtw_evaluator;
return dtw_evaluator.EvaluateWarpingCost(
first_sequence, second_sequence, distance_fn);
}
} // namespace simple_dtw
} // namespace common_robotics_utilities
| 30.765152 | 80 | 0.645654 | EricCousineau-TRI |
246d5610bfb128a44e51d3a4ff61c77c00376058 | 199 | cpp | C++ | ModelChecker/unitary_tests/Model_checker/unused_var.cpp | jxw1102/projet_merou | 886c6774c5d2dbd91556ec5592a2296703da0132 | [
"Apache-2.0"
] | 3 | 2015-02-11T20:10:38.000Z | 2015-12-26T07:30:37.000Z | ModelChecker/unitary_tests/Model_checker/unused_var.cpp | jxw1102/projet_merou | 886c6774c5d2dbd91556ec5592a2296703da0132 | [
"Apache-2.0"
] | 7 | 2015-02-06T23:34:58.000Z | 2015-02-26T21:53:20.000Z | ModelChecker/unitary_tests/Model_checker/unused_var.cpp | jxw1102/projet_merou | 886c6774c5d2dbd91556ec5592a2296703da0132 | [
"Apache-2.0"
] | 1 | 2015-04-24T07:54:22.000Z | 2015-04-24T07:54:22.000Z | int f() {
return 2;
}
int main(int argc, char** argv) {
int x;
int y;
int z;
x + y + 2 + f();
if (x > 2) {
int r = 3;
} else {
int r = 2;
r++;
}
return 0;
} | 9.47619 | 34 | 0.376884 | jxw1102 |
246e7c5a830df24ef92625e448e2d17a770c243a | 7,270 | hpp | C++ | Engine/Core/Headers/Molten/Gui/CanvasRenderer.hpp | jimmiebergmann/CurseEngine | 74a0502e36327f893c8e4f3e7cbe5b9d38fbe194 | [
"MIT"
] | 2 | 2019-11-11T21:17:14.000Z | 2019-11-11T22:07:26.000Z | Engine/Core/Headers/Molten/Gui/CanvasRenderer.hpp | jimmiebergmann/CurseEngine | 74a0502e36327f893c8e4f3e7cbe5b9d38fbe194 | [
"MIT"
] | null | null | null | Engine/Core/Headers/Molten/Gui/CanvasRenderer.hpp | jimmiebergmann/CurseEngine | 74a0502e36327f893c8e4f3e7cbe5b9d38fbe194 | [
"MIT"
] | 1 | 2020-04-05T03:50:57.000Z | 2020-04-05T03:50:57.000Z | /*
* MIT License
*
* Copyright (c) 2022 Jimmie Bergmann
*
* 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.
*
*/
#ifndef MOLTEN_CORE_GUI_CANVASRENDERER_HPP
#define MOLTEN_CORE_GUI_CANVASRENDERER_HPP
#include "Molten/Gui/GuiTypes.hpp"
#include "Molten/Gui/Font.hpp"
#include "Molten/Math/Vector.hpp"
#include "Molten/Math/Matrix.hpp"
#include "Molten/Math/Bounds.hpp"
#include "Molten/Math/AABB.hpp"
#include "Molten/Renderer/RenderResource.hpp"
#include "Molten/Renderer/Sampler.hpp"
#include "Molten/Renderer/ShaderProgram.hpp"
#include "Molten/Renderer/Texture.hpp"
#include "Molten/Renderer/VertexBuffer.hpp"
namespace Molten
{
class Renderer;
class CommandBuffer;
class Pipeline;
class VertexBuffer;
class IndexBuffer;
class DescriptorSet;
class FramedDescriptorSet;
class Logger;
}
namespace Molten::Shader::Visual
{
class VertexScript;
class FragmentScript;
}
namespace Molten::Gui
{
class CanvasRenderer;
struct MOLTEN_API CanvasRendererTexture
{
CanvasRendererTexture() = default;
CanvasRendererTexture(const CanvasRendererTexture&) = delete;
CanvasRendererTexture(CanvasRendererTexture&&) noexcept = default;
CanvasRendererTexture& operator =(const CanvasRendererTexture&) = delete;
CanvasRendererTexture& operator =(CanvasRendererTexture&&) noexcept = default;
SharedRenderResource<Texture2D> texture;
Vector2ui32 dimensions;
RenderResource<DescriptorSet> descriptorSet;
};
struct MOLTEN_API CanvasRendererFramedTexture
{
CanvasRendererFramedTexture() = default;
~CanvasRendererFramedTexture() = default;
CanvasRendererFramedTexture(const CanvasRendererTexture&) = delete;
CanvasRendererFramedTexture(CanvasRendererFramedTexture&&) noexcept = default;
CanvasRendererFramedTexture& operator =(const CanvasRendererFramedTexture&) = delete;
CanvasRendererFramedTexture& operator =(CanvasRendererFramedTexture&&) noexcept = default;
SharedRenderResource<FramedTexture2D> framedTexture;
RenderResource<FramedDescriptorSet> framedDescriptorSet;
};
struct MOLTEN_API CanvasRendererFontSequence
{
struct Group
{
Group() = default;
Group(const Group&) = delete;
Group(Group&&) noexcept = default;
Group& operator =(const Group&) = delete;
Group& operator =(Group&&) noexcept = default;
CanvasRendererTexture* texture;
RenderResource<VertexBuffer> vertexBuffer;
};
CanvasRendererFontSequence() = default;
CanvasRendererFontSequence(const CanvasRendererFontSequence&) = delete;
CanvasRendererFontSequence(CanvasRendererFontSequence&&) noexcept = default;
CanvasRendererFontSequence& operator =(const CanvasRendererFontSequence&) = delete;
CanvasRendererFontSequence& operator =(CanvasRendererFontSequence&&) noexcept = default;
std::vector<Group> groups;
};
class MOLTEN_API CanvasRenderer
{
public:
static CanvasRendererPointer Create(Renderer& renderer, Logger * logger = nullptr, const Vector2f32& size = { 0.0f, 0.0f });
CanvasRenderer(Renderer& renderer, Logger* logger = nullptr, const Vector2f32& size = {0.0f, 0.0f});
~CanvasRenderer();
CanvasRenderer(const CanvasRenderer&) = delete;
CanvasRenderer(CanvasRenderer&&) = delete;
CanvasRenderer& operator =(const CanvasRenderer&) = delete;
CanvasRenderer& operator =(CanvasRenderer&&) = delete;
void Close();
void Resize(const Vector2f32& size);
CanvasRendererTexture CreateTexture(const TextureDescriptor2D& textureDescriptor);
bool UpdateTexture(CanvasRendererTexture& texture, const TextureUpdateDescriptor2D& textureUpdateDescriptor);
CanvasRendererFramedTexture CreateFramedTexture(SharedRenderResource<FramedTexture2D> framedTexture);
CanvasRendererFontSequence CreateFontSequence(FontGroupedSequence& fontGroupedSequence);
void SetCommandBuffer(CommandBuffer& commandBuffer);
void DrawRect(const AABB2f32& bounds, const Vector4f32& color);
void DrawRect(const AABB2f32& bounds, CanvasRendererTexture& texture);
void DrawRect(const AABB2f32& bounds, const Bounds2f32& textureCoords, CanvasRendererTexture& texture);
void DrawRect(const AABB2f32& bounds, const Bounds2f32& textureCoords, CanvasRendererFramedTexture& framedtexture);
void DrawFontSequence(const Vector2f32& position, CanvasRendererFontSequence& fontSequence);
private:
struct ColoredRectData
{
ColoredRectData();
RenderResource<Pipeline> pipeline;
RenderResource<VertexBuffer> vertexBuffer;
RenderResource<IndexBuffer> indexBuffer;
uint32_t projectionLocation;
uint32_t positionLocation;
uint32_t sizeLocation;
uint32_t colorLocation;
};
struct TexturedRectData
{
TexturedRectData();
RenderResource<Pipeline> pipeline;
RenderResource<VertexBuffer> vertexBuffer;
RenderResource<IndexBuffer> indexBuffer;
uint32_t projectionLocation;
uint32_t positionLocation;
uint32_t sizeLocation;
uint32_t uvPositionLocation;
uint32_t uvSizeLocation;
};
struct FontRenderData
{
FontRenderData();
RenderResource<Pipeline> pipeline;
uint32_t projectionLocation;
uint32_t positionLocation;
};
static void DestroyColoredRect(ColoredRectData& data);
static void DestroyTexturedRect(TexturedRectData& data);
void LoadColoredRect();
void LoadTexturedRect();
void LoadFontRenderData();
//Logger* m_logger;
Renderer& m_backendRenderer;
CommandBuffer* m_commandBuffer;
Matrix4x4f32 m_projection;
SharedRenderResource<Sampler2D> m_sampler2D;
ColoredRectData m_coloredRect;
TexturedRectData m_texturedRect;
FontRenderData m_fontRenderData;
};
}
#endif | 33.657407 | 132 | 0.708391 | jimmiebergmann |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.