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 108 | 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 67k ⌀ | 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 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
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 |
989c7c48742d8bc4d937eb781473c188d3afa57a | 803 | cpp | C++ | src/hal/STM32F0/exti/exti.example.cpp | ghsecuritylab/omef | a6b2dec8d57545c3804174883e582080ef6f3af9 | [
"MIT"
] | null | null | null | src/hal/STM32F0/exti/exti.example.cpp | ghsecuritylab/omef | a6b2dec8d57545c3804174883e582080ef6f3af9 | [
"MIT"
] | null | null | null | src/hal/STM32F0/exti/exti.example.cpp | ghsecuritylab/omef | a6b2dec8d57545c3804174883e582080ef6f3af9 | [
"MIT"
] | null | null | null | #include "common/assert.h"
#include "gpio/gpio.hpp"
#include "exti/exti.hpp"
#include "FreeRTOS.h"
#include "task.h"
using namespace hal;
static void main_task(void *pvParameters)
{
gpio *green_led = (gpio *)pvParameters;
while(1)
{
green_led->toggle();
vTaskDelay(500);
}
}
static void exti_cb(exti *exti, void *ctx)
{
gpio *blue_led = (gpio *)ctx;
blue_led->toggle();
}
int main(void)
{
static gpio green_led(2, 9, gpio::MODE_DO, 0);
static gpio blue_led(2, 7, gpio::MODE_DO, 0);
static gpio exti1_gpio(0, 0, gpio::MODE_DI, 0);
static exti exti1(exti1_gpio, exti::TRIGGER_FALLING);
exti1.cb(exti_cb, &blue_led);
exti1.on();
ASSERT(xTaskCreate(main_task, "main", configMINIMAL_STACK_SIZE * 1,
&green_led, tskIDLE_PRIORITY + 1, NULL) == pdPASS);
vTaskStartScheduler();
}
| 19.585366 | 68 | 0.693649 | ghsecuritylab |
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 |
989e432a333827c529ba4900bacad769ee142254 | 9,883 | cpp | C++ | src/mame/drivers/spg2xx_digimake.cpp | Robbbert/messui | 49b756e2140d8831bc81335298ee8c5471045e79 | [
"BSD-3-Clause"
] | 26 | 2015-03-31T06:25:51.000Z | 2021-12-14T09:29:04.000Z | src/mame/drivers/spg2xx_digimake.cpp | Robbbert/messui | 49b756e2140d8831bc81335298ee8c5471045e79 | [
"BSD-3-Clause"
] | null | null | null | src/mame/drivers/spg2xx_digimake.cpp | Robbbert/messui | 49b756e2140d8831bc81335298ee8c5471045e79 | [
"BSD-3-Clause"
] | 10 | 2015-03-27T05:45:51.000Z | 2022-02-04T06:57:36.000Z | // license:BSD-3-Clause
// copyright-holders:Ryan Holtz, David Haywood
// Digi Makeover - this uses a camera and touchpad, both currently unsupported
// - why do we need a hack to boot?
#include "emu.h"
#include "includes/spg2xx.h"
#include "machine/nvram.h"
class spg2xx_game_digimake_state : public spg2xx_game_state
{
public:
spg2xx_game_digimake_state(const machine_config &mconfig, device_type type, const char *tag) :
spg2xx_game_state(mconfig, type, tag)
{ }
void digimake(machine_config &config);
void mem_map_digi(address_map& map);
private:
virtual void portc_w(offs_t offset, uint16_t data, uint16_t mem_mask = ~0) override;
};
void spg2xx_game_digimake_state::mem_map_digi(address_map &map)
{
map(0x000000, 0x1fffff).bankr("cartbank");
// there is also a write/read on 37FFFF before anything is configured as RAM
map(0x380000, 0x3fffff).ram();
}
static INPUT_PORTS_START( rad_digi ) // some of the inputs seem to act like buttons, others are positional touchpad?
PORT_START("P1")
PORT_DIPNAME( 0x0001, 0x0001, "Used 1" )
PORT_DIPSETTING( 0x0001, DEF_STR( Off ) )
PORT_DIPSETTING( 0x0000, DEF_STR( On ) )
PORT_DIPNAME( 0x0002, 0x0002, "1" )
PORT_DIPSETTING( 0x0002, DEF_STR( Off ) )
PORT_DIPSETTING( 0x0000, DEF_STR( On ) )
PORT_DIPNAME( 0x0004, 0x0004, "Used 2" )
PORT_DIPSETTING( 0x0004, DEF_STR( Off ) )
PORT_DIPSETTING( 0x0000, DEF_STR( On ) )
PORT_DIPNAME( 0x0008, 0x0008, DEF_STR( Unknown ) )
PORT_DIPSETTING( 0x0008, DEF_STR( Off ) )
PORT_DIPSETTING( 0x0000, DEF_STR( On ) )
PORT_BIT( 0x0010, IP_ACTIVE_LOW, IPT_BUTTON6 ) PORT_NAME("6")
PORT_BIT( 0x0020, IP_ACTIVE_LOW, IPT_BUTTON5 ) PORT_NAME("5")
PORT_BIT( 0x0040, IP_ACTIVE_LOW, IPT_BUTTON4 ) PORT_NAME("4")
PORT_BIT( 0x0080, IP_ACTIVE_LOW, IPT_BUTTON3 ) PORT_NAME("3")
PORT_BIT( 0x0100, IP_ACTIVE_LOW, IPT_BUTTON2 ) PORT_NAME("2")
PORT_BIT( 0x0200, IP_ACTIVE_LOW, IPT_BUTTON1 ) PORT_NAME("1")
PORT_DIPNAME( 0x0400, 0x0400, DEF_STR( Unknown ) )
PORT_DIPSETTING( 0x0400, DEF_STR( Off ) )
PORT_DIPSETTING( 0x0000, DEF_STR( On ) )
PORT_DIPNAME( 0x0800, 0x0800, DEF_STR( Unknown ) )
PORT_DIPSETTING( 0x0800, DEF_STR( Off ) )
PORT_DIPSETTING( 0x0000, DEF_STR( On ) )
PORT_DIPNAME( 0x1000, 0x1000, DEF_STR( Unknown ) )
PORT_DIPSETTING( 0x1000, DEF_STR( Off ) )
PORT_DIPSETTING( 0x0000, DEF_STR( On ) )
PORT_DIPNAME( 0x2000, 0x2000, DEF_STR( Unknown ) )
PORT_DIPSETTING( 0x2000, DEF_STR( Off ) )
PORT_DIPSETTING( 0x0000, DEF_STR( On ) )
PORT_DIPNAME( 0x4000, 0x4000, DEF_STR( Unknown ) )
PORT_DIPSETTING( 0x4000, DEF_STR( Off ) )
PORT_DIPSETTING( 0x0000, DEF_STR( On ) )
PORT_DIPNAME( 0x8000, 0x8000, DEF_STR( Unknown ) )
PORT_DIPSETTING( 0x8000, DEF_STR( Off ) )
PORT_DIPSETTING( 0x0000, DEF_STR( On ) )
PORT_START("P2")
PORT_DIPNAME( 0x0001, 0x0001, "2" )
PORT_DIPSETTING( 0x0001, DEF_STR( Off ) )
PORT_DIPSETTING( 0x0000, DEF_STR( On ) )
PORT_DIPNAME( 0x0002, 0x0002, DEF_STR( Unknown ) )
PORT_DIPSETTING( 0x0002, DEF_STR( Off ) )
PORT_DIPSETTING( 0x0000, DEF_STR( On ) )
PORT_DIPNAME( 0x0004, 0x0004, DEF_STR( Unknown ) )
PORT_DIPSETTING( 0x0004, DEF_STR( Off ) )
PORT_DIPSETTING( 0x0000, DEF_STR( On ) )
PORT_DIPNAME( 0x0008, 0x0008, DEF_STR( Unknown ) )
PORT_DIPSETTING( 0x0008, DEF_STR( Off ) )
PORT_DIPSETTING( 0x0000, DEF_STR( On ) )
PORT_DIPNAME( 0x0010, 0x0010, DEF_STR( Unknown ) )
PORT_DIPSETTING( 0x0010, DEF_STR( Off ) )
PORT_DIPSETTING( 0x0000, DEF_STR( On ) )
PORT_DIPNAME( 0x0020, 0x0020, DEF_STR( Unknown ) )
PORT_DIPSETTING( 0x0020, DEF_STR( Off ) )
PORT_DIPSETTING( 0x0000, DEF_STR( On ) )
PORT_DIPNAME( 0x0040, 0x0040, DEF_STR( Unknown ) )
PORT_DIPSETTING( 0x0040, DEF_STR( Off ) )
PORT_DIPSETTING( 0x0000, DEF_STR( On ) )
PORT_DIPNAME( 0x0080, 0x0080, DEF_STR( Unknown ) )
PORT_DIPSETTING( 0x0080, DEF_STR( Off ) )
PORT_DIPSETTING( 0x0000, DEF_STR( On ) )
PORT_DIPNAME( 0x0100, 0x0100, DEF_STR( Unknown ) )
PORT_DIPSETTING( 0x0100, DEF_STR( Off ) )
PORT_DIPSETTING( 0x0000, DEF_STR( On ) )
PORT_DIPNAME( 0x0200, 0x0200, DEF_STR( Unknown ) )
PORT_DIPSETTING( 0x0200, DEF_STR( Off ) )
PORT_DIPSETTING( 0x0000, DEF_STR( On ) )
PORT_DIPNAME( 0x0400, 0x0400, DEF_STR( Unknown ) )
PORT_DIPSETTING( 0x0400, DEF_STR( Off ) )
PORT_DIPSETTING( 0x0000, DEF_STR( On ) )
PORT_DIPNAME( 0x0800, 0x0800, DEF_STR( Unknown ) )
PORT_DIPSETTING( 0x0800, DEF_STR( Off ) )
PORT_DIPSETTING( 0x0000, DEF_STR( On ) )
PORT_DIPNAME( 0x1000, 0x1000, DEF_STR( Unknown ) )
PORT_DIPSETTING( 0x1000, DEF_STR( Off ) )
PORT_DIPSETTING( 0x0000, DEF_STR( On ) )
PORT_DIPNAME( 0x2000, 0x2000, DEF_STR( Unknown ) )
PORT_DIPSETTING( 0x2000, DEF_STR( Off ) )
PORT_DIPSETTING( 0x0000, DEF_STR( On ) )
PORT_DIPNAME( 0x4000, 0x4000, DEF_STR( Unknown ) )
PORT_DIPSETTING( 0x4000, DEF_STR( Off ) )
PORT_DIPSETTING( 0x0000, DEF_STR( On ) )
PORT_DIPNAME( 0x8000, 0x8000, DEF_STR( Unknown ) )
PORT_DIPSETTING( 0x8000, DEF_STR( Off ) )
PORT_DIPSETTING( 0x0000, DEF_STR( On ) )
PORT_START("P3")
PORT_DIPNAME( 0x0001, 0x0001, "3" )
PORT_DIPSETTING( 0x0001, DEF_STR( Off ) )
PORT_DIPSETTING( 0x0000, DEF_STR( On ) )
PORT_DIPNAME( 0x0002, 0x0002, "Save" )
PORT_DIPSETTING( 0x0002, DEF_STR( Off ) )
PORT_DIPSETTING( 0x0000, DEF_STR( On ) )
PORT_DIPNAME( 0x0004, 0x0004, DEF_STR( Unknown ) )
PORT_DIPSETTING( 0x0004, DEF_STR( Off ) )
PORT_DIPSETTING( 0x0000, DEF_STR( On ) )
PORT_DIPNAME( 0x0008, 0x0008, "Something" )
PORT_DIPSETTING( 0x0008, DEF_STR( Off ) )
PORT_DIPSETTING( 0x0000, DEF_STR( On ) )
PORT_DIPNAME( 0x0010, 0x0010, DEF_STR( Unknown ) )
PORT_DIPSETTING( 0x0010, DEF_STR( Off ) )
PORT_DIPSETTING( 0x0000, DEF_STR( On ) )
PORT_DIPNAME( 0x0020, 0x0020, "Touch?" )
PORT_DIPSETTING( 0x0020, DEF_STR( Off ) )
PORT_DIPSETTING( 0x0000, DEF_STR( On ) )
PORT_DIPNAME( 0x0040, 0x0040, DEF_STR( Unknown ) )
PORT_DIPSETTING( 0x0040, DEF_STR( Off ) )
PORT_DIPSETTING( 0x0000, DEF_STR( On ) )
PORT_DIPNAME( 0x0080, 0x0080, DEF_STR( Unknown ) )
PORT_DIPSETTING( 0x0080, DEF_STR( Off ) )
PORT_DIPSETTING( 0x0000, DEF_STR( On ) )
PORT_DIPNAME( 0x0100, 0x0100, DEF_STR( Unknown ) )
PORT_DIPSETTING( 0x0100, DEF_STR( Off ) )
PORT_DIPSETTING( 0x0000, DEF_STR( On ) )
PORT_DIPNAME( 0x0200, 0x0200, "Forward" )
PORT_DIPSETTING( 0x0200, DEF_STR( Off ) )
PORT_DIPSETTING( 0x0000, DEF_STR( On ) )
PORT_DIPNAME( 0x0400, 0x0400, "Back?" )
PORT_DIPSETTING( 0x0400, DEF_STR( Off ) )
PORT_DIPSETTING( 0x0000, DEF_STR( On ) )
PORT_DIPNAME( 0x0800, 0x0800, DEF_STR( Unknown ) )
PORT_DIPSETTING( 0x0800, DEF_STR( Off ) )
PORT_DIPSETTING( 0x0000, DEF_STR( On ) )
PORT_DIPNAME( 0x1000, 0x1000, DEF_STR( Unknown ) )
PORT_DIPSETTING( 0x1000, DEF_STR( Off ) )
PORT_DIPSETTING( 0x0000, DEF_STR( On ) )
PORT_DIPNAME( 0x2000, 0x2000, DEF_STR( Unknown ) )
PORT_DIPSETTING( 0x2000, DEF_STR( Off ) )
PORT_DIPSETTING( 0x0000, DEF_STR( On ) )
PORT_DIPNAME( 0x4000, 0x4000, DEF_STR( Unknown ) )
PORT_DIPSETTING( 0x4000, DEF_STR( Off ) )
PORT_DIPSETTING( 0x0000, DEF_STR( On ) )
PORT_DIPNAME( 0x8000, 0x8000, DEF_STR( Unknown ) )
PORT_DIPSETTING( 0x8000, DEF_STR( Off ) )
PORT_DIPSETTING( 0x0000, DEF_STR( On ) )
INPUT_PORTS_END
void spg2xx_game_digimake_state::digimake(machine_config &config)
{
SPG24X(config, m_maincpu, XTAL(27'000'000), m_screen);
m_maincpu->set_addrmap(AS_PROGRAM, &spg2xx_game_digimake_state::mem_map_digi);
spg2xx_base(config);
m_maincpu->porta_in().set(FUNC(spg2xx_game_digimake_state::base_porta_r));
m_maincpu->portb_in().set(FUNC(spg2xx_game_digimake_state::base_portb_r));
m_maincpu->portc_in().set(FUNC(spg2xx_game_digimake_state::base_portc_r));
m_maincpu->portc_out().set(FUNC(spg2xx_game_digimake_state::portc_w));
}
void spg2xx_game_digimake_state::portc_w(offs_t offset, uint16_t data, uint16_t mem_mask)
{
logerror("%s: portc_w %04x (%04x) %c %c %c %c | %c %c %c %c | %c %c %c %c | %c %c %c %c \n", machine().describe_context(), data, mem_mask,
(mem_mask & 0x8000) ? ((data & 0x8000) ? '1' : '0') : 'x',
(mem_mask & 0x4000) ? ((data & 0x4000) ? '1' : '0') : 'x',
(mem_mask & 0x2000) ? ((data & 0x2000) ? '1' : '0') : 'x',
(mem_mask & 0x1000) ? ((data & 0x1000) ? '1' : '0') : 'x',
(mem_mask & 0x0800) ? ((data & 0x0800) ? '1' : '0') : 'x',
(mem_mask & 0x0400) ? ((data & 0x0400) ? '1' : '0') : 'x',
(mem_mask & 0x0200) ? ((data & 0x0200) ? '1' : '0') : 'x',
(mem_mask & 0x0100) ? ((data & 0x0100) ? '1' : '0') : 'x',
(mem_mask & 0x0080) ? ((data & 0x0080) ? '1' : '0') : 'x',
(mem_mask & 0x0040) ? ((data & 0x0040) ? '1' : '0') : 'x',
(mem_mask & 0x0020) ? ((data & 0x0020) ? '1' : '0') : 'x',
(mem_mask & 0x0010) ? ((data & 0x0010) ? '1' : '0') : 'x',
(mem_mask & 0x0008) ? ((data & 0x0008) ? '1' : '0') : 'x',
(mem_mask & 0x0004) ? ((data & 0x0004) ? '1' : '0') : 'x',
(mem_mask & 0x0002) ? ((data & 0x0002) ? '1' : '0') : 'x',
(mem_mask & 0x0001) ? ((data & 0x0001) ? '1' : '0') : 'x');
// HACK! force vbl interrupt to be on, I'm guessing some check is failing causing it to remain off otherwise?
if (m_maincpu->pc() == 0xaf5a)
{
address_space& mem = m_maincpu->space(AS_PROGRAM);
mem.write_word(0x2862, 0x0003);
}
}
ROM_START( rad_digi )
ROM_REGION( 0x800000, "maincpu", ROMREGION_ERASE00 )
ROM_LOAD16_WORD_SWAP( "digimakeover.bin", 0x000000, 0x400000, CRC(bbe60bc2) SHA1(fb0c96d1f35af85d6d0fa76c390e42e2eda301ae) )
ROM_END
CONS( 2005, rad_digi, 0, 0, digimake, rad_digi, spg2xx_game_digimake_state, init_crc, "Radica", "Digi Makeover (Girl Tech)", MACHINE_IMPERFECT_SOUND | MACHINE_NOT_WORKING )
| 44.719457 | 184 | 0.672468 | Robbbert |
989f98926969fd848eb2b8ed6373e038802a29db | 75,185 | cpp | C++ | lammps-master/src/read_data.cpp | rajkubp020/helloword | 4bd22691de24b30a0f5b73821c35a7ac0666b034 | [
"MIT"
] | null | null | null | lammps-master/src/read_data.cpp | rajkubp020/helloword | 4bd22691de24b30a0f5b73821c35a7ac0666b034 | [
"MIT"
] | null | null | null | lammps-master/src/read_data.cpp | rajkubp020/helloword | 4bd22691de24b30a0f5b73821c35a7ac0666b034 | [
"MIT"
] | null | null | null | /* ----------------------------------------------------------------------
LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
http://lammps.sandia.gov, Sandia National Laboratories
Steve Plimpton, sjplimp@sandia.gov
Copyright (2003) Sandia Corporation. Under the terms of Contract
DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government retains
certain rights in this software. This software is distributed under
the GNU General Public License.
See the README file in the top-level LAMMPS directory.
------------------------------------------------------------------------- */
// lmptype.h must be first b/c this file uses MAXBIGINT and includes mpi.h
// due to OpenMPI bug which sets INT64_MAX via its mpi.h
// before lmptype.h can set flags to insure it is done correctly
#include "lmptype.h"
#include <mpi.h>
#include <cmath>
#include <cstring>
#include <cstdlib>
#include <cctype>
#include "read_data.h"
#include "atom.h"
#include "atom_vec.h"
#include "atom_vec_ellipsoid.h"
#include "atom_vec_line.h"
#include "atom_vec_tri.h"
#include "force.h"
#include "molecule.h"
#include "group.h"
#include "comm.h"
#include "update.h"
#include "modify.h"
#include "fix.h"
#include "force.h"
#include "pair.h"
#include "domain.h"
#include "bond.h"
#include "angle.h"
#include "dihedral.h"
#include "improper.h"
#include "special.h"
#include "irregular.h"
#include "error.h"
#include "memory.h"
#include "utils.h"
using namespace LAMMPS_NS;
#define MAXLINE 256
#define LB_FACTOR 1.1
#define CHUNK 1024
#define DELTA 4 // must be 2 or larger
#define MAXBODY 32 // max # of lines in one body
// customize for new sections
#define NSECTIONS 25 // change when add to header::section_keywords
enum{NONE,APPEND,VALUE,MERGE};
// pair style suffixes to ignore
// when matching Pair Coeffs comment to currently-defined pair style
const char *suffixes[] = {"/cuda","/gpu","/opt","/omp","/kk",
"/coul/cut","/coul/long","/coul/msm",
"/coul/dsf","/coul/debye","/coul/charmm",
NULL};
/* ---------------------------------------------------------------------- */
ReadData::ReadData(LAMMPS *lmp) : Pointers(lmp)
{
MPI_Comm_rank(world,&me);
line = new char[MAXLINE];
copy = new char[MAXLINE];
keyword = new char[MAXLINE];
style = new char[MAXLINE];
buffer = new char[CHUNK*MAXLINE];
narg = maxarg = 0;
arg = NULL;
fp = NULL;
// customize for new sections
// pointers to atom styles that store extra info
nellipsoids = 0;
avec_ellipsoid = (AtomVecEllipsoid *) atom->style_match("ellipsoid");
nlines = 0;
avec_line = (AtomVecLine *) atom->style_match("line");
ntris = 0;
avec_tri = (AtomVecTri *) atom->style_match("tri");
nbodies = 0;
avec_body = (AtomVecBody *) atom->style_match("body");
}
/* ---------------------------------------------------------------------- */
ReadData::~ReadData()
{
delete [] line;
delete [] copy;
delete [] keyword;
delete [] style;
delete [] buffer;
memory->sfree(arg);
for (int i = 0; i < nfix; i++) {
delete [] fix_header[i];
delete [] fix_section[i];
}
memory->destroy(fix_index);
memory->sfree(fix_header);
memory->sfree(fix_section);
}
/* ---------------------------------------------------------------------- */
void ReadData::command(int narg, char **arg)
{
if (narg < 1) error->all(FLERR,"Illegal read_data command");
MPI_Barrier(world);
double time1 = MPI_Wtime();
// optional args
addflag = NONE;
coeffflag = 1;
id_offset = mol_offset = 0;
offsetflag = shiftflag = 0;
toffset = boffset = aoffset = doffset = ioffset = 0;
shift[0] = shift[1] = shift[2] = 0.0;
extra_atom_types = extra_bond_types = extra_angle_types =
extra_dihedral_types = extra_improper_types = 0;
groupbit = 0;
nfix = 0;
fix_index = NULL;
fix_header = NULL;
fix_section = NULL;
int iarg = 1;
while (iarg < narg) {
if (strcmp(arg[iarg],"add") == 0) {
if (iarg+2 > narg) error->all(FLERR,"Illegal read_data command");
if (strcmp(arg[iarg+1],"append") == 0) addflag = APPEND;
else if (strcmp(arg[iarg+1],"merge") == 0) addflag = MERGE;
else {
if (atom->molecule_flag && (iarg+3 > narg))
error->all(FLERR,"Illegal read_data command");
addflag = VALUE;
bigint offset = force->bnumeric(FLERR,arg[iarg+1]);
if (offset > MAXTAGINT)
error->all(FLERR,"Read data add atomID offset is too big");
id_offset = offset;
if (atom->molecule_flag) {
offset = force->bnumeric(FLERR,arg[iarg+2]);
if (offset > MAXTAGINT)
error->all(FLERR,"Read data add molID offset is too big");
mol_offset = offset;
iarg++;
}
}
iarg += 2;
} else if (strcmp(arg[iarg],"offset") == 0) {
if (iarg+6 > narg) error->all(FLERR,"Illegal read_data command");
offsetflag = 1;
toffset = force->inumeric(FLERR,arg[iarg+1]);
boffset = force->inumeric(FLERR,arg[iarg+2]);
aoffset = force->inumeric(FLERR,arg[iarg+3]);
doffset = force->inumeric(FLERR,arg[iarg+4]);
ioffset = force->inumeric(FLERR,arg[iarg+5]);
if (toffset < 0 || boffset < 0 || aoffset < 0 ||
doffset < 0 || ioffset < 0)
error->all(FLERR,"Illegal read_data command");
iarg += 6;
} else if (strcmp(arg[iarg],"shift") == 0) {
if (iarg+4 > narg) error->all(FLERR,"Illegal read_data command");
shiftflag = 1;
shift[0] = force->numeric(FLERR,arg[iarg+1]);
shift[1] = force->numeric(FLERR,arg[iarg+2]);
shift[2] = force->numeric(FLERR,arg[iarg+3]);
if (domain->dimension == 2 && shift[2] != 0.0)
error->all(FLERR,"Non-zero read_data shift z value for 2d simulation");
iarg += 4;
} else if (strcmp(arg[iarg],"nocoeff") == 0) {
coeffflag = 0;
iarg ++;
} else if (strcmp(arg[iarg],"extra/atom/types") == 0) {
if (iarg+2 > narg) error->all(FLERR,"Illegal read_data command");
extra_atom_types = force->inumeric(FLERR,arg[iarg+1]);
if (extra_atom_types < 0) error->all(FLERR,"Illegal read_data command");
iarg += 2;
} else if (strcmp(arg[iarg],"extra/bond/types") == 0) {
if (iarg+2 > narg) error->all(FLERR,"Illegal read_data command");
if (!atom->avec->bonds_allow)
error->all(FLERR,"No bonds allowed with this atom style");
extra_bond_types = force->inumeric(FLERR,arg[iarg+1]);
if (extra_bond_types < 0) error->all(FLERR,"Illegal read_data command");
iarg += 2;
} else if (strcmp(arg[iarg],"extra/angle/types") == 0) {
if (iarg+2 > narg) error->all(FLERR,"Illegal read_data command");
if (!atom->avec->angles_allow)
error->all(FLERR,"No angles allowed with this atom style");
extra_angle_types = force->inumeric(FLERR,arg[iarg+1]);
if (extra_angle_types < 0) error->all(FLERR,"Illegal read_data command");
iarg += 2;
} else if (strcmp(arg[iarg],"extra/dihedral/types") == 0) {
if (iarg+2 > narg) error->all(FLERR,"Illegal read_data command");
if (!atom->avec->dihedrals_allow)
error->all(FLERR,"No dihedrals allowed with this atom style");
extra_dihedral_types = force->inumeric(FLERR,arg[iarg+1]);
if (extra_dihedral_types < 0)
error->all(FLERR,"Illegal read_data command");
iarg += 2;
} else if (strcmp(arg[iarg],"extra/improper/types") == 0) {
if (iarg+2 > narg) error->all(FLERR,"Illegal read_data command");
if (!atom->avec->impropers_allow)
error->all(FLERR,"No impropers allowed with this atom style");
extra_improper_types = force->inumeric(FLERR,arg[iarg+1]);
if (extra_improper_types < 0)
error->all(FLERR,"Illegal read_data command");
iarg += 2;
} else if (strcmp(arg[iarg],"extra/bond/per/atom") == 0) {
if (iarg+2 > narg) error->all(FLERR,"Illegal read_data command");
if (! atom->molecular)
error->all(FLERR,"No bonds allowed with this atom style");
atom->extra_bond_per_atom = force->inumeric(FLERR,arg[iarg+1]);
if (atom->extra_bond_per_atom < 0)
error->all(FLERR,"Illegal read_data command");
iarg += 2;
} else if (strcmp(arg[iarg],"extra/angle/per/atom") == 0) {
if (iarg+2 > narg) error->all(FLERR,"Illegal read_data command");
if (! atom->molecular)
error->all(FLERR,"No angles allowed with this atom style");
atom->extra_angle_per_atom = force->inumeric(FLERR,arg[iarg+1]);
if (atom->extra_angle_per_atom < 0)
error->all(FLERR,"Illegal read_data command");
iarg += 2;
} else if (strcmp(arg[iarg],"extra/dihedral/per/atom") == 0) {
if (iarg+2 > narg) error->all(FLERR,"Illegal read_data command");
if (! atom->molecular)
error->all(FLERR,"No dihedrals allowed with this atom style");
atom->extra_dihedral_per_atom = force->inumeric(FLERR,arg[iarg+1]);
if (atom->extra_dihedral_per_atom < 0)
error->all(FLERR,"Illegal read_data command");
iarg += 2;
} else if (strcmp(arg[iarg],"extra/improper/per/atom") == 0) {
if (iarg+2 > narg) error->all(FLERR,"Illegal read_data command");
if (! atom->molecular)
error->all(FLERR,"No impropers allowed with this atom style");
atom->extra_improper_per_atom = force->inumeric(FLERR,arg[iarg+1]);
if (atom->extra_improper_per_atom < 0)
error->all(FLERR,"Illegal read_data command");
iarg += 2;
} else if (strcmp(arg[iarg],"extra/special/per/atom") == 0) {
if (iarg+2 > narg) error->all(FLERR,"Illegal read_data command");
if (! atom->molecular)
error->all(FLERR,"No bonded interactions allowed with this atom style");
force->special_extra = force->inumeric(FLERR,arg[iarg+1]);
if (force->special_extra < 0)
error->all(FLERR,"Illegal read_data command");
iarg += 2;
} else if (strcmp(arg[iarg],"group") == 0) {
if (iarg+2 > narg) error->all(FLERR,"Illegal read_data command");
int igroup = group->find_or_create(arg[iarg+1]);
groupbit = group->bitmask[igroup];
iarg += 2;
} else if (strcmp(arg[iarg],"fix") == 0) {
if (iarg+4 > narg)
error->all(FLERR,"Illegal read_data command");
memory->grow(fix_index,nfix+1,"read_data:fix_index");
fix_header = (char **)
memory->srealloc(fix_header,(nfix+1)*sizeof(char *),
"read_data:fix_header");
fix_section = (char **)
memory->srealloc(fix_section,(nfix+1)*sizeof(char *),
"read_data:fix_section");
fix_index[nfix] = modify->find_fix(arg[iarg+1]);
if (fix_index[nfix] < 0)
error->all(FLERR,"Fix ID for read_data does not exist");
if (strcmp(arg[iarg+2],"NULL") == 0) fix_header[nfix] = NULL;
else {
int n = strlen(arg[iarg+2]) + 1;
fix_header[nfix] = new char[n];
strcpy(fix_header[nfix],arg[iarg+2]);
}
int n = strlen(arg[iarg+3]) + 1;
fix_section[nfix] = new char[n];
strcpy(fix_section[nfix],arg[iarg+3]);
nfix++;
iarg += 4;
} else error->all(FLERR,"Illegal read_data command");
}
// error checks
if (domain->dimension == 2 && domain->zperiodic == 0)
error->all(FLERR,"Cannot run 2d simulation with nonperiodic Z dimension");
if (domain->box_exist && !addflag)
error->all(FLERR,"Cannot read_data without add keyword "
"after simulation box is defined");
if (!domain->box_exist && addflag)
error->all(FLERR,"Cannot use read_data add before "
"simulation box is defined");
if (offsetflag && addflag == NONE)
error->all(FLERR,"Cannot use read_data offset without add flag");
if (shiftflag && addflag == NONE)
error->all(FLERR,"Cannot use read_data shift without add flag");
if (addflag != NONE &&
(extra_atom_types || extra_bond_types || extra_angle_types ||
extra_dihedral_types || extra_improper_types))
error->all(FLERR,"Cannot use read_data extra with add flag");
// first time system initialization
if (addflag == NONE) {
domain->box_exist = 1;
update->ntimestep = 0;
}
// compute atomID and optionally moleculeID offset for addflag = APPEND
if (addflag == APPEND) {
tagint *tag = atom->tag;
tagint *molecule = atom->molecule;
int nlocal = atom->nlocal;
tagint maxid = 0, maxmol = 0;
for (int i = 0; i < nlocal; i++) maxid = MAX(maxid,tag[i]);
if (atom->molecule_flag)
for (int i = 0; i < nlocal; i++) maxmol = MAX(maxmol,molecule[i]);
MPI_Allreduce(&maxid,&id_offset,1,MPI_LMP_TAGINT,MPI_MAX,world);
MPI_Allreduce(&maxmol,&mol_offset,1,MPI_LMP_TAGINT,MPI_MAX,world);
}
// set up pointer to hold original styles while we replace them with "zero"
Pair *saved_pair = NULL;
Bond *saved_bond = NULL;
Angle *saved_angle = NULL;
Dihedral *saved_dihedral = NULL;
Improper *saved_improper = NULL;
KSpace *saved_kspace = NULL;
if (coeffflag == 0) {
char *coeffs[2];
coeffs[0] = (char *) "10.0";
coeffs[1] = (char *) "nocoeff";
saved_pair = force->pair;
force->pair = NULL;
force->create_pair("zero",0);
if (force->pair) force->pair->settings(2,coeffs);
coeffs[0] = coeffs[1];
saved_bond = force->bond;
force->bond = NULL;
force->create_bond("zero",0);
if (force->bond) force->bond->settings(1,coeffs);
saved_angle = force->angle;
force->angle = NULL;
force->create_angle("zero",0);
if (force->angle) force->angle->settings(1,coeffs);
saved_dihedral = force->dihedral;
force->dihedral = NULL;
force->create_dihedral("zero",0);
if (force->dihedral) force->dihedral->settings(1,coeffs);
saved_improper = force->improper;
force->improper = NULL;
force->create_improper("zero",0);
if (force->improper) force->improper->settings(1,coeffs);
saved_kspace = force->kspace;
force->kspace = NULL;
}
// -----------------------------------------------------------------
// perform 1-pass read if no molecular topology in file
// perform 2-pass read if molecular topology,
// first pass calculates max topology/atom
// flags for this data file
int atomflag,topoflag;
int bondflag,angleflag,dihedralflag,improperflag;
int ellipsoidflag,lineflag,triflag,bodyflag;
atomflag = topoflag = 0;
bondflag = angleflag = dihedralflag = improperflag = 0;
ellipsoidflag = lineflag = triflag = bodyflag = 0;
// values in this data file
natoms = 0;
ntypes = 0;
nbonds = nangles = ndihedrals = nimpropers = 0;
nbondtypes = nangletypes = ndihedraltypes = nimpropertypes = 0;
boxlo[0] = boxlo[1] = boxlo[2] = -0.5;
boxhi[0] = boxhi[1] = boxhi[2] = 0.5;
triclinic = 0;
keyword[0] = '\0';
nlocal_previous = atom->nlocal;
int firstpass = 1;
while (1) {
// open file on proc 0
if (me == 0) {
if (firstpass && screen) fprintf(screen,"Reading data file ...\n");
open(arg[0]);
} else fp = NULL;
// read header info
header(firstpass);
// problem setup using info from header
// only done once, if firstpass and first data file
// apply extra settings before grow(), even if no topology in file
// deallocate() insures new settings are used for topology arrays
// if per-atom topology is in file, another grow() is done below
if (firstpass && addflag == NONE) {
atom->bond_per_atom = atom->extra_bond_per_atom;
atom->angle_per_atom = atom->extra_angle_per_atom;
atom->dihedral_per_atom = atom->extra_dihedral_per_atom;
atom->improper_per_atom = atom->extra_improper_per_atom;
int n;
if (comm->nprocs == 1) n = static_cast<int> (atom->natoms);
else n = static_cast<int> (LB_FACTOR * atom->natoms / comm->nprocs);
atom->allocate_type_arrays();
atom->deallocate_topology();
atom->avec->grow(n);
domain->boxlo[0] = boxlo[0]; domain->boxhi[0] = boxhi[0];
domain->boxlo[1] = boxlo[1]; domain->boxhi[1] = boxhi[1];
domain->boxlo[2] = boxlo[2]; domain->boxhi[2] = boxhi[2];
if (triclinic) {
domain->triclinic = 1;
domain->xy = xy; domain->xz = xz; domain->yz = yz;
}
domain->print_box(" ");
domain->set_initial_box();
domain->set_global_box();
comm->set_proc_grid();
domain->set_local_box();
}
// change simulation box to be union of existing box and new box + shift
// only done if firstpass and not first data file
if (firstpass && addflag != NONE) {
domain->boxlo[0] = MIN(domain->boxlo[0],boxlo[0]+shift[0]);
domain->boxhi[0] = MAX(domain->boxhi[0],boxhi[0]+shift[0]);
domain->boxlo[1] = MIN(domain->boxlo[1],boxlo[1]+shift[1]);
domain->boxhi[1] = MAX(domain->boxhi[1],boxhi[1]+shift[1]);
domain->boxlo[2] = MIN(domain->boxlo[2],boxlo[2]+shift[2]);
domain->boxhi[2] = MAX(domain->boxhi[2],boxhi[2]+shift[2]);
// NOTE: not sure what to do about tilt value in subsequent data files
//if (triclinic) {
// domain->xy = xy; domain->xz = xz; domain->yz = yz;
// }
domain->print_box(" ");
domain->set_initial_box();
domain->set_global_box();
comm->set_proc_grid();
domain->set_local_box();
}
// customize for new sections
// read rest of file in free format
while (strlen(keyword)) {
// if special fix matches, it processes section
if (nfix) {
int i;
for (i = 0; i < nfix; i++)
if (strcmp(keyword,fix_section[i]) == 0) {
if (firstpass) fix(fix_index[i],keyword);
else skip_lines(modify->fix[fix_index[i]]->
read_data_skip_lines(keyword));
parse_keyword(0);
break;
}
if (i < nfix) continue;
}
if (strcmp(keyword,"Atoms") == 0) {
atomflag = 1;
if (firstpass) {
if (me == 0 && !style_match(style,atom->atom_style))
error->warning(FLERR,"Atom style in data file differs "
"from currently defined atom style");
atoms();
} else skip_lines(natoms);
} else if (strcmp(keyword,"Velocities") == 0) {
if (atomflag == 0)
error->all(FLERR,"Must read Atoms before Velocities");
if (firstpass) velocities();
else skip_lines(natoms);
} else if (strcmp(keyword,"Bonds") == 0) {
topoflag = bondflag = 1;
if (nbonds == 0)
error->all(FLERR,"Invalid data file section: Bonds");
if (atomflag == 0) error->all(FLERR,"Must read Atoms before Bonds");
bonds(firstpass);
} else if (strcmp(keyword,"Angles") == 0) {
topoflag = angleflag = 1;
if (nangles == 0)
error->all(FLERR,"Invalid data file section: Angles");
if (atomflag == 0) error->all(FLERR,"Must read Atoms before Angles");
angles(firstpass);
} else if (strcmp(keyword,"Dihedrals") == 0) {
topoflag = dihedralflag = 1;
if (ndihedrals == 0)
error->all(FLERR,"Invalid data file section: Dihedrals");
if (atomflag == 0) error->all(FLERR,"Must read Atoms before Dihedrals");
dihedrals(firstpass);
} else if (strcmp(keyword,"Impropers") == 0) {
topoflag = improperflag = 1;
if (nimpropers == 0)
error->all(FLERR,"Invalid data file section: Impropers");
if (atomflag == 0) error->all(FLERR,"Must read Atoms before Impropers");
impropers(firstpass);
} else if (strcmp(keyword,"Ellipsoids") == 0) {
ellipsoidflag = 1;
if (!avec_ellipsoid)
error->all(FLERR,"Invalid data file section: Ellipsoids");
if (atomflag == 0)
error->all(FLERR,"Must read Atoms before Ellipsoids");
if (firstpass)
bonus(nellipsoids,(AtomVec *) avec_ellipsoid,"ellipsoids");
else skip_lines(nellipsoids);
} else if (strcmp(keyword,"Lines") == 0) {
lineflag = 1;
if (!avec_line)
error->all(FLERR,"Invalid data file section: Lines");
if (atomflag == 0) error->all(FLERR,"Must read Atoms before Lines");
if (firstpass) bonus(nlines,(AtomVec *) avec_line,"lines");
else skip_lines(nlines);
} else if (strcmp(keyword,"Triangles") == 0) {
triflag = 1;
if (!avec_tri)
error->all(FLERR,"Invalid data file section: Triangles");
if (atomflag == 0) error->all(FLERR,"Must read Atoms before Triangles");
if (firstpass) bonus(ntris,(AtomVec *) avec_tri,"triangles");
else skip_lines(ntris);
} else if (strcmp(keyword,"Bodies") == 0) {
bodyflag = 1;
if (!avec_body)
error->all(FLERR,"Invalid data file section: Bodies");
if (atomflag == 0) error->all(FLERR,"Must read Atoms before Bodies");
bodies(firstpass);
} else if (strcmp(keyword,"Masses") == 0) {
if (firstpass) mass();
else skip_lines(ntypes);
} else if (strcmp(keyword,"Pair Coeffs") == 0) {
if (force->pair == NULL)
error->all(FLERR,"Must define pair_style before Pair Coeffs");
if (firstpass) {
if (me == 0 && !style_match(style,force->pair_style))
error->warning(FLERR,"Pair style in data file differs "
"from currently defined pair style");
paircoeffs();
} else skip_lines(ntypes);
} else if (strcmp(keyword,"PairIJ Coeffs") == 0) {
if (force->pair == NULL)
error->all(FLERR,"Must define pair_style before PairIJ Coeffs");
if (firstpass) {
if (me == 0 && !style_match(style,force->pair_style))
error->warning(FLERR,"Pair style in data file differs "
"from currently defined pair style");
pairIJcoeffs();
} else skip_lines(ntypes*(ntypes+1)/2);
} else if (strcmp(keyword,"Bond Coeffs") == 0) {
if (atom->avec->bonds_allow == 0)
error->all(FLERR,"Invalid data file section: Bond Coeffs");
if (force->bond == NULL)
error->all(FLERR,"Must define bond_style before Bond Coeffs");
if (firstpass) {
if (me == 0 && !style_match(style,force->bond_style))
error->warning(FLERR,"Bond style in data file differs "
"from currently defined bond style");
bondcoeffs();
} else skip_lines(nbondtypes);
} else if (strcmp(keyword,"Angle Coeffs") == 0) {
if (atom->avec->angles_allow == 0)
error->all(FLERR,"Invalid data file section: Angle Coeffs");
if (force->angle == NULL)
error->all(FLERR,"Must define angle_style before Angle Coeffs");
if (firstpass) {
if (me == 0 && !style_match(style,force->angle_style))
error->warning(FLERR,"Angle style in data file differs "
"from currently defined angle style");
anglecoeffs(0);
} else skip_lines(nangletypes);
} else if (strcmp(keyword,"Dihedral Coeffs") == 0) {
if (atom->avec->dihedrals_allow == 0)
error->all(FLERR,"Invalid data file section: Dihedral Coeffs");
if (force->dihedral == NULL)
error->all(FLERR,"Must define dihedral_style before Dihedral Coeffs");
if (firstpass) {
if (me == 0 && !style_match(style,force->dihedral_style))
error->warning(FLERR,"Dihedral style in data file differs "
"from currently defined dihedral style");
dihedralcoeffs(0);
} else skip_lines(ndihedraltypes);
} else if (strcmp(keyword,"Improper Coeffs") == 0) {
if (atom->avec->impropers_allow == 0)
error->all(FLERR,"Invalid data file section: Improper Coeffs");
if (force->improper == NULL)
error->all(FLERR,"Must define improper_style before Improper Coeffs");
if (firstpass) {
if (me == 0 && !style_match(style,force->improper_style))
error->warning(FLERR,"Improper style in data file differs "
"from currently defined improper style");
impropercoeffs(0);
} else skip_lines(nimpropertypes);
} else if (strcmp(keyword,"BondBond Coeffs") == 0) {
if (atom->avec->angles_allow == 0)
error->all(FLERR,"Invalid data file section: BondBond Coeffs");
if (force->angle == NULL)
error->all(FLERR,"Must define angle_style before BondBond Coeffs");
if (firstpass) anglecoeffs(1);
else skip_lines(nangletypes);
} else if (strcmp(keyword,"BondAngle Coeffs") == 0) {
if (atom->avec->angles_allow == 0)
error->all(FLERR,"Invalid data file section: BondAngle Coeffs");
if (force->angle == NULL)
error->all(FLERR,"Must define angle_style before BondAngle Coeffs");
if (firstpass) anglecoeffs(2);
else skip_lines(nangletypes);
} else if (strcmp(keyword,"MiddleBondTorsion Coeffs") == 0) {
if (atom->avec->dihedrals_allow == 0)
error->all(FLERR,
"Invalid data file section: MiddleBondTorsion Coeffs");
if (force->dihedral == NULL)
error->all(FLERR,
"Must define dihedral_style before "
"MiddleBondTorsion Coeffs");
if (firstpass) dihedralcoeffs(1);
else skip_lines(ndihedraltypes);
} else if (strcmp(keyword,"EndBondTorsion Coeffs") == 0) {
if (atom->avec->dihedrals_allow == 0)
error->all(FLERR,"Invalid data file section: EndBondTorsion Coeffs");
if (force->dihedral == NULL)
error->all(FLERR,
"Must define dihedral_style before EndBondTorsion Coeffs");
if (firstpass) dihedralcoeffs(2);
else skip_lines(ndihedraltypes);
} else if (strcmp(keyword,"AngleTorsion Coeffs") == 0) {
if (atom->avec->dihedrals_allow == 0)
error->all(FLERR,"Invalid data file section: AngleTorsion Coeffs");
if (force->dihedral == NULL)
error->all(FLERR,
"Must define dihedral_style before AngleTorsion Coeffs");
if (firstpass) dihedralcoeffs(3);
else skip_lines(ndihedraltypes);
} else if (strcmp(keyword,"AngleAngleTorsion Coeffs") == 0) {
if (atom->avec->dihedrals_allow == 0)
error->all(FLERR,
"Invalid data file section: AngleAngleTorsion Coeffs");
if (force->dihedral == NULL)
error->all(FLERR,
"Must define dihedral_style before "
"AngleAngleTorsion Coeffs");
if (firstpass) dihedralcoeffs(4);
else skip_lines(ndihedraltypes);
} else if (strcmp(keyword,"BondBond13 Coeffs") == 0) {
if (atom->avec->dihedrals_allow == 0)
error->all(FLERR,"Invalid data file section: BondBond13 Coeffs");
if (force->dihedral == NULL)
error->all(FLERR,
"Must define dihedral_style before BondBond13 Coeffs");
if (firstpass) dihedralcoeffs(5);
else skip_lines(ndihedraltypes);
} else if (strcmp(keyword,"AngleAngle Coeffs") == 0) {
if (atom->avec->impropers_allow == 0)
error->all(FLERR,"Invalid data file section: AngleAngle Coeffs");
if (force->improper == NULL)
error->all(FLERR,
"Must define improper_style before AngleAngle Coeffs");
if (firstpass) impropercoeffs(1);
else skip_lines(nimpropertypes);
} else {
char str[128];
snprintf(str,128,"Unknown identifier in data file: %s",keyword);
error->all(FLERR,str);
}
parse_keyword(0);
}
// error if natoms > 0 yet no atoms were read
if (natoms > 0 && atomflag == 0)
error->all(FLERR,"No atoms in data file");
// close file
if (me == 0) {
if (compressed) pclose(fp);
else fclose(fp);
fp = NULL;
}
// done if this was 2nd pass
if (!firstpass) break;
// at end of 1st pass, error check for required sections
// customize for new sections
if ((nbonds && !bondflag) || (nangles && !angleflag) ||
(ndihedrals && !dihedralflag) || (nimpropers && !improperflag))
error->one(FLERR,"Needed molecular topology not in data file");
if ((nellipsoids && !ellipsoidflag) || (nlines && !lineflag) ||
(ntris && !triflag) || (nbodies && !bodyflag))
error->one(FLERR,"Needed bonus data not in data file");
// break out of loop if no molecular topology in file
// else make 2nd pass
if (!topoflag) break;
firstpass = 0;
// reallocate bond,angle,diehdral,improper arrays via grow()
// will use new bond,angle,dihedral,improper per-atom values from 1st pass
// will also observe extra settings even if bond/etc topology not in file
// leaves other atom arrays unchanged, since already nmax in length
if (addflag == NONE) atom->deallocate_topology();
atom->avec->grow(atom->nmax);
}
// init per-atom fix/compute/variable values for created atoms
atom->data_fix_compute_variable(nlocal_previous,atom->nlocal);
// assign atoms added by this data file to specified group
if (groupbit) {
int *mask = atom->mask;
int nlocal = atom->nlocal;
for (int i = nlocal_previous; i < nlocal; i++)
mask[i] |= groupbit;
}
// create special bond lists for molecular systems
if (atom->molecular == 1) {
Special special(lmp);
special.build();
}
// for atom style template systems, count total bonds,angles,etc
if (atom->molecular == 2) {
Molecule **onemols = atom->avec->onemols;
int *molindex = atom->molindex;
int *molatom = atom->molatom;
int nlocal = atom->nlocal;
int imol,iatom;
bigint nbonds,nangles,ndihedrals,nimpropers;
nbonds = nangles = ndihedrals = nimpropers = 0;
for (int i = 0; i < nlocal; i++) {
imol = molindex[i];
iatom = molatom[i];
nbonds += onemols[imol]->num_bond[iatom];
nangles += onemols[imol]->num_angle[iatom];
ndihedrals += onemols[imol]->num_dihedral[iatom];
nimpropers += onemols[imol]->num_improper[iatom];
}
MPI_Allreduce(&nbonds,&atom->nbonds,1,MPI_LMP_BIGINT,MPI_SUM,world);
MPI_Allreduce(&nangles,&atom->nangles,1,MPI_LMP_BIGINT,MPI_SUM,world);
MPI_Allreduce(&ndihedrals,&atom->ndihedrals,1,MPI_LMP_BIGINT,MPI_SUM,world);
MPI_Allreduce(&nimpropers,&atom->nimpropers,1,MPI_LMP_BIGINT,MPI_SUM,world);
if (!force->newton_bond) {
atom->nbonds /= 2;
atom->nangles /= 3;
atom->ndihedrals /= 4;
atom->nimpropers /= 4;
}
if (me == 0) {
if (atom->nbonds) {
if (screen)
fprintf(screen," " BIGINT_FORMAT " template bonds\n",atom->nbonds);
if (logfile)
fprintf(logfile," " BIGINT_FORMAT " template bonds\n",atom->nbonds);
}
if (atom->nangles) {
if (screen)
fprintf(screen," " BIGINT_FORMAT " template angles\n",
atom->nangles);
if (logfile)
fprintf(logfile," " BIGINT_FORMAT " template angles\n",
atom->nangles);
}
if (atom->ndihedrals) {
if (screen)
fprintf(screen," " BIGINT_FORMAT " template dihedrals\n",
atom->nbonds);
if (logfile)
fprintf(logfile," " BIGINT_FORMAT " template bonds\n",
atom->ndihedrals);
}
if (atom->nimpropers) {
if (screen)
fprintf(screen," " BIGINT_FORMAT " template impropers\n",
atom->nimpropers);
if (logfile)
fprintf(logfile," " BIGINT_FORMAT " template impropers\n",
atom->nimpropers);
}
}
}
// for atom style template systems
// insure nbondtypes,etc are still consistent with template molecules,
// in case data file re-defined them
if (atom->molecular == 2) atom->avec->onemols[0]->check_attributes(1);
// if adding atoms, migrate atoms to new processors
// use irregular() b/c box size could have changed dramaticaly
// resulting in procs now owning very different subboxes
// with their previously owned atoms now far outside the subbox
if (addflag != NONE) {
if (domain->triclinic) domain->x2lamda(atom->nlocal);
Irregular *irregular = new Irregular(lmp);
irregular->migrate_atoms(1);
delete irregular;
if (domain->triclinic) domain->lamda2x(atom->nlocal);
}
// shrink-wrap the box if necessary and move atoms to new procs
// if atoms are lost is b/c data file box was far from shrink-wrapped
// do not use irregular() comm, which would not lose atoms,
// b/c then user could specify data file box as far too big and empty
// do comm->init() but not comm->setup() b/c pair/neigh cutoffs not yet set
// need call to map_set() b/c comm->exchange clears atom map
if (domain->nonperiodic == 2) {
if (domain->triclinic) domain->x2lamda(atom->nlocal);
domain->reset_box();
Irregular *irregular = new Irregular(lmp);
irregular->migrate_atoms(1);
delete irregular;
if (domain->triclinic) domain->lamda2x(atom->nlocal);
bigint natoms;
bigint nblocal = atom->nlocal;
MPI_Allreduce(&nblocal,&natoms,1,MPI_LMP_BIGINT,MPI_SUM,world);
if (natoms != atom->natoms)
error->all(FLERR,
"Read_data shrink wrap did not assign all atoms correctly");
}
// restore old styles, when reading with nocoeff flag given
if (coeffflag == 0) {
if (force->pair) delete force->pair;
force->pair = saved_pair;
if (force->bond) delete force->bond;
force->bond = saved_bond;
if (force->angle) delete force->angle;
force->angle = saved_angle;
if (force->dihedral) delete force->dihedral;
force->dihedral = saved_dihedral;
if (force->improper) delete force->improper;
force->improper = saved_improper;
force->kspace = saved_kspace;
}
// total time
MPI_Barrier(world);
double time2 = MPI_Wtime();
if (comm->me == 0) {
if (screen)
fprintf(screen," read_data CPU = %g secs\n",time2-time1);
if (logfile)
fprintf(logfile," read_data CPU = %g secs\n",time2-time1);
}
}
/* ----------------------------------------------------------------------
read free-format header of data file
1st line and blank lines are skipped
non-blank lines are checked for header keywords and leading value is read
header ends with EOF or non-blank line containing no header keyword
if EOF, line is set to blank line
else line has first keyword line for rest of file
some logic differs if adding atoms
------------------------------------------------------------------------- */
void ReadData::header(int firstpass)
{
int n;
char *ptr;
// customize for new sections
const char *section_keywords[NSECTIONS] =
{"Atoms","Velocities","Ellipsoids","Lines","Triangles","Bodies",
"Bonds","Angles","Dihedrals","Impropers",
"Masses","Pair Coeffs","PairIJ Coeffs","Bond Coeffs","Angle Coeffs",
"Dihedral Coeffs","Improper Coeffs",
"BondBond Coeffs","BondAngle Coeffs","MiddleBondTorsion Coeffs",
"EndBondTorsion Coeffs","AngleTorsion Coeffs",
"AngleAngleTorsion Coeffs","BondBond13 Coeffs","AngleAngle Coeffs"};
// skip 1st line of file
if (me == 0) {
char *eof = fgets(line,MAXLINE,fp);
if (eof == NULL) error->one(FLERR,"Unexpected end of data file");
}
while (1) {
// read a line and bcast length
if (me == 0) {
if (fgets(line,MAXLINE,fp) == NULL) n = 0;
else n = strlen(line) + 1;
}
MPI_Bcast(&n,1,MPI_INT,0,world);
// if n = 0 then end-of-file so return with blank line
if (n == 0) {
line[0] = '\0';
return;
}
MPI_Bcast(line,n,MPI_CHAR,0,world);
// trim anything from '#' onward
// if line is blank, continue
if ((ptr = strchr(line,'#'))) *ptr = '\0';
if (strspn(line," \t\n\r") == strlen(line)) continue;
// allow special fixes first chance to match and process the line
// if fix matches, continue to next header line
if (nfix) {
for (n = 0; n < nfix; n++) {
if (!fix_header[n]) continue;
if (strstr(line,fix_header[n])) {
modify->fix[fix_index[n]]->read_data_header(line);
break;
}
}
if (n < nfix) continue;
}
// search line for header keyword and set corresponding variable
// customize for new header lines
// check for triangles before angles so "triangles" not matched as "angles"
int extra_flag_value = 0;
int rv;
if (utils::strmatch(line,"^\\s*\\d+\\s+atoms\\s")) {
rv = sscanf(line,BIGINT_FORMAT,&natoms);
if (rv != 1)
error->all(FLERR,"Could not parse 'atoms' line in data file header");
if (addflag == NONE) atom->natoms = natoms;
else if (firstpass) atom->natoms += natoms;
} else if (utils::strmatch(line,"^\\s*\\d+\\s+ellipsoids\\s")) {
if (!avec_ellipsoid)
error->all(FLERR,"No ellipsoids allowed with this atom style");
rv = sscanf(line,BIGINT_FORMAT,&nellipsoids);
if (rv != 1)
error->all(FLERR,"Could not parse 'ellipsoids' line in data file header");
if (addflag == NONE) atom->nellipsoids = nellipsoids;
else if (firstpass) atom->nellipsoids += nellipsoids;
} else if (utils::strmatch(line,"^\\s*\\d+\\s+lines\\s")) {
if (!avec_line)
error->all(FLERR,"No lines allowed with this atom style");
rv = sscanf(line,BIGINT_FORMAT,&nlines);
if (rv != 1)
error->all(FLERR,"Could not parse 'lines' line in data file header");
if (addflag == NONE) atom->nlines = nlines;
else if (firstpass) atom->nlines += nlines;
} else if (utils::strmatch(line,"^\\s*\\d+\\s+triangles\\s")) {
if (!avec_tri)
error->all(FLERR,"No triangles allowed with this atom style");
rv = sscanf(line,BIGINT_FORMAT,&ntris);
if (rv != 1)
error->all(FLERR,"Could not parse 'triangles' line in data file header");
if (addflag == NONE) atom->ntris = ntris;
else if (firstpass) atom->ntris += ntris;
} else if (utils::strmatch(line,"^\\s*\\d+\\s+bodies\\s")) {
if (!avec_body)
error->all(FLERR,"No bodies allowed with this atom style");
rv = sscanf(line,BIGINT_FORMAT,&nbodies);
if (rv != 1)
error->all(FLERR,"Could not parse 'bodies' line in data file header");
if (addflag == NONE) atom->nbodies = nbodies;
else if (firstpass) atom->nbodies += nbodies;
} else if (utils::strmatch(line,"^\\s*\\d+\\s+bonds\\s")) {
rv = sscanf(line,BIGINT_FORMAT,&nbonds);
if (rv != 1)
error->all(FLERR,"Could not parse 'bonds' line in data file header");
if (addflag == NONE) atom->nbonds = nbonds;
else if (firstpass) atom->nbonds += nbonds;
} else if (utils::strmatch(line,"^\\s*\\d+\\s+angles\\s")) {
rv = sscanf(line,BIGINT_FORMAT,&nangles);
if (rv != 1)
error->all(FLERR,"Could not parse 'angles' line in data file header");
if (addflag == NONE) atom->nangles = nangles;
else if (firstpass) atom->nangles += nangles;
} else if (utils::strmatch(line,"^\\s*\\d+\\s+dihedrals\\s")) {
rv = sscanf(line,BIGINT_FORMAT,&ndihedrals);
if (rv != 1)
error->all(FLERR,"Could not parse 'dihedrals' line in data file header");
if (addflag == NONE) atom->ndihedrals = ndihedrals;
else if (firstpass) atom->ndihedrals += ndihedrals;
} else if (utils::strmatch(line,"^\\s*\\d+\\s+impropers\\s")) {
rv = sscanf(line,BIGINT_FORMAT,&nimpropers);
if (rv != 1)
error->all(FLERR,"Could not parse 'impropers' line in data file header");
if (addflag == NONE) atom->nimpropers = nimpropers;
else if (firstpass) atom->nimpropers += nimpropers;
// Atom class type settings are only set by first data file
} else if (utils::strmatch(line,"^\\s*\\d+\\s+atom\\s+types\\s")) {
rv = sscanf(line,"%d",&ntypes);
if (rv != 1)
error->all(FLERR,"Could not parse 'atom types' line "
"in data file header");
if (addflag == NONE) atom->ntypes = ntypes + extra_atom_types;
} else if (utils::strmatch(line,"\\s*\\d+\\s+bond\\s+types\\s")) {
rv = sscanf(line,"%d",&nbondtypes);
if (rv != 1)
error->all(FLERR,"Could not parse 'bond types' line "
"in data file header");
if (addflag == NONE) atom->nbondtypes = nbondtypes + extra_bond_types;
} else if (utils::strmatch(line,"^\\s*\\d+\\s+angle\\s+types\\s")) {
rv = sscanf(line,"%d",&nangletypes);
if (rv != 1)
error->all(FLERR,"Could not parse 'angle types' line "
"in data file header");
if (addflag == NONE) atom->nangletypes = nangletypes + extra_angle_types;
} else if (utils::strmatch(line,"^\\s*\\d+\\s+dihedral\\s+types\\s")) {
rv = sscanf(line,"%d",&ndihedraltypes);
if (rv != 1)
error->all(FLERR,"Could not parse 'dihedral types' line "
"in data file header");
if (addflag == NONE)
atom->ndihedraltypes = ndihedraltypes + extra_dihedral_types;
} else if (utils::strmatch(line,"^\\s*\\d+\\s+improper\\s+types\\s")) {
rv = sscanf(line,"%d",&nimpropertypes);
if (rv != 1)
error->all(FLERR,"Could not parse 'improper types' line "
"in data file header");
if (addflag == NONE)
atom->nimpropertypes = nimpropertypes + extra_improper_types;
// these settings only used by first data file
// also, these are obsolescent. we parse them to maintain backward
// compatibility, but the recommended way is to set them via keywords
// in the LAMMPS input file. In case these flags are set in both,
// the input and the data file, we use the larger of the two.
} else if (strstr(line,"extra bond per atom")) {
if (addflag == NONE) sscanf(line,"%d",&extra_flag_value);
atom->extra_bond_per_atom = MAX(atom->extra_bond_per_atom,extra_flag_value);
} else if (strstr(line,"extra angle per atom")) {
if (addflag == NONE) sscanf(line,"%d",&extra_flag_value);
atom->extra_angle_per_atom = MAX(atom->extra_angle_per_atom,extra_flag_value);
} else if (strstr(line,"extra dihedral per atom")) {
if (addflag == NONE) sscanf(line,"%d",&extra_flag_value);
atom->extra_dihedral_per_atom = MAX(atom->extra_dihedral_per_atom,extra_flag_value);
} else if (strstr(line,"extra improper per atom")) {
if (addflag == NONE) sscanf(line,"%d",&extra_flag_value);
atom->extra_improper_per_atom = MAX(atom->extra_improper_per_atom,extra_flag_value);
} else if (strstr(line,"extra special per atom")) {
if (addflag == NONE) sscanf(line,"%d",&extra_flag_value);
force->special_extra = MAX(force->special_extra,extra_flag_value);
// local copy of box info
// so can treat differently for first vs subsequent data files
} else if (utils::strmatch(line,"^\\s*\\f+\\s+\\f+\\s+xlo\\s+xhi\\s")) {
rv = sscanf(line,"%lg %lg",&boxlo[0],&boxhi[0]);
if (rv != 2)
error->all(FLERR,"Could not parse 'xlo xhi' line in data file header");
} else if (utils::strmatch(line,"^\\s*\\f+\\s+\\f+\\s+ylo\\s+yhi\\s")) {
rv = sscanf(line,"%lg %lg",&boxlo[1],&boxhi[1]);
if (rv != 2)
error->all(FLERR,"Could not parse 'ylo yhi' line in data file header");
} else if (utils::strmatch(line,"^\\s*\\f+\\s+\\f+\\s+zlo\\s+zhi\\s")) {
rv = sscanf(line,"%lg %lg",&boxlo[2],&boxhi[2]);
if (rv != 2)
error->all(FLERR,"Could not parse 'zlo zhi' line in data file header");
} else if (utils::strmatch(line,"^\\s*\\f+\\s+\\f+\\s+\\f+"
"\\s+xy\\s+xz\\s+yz\\s")) {
triclinic = 1;
rv = sscanf(line,"%lg %lg %lg",&xy,&xz,&yz);
if (rv != 3)
error->all(FLERR,"Could not parse 'xy xz yz' line in data file header");
} else break;
}
// error check on total system size
if (atom->natoms < 0 || atom->natoms >= MAXBIGINT ||
atom->nellipsoids < 0 || atom->nellipsoids >= MAXBIGINT ||
atom->nlines < 0 || atom->nlines >= MAXBIGINT ||
atom->ntris < 0 || atom->ntris >= MAXBIGINT ||
atom->nbodies < 0 || atom->nbodies >= MAXBIGINT ||
atom->nbonds < 0 || atom->nbonds >= MAXBIGINT ||
atom->nangles < 0 || atom->nangles >= MAXBIGINT ||
atom->ndihedrals < 0 || atom->ndihedrals >= MAXBIGINT ||
atom->nimpropers < 0 || atom->nimpropers >= MAXBIGINT)
error->all(FLERR,"System in data file is too big");
// check that exiting string is a valid section keyword
parse_keyword(1);
for (n = 0; n < NSECTIONS; n++)
if (strcmp(keyword,section_keywords[n]) == 0) break;
if (n == NSECTIONS) {
char str[128];
sprintf(str,"Unknown identifier in data file: %s",keyword);
error->all(FLERR,str);
}
// error checks on header values
// must be consistent with atom style and other header values
if ((atom->nbonds || atom->nbondtypes) &&
atom->avec->bonds_allow == 0)
error->all(FLERR,"No bonds allowed with this atom style");
if ((atom->nangles || atom->nangletypes) &&
atom->avec->angles_allow == 0)
error->all(FLERR,"No angles allowed with this atom style");
if ((atom->ndihedrals || atom->ndihedraltypes) &&
atom->avec->dihedrals_allow == 0)
error->all(FLERR,"No dihedrals allowed with this atom style");
if ((atom->nimpropers || atom->nimpropertypes) &&
atom->avec->impropers_allow == 0)
error->all(FLERR,"No impropers allowed with this atom style");
if (atom->nbonds > 0 && atom->nbondtypes <= 0)
error->all(FLERR,"Bonds defined but no bond types");
if (atom->nangles > 0 && atom->nangletypes <= 0)
error->all(FLERR,"Angles defined but no angle types");
if (atom->ndihedrals > 0 && atom->ndihedraltypes <= 0)
error->all(FLERR,"Dihedrals defined but no dihedral types");
if (atom->nimpropers > 0 && atom->nimpropertypes <= 0)
error->all(FLERR,"Impropers defined but no improper types");
if (atom->molecular == 2) {
if (atom->nbonds || atom->nangles || atom->ndihedrals || atom->nimpropers)
error->all(FLERR,"No molecule topology allowed with atom style template");
}
}
/* ----------------------------------------------------------------------
read all atoms
------------------------------------------------------------------------- */
void ReadData::atoms()
{
int nchunk,eof;
if (me == 0) {
if (screen) fprintf(screen," reading atoms ...\n");
if (logfile) fprintf(logfile," reading atoms ...\n");
}
bigint nread = 0;
while (nread < natoms) {
nchunk = MIN(natoms-nread,CHUNK);
eof = comm->read_lines_from_file(fp,nchunk,MAXLINE,buffer);
if (eof) error->all(FLERR,"Unexpected end of data file");
atom->data_atoms(nchunk,buffer,id_offset,mol_offset,toffset,shiftflag,shift);
nread += nchunk;
}
// check that all atoms were assigned correctly
bigint n = atom->nlocal;
bigint sum;
MPI_Allreduce(&n,&sum,1,MPI_LMP_BIGINT,MPI_SUM,world);
bigint nassign = sum - (atom->natoms - natoms);
if (me == 0) {
if (screen) fprintf(screen," " BIGINT_FORMAT " atoms\n",nassign);
if (logfile) fprintf(logfile," " BIGINT_FORMAT " atoms\n",nassign);
}
if (sum != atom->natoms)
error->all(FLERR,"Did not assign all atoms correctly");
// check that atom IDs are valid
atom->tag_check();
// check that bonus data has been reserved as needed
atom->bonus_check();
// create global mapping of atoms
if (atom->map_style) {
atom->map_init();
atom->map_set();
}
}
/* ----------------------------------------------------------------------
read all velocities
to find atoms, must build atom map if not a molecular system
------------------------------------------------------------------------- */
void ReadData::velocities()
{
int nchunk,eof;
if (me == 0) {
if (screen) fprintf(screen," reading velocities ...\n");
if (logfile) fprintf(logfile," reading velocities ...\n");
}
int mapflag = 0;
if (atom->map_style == 0) {
mapflag = 1;
atom->map_init();
atom->map_set();
}
bigint nread = 0;
while (nread < natoms) {
nchunk = MIN(natoms-nread,CHUNK);
eof = comm->read_lines_from_file(fp,nchunk,MAXLINE,buffer);
if (eof) error->all(FLERR,"Unexpected end of data file");
atom->data_vels(nchunk,buffer,id_offset);
nread += nchunk;
}
if (mapflag) {
atom->map_delete();
atom->map_style = 0;
}
if (me == 0) {
if (screen) fprintf(screen," " BIGINT_FORMAT " velocities\n",natoms);
if (logfile) fprintf(logfile," " BIGINT_FORMAT " velocities\n",natoms);
}
}
/* ----------------------------------------------------------------------
scan or read all bonds
------------------------------------------------------------------------- */
void ReadData::bonds(int firstpass)
{
int nchunk,eof;
if (me == 0) {
if (firstpass) {
if (screen) fprintf(screen," scanning bonds ...\n");
if (logfile) fprintf(logfile," scanning bonds ...\n");
} else {
if (screen) fprintf(screen," reading bonds ...\n");
if (logfile) fprintf(logfile," reading bonds ...\n");
}
}
// allocate count if firstpass
int nlocal = atom->nlocal;
int *count = NULL;
if (firstpass) {
memory->create(count,nlocal,"read_data:count");
memset(count,0,nlocal*sizeof(int));
}
// read and process bonds
bigint nread = 0;
while (nread < nbonds) {
nchunk = MIN(nbonds-nread,CHUNK);
eof = comm->read_lines_from_file(fp,nchunk,MAXLINE,buffer);
if (eof) error->all(FLERR,"Unexpected end of data file");
atom->data_bonds(nchunk,buffer,count,id_offset,boffset);
nread += nchunk;
}
// if firstpass: tally max bond/atom and return
// if addflag = NONE, store max bond/atom with extra
// else just check actual max does not exceed existing max
if (firstpass) {
int max = 0;
for (int i = nlocal_previous; i < nlocal; i++) max = MAX(max,count[i]);
int maxall;
MPI_Allreduce(&max,&maxall,1,MPI_INT,MPI_MAX,world);
if (addflag == NONE) maxall += atom->extra_bond_per_atom;
if (me == 0) {
if (screen) fprintf(screen," %d = max bonds/atom\n",maxall);
if (logfile) fprintf(logfile," %d = max bonds/atom\n",maxall);
}
if (addflag != NONE) {
if (maxall > atom->bond_per_atom)
error->all(FLERR,"Subsequent read data induced "
"too many bonds per atom");
} else atom->bond_per_atom = maxall;
memory->destroy(count);
return;
}
// if 2nd pass: check that bonds were assigned correctly
bigint n = 0;
for (int i = nlocal_previous; i < nlocal; i++) n += atom->num_bond[i];
bigint sum;
MPI_Allreduce(&n,&sum,1,MPI_LMP_BIGINT,MPI_SUM,world);
int factor = 1;
if (!force->newton_bond) factor = 2;
if (me == 0) {
if (screen) fprintf(screen," " BIGINT_FORMAT " bonds\n",sum/factor);
if (logfile) fprintf(logfile," " BIGINT_FORMAT " bonds\n",sum/factor);
}
if (sum != factor*nbonds)
error->all(FLERR,"Bonds assigned incorrectly");
}
/* ----------------------------------------------------------------------
scan or read all angles
------------------------------------------------------------------------- */
void ReadData::angles(int firstpass)
{
int nchunk,eof;
if (me == 0) {
if (firstpass) {
if (screen) fprintf(screen," scanning angles ...\n");
if (logfile) fprintf(logfile," scanning angles ...\n");
} else {
if (screen) fprintf(screen," reading angles ...\n");
if (logfile) fprintf(logfile," reading angles ...\n");
}
}
// allocate count if firstpass
int nlocal = atom->nlocal;
int *count = NULL;
if (firstpass) {
memory->create(count,nlocal,"read_data:count");
memset(count,0,nlocal*sizeof(int));
}
// read and process angles
bigint nread = 0;
while (nread < nangles) {
nchunk = MIN(nangles-nread,CHUNK);
eof = comm->read_lines_from_file(fp,nchunk,MAXLINE,buffer);
if (eof) error->all(FLERR,"Unexpected end of data file");
atom->data_angles(nchunk,buffer,count,id_offset,aoffset);
nread += nchunk;
}
// if firstpass: tally max angle/atom and return
// if addflag = NONE, store max angle/atom with extra
// else just check actual max does not exceed existing max
if (firstpass) {
int max = 0;
for (int i = nlocal_previous; i < nlocal; i++) max = MAX(max,count[i]);
int maxall;
MPI_Allreduce(&max,&maxall,1,MPI_INT,MPI_MAX,world);
if (addflag == NONE) maxall += atom->extra_angle_per_atom;
if (me == 0) {
if (screen) fprintf(screen," %d = max angles/atom\n",maxall);
if (logfile) fprintf(logfile," %d = max angles/atom\n",maxall);
}
if (addflag != NONE) {
if (maxall > atom->angle_per_atom)
error->all(FLERR,"Subsequent read data induced "
"too many angles per atom");
} else atom->angle_per_atom = maxall;
memory->destroy(count);
return;
}
// if 2nd pass: check that angles were assigned correctly
bigint n = 0;
for (int i = nlocal_previous; i < nlocal; i++) n += atom->num_angle[i];
bigint sum;
MPI_Allreduce(&n,&sum,1,MPI_LMP_BIGINT,MPI_SUM,world);
int factor = 1;
if (!force->newton_bond) factor = 3;
if (me == 0) {
if (screen) fprintf(screen," " BIGINT_FORMAT " angles\n",sum/factor);
if (logfile) fprintf(logfile," " BIGINT_FORMAT " angles\n",sum/factor);
}
if (sum != factor*nangles)
error->all(FLERR,"Angles assigned incorrectly");
}
/* ----------------------------------------------------------------------
scan or read all dihedrals
------------------------------------------------------------------------- */
void ReadData::dihedrals(int firstpass)
{
int nchunk,eof;
if (me == 0) {
if (firstpass) {
if (screen) fprintf(screen," scanning dihedrals ...\n");
if (logfile) fprintf(logfile," scanning dihedrals ...\n");
} else {
if (screen) fprintf(screen," reading dihedrals ...\n");
if (logfile) fprintf(logfile," reading dihedrals ...\n");
}
}
// allocate count if firstpass
int nlocal = atom->nlocal;
int *count = NULL;
if (firstpass) {
memory->create(count,nlocal,"read_data:count");
memset(count,0,nlocal*sizeof(int));
}
// read and process dihedrals
bigint nread = 0;
while (nread < ndihedrals) {
nchunk = MIN(ndihedrals-nread,CHUNK);
eof = comm->read_lines_from_file(fp,nchunk,MAXLINE,buffer);
if (eof) error->all(FLERR,"Unexpected end of data file");
atom->data_dihedrals(nchunk,buffer,count,id_offset,doffset);
nread += nchunk;
}
// if firstpass: tally max dihedral/atom and return
// if addflag = NONE, store max dihedral/atom with extra
// else just check actual max does not exceed existing max
if (firstpass) {
int max = 0;
for (int i = nlocal_previous; i < nlocal; i++) max = MAX(max,count[i]);
int maxall;
MPI_Allreduce(&max,&maxall,1,MPI_INT,MPI_MAX,world);
if (addflag == NONE) maxall += atom->extra_dihedral_per_atom;
if (me == 0) {
if (screen) fprintf(screen," %d = max dihedrals/atom\n",maxall);
if (logfile) fprintf(logfile," %d = max dihedrals/atom\n",maxall);
}
if (addflag != NONE) {
if (maxall > atom->dihedral_per_atom)
error->all(FLERR,"Subsequent read data induced "
"too many dihedrals per atom");
} else atom->dihedral_per_atom = maxall;
memory->destroy(count);
return;
}
// if 2nd pass: check that dihedrals were assigned correctly
bigint n = 0;
for (int i = nlocal_previous; i < nlocal; i++) n += atom->num_dihedral[i];
bigint sum;
MPI_Allreduce(&n,&sum,1,MPI_LMP_BIGINT,MPI_SUM,world);
int factor = 1;
if (!force->newton_bond) factor = 4;
if (me == 0) {
if (screen) fprintf(screen," " BIGINT_FORMAT " dihedrals\n",sum/factor);
if (logfile) fprintf(logfile," " BIGINT_FORMAT " dihedrals\n",sum/factor);
}
if (sum != factor*ndihedrals)
error->all(FLERR,"Dihedrals assigned incorrectly");
}
/* ----------------------------------------------------------------------
scan or read all impropers
------------------------------------------------------------------------- */
void ReadData::impropers(int firstpass)
{
int nchunk,eof;
if (me == 0) {
if (firstpass) {
if (screen) fprintf(screen," scanning impropers ...\n");
if (logfile) fprintf(logfile," scanning impropers ...\n");
} else {
if (screen) fprintf(screen," reading impropers ...\n");
if (logfile) fprintf(logfile," reading impropers ...\n");
}
}
// allocate count if firstpass
int nlocal = atom->nlocal;
int *count = NULL;
if (firstpass) {
memory->create(count,nlocal,"read_data:count");
memset(count,0,nlocal*sizeof(int));
}
// read and process impropers
bigint nread = 0;
while (nread < nimpropers) {
nchunk = MIN(nimpropers-nread,CHUNK);
eof = comm->read_lines_from_file(fp,nchunk,MAXLINE,buffer);
if (eof) error->all(FLERR,"Unexpected end of data file");
atom->data_impropers(nchunk,buffer,count,id_offset,ioffset);
nread += nchunk;
}
// if firstpass: tally max improper/atom and return
// if addflag = NONE, store max improper/atom
// else just check it does not exceed existing max
if (firstpass) {
int max = 0;
for (int i = nlocal_previous; i < nlocal; i++) max = MAX(max,count[i]);
int maxall;
MPI_Allreduce(&max,&maxall,1,MPI_INT,MPI_MAX,world);
if (addflag == NONE) maxall += atom->extra_improper_per_atom;
if (me == 0) {
if (screen) fprintf(screen," %d = max impropers/atom\n",maxall);
if (logfile) fprintf(logfile," %d = max impropers/atom\n",maxall);
}
if (addflag != NONE) {
if (maxall > atom->improper_per_atom)
error->all(FLERR,"Subsequent read data induced "
"too many impropers per atom");
} else atom->improper_per_atom = maxall;
memory->destroy(count);
return;
}
// if 2nd pass: check that impropers were assigned correctly
bigint n = 0;
for (int i = nlocal_previous; i < nlocal; i++) n += atom->num_improper[i];
bigint sum;
MPI_Allreduce(&n,&sum,1,MPI_LMP_BIGINT,MPI_SUM,world);
int factor = 1;
if (!force->newton_bond) factor = 4;
if (me == 0) {
if (screen) fprintf(screen," " BIGINT_FORMAT " impropers\n",sum/factor);
if (logfile) fprintf(logfile," " BIGINT_FORMAT " impropers\n",sum/factor);
}
if (sum != factor*nimpropers)
error->all(FLERR,"Impropers assigned incorrectly");
}
/* ----------------------------------------------------------------------
read all bonus data
to find atoms, must build atom map if not a molecular system
------------------------------------------------------------------------- */
void ReadData::bonus(bigint nbonus, AtomVec *ptr, const char *type)
{
int nchunk,eof;
int mapflag = 0;
if (atom->map_style == 0) {
mapflag = 1;
atom->map_init();
atom->map_set();
}
bigint nread = 0;
bigint natoms = nbonus;
while (nread < natoms) {
nchunk = MIN(natoms-nread,CHUNK);
eof = comm->read_lines_from_file(fp,nchunk,MAXLINE,buffer);
if (eof) error->all(FLERR,"Unexpected end of data file");
atom->data_bonus(nchunk,buffer,ptr,id_offset);
nread += nchunk;
}
if (mapflag) {
atom->map_delete();
atom->map_style = 0;
}
if (me == 0) {
if (screen) fprintf(screen," " BIGINT_FORMAT " %s\n",natoms,type);
if (logfile) fprintf(logfile," " BIGINT_FORMAT " %s\n",natoms,type);
}
}
/* ----------------------------------------------------------------------
read all body data
variable amount of info per body, described by ninteger and ndouble
to find atoms, must build atom map if not a molecular system
if not firstpass, just read past data, but no processing of data
------------------------------------------------------------------------- */
void ReadData::bodies(int firstpass)
{
int m,nchunk,nline,nmax,ninteger,ndouble,nword,ncount,onebody,tmp,rv;
char *eof;
int mapflag = 0;
if (atom->map_style == 0 && firstpass) {
mapflag = 1;
atom->map_init();
atom->map_set();
}
// nmax = max # of bodies to read in this chunk
// nchunk = actual # read
bigint nread = 0;
bigint natoms = nbodies;
while (nread < natoms) {
if (natoms-nread > CHUNK) nmax = CHUNK;
else nmax = natoms-nread;
if (me == 0) {
nchunk = 0;
nline = 0;
m = 0;
while (nchunk < nmax && nline <= CHUNK-MAXBODY) {
eof = fgets(&buffer[m],MAXLINE,fp);
if (eof == NULL) error->one(FLERR,"Unexpected end of data file");
rv = sscanf(&buffer[m],"%d %d %d",&tmp,&ninteger,&ndouble);
if (rv != 3)
error->one(FLERR,"Incorrect format in Bodies section of data file");
m += strlen(&buffer[m]);
// read lines one at a time into buffer and count words
// count to ninteger and ndouble until have enough lines
onebody = 0;
nword = 0;
while (nword < ninteger) {
eof = fgets(&buffer[m],MAXLINE,fp);
if (eof == NULL) error->one(FLERR,"Unexpected end of data file");
ncount = atom->count_words(&buffer[m],copy);
if (ncount == 0)
error->one(FLERR,"Too few values in body lines in data file");
nword += ncount;
m += strlen(&buffer[m]);
onebody++;
}
if (nword > ninteger)
error->one(FLERR,"Too many values in body lines in data file");
nword = 0;
while (nword < ndouble) {
eof = fgets(&buffer[m],MAXLINE,fp);
if (eof == NULL) error->one(FLERR,"Unexpected end of data file");
ncount = atom->count_words(&buffer[m],copy);
if (ncount == 0)
error->one(FLERR,"Too few values in body lines in data file");
nword += ncount;
m += strlen(&buffer[m]);
onebody++;
}
if (nword > ndouble)
error->one(FLERR,"Too many values in body lines in data file");
if (onebody+1 > MAXBODY)
error->one(FLERR,
"Too many lines in one body in data file - boost MAXBODY");
nchunk++;
nline += onebody+1;
}
if (buffer[m-1] != '\n') strcpy(&buffer[m++],"\n");
m++;
}
MPI_Bcast(&nchunk,1,MPI_INT,0,world);
MPI_Bcast(&m,1,MPI_INT,0,world);
MPI_Bcast(buffer,m,MPI_CHAR,0,world);
if (firstpass) atom->data_bodies(nchunk,buffer,avec_body,id_offset);
nread += nchunk;
}
if (mapflag && firstpass) {
atom->map_delete();
atom->map_style = 0;
}
if (me == 0 && firstpass) {
if (screen) fprintf(screen," " BIGINT_FORMAT " bodies\n",natoms);
if (logfile) fprintf(logfile," " BIGINT_FORMAT " bodies\n",natoms);
}
}
/* ---------------------------------------------------------------------- */
void ReadData::mass()
{
char *next;
char *buf = new char[ntypes*MAXLINE];
int eof = comm->read_lines_from_file(fp,ntypes,MAXLINE,buf);
if (eof) error->all(FLERR,"Unexpected end of data file");
char *original = buf;
for (int i = 0; i < ntypes; i++) {
next = strchr(buf,'\n');
*next = '\0';
atom->set_mass(FLERR,buf,toffset);
buf = next + 1;
}
delete [] original;
}
/* ---------------------------------------------------------------------- */
void ReadData::paircoeffs()
{
char *next;
char *buf = new char[ntypes*MAXLINE];
int eof = comm->read_lines_from_file(fp,ntypes,MAXLINE,buf);
if (eof) error->all(FLERR,"Unexpected end of data file");
char *original = buf;
for (int i = 0; i < ntypes; i++) {
next = strchr(buf,'\n');
*next = '\0';
parse_coeffs(buf,NULL,1,2,toffset);
if (narg == 0)
error->all(FLERR,"Unexpected empty line in PairCoeffs section");
force->pair->coeff(narg,arg);
buf = next + 1;
}
delete [] original;
}
/* ---------------------------------------------------------------------- */
void ReadData::pairIJcoeffs()
{
int i,j;
char *next;
int nsq = ntypes * (ntypes+1) / 2;
char *buf = new char[nsq * MAXLINE];
int eof = comm->read_lines_from_file(fp,nsq,MAXLINE,buf);
if (eof) error->all(FLERR,"Unexpected end of data file");
char *original = buf;
for (i = 0; i < ntypes; i++)
for (j = i; j < ntypes; j++) {
next = strchr(buf,'\n');
*next = '\0';
parse_coeffs(buf,NULL,0,2,toffset);
if (narg == 0)
error->all(FLERR,"Unexpected empty line in PairCoeffs section");
force->pair->coeff(narg,arg);
buf = next + 1;
}
delete [] original;
}
/* ---------------------------------------------------------------------- */
void ReadData::bondcoeffs()
{
if (!nbondtypes) return;
char *next;
char *buf = new char[nbondtypes*MAXLINE];
int eof = comm->read_lines_from_file(fp,nbondtypes,MAXLINE,buf);
if (eof) error->all(FLERR,"Unexpected end of data file");
char *original = buf;
for (int i = 0; i < nbondtypes; i++) {
next = strchr(buf,'\n');
*next = '\0';
parse_coeffs(buf,NULL,0,1,boffset);
if (narg == 0)
error->all(FLERR,"Unexpected empty line in BondCoeffs section");
force->bond->coeff(narg,arg);
buf = next + 1;
}
delete [] original;
}
/* ---------------------------------------------------------------------- */
void ReadData::anglecoeffs(int which)
{
if (!nangletypes) return;
char *next;
char *buf = new char[nangletypes*MAXLINE];
int eof = comm->read_lines_from_file(fp,nangletypes,MAXLINE,buf);
if (eof) error->all(FLERR,"Unexpected end of data file");
char *original = buf;
for (int i = 0; i < nangletypes; i++) {
next = strchr(buf,'\n');
*next = '\0';
if (which == 0) parse_coeffs(buf,NULL,0,1,aoffset);
else if (which == 1) parse_coeffs(buf,"bb",0,1,aoffset);
else if (which == 2) parse_coeffs(buf,"ba",0,1,aoffset);
if (narg == 0) error->all(FLERR,"Unexpected empty line in AngleCoeffs section");
force->angle->coeff(narg,arg);
buf = next + 1;
}
delete [] original;
}
/* ---------------------------------------------------------------------- */
void ReadData::dihedralcoeffs(int which)
{
if (!ndihedraltypes) return;
char *next;
char *buf = new char[ndihedraltypes*MAXLINE];
int eof = comm->read_lines_from_file(fp,ndihedraltypes,MAXLINE,buf);
if (eof) error->all(FLERR,"Unexpected end of data file");
char *original = buf;
for (int i = 0; i < ndihedraltypes; i++) {
next = strchr(buf,'\n');
*next = '\0';
if (which == 0) parse_coeffs(buf,NULL,0,1,doffset);
else if (which == 1) parse_coeffs(buf,"mbt",0,1,doffset);
else if (which == 2) parse_coeffs(buf,"ebt",0,1,doffset);
else if (which == 3) parse_coeffs(buf,"at",0,1,doffset);
else if (which == 4) parse_coeffs(buf,"aat",0,1,doffset);
else if (which == 5) parse_coeffs(buf,"bb13",0,1,doffset);
if (narg == 0)
error->all(FLERR,"Unexpected empty line in DihedralCoeffs section");
force->dihedral->coeff(narg,arg);
buf = next + 1;
}
delete [] original;
}
/* ---------------------------------------------------------------------- */
void ReadData::impropercoeffs(int which)
{
if (!nimpropertypes) return;
char *next;
char *buf = new char[nimpropertypes*MAXLINE];
int eof = comm->read_lines_from_file(fp,nimpropertypes,MAXLINE,buf);
if (eof) error->all(FLERR,"Unexpected end of data file");
char *original = buf;
for (int i = 0; i < nimpropertypes; i++) {
next = strchr(buf,'\n');
*next = '\0';
if (which == 0) parse_coeffs(buf,NULL,0,1,ioffset);
else if (which == 1) parse_coeffs(buf,"aa",0,1,ioffset);
if (narg == 0) error->all(FLERR,"Unexpected empty line in ImproperCoeffs section");
force->improper->coeff(narg,arg);
buf = next + 1;
}
delete [] original;
}
/* ----------------------------------------------------------------------
read fix section, pass lines to fix to process
n = index of fix
------------------------------------------------------------------------- */
void ReadData::fix(int ifix, char *keyword)
{
int nchunk,eof;
bigint nline = modify->fix[ifix]->read_data_skip_lines(keyword);
bigint nread = 0;
while (nread < nline) {
nchunk = MIN(nline-nread,CHUNK);
eof = comm->read_lines_from_file(fp,nchunk,MAXLINE,buffer);
if (eof) error->all(FLERR,"Unexpected end of data file");
modify->fix[ifix]->read_data_section(keyword,nchunk,buffer,id_offset);
nread += nchunk;
}
}
/* ----------------------------------------------------------------------
reallocate the count vector from cmax to amax+1 and return new length
zero new locations
------------------------------------------------------------------------- */
int ReadData::reallocate(int **pcount, int cmax, int amax)
{
int *count = *pcount;
memory->grow(count,amax+1,"read_data:count");
for (int i = cmax; i <= amax; i++) count[i] = 0;
*pcount = count;
return amax+1;
}
/* ----------------------------------------------------------------------
proc 0 opens data file
test if gzipped
------------------------------------------------------------------------- */
void ReadData::open(char *file)
{
compressed = 0;
char *suffix = file + strlen(file) - 3;
if (suffix > file && strcmp(suffix,".gz") == 0) compressed = 1;
if (!compressed) fp = fopen(file,"r");
else {
#ifdef LAMMPS_GZIP
char gunzip[128];
snprintf(gunzip,128,"gzip -c -d %s",file);
#ifdef _WIN32
fp = _popen(gunzip,"rb");
#else
fp = popen(gunzip,"r");
#endif
#else
error->one(FLERR,"Cannot open gzipped file");
#endif
}
if (fp == NULL) {
char str[128];
snprintf(str,128,"Cannot open file %s",file);
error->one(FLERR,str);
}
}
/* ----------------------------------------------------------------------
grab next keyword
read lines until one is non-blank
keyword is all text on line w/out leading & trailing white space
optional style can be appended after comment char '#'
read one additional line (assumed blank)
if any read hits EOF, set keyword to empty
if first = 1, line variable holds non-blank line that ended header
------------------------------------------------------------------------- */
void ReadData::parse_keyword(int first)
{
int eof = 0;
int done = 0;
// proc 0 reads upto non-blank line plus 1 following line
// eof is set to 1 if any read hits end-of-file
if (me == 0) {
if (!first) {
if (fgets(line,MAXLINE,fp) == NULL) eof = 1;
}
while (eof == 0 && done == 0) {
int blank = strspn(line," \t\n\r");
if ((blank == (int)strlen(line)) || (line[blank] == '#')) {
if (fgets(line,MAXLINE,fp) == NULL) eof = 1;
} else done = 1;
}
if (fgets(buffer,MAXLINE,fp) == NULL) {
eof = 1;
buffer[0] = '\0';
}
}
// if eof, set keyword empty and return
MPI_Bcast(&eof,1,MPI_INT,0,world);
if (eof) {
keyword[0] = '\0';
return;
}
// bcast keyword line to all procs
int n;
if (me == 0) n = strlen(line) + 1;
MPI_Bcast(&n,1,MPI_INT,0,world);
MPI_Bcast(line,n,MPI_CHAR,0,world);
// store optional "style" following comment char '#' after keyword
char *ptr;
if ((ptr = strchr(line,'#'))) {
*ptr++ = '\0';
while (*ptr == ' ' || *ptr == '\t') ptr++;
int stop = strlen(ptr) - 1;
while (ptr[stop] == ' ' || ptr[stop] == '\t'
|| ptr[stop] == '\n' || ptr[stop] == '\r') stop--;
ptr[stop+1] = '\0';
strcpy(style,ptr);
} else style[0] = '\0';
// copy non-whitespace portion of line into keyword
int start = strspn(line," \t\n\r");
int stop = strlen(line) - 1;
while (line[stop] == ' ' || line[stop] == '\t'
|| line[stop] == '\n' || line[stop] == '\r') stop--;
line[stop+1] = '\0';
strcpy(keyword,&line[start]);
}
/* ----------------------------------------------------------------------
proc 0 reads N lines from file
could be skipping Natoms lines, so use bigints
------------------------------------------------------------------------- */
void ReadData::skip_lines(bigint n)
{
if (me) return;
if (n <= 0) return;
char *eof = NULL;
for (bigint i = 0; i < n; i++) eof = fgets(line,MAXLINE,fp);
if (eof == NULL) error->one(FLERR,"Unexpected end of data file");
}
/* ----------------------------------------------------------------------
parse a line of coeffs into words, storing them in narg,arg
trim anything from '#' onward
word strings remain in line, are not copied
if addstr != NULL, add addstr as extra arg for class2 angle/dihedral/improper
if 2nd word starts with letter, then is hybrid style, add addstr after it
else add addstr before 2nd word
if dupflag, duplicate 1st word, so pair_coeff "2" becomes "2 2"
if noffset, add offset to first noffset args, which are atom/bond/etc types
------------------------------------------------------------------------- */
void ReadData::parse_coeffs(char *line, const char *addstr,
int dupflag, int noffset, int offset)
{
char *ptr;
if ((ptr = strchr(line,'#'))) *ptr = '\0';
narg = 0;
char *word = strtok(line," \t\n\r\f");
while (word) {
if (narg == maxarg) {
maxarg += DELTA;
arg = (char **)
memory->srealloc(arg,maxarg*sizeof(char *),"read_data:arg");
}
if (addstr && narg == 1 && !islower(word[0])) arg[narg++] = (char *) addstr;
arg[narg++] = word;
if (addstr && narg == 2 && islower(word[0])) arg[narg++] = (char *) addstr;
if (dupflag && narg == 1) arg[narg++] = word;
word = strtok(NULL," \t\n\r\f");
}
// to avoid segfaults on empty lines
if (narg == 0) return;
if (noffset) {
int value = force->inumeric(FLERR,arg[0]);
sprintf(argoffset1,"%d",value+offset);
arg[0] = argoffset1;
if (noffset == 2) {
value = force->inumeric(FLERR,arg[1]);
sprintf(argoffset2,"%d",value+offset);
arg[1] = argoffset2;
}
}
}
/* ----------------------------------------------------------------------
compare two style strings if they both exist
one = comment in data file section, two = currently-defined style
ignore suffixes listed in suffixes array at top of file
------------------------------------------------------------------------- */
int ReadData::style_match(const char *one, const char *two)
{
int i,delta,len,len1,len2;
if ((one == NULL) || (two == NULL)) return 1;
len1 = strlen(one);
len2 = strlen(two);
for (i = 0; suffixes[i] != NULL; i++) {
len = strlen(suffixes[i]);
if ((delta = len1 - len) > 0)
if (strcmp(one+delta,suffixes[i]) == 0) len1 = delta;
if ((delta = len2 - len) > 0)
if (strcmp(two+delta,suffixes[i]) == 0) len2 = delta;
}
if ((len1 == 0) || (len1 == len2) || (strncmp(one,two,len1) == 0)) return 1;
return 0;
}
| 34.221666 | 90 | 0.58384 | rajkubp020 |
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 |
98a4d7e8b144fc20f9691e14bc3c986e55e287a3 | 1,374 | cpp | C++ | kernel/klib/misc/math_hacks.cpp | martin-hughes/project_azalea | 28aa0183cde350073cf0167df3f51435ea409c8b | [
"MIT"
] | 13 | 2017-12-20T00:02:38.000Z | 2022-01-07T11:18:36.000Z | kernel/klib/misc/math_hacks.cpp | martin-hughes/project_azalea | 28aa0183cde350073cf0167df3f51435ea409c8b | [
"MIT"
] | 21 | 2016-09-21T16:50:39.000Z | 2020-04-12T12:58:19.000Z | kernel/klib/misc/math_hacks.cpp | martin-hughes/project_azalea | 28aa0183cde350073cf0167df3f51435ea409c8b | [
"MIT"
] | 6 | 2017-12-20T00:02:27.000Z | 2019-03-21T16:28:24.000Z | /// @file
/// @brief Simple math functions that are useful.
#include "math_hacks.h"
#ifdef _MSVC_LANG
#include <intrin.h>
#endif
/// @brief Round a number to the next-highest power of two.
///
/// @param input The number to round up.
///
/// @return Input rounded up to the next highest power of two - or itself, if input is a power of two already.
uint64_t round_to_power_two(uint64_t input)
{
uint64_t pos;
uint64_t output;
uint64_t first_in = input;
if (input == 0)
{
return 0;
}
if ((input & 0x1000000000000000) != 0)
{
return 0;
}
#ifndef _MSVC_LANG
pos = __builtin_clzl(input);
#else
pos = __lzcnt64(input);
#endif
output = (uint64_t)1 << (63 - pos);
if (first_in != output)
{
output = output << 1;
}
return output;
}
/// @brief Which power of two is the greatest one still lower than this number?
///
/// That is, for any given input, the result is the maximum value of x where 2^x is less than, or equal to input. Or in
/// other words, log (input) / log(2) rounded down to the next integer.
///
/// @param input The number to convert.
///
/// @return The value described above.
uint64_t which_power_of_two(uint64_t input)
{
uint64_t first_bit_pos;
#ifndef _MSVC_LANG
first_bit_pos = __builtin_clzl(input);
#else
first_bit_pos = __lzcnt64(input);
#endif
return (input == 0) ? 0 : (63 - first_bit_pos);
} | 21.138462 | 119 | 0.673945 | martin-hughes |
f0f657b04c2e600cd4574d10968c62acb5025a92 | 18,046 | cpp | C++ | neo/tools/kademlia/kademlia/Kademlia.cpp | vic3t3chn0/OpenKrown | 201c8fb6895cb0439e39c984d2fbc2c2eaf185b4 | [
"MIT"
] | 1 | 2018-11-07T22:44:23.000Z | 2018-11-07T22:44:23.000Z | neo/tools/kademlia/kademlia/Kademlia.cpp | vic3t3chn0/OpenKrown | 201c8fb6895cb0439e39c984d2fbc2c2eaf185b4 | [
"MIT"
] | null | null | null | neo/tools/kademlia/kademlia/Kademlia.cpp | vic3t3chn0/OpenKrown | 201c8fb6895cb0439e39c984d2fbc2c2eaf185b4 | [
"MIT"
] | null | null | null | //
// This file is part of the aMule Project.
//
// Copyright (c) 2004-2011 Angel Vidal ( kry@amule.org )
// Copyright (c) 2004-2011 aMule Team ( admin@amule.org / http://www.amule.org )
// Copyright (c) 2003-2011 Barry Dunne (http://www.emule-project.net)
//
// Any parts of this program derived from the xMule, lMule or eMule project,
// or contributed by third-party developers are copyrighted by their
// respective authors.
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
//
// Note To Mods //
/*
Please do not change anything here and release it..
There is going to be a new forum created just for the Kademlia side of the client..
If you feel there is an error or a way to improve something, please
post it in the forum first and let us look at it.. If it is a real improvement,
it will be added to the offical client.. Changing something without knowing
what all it does can cause great harm to the network if released in mass form..
Any mod that changes anything within the Kademlia side will not be allowed to advertise
there client on the eMule forum..
*/
#include "Kademlia.h" // Interface declarations
#include <protocol/kad/Constants.h>
#include "Defines.h"
#include "Indexed.h"
#include "UDPFirewallTester.h"
#include "../routing/RoutingZone.h"
#include "../utils/KadUDPKey.h"
#include "../utils/KadClientSearcher.h"
#include "../../amule.h"
#include "../../Logger.h"
#include <protocol/kad2/Client2Client/UDP.h>
#ifdef _MSC_VER // silly warnings about deprecated functions
#pragma warning(disable:4996)
#endif
const CUInt128 Kademlia::s_nullUInt128(false);
////////////////////////////////////////
using namespace Kademlia;
////////////////////////////////////////
CKademlia * CKademlia::instance = NULL;
EventMap CKademlia::m_events;
time_t CKademlia::m_nextSearchJumpStart;
time_t CKademlia::m_nextSelfLookup;
time_t CKademlia::m_statusUpdate;
time_t CKademlia::m_bigTimer;
time_t CKademlia::m_nextFirewallCheck;
time_t CKademlia::m_nextFindBuddy;
time_t CKademlia::m_bootstrap;
time_t CKademlia::m_consolidate;
time_t CKademlia::m_externPortLookup;
time_t CKademlia::m_lanModeCheck = 0;
bool CKademlia::m_running = false;
bool CKademlia::m_lanMode = false;
ContactList CKademlia::s_bootstrapList;
std::list<uint32_t> CKademlia::m_statsEstUsersProbes;
void CKademlia::Start(CPrefs *prefs)
{
if (instance) {
// If we already have an instance, something is wrong.
delete prefs;
wxASSERT(instance->m_running);
wxASSERT(instance->m_prefs);
return;
}
// Make sure a prefs was passed in..
if (!prefs) {
return;
}
AddDebugLogLineN(logKadMain, wxT("Starting Kademlia"));
// Init jump start timer.
m_nextSearchJumpStart = time(NULL);
// Force a FindNodeComplete within the first 3 minutes.
m_nextSelfLookup = time(NULL) + MIN2S(3);
// Init status timer.
m_statusUpdate = time(NULL);
// Init big timer for Zones
m_bigTimer = time(NULL);
// First Firewall check is done on connect, init next check.
m_nextFirewallCheck = time(NULL) + (HR2S(1));
// Find a buddy after the first 5mins of starting the client.
// We wait just in case it takes a bit for the client to determine firewall status..
m_nextFindBuddy = time(NULL) + (MIN2S(5));
// Init contact consolidate timer;
m_consolidate = time(NULL) + (MIN2S(45));
// Look up our extern port
m_externPortLookup = time(NULL);
// Init bootstrap time.
m_bootstrap = 0;
// Init our random seed.
srand((uint32_t)time(NULL));
// Create our Kad objects.
instance = new CKademlia();
instance->m_prefs = prefs;
instance->m_indexed = new CIndexed();
instance->m_routingZone = new CRoutingZone();
instance->m_udpListener = new CKademliaUDPListener();
// Mark Kad as running state.
m_running = true;
}
void CKademlia::Stop()
{
// Make sure we are running to begin with.
if (!m_running) {
return;
}
AddDebugLogLineN(logKadMain, wxT("Stopping Kademlia"));
// Mark Kad as being in the stop state to make sure nothing else is used.
m_running = false;
// Reset Firewallstate
CUDPFirewallTester::Reset();
// Remove all active searches.
CSearchManager::StopAllSearches();
// Delete all Kad Objects.
delete instance->m_udpListener;
instance->m_udpListener = NULL;
delete instance->m_routingZone;
instance->m_routingZone = NULL;
delete instance->m_indexed;
instance->m_indexed = NULL;
delete instance->m_prefs;
instance->m_prefs = NULL;
delete instance;
instance = NULL;
for (ContactList::iterator it = s_bootstrapList.begin(); it != s_bootstrapList.end(); ++it) {
delete *it;
}
s_bootstrapList.clear();
// Make sure all zones are removed.
m_events.clear();
// theApp->ShowConnectionState();
}
void CKademlia::Process()
{
if (instance == NULL || !m_running) {
return;
}
time_t now = time(NULL);
uint32_t maxUsers = 0;
uint32_t tempUsers = 0;
uint32_t lastContact = 0;
bool updateUserFile = false;
wxASSERT(instance->m_prefs != NULL);
lastContact = instance->m_prefs->GetLastContact();
CSearchManager::UpdateStats();
if (m_statusUpdate <= now) {
updateUserFile = true;
m_statusUpdate = MIN2S(1) + now;
}
if (m_nextFirewallCheck <= now) {
RecheckFirewalled();
}
if (m_nextSelfLookup <= now) {
CSearchManager::FindNode(instance->m_prefs->GetKadID(), true);
m_nextSelfLookup = HR2S(4) + now;
}
if (m_nextFindBuddy <= now) {
instance->m_prefs->SetFindBuddy();
m_nextFindBuddy = MIN2S(20) + now;
}
if (m_externPortLookup <= now && CUDPFirewallTester::IsFWCheckUDPRunning() && GetPrefs()->FindExternKadPort(false)) {
// If our UDP firewallcheck is running and we don't know our external port, we send a request every 15 seconds
CContact *contact = GetRoutingZone()->GetRandomContact(3, 6);
if (contact != NULL) {
AddDebugLogLineN(logKadPrefs, wxT("Requesting our external port from ") + KadIPToString(contact->GetIPAddress()));
DebugSend(Kad2Ping, contact->GetIPAddress(), contact->GetUDPPort());
GetUDPListener()->SendNullPacket(KADEMLIA2_PING, contact->GetIPAddress(), contact->GetUDPPort(), contact->GetUDPKey(), &contact->GetClientID());
} else {
AddDebugLogLineN(logKadPrefs, wxT("No valid client for requesting external port available"));
}
m_externPortLookup = 15 + now;
}
for (EventMap::const_iterator it = m_events.begin(); it != m_events.end(); ++it) {
CRoutingZone *zone = it->first;
if (updateUserFile) {
// The EstimateCount function is not made for really small networks, if we are in LAN mode, it is actually
// better to assume that all users of the network are in our routing table and use the real count function
if (IsRunningInLANMode()) {
tempUsers = zone->GetNumContacts();
} else {
tempUsers = zone->EstimateCount();
}
if (maxUsers < tempUsers) {
maxUsers = tempUsers;
}
}
if (m_bigTimer <= now) {
if (zone->m_nextBigTimer <= now) {
if(zone->OnBigTimer()) {
zone->m_nextBigTimer = HR2S(1) + now;
m_bigTimer = SEC(10) + now;
}
} else {
if (lastContact && (now - lastContact > KADEMLIADISCONNECTDELAY - MIN2S(5))) {
if(zone->OnBigTimer()) {
zone->m_nextBigTimer = HR2S(1) + now;
m_bigTimer = SEC(10) + now;
}
}
}
}
if (zone->m_nextSmallTimer <= now) {
zone->OnSmallTimer();
zone->m_nextSmallTimer = MIN2S(1) + now;
}
}
// This is a convenient place to add this, although not related to routing
if (m_nextSearchJumpStart <= now) {
CSearchManager::JumpStart();
m_nextSearchJumpStart = SEARCH_JUMPSTART + now;
}
// Try to consolidate any zones that are close to empty.
if (m_consolidate <= now) {
uint32_t mergedCount = instance->m_routingZone->Consolidate();
if (mergedCount) {
AddDebugLogLineN(logKadRouting, CFormat(wxT("Kad merged %u zones")) % mergedCount);
}
m_consolidate = MIN2S(45) + now;
}
// Update user count only if changed.
if (updateUserFile) {
if (maxUsers != instance->m_prefs->GetKademliaUsers()) {
instance->m_prefs->SetKademliaUsers(maxUsers);
instance->m_prefs->SetKademliaFiles();
theApp->ShowUserCount();
}
}
if (!IsConnected() && !s_bootstrapList.empty() && (now - m_bootstrap > 15 || (GetRoutingZone()->GetNumContacts() == 0 && now - m_bootstrap >= 2))) {
CContact *contact = s_bootstrapList.front();
s_bootstrapList.pop_front();
m_bootstrap = now;
AddDebugLogLineN(logKadMain, CFormat(wxT("Trying to bootstrap Kad from %s, Distance: %s Version: %u, %u contacts left"))
% KadIPToString(contact->GetIPAddress()) % contact->GetDistance().ToHexString() % contact->GetVersion() % s_bootstrapList.size());
instance->m_udpListener->Bootstrap(contact->GetIPAddress(), contact->GetUDPPort(), contact->GetVersion(), &contact->GetClientID());
delete contact;
}
if (GetUDPListener() != NULL) {
GetUDPListener()->ExpireClientSearch(); // function does only one compare in most cases, so no real need for a timer
}
}
void CKademlia::ProcessPacket(const uint8_t *data, uint32_t lenData, uint32_t ip, uint16_t port, bool validReceiverKey, const CKadUDPKey& senderKey)
{
try {
if( instance && instance->m_udpListener ) {
instance->m_udpListener->ProcessPacket(data, lenData, ip, port, validReceiverKey, senderKey);
}
} catch (const wxString& DEBUG_ONLY(error)) {
AddDebugLogLineN(logKadMain, CFormat(wxT("Exception on Kad ProcessPacket while processing packet (length = %u) from %s:"))
% lenData % KadIPPortToString(ip, port));
AddDebugLogLineN(logKadMain, error);
throw;
} catch (...) {
AddDebugLogLineN(logKadMain, wxT("Unhandled exception on Kad ProcessPacket"));
throw;
}
}
void CKademlia::RecheckFirewalled()
{
if (instance && instance->m_prefs && !IsRunningInLANMode()) {
// Something is forcing a new firewall check
// Stop any new buddy requests, and tell the client
// to recheck it's IP which in turns rechecks firewall.
instance->m_prefs->SetFindBuddy(false);
instance->m_prefs->SetRecheckIP();
// also UDP check
CUDPFirewallTester::ReCheckFirewallUDP(false);
time_t now = time(NULL);
// Delay the next buddy search to at least 5 minutes after our firewallcheck so we are sure to be still firewalled
m_nextFindBuddy = (m_nextFindBuddy < MIN2S(5) + now) ? MIN2S(5) + now : m_nextFindBuddy;
m_nextFirewallCheck = HR2S(1) + now;
}
}
#if 0 // currently unused function
bool CKademlia::FindNodeIDByIP(CKadClientSearcher& requester, uint32_t ip, uint16_t tcpPort, uint16_t udpPort)
{
wxCHECK(IsRunning() && instance && GetUDPListener() && GetRoutingZone(), false);
// first search our known contacts if we can deliver a result without asking, otherwise forward the request
CContact* contact;
if ((contact = GetRoutingZone()->GetContact(wxUINT32_SWAP_ALWAYS(ip), tcpPort, true)) != NULL) {
uint8_t nodeID[16];
contact->GetClientID().ToByteArray(nodeID);
requester.KadSearchNodeIDByIPResult(KCSR_SUCCEEDED, nodeID);
return true;
} else {
return GetUDPListener()->FindNodeIDByIP(&requester, wxUINT32_SWAP_ALWAYS(ip), tcpPort, udpPort);
}
}
#endif
bool CKademlia::FindIPByNodeID(CKadClientSearcher& requester, const uint8_t* nodeID)
{
wxCHECK(IsRunning() && instance && GetUDPListener(), false);
// first search our known contacts if we can deliver a result without asking, otherwise forward the request
CContact* contact;
if ((contact = GetRoutingZone()->GetContact(CUInt128(nodeID))) != NULL) {
// make sure that this entry is not too old, otherwise just do a search to be sure
if (contact->GetLastSeen() != 0 && time(NULL) - contact->GetLastSeen() < 1800) {
requester.KadSearchIPByNodeIDResult(KCSR_SUCCEEDED, wxUINT32_SWAP_ALWAYS(contact->GetIPAddress()), contact->GetTCPPort());
return true;
}
}
return CSearchManager::FindNodeSpecial(CUInt128(nodeID), &requester);
}
void CKademlia::CancelClientSearch(CKadClientSearcher& fromRequester)
{
wxCHECK_RET(instance && GetUDPListener(), wxT("Something is really bad"));
GetUDPListener()->ExpireClientSearch(&fromRequester);
CSearchManager::CancelNodeSpecial(&fromRequester);
}
void CKademlia::StatsAddClosestDistance(const CUInt128& distance)
{
if (distance.Get32BitChunk(0) > 0) {
uint32_t toAdd = (0xFFFFFFFF / distance.Get32BitChunk(0)) / 2;
std::list<uint32_t>::iterator it = m_statsEstUsersProbes.begin();
for (; it != m_statsEstUsersProbes.end(); ++it) {
if (*it == toAdd) {
break;
}
}
if (it == m_statsEstUsersProbes.end()) {
m_statsEstUsersProbes.push_front(toAdd);
}
}
if (m_statsEstUsersProbes.size() > 100) {
m_statsEstUsersProbes.pop_back();
}
}
uint32_t CKademlia::CalculateKadUsersNew()
{
// the idea of calculating the user count with this method is simple:
// whenever we do a search for any NodeID (except in certain cases where the result is not usable),
// we remember the distance of the closest node we found. Because we assume all NodeIDs are distributed
// equally, we can calculate based on this distance how "filled" the possible NodesID room is and by this
// calculate how many users there are. Of course this only works if we have enough samples, because
// each single sample will be wrong, but the average of them should produce a usable number. To avoid
// drifts caused by a a single (or more) really close or really far away hits, we do use median-average instead through
// doesn't work well if we have no files to index and nothing to download and the numbers seems to be a bit too low
// compared to our other method. So let's stay with the old one for now, but keep this here as an alternative
if (m_statsEstUsersProbes.size() < 10) {
return 0;
}
uint32_t median = 0;
std::list<uint32_t> medianList;
for (std::list<uint32_t>::iterator it1 = m_statsEstUsersProbes.begin(); it1 != m_statsEstUsersProbes.end(); ++it1) {
uint32_t probe = *it1;
bool inserted = false;
for (std::list<uint32_t>::iterator it2 = medianList.begin(); it2 != medianList.end(); ++it2) {
if (*it2 > probe) {
medianList.insert(it2, probe);
inserted = true;
break;
}
}
if (!inserted) {
medianList.push_back(probe);
}
}
// cut away 1/3 of the values - 1/6 of the top and 1/6 of the bottom to avoid spikes having too much influence, build the average of the rest
std::list<uint32_t>::size_type cut = medianList.size() / 6;
for (std::list<uint32_t>::size_type i = 0; i != cut; ++i) {
medianList.pop_front();
medianList.pop_back();
}
uint64_t average = 0;
for (std::list<uint32_t>::iterator it = medianList.begin(); it != medianList.end(); ++it) {
average += *it;
}
median = (uint32_t)(average / medianList.size());
// LowIDModififier
// Modify count by assuming 20% of the users are firewalled and can't be a contact for < 0.49b nodes
// Modify count by actual statistics of Firewalled ratio for >= 0.49b if we are not firewalled ourself
// Modify count by 40% for >= 0.49b if we are firewalled ourself (the actual Firewalled count at this date on kad is 35-55%)
const float firewalledModifyOld = 1.20f;
float firewalledModifyNew = 0.0;
if (CUDPFirewallTester::IsFirewalledUDP(true)) {
firewalledModifyNew = 1.40f; // we are firewalled and can't get the real statistics, assume 40% firewalled >=0.49b nodes
} else if (GetPrefs()->StatsGetFirewalledRatio(true) > 0) {
firewalledModifyNew = 1.0 + (CKademlia::GetPrefs()->StatsGetFirewalledRatio(true)); // apply the firewalled ratio to the modify
wxASSERT(firewalledModifyNew > 1.0 && firewalledModifyNew < 1.90);
}
float newRatio = CKademlia::GetPrefs()->StatsGetKadV8Ratio();
float firewalledModifyTotal = 0.0;
if (newRatio > 0 && firewalledModifyNew > 0) { // weigth the old and the new modifier based on how many new contacts we have
firewalledModifyTotal = (newRatio * firewalledModifyNew) + ((1 - newRatio) * firewalledModifyOld);
} else {
firewalledModifyTotal = firewalledModifyOld;
}
wxASSERT(firewalledModifyTotal > 1.0 && firewalledModifyTotal < 1.90);
return (uint32_t)((float)median * firewalledModifyTotal);
}
bool CKademlia::IsRunningInLANMode()
{
if (thePrefs::FilterLanIPs() || !IsRunning()) {
return false;
}
time_t now = time(NULL);
if (m_lanModeCheck + 10 <= now) {
m_lanModeCheck = now;
uint32_t count = GetRoutingZone()->GetNumContacts();
// Limit to 256 nodes, if we have more we don't want to use the LAN mode which is assuming we use a small home LAN
// (otherwise we might need to do firewallcheck, external port requests etc after all)
if (count == 0 || count > 256) {
m_lanMode = false;
} else {
if (GetRoutingZone()->HasOnlyLANNodes()) {
if (!m_lanMode) {
m_lanMode = true;
theApp->ShowConnectionState();
AddDebugLogLineN(logKadMain, wxT("Activating LAN mode"));
}
} else {
if (m_lanMode) {
m_lanMode = false;
theApp->ShowConnectionState();
AddDebugLogLineN(logKadMain, wxT("Deactivating LAN mode"));
}
}
}
}
return m_lanMode;
}
// Global function.
#include "../../CryptoPP_Inc.h"
void KadGetKeywordHash(const wxString& rstrKeyword, Kademlia::CUInt128* pKadID)
{
byte Output[16];
#ifdef __WEAK_CRYPTO__
CryptoPP::Weak::MD4 md4_hasher;
#else
CryptoPP::MD4 md4_hasher;
#endif
// This should be safe - we assume rstrKeyword is ANSI anyway.
char* ansi_buffer = strdup(unicode2UTF8(rstrKeyword));
//printf("Kad keyword hash: UTF8 %s\n",ansi_buffer);
md4_hasher.CalculateDigest(Output,(const unsigned char*)ansi_buffer,strlen(ansi_buffer));
//DumpMem(Output,16);
free(ansi_buffer);
pKadID->SetValueBE(Output);
}
| 34.703846 | 149 | 0.714895 | vic3t3chn0 |
f0f65a6014974d9598e9b3ffaaf113ad512bd731 | 3,848 | cc | C++ | net/base/priority_queue_unittest.cc | Scopetta197/chromium | b7bf8e39baadfd9089de2ebdc0c5d982de4a9820 | [
"BSD-3-Clause"
] | 212 | 2015-01-31T11:55:58.000Z | 2022-02-22T06:35:11.000Z | net/base/priority_queue_unittest.cc | Scopetta197/chromium | b7bf8e39baadfd9089de2ebdc0c5d982de4a9820 | [
"BSD-3-Clause"
] | 5 | 2015-03-27T14:29:23.000Z | 2019-09-25T13:23:12.000Z | net/base/priority_queue_unittest.cc | Scopetta197/chromium | b7bf8e39baadfd9089de2ebdc0c5d982de4a9820 | [
"BSD-3-Clause"
] | 221 | 2015-01-07T06:21:24.000Z | 2022-02-11T02:51:12.000Z | // Copyright (c) 2012 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "net/base/priority_queue.h"
#include "testing/gtest/include/gtest/gtest.h"
namespace net {
namespace {
typedef PriorityQueue<int>::Priority Priority;
const Priority kPriorities[] = { 2, 1, 2, 0, 4, 3, 1, 4, 0 };
const Priority kNumPriorities = 5; // max(kPriorities) + 1
const size_t kNumElements = arraysize(kPriorities);
const int kFirstMinOrder[kNumElements] = { 3, 8, 1, 6, 0, 2, 5, 4, 7 };
const int kLastMaxOrder[kNumElements] = { 7, 4, 5, 2, 0, 6, 1, 8, 3 };
const int kFirstMaxOrder[kNumElements] = { 4, 7, 5, 0, 2, 1, 6, 3, 8 };
const int kLastMinOrder[kNumElements] = { 8, 3, 6, 1, 2, 0, 5, 7, 4 };
void CheckEmpty(PriorityQueue<int>* queue) {
EXPECT_EQ(0u, queue->size());
EXPECT_TRUE(queue->FirstMin().is_null());
EXPECT_TRUE(queue->LastMin().is_null());
EXPECT_TRUE(queue->FirstMax().is_null());
EXPECT_TRUE(queue->LastMax().is_null());
}
TEST(PriorityQueueTest, AddAndClear) {
PriorityQueue<int> queue(kNumPriorities);
PriorityQueue<int>::Pointer pointers[kNumElements];
CheckEmpty(&queue);
for (size_t i = 0; i < kNumElements; ++i) {
EXPECT_EQ(i, queue.size());
pointers[i] = queue.Insert(static_cast<int>(i), kPriorities[i]);
}
EXPECT_EQ(kNumElements, queue.size());
for (size_t i = 0; i < kNumElements; ++i) {
EXPECT_EQ(kPriorities[i], pointers[i].priority());
EXPECT_EQ(static_cast<int>(i), pointers[i].value());
}
queue.Clear();
CheckEmpty(&queue);
}
TEST(PriorityQueueTest, FirstMinOrder) {
PriorityQueue<int> queue(kNumPriorities);
PriorityQueue<int>::Pointer pointers[kNumElements];
for (size_t i = 0; i < kNumElements; ++i) {
pointers[i] = queue.Insert(static_cast<int>(i), kPriorities[i]);
}
for (size_t i = 0; i < kNumElements; ++i) {
EXPECT_EQ(kNumElements - i, queue.size());
// Also check Equals.
EXPECT_TRUE(queue.FirstMin().Equals(pointers[kFirstMinOrder[i]]));
EXPECT_EQ(kFirstMinOrder[i], queue.FirstMin().value());
queue.Erase(queue.FirstMin());
}
CheckEmpty(&queue);
}
TEST(PriorityQueueTest, LastMinOrder) {
PriorityQueue<int> queue(kNumPriorities);
for (size_t i = 0; i < kNumElements; ++i) {
queue.Insert(static_cast<int>(i), kPriorities[i]);
}
for (size_t i = 0; i < kNumElements; ++i) {
EXPECT_EQ(kLastMinOrder[i], queue.LastMin().value());
queue.Erase(queue.LastMin());
}
CheckEmpty(&queue);
}
TEST(PriorityQueueTest, FirstMaxOrder) {
PriorityQueue<int> queue(kNumPriorities);
for (size_t i = 0; i < kNumElements; ++i) {
queue.Insert(static_cast<int>(i), kPriorities[i]);
}
for (size_t i = 0; i < kNumElements; ++i) {
EXPECT_EQ(kFirstMaxOrder[i], queue.FirstMax().value());
queue.Erase(queue.FirstMax());
}
CheckEmpty(&queue);
}
TEST(PriorityQueueTest, LastMaxOrder) {
PriorityQueue<int> queue(kNumPriorities);
for (size_t i = 0; i < kNumElements; ++i) {
queue.Insert(static_cast<int>(i), kPriorities[i]);
}
for (size_t i = 0; i < kNumElements; ++i) {
EXPECT_EQ(kLastMaxOrder[i], queue.LastMax().value());
queue.Erase(queue.LastMax());
}
CheckEmpty(&queue);
}
TEST(PriorityQueueTest, EraseFromMiddle) {
PriorityQueue<int> queue(kNumPriorities);
PriorityQueue<int>::Pointer pointers[kNumElements];
for (size_t i = 0; i < kNumElements; ++i) {
pointers[i] = queue.Insert(static_cast<int>(i), kPriorities[i]);
}
queue.Erase(pointers[2]);
queue.Erase(pointers[3]);
int expected_order[] = { 8, 1, 6, 0, 5, 4, 7 };
for (size_t i = 0; i < arraysize(expected_order); ++i) {
EXPECT_EQ(expected_order[i], queue.FirstMin().value());
queue.Erase(queue.FirstMin());
}
CheckEmpty(&queue);
}
} // namespace
} // namespace net
| 28.932331 | 73 | 0.66684 | Scopetta197 |
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 |
f0fc4510fda8347aa3457a957632461ac6db4a17 | 3,555 | cc | C++ | mojo/system/data_pipe_consumer_dispatcher.cc | SlimKatLegacy/android_external_chromium_org | ee480ef5039d7c561fc66ccf52169ead186f1bea | [
"BSD-3-Clause-No-Nuclear-License-2014",
"BSD-3-Clause"
] | 2 | 2015-03-04T02:36:53.000Z | 2016-06-25T11:22:17.000Z | mojo/system/data_pipe_consumer_dispatcher.cc | j4ckfrost/android_external_chromium_org | a1a3dad8b08d1fcf6b6b36c267158ed63217c780 | [
"BSD-3-Clause-No-Nuclear-License-2014",
"BSD-3-Clause"
] | null | null | null | mojo/system/data_pipe_consumer_dispatcher.cc | j4ckfrost/android_external_chromium_org | a1a3dad8b08d1fcf6b6b36c267158ed63217c780 | [
"BSD-3-Clause-No-Nuclear-License-2014",
"BSD-3-Clause"
] | 4 | 2015-02-09T08:49:30.000Z | 2017-08-26T02:03:34.000Z | // Copyright 2013 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "mojo/system/data_pipe_consumer_dispatcher.h"
#include "base/logging.h"
#include "mojo/system/data_pipe.h"
#include "mojo/system/memory.h"
namespace mojo {
namespace system {
DataPipeConsumerDispatcher::DataPipeConsumerDispatcher() {
}
void DataPipeConsumerDispatcher::Init(scoped_refptr<DataPipe> data_pipe) {
DCHECK(data_pipe.get());
data_pipe_ = data_pipe;
}
DataPipeConsumerDispatcher::~DataPipeConsumerDispatcher() {
// |Close()|/|CloseImplNoLock()| should have taken care of the pipe.
DCHECK(!data_pipe_.get());
}
void DataPipeConsumerDispatcher::CancelAllWaitersNoLock() {
lock().AssertAcquired();
data_pipe_->ConsumerCancelAllWaiters();
}
MojoResult DataPipeConsumerDispatcher::CloseImplNoLock() {
lock().AssertAcquired();
data_pipe_->ConsumerClose();
data_pipe_ = NULL;
return MOJO_RESULT_OK;
}
MojoResult DataPipeConsumerDispatcher::ReadDataImplNoLock(
void* elements,
uint32_t* num_elements,
MojoReadDataFlags flags) {
lock().AssertAcquired();
if (!VerifyUserPointer<uint32_t>(num_elements, 1))
return MOJO_RESULT_INVALID_ARGUMENT;
// These flags are mutally exclusive.
if ((flags & MOJO_READ_DATA_FLAG_DISCARD) &&
(flags & MOJO_READ_DATA_FLAG_QUERY))
return MOJO_RESULT_INVALID_ARGUMENT;
if ((flags & MOJO_READ_DATA_FLAG_DISCARD) ||
(flags & MOJO_READ_DATA_FLAG_QUERY)) {
DVLOG_IF(2, elements) << "Discard/query mode: ignoring non-null |elements|";
elements = NULL; // Null it out for safety.
} else {
// Only verify |elements| if we're neither discarding nor querying.
if (!VerifyUserPointerForSize(elements, data_pipe_->element_size(),
*num_elements))
return MOJO_RESULT_INVALID_ARGUMENT;
}
return data_pipe_->ConsumerReadData(elements, num_elements, flags);
}
MojoResult DataPipeConsumerDispatcher::BeginReadDataImplNoLock(
const void** buffer,
uint32_t* buffer_num_elements,
MojoReadDataFlags flags) {
lock().AssertAcquired();
if (!VerifyUserPointer<const void*>(buffer, 1))
return MOJO_RESULT_INVALID_ARGUMENT;
if (!VerifyUserPointer<uint32_t>(buffer_num_elements, 1))
return MOJO_RESULT_INVALID_ARGUMENT;
// These flags may not be used in two-phase mode.
if ((flags & MOJO_READ_DATA_FLAG_DISCARD) ||
(flags & MOJO_READ_DATA_FLAG_QUERY))
return MOJO_RESULT_INVALID_ARGUMENT;
return data_pipe_->ConsumerBeginReadData(buffer, buffer_num_elements, flags);
}
MojoResult DataPipeConsumerDispatcher::EndReadDataImplNoLock(
uint32_t num_elements_read) {
lock().AssertAcquired();
return data_pipe_->ConsumerEndReadData(num_elements_read);
}
MojoResult DataPipeConsumerDispatcher::AddWaiterImplNoLock(
Waiter* waiter,
MojoWaitFlags flags,
MojoResult wake_result) {
lock().AssertAcquired();
return data_pipe_->ConsumerAddWaiter(waiter, flags, wake_result);
}
void DataPipeConsumerDispatcher::RemoveWaiterImplNoLock(Waiter* waiter) {
lock().AssertAcquired();
data_pipe_->ConsumerRemoveWaiter(waiter);
}
scoped_refptr<Dispatcher>
DataPipeConsumerDispatcher::CreateEquivalentDispatcherAndCloseImplNoLock() {
lock().AssertAcquired();
scoped_refptr<DataPipeConsumerDispatcher> rv =
new DataPipeConsumerDispatcher();
rv->Init(data_pipe_);
data_pipe_ = NULL;
return scoped_refptr<Dispatcher>(rv.get());
}
} // namespace system
} // namespace mojo
| 30.646552 | 80 | 0.753305 | SlimKatLegacy |
f0fd2f238a433d471250797b76f06a9c20eff921 | 6,951 | cpp | C++ | Granite/third_party/oboe/src/common/AudioStream.cpp | dmrlawson/parallel-rdp | f18e00728bb45e3a769ab7ad3b9064359ef82209 | [
"MIT"
] | 1 | 2020-03-02T04:50:18.000Z | 2020-03-02T04:50:18.000Z | Granite/third_party/oboe/src/common/AudioStream.cpp | dmrlawson/parallel-rdp | f18e00728bb45e3a769ab7ad3b9064359ef82209 | [
"MIT"
] | null | null | null | Granite/third_party/oboe/src/common/AudioStream.cpp | dmrlawson/parallel-rdp | f18e00728bb45e3a769ab7ad3b9064359ef82209 | [
"MIT"
] | null | null | null | /*
* Copyright 2015 The Android Open Source Project
*
* 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 <sys/types.h>
#include <pthread.h>
#include <thread>
#include <oboe/AudioStream.h>
#include "OboeDebug.h"
#include "AudioClock.h"
#include <oboe/Utilities.h>
namespace oboe {
/*
* AudioStream
*/
AudioStream::AudioStream(const AudioStreamBuilder &builder)
: AudioStreamBase(builder) {
}
Result AudioStream::close() {
// Update local counters so they can be read after the close.
updateFramesWritten();
updateFramesRead();
return Result::OK;
}
DataCallbackResult AudioStream::fireDataCallback(void *audioData, int32_t numFrames) {
if (!isDataCallbackEnabled()) {
LOGW("AudioStream::%s() called with data callback disabled!", __func__);
return DataCallbackResult::Stop; // We should not be getting called any more.
}
// TODO remove
int scheduler = sched_getscheduler(0) & ~SCHED_RESET_ON_FORK; // for current thread
if (scheduler != mPreviousScheduler) {
LOGD("AudioStream::%s() scheduler = %s", __func__,
((scheduler == SCHED_FIFO) ? "SCHED_FIFO" :
((scheduler == SCHED_OTHER) ? "SCHED_OTHER" :
((scheduler == SCHED_RR) ? "SCHED_RR" : "UNKNOWN")))
);
mPreviousScheduler = scheduler;
}
DataCallbackResult result;
if (mStreamCallback == nullptr) {
result = onDefaultCallback(audioData, numFrames);
} else {
result = mStreamCallback->onAudioReady(this, audioData, numFrames);
}
// On Oreo, we might get called after returning stop.
// So block that here.
setDataCallbackEnabled(result == DataCallbackResult::Continue);
return result;
}
Result AudioStream::waitForStateTransition(StreamState startingState,
StreamState endingState,
int64_t timeoutNanoseconds)
{
StreamState state;
{
std::lock_guard<std::mutex> lock(mLock);
state = getState();
if (state == StreamState::Closed) {
return Result::ErrorClosed;
} else if (state == StreamState::Disconnected) {
return Result::ErrorDisconnected;
}
}
StreamState nextState = state;
// TODO Should this be a while()?!
if (state == startingState && state != endingState) {
Result result = waitForStateChange(state, &nextState, timeoutNanoseconds);
if (result != Result::OK) {
return result;
}
}
if (nextState != endingState) {
return Result::ErrorInvalidState;
} else {
return Result::OK;
}
}
Result AudioStream::start(int64_t timeoutNanoseconds)
{
Result result = requestStart();
if (result != Result::OK) return result;
if (timeoutNanoseconds <= 0) return result;
return waitForStateTransition(StreamState::Starting,
StreamState::Started, timeoutNanoseconds);
}
Result AudioStream::pause(int64_t timeoutNanoseconds)
{
Result result = requestPause();
if (result != Result::OK) return result;
if (timeoutNanoseconds <= 0) return result;
return waitForStateTransition(StreamState::Pausing,
StreamState::Paused, timeoutNanoseconds);
}
Result AudioStream::flush(int64_t timeoutNanoseconds)
{
Result result = requestFlush();
if (result != Result::OK) return result;
if (timeoutNanoseconds <= 0) return result;
return waitForStateTransition(StreamState::Flushing,
StreamState::Flushed, timeoutNanoseconds);
}
Result AudioStream::stop(int64_t timeoutNanoseconds)
{
Result result = requestStop();
if (result != Result::OK) return result;
if (timeoutNanoseconds <= 0) return result;
return waitForStateTransition(StreamState::Stopping,
StreamState::Stopped, timeoutNanoseconds);
}
int32_t AudioStream::getBytesPerSample() const {
return convertFormatToSizeInBytes(mFormat);
}
int64_t AudioStream::getFramesRead() {
updateFramesRead();
return mFramesRead;
}
int64_t AudioStream::getFramesWritten() {
updateFramesWritten();
return mFramesWritten;
}
ResultWithValue<int32_t> AudioStream::getAvailableFrames() {
int64_t readCounter = getFramesRead();
if (readCounter < 0) return ResultWithValue<int32_t>::createBasedOnSign(readCounter);
int64_t writeCounter = getFramesWritten();
if (writeCounter < 0) return ResultWithValue<int32_t>::createBasedOnSign(writeCounter);
int32_t framesAvailable = writeCounter - readCounter;
return ResultWithValue<int32_t>(framesAvailable);
}
ResultWithValue<int32_t> AudioStream::waitForAvailableFrames(int32_t numFrames,
int64_t timeoutNanoseconds) {
if (numFrames == 0) return Result::OK;
if (numFrames < 0) return Result::ErrorOutOfRange;
int64_t framesAvailable = 0;
int64_t burstInNanos = getFramesPerBurst() * kNanosPerSecond / getSampleRate();
bool ready = false;
int64_t deadline = AudioClock::getNanoseconds() + timeoutNanoseconds;
do {
ResultWithValue<int32_t> result = getAvailableFrames();
if (!result) return result;
framesAvailable = result.value();
ready = (framesAvailable >= numFrames);
if (!ready) {
int64_t now = AudioClock::getNanoseconds();
if (now > deadline) break;
AudioClock::sleepForNanos(burstInNanos);
}
} while (!ready);
return (!ready)
? ResultWithValue<int32_t>(Result::ErrorTimeout)
: ResultWithValue<int32_t>(framesAvailable);
}
ResultWithValue<FrameTimestamp> AudioStream::getTimestamp(clockid_t clockId) {
FrameTimestamp frame;
Result result = getTimestamp(clockId, &frame.position, &frame.timestamp);
if (result == Result::OK){
return ResultWithValue<FrameTimestamp>(frame);
} else {
return ResultWithValue<FrameTimestamp>(static_cast<Result>(result));
}
}
static void oboe_stop_thread_proc(AudioStream *oboeStream) {
LOGD("%s() called ----)))))", __func__);
if (oboeStream != nullptr) {
oboeStream->requestStop();
}
LOGD("%s() returning (((((----", __func__);
}
void AudioStream::launchStopThread() {
// Stop this stream on a separate thread
std::thread t(oboe_stop_thread_proc, this);
t.detach();
}
} // namespace oboe
| 32.787736 | 91 | 0.664796 | dmrlawson |
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 <davide.pesavento@lip6.fr>
*/
#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 |
0b024a0f19c9581d2c2227304f5e2d215c992612 | 3,716 | cc | C++ | src/shared/profiler_malloc.cc | schinmayee/nimbus | 170cd15e24a7a88243a6ea80aabadc0fc0e6e177 | [
"BSD-3-Clause"
] | 20 | 2017-07-03T19:09:09.000Z | 2021-09-10T02:53:56.000Z | src/shared/profiler_malloc.cc | schinmayee/nimbus | 170cd15e24a7a88243a6ea80aabadc0fc0e6e177 | [
"BSD-3-Clause"
] | null | null | null | src/shared/profiler_malloc.cc | schinmayee/nimbus | 170cd15e24a7a88243a6ea80aabadc0fc0e6e177 | [
"BSD-3-Clause"
] | 9 | 2017-09-17T02:05:06.000Z | 2020-01-31T00:12:01.000Z | /*
* Copyright 2013 Stanford University.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* - Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* - Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the
* distribution.
*
* - Neither the name of the copyright holders nor the names of
* its contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
* THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
* INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
* OF THE POSSIBILITY OF SUCH DAMAGE.
*/
/*
* Author: Andrew Lim <alim16@stanford.edu>
*
* Routines to log memory allocations on a per thread basis.
*/
#ifdef __MACH__
#include <malloc/malloc.h>
#else
#include <malloc.h>
#endif
#include <stdlib.h>
#include <stdio.h>
#include <dlfcn.h>
#include <assert.h>
#include <signal.h>
#include <string.h>
#include "src/shared/profiler_malloc.h"
namespace nimbus {
__thread size_t curr_alloc = 0;
__thread size_t max_alloc = 0;
__thread size_t base_alloc = 0;
void ProfilerMalloc::AddPointerToThreadLocalData(void *ptr) {
#ifdef __MACH__
size_t size = malloc_size(ptr);
#else
size_t size = malloc_usable_size(ptr);
#endif
curr_alloc += size;
if (curr_alloc > max_alloc) {
max_alloc = curr_alloc;
}
}
void ProfilerMalloc::RemovePointerFromThreadLocalData(void *ptr) {
#ifdef __MACH__
size_t size = malloc_size(ptr);
#else
size_t size = malloc_usable_size(ptr);
#endif
curr_alloc -= size;
}
void ProfilerMalloc::ResetBaseAlloc() {
base_alloc = curr_alloc;
max_alloc = curr_alloc;
}
size_t ProfilerMalloc::GetMaxAlloc() {
return max_alloc - base_alloc;
}
size_t ProfilerMalloc::GetCurrAlloc() {
return curr_alloc;
}
size_t ProfilerMalloc::GetBaseAlloc() {
return base_alloc;
}
void *ProfilerMalloc::p_malloc(size_t size) {
static void *(*mallocp)(size_t size) = NULL;
char *error;
void *ptr;
if (!mallocp) {
mallocp = reinterpret_cast<void *(*)(size_t size)>(dlsym(RTLD_NEXT, "malloc"));
if ((error = dlerror()) != NULL) {
fputs(error, stderr);
exit(1);
}
}
ptr = mallocp(size);
ProfilerMalloc::AddPointerToThreadLocalData(ptr);
return ptr;
}
void ProfilerMalloc::p_free(void *ptr) {
static void (*freep)(void *ptr) = NULL;
char *error;
if (!freep) {
freep = reinterpret_cast<void (*)(void *ptr)>(dlsym(RTLD_NEXT, "free"));
if ((error = dlerror()) != NULL) {
fputs(error, stderr);
exit(1);
}
}
ProfilerMalloc::RemovePointerFromThreadLocalData(ptr);
freep(ptr);
}
} // namespace nimbus
| 28.366412 | 85 | 0.69887 | schinmayee |
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 |
0b04566b87dd10078c7ed7b6a16c0cdd7458c276 | 7,075 | cc | C++ | src/hw/gps/ubx.cc | ParikhKadam/cycloid | c5e64e8379f801417a38755eb6b2fde881dabd8c | [
"MIT"
] | 156 | 2017-08-12T03:58:21.000Z | 2022-03-21T13:38:52.000Z | src/hw/gps/ubx.cc | ParikhKadam/cycloid | c5e64e8379f801417a38755eb6b2fde881dabd8c | [
"MIT"
] | 3 | 2018-12-11T11:31:06.000Z | 2019-12-05T18:43:51.000Z | src/hw/gps/ubx.cc | ParikhKadam/cycloid | c5e64e8379f801417a38755eb6b2fde881dabd8c | [
"MIT"
] | 18 | 2017-08-17T02:05:54.000Z | 2022-02-24T20:54:27.000Z | #include <fcntl.h>
#include <math.h>
#include <stdio.h>
#include <string.h>
#include <sys/ioctl.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <sys/uio.h>
#include <termios.h>
#include <unistd.h>
#include "hw/gps/ubx.h"
const char ubx_port[] = "/dev/serial0";
#define startup_ioctl_baud B9600
#define runtime_baudrate 115200
#define runtime_ioctl_baud B115200
namespace {
void nmea_sendmsg(int fd, const char *msg) {
int i, cksum = 0, len = strlen(msg);
char footer[6];
for (i = 1; i < len; i++)
cksum ^= msg[i];
snprintf(footer, sizeof(footer), "*%02x\r\n", cksum);
write(fd, msg, len);
write(fd, footer, 5);
}
void ubx_sendmsg(int fd, int msg_class, int msg_id, uint8_t *msg, int msg_len) {
static uint8_t header[6] = {0xb5, 0x62}, footer[2];
static struct iovec iov[3] = {{header, 6}, {0, 0}, {footer, 2}};
uint8_t cka, ckb;
int i;
iov[1].iov_base = msg;
iov[1].iov_len = msg_len;
header[2] = msg_class;
cka = ckb = msg_class;
header[3] = msg_id;
cka += msg_id;
ckb += cka;
header[4] = msg_len & 0xff;
cka += header[4];
ckb += cka;
header[5] = msg_len >> 8;
cka += header[5];
ckb += cka;
for (i = 0; i < msg_len; i++) {
cka += msg[i];
ckb += cka;
}
footer[0] = cka;
footer[1] = ckb;
int len = writev(fd, iov, 3);
#if 0
for (i = 0; i < 6; i++)
printf("%02x ", header[i]);
printf("| ");
for (i = 0; i < msg_len; i++)
printf("%02x ", msg[i]);
printf("| ");
printf("%02x %02x -- wrote %d\n", footer[0], footer[1], len);
#endif
if (len == -1) {
perror("ubx_sendmsg: writev");
}
}
void ubx_enable_periodic(int fd, uint8_t msgclass, uint8_t msgid, uint8_t enable) {
fprintf(stderr, "%sabling (%d,%d)\n", enable ? "en" : "dis",
msgclass, msgid);
// now, CFG-MSG and set NAV-SOL output on every epoch
uint8_t cfg_msg[] = {
msgclass, msgid, // class/id of NAV-POSLLH
0, enable, 0, 0, 0, 0 // output once per epoch on port 1
};
ubx_sendmsg(fd, 6, 1, cfg_msg, 8);
}
void process_msg(int fd, int msg_class, int msg_id, uint8_t *msgbuf,
int msg_length, NavListener *listener) {
int i;
switch ((msg_class << 8) + msg_id) {
case 0x0101: // NAV-POSECEF
{
// struct nav_posecef *navmsg = (struct nav_posecef *)msgbuf;
// on_ecef(navmsg);
} break;
case 0x0102: // NAV-POSLLH (ignored)
break;
case 0x0107: // NAV-PVT
{
const struct nav_pvt *navmsg = (struct nav_pvt *)msgbuf;
listener->OnNav(*navmsg);
break;
}
case 0x0501: // ACK
case 0x0500: // NAK
fprintf(stderr, "%s (%d,%d)\n", msg_id == 1 ? "ack" : "nak", msgbuf[0],
msgbuf[1]);
break;
default:
fprintf(stderr, "read msg (%02x,%02x): ", msg_class, msg_id);
for (i = 0; i < msg_length; i++) fprintf(stderr, "%02x ", msgbuf[i]);
fprintf(stderr, "\n");
// diable unknown messages?
// ubx_enable_periodic(fd, msg_class, msg_id, 0);
}
}
void init_ubx_protocol(int fd) {
struct termios tios;
tcgetattr(fd, &tios);
// disable flow control and all that, and ignore break and parity errors
tios.c_iflag = IGNBRK | IGNPAR;
tios.c_oflag = 0;
tios.c_lflag = 0;
cfsetspeed(&tios, startup_ioctl_baud);
tcsetattr(fd, TCSAFLUSH, &tios);
// the serial port has a brief glitch once we turn it on which generates a
// start bit; sleep for 1ms to let it settle
usleep(10000);
write(fd, "\r\n\r\n", 4);
// now send baudrate-changing message
char nmeamsg[256];
snprintf(nmeamsg, sizeof(nmeamsg),
"$PUBX,41,1,0007,0001,%d,0", runtime_baudrate);
nmea_sendmsg(fd, nmeamsg);
// add some guard time before and after changing baud rates
usleep(100000);
cfsetspeed(&tios, runtime_ioctl_baud);
tcsetattr(fd, TCSADRAIN, &tios);
}
} // empty namespace
int ubx_open() {
int fd = open(ubx_port, O_RDWR);
if (fd == -1) {
perror(ubx_port);
return -1;
}
init_ubx_protocol(fd);
close(fd);
fd = open(ubx_port, O_RDWR);
if (fd == -1) {
perror(ubx_port);
return -1;
}
// ubx_sendmsg(fd, 6, 6, NULL, 0);
// ubx-cfg-rate
uint8_t msgbuf[6] = {100, 0, 1, 0, 0, 0}; // 100ms measurements, one solution per measurement, UTC timeref
ubx_sendmsg(fd, 6, 8, msgbuf, 6);
// ubx_enable_periodic(fd, 1, 2, 1); // enable NAV-POSLLH
// ubx_enable_periodic(fd, 1, 1, 1); // enable NAV-POSECEF
ubx_enable_periodic(fd, 1, 7, 1); // enable UBX-NAV-PVT
return fd;
}
void ubx_read_loop(int fd, NavListener *listener) {
uint8_t buf[512];
static uint8_t msgbuf[512];
static int read_state = 0;
static unsigned msg_length = 0, msg_ptr = 0;
static int msg_cls = 0, msg_id = 0;
static uint8_t msg_cka = 0, msg_ckb = 0;
for (;;) {
int len = read(fd, buf, sizeof(buf));
int i;
if (len == -1) {
perror("read");
return;
}
for (i = 0; i < len; i++) {
// printf("%02x ", buf[i]);
if (read_state > 1 && read_state < 7) {
msg_cka += buf[i];
msg_ckb += msg_cka;
}
switch (read_state) {
case 0:
if (buf[i] == 0xb5) {
read_state++;
} else {
putchar(buf[i]);
fflush(stdout);
}
break;
case 1:
if (buf[i] == 0x62)
read_state++;
else if (buf[i] != 0xb5)
read_state = 0;
msg_cka = 0;
msg_ckb = 0;
break;
case 2:
msg_cls = buf[i];
read_state++;
break;
case 3:
msg_id = buf[i];
read_state++;
break;
case 4:
msg_length = buf[i];
read_state++;
break;
case 5:
msg_length += buf[i] << 8;
read_state++;
msg_ptr = 0;
if (msg_length > sizeof(msgbuf)) {
fprintf(stderr,
"discarding (%02x,%02x) message of length %d "
"(buffer is %d)\n",
msg_cls, msg_id, msg_length, sizeof(msgbuf));
read_state = 0;
}
if (msg_length == 0) read_state++; // skip payload read
break;
case 6:
msgbuf[msg_ptr++] = buf[i];
if (msg_ptr == msg_length) read_state++;
break;
case 7:
if (msg_cka != buf[i]) {
fprintf(stderr,
"discarding (%02x,%02x) message; "
"cka mismatch (got %02x calc'd %02x)\n",
msg_cls, msg_id, buf[i], msg_cka);
read_state = 0;
} else {
read_state++;
}
break;
case 8:
if (msg_ckb != buf[i]) {
fprintf(stderr,
"discarding (%02x,%02x) message; "
"cka mismatch (got %02x calc'd %02x)\n",
msg_cls, msg_id, buf[i], msg_cka);
} else {
process_msg(fd, msg_cls, msg_id, msgbuf, msg_length, listener);
}
read_state = 0;
break;
}
}
// printf("\n");
}
}
| 27.10728 | 109 | 0.541767 | ParikhKadam |
0b060e2e11c0ce98e035b4e8b4d0c85e1bf3be5d | 637 | hpp | C++ | contrib/libboost/boost_1_62_0/boost/exception/errinfo_type_info_name.hpp | 189569400/ClickHouse | 0b8683c8c9f0e17446bef5498403c39e9cb483b8 | [
"Apache-2.0"
] | 12,278 | 2015-01-29T17:11:33.000Z | 2022-03-31T21:12:00.000Z | contrib/libboost/boost_1_62_0/boost/exception/errinfo_type_info_name.hpp | 189569400/ClickHouse | 0b8683c8c9f0e17446bef5498403c39e9cb483b8 | [
"Apache-2.0"
] | 9,469 | 2015-01-30T05:33:07.000Z | 2022-03-31T16:17:21.000Z | contrib/libboost/boost_1_62_0/boost/exception/errinfo_type_info_name.hpp | 189569400/ClickHouse | 0b8683c8c9f0e17446bef5498403c39e9cb483b8 | [
"Apache-2.0"
] | 1,343 | 2017-12-08T19:47:19.000Z | 2022-03-26T11:31:36.000Z | //Copyright (c) 2006-2009 Emil Dotchevski and Reverge Studios, Inc.
//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 UUID_0E11109E6C1311DEB7EA649255D89593
#define UUID_0E11109E6C1311DEB7EA649255D89593
#include <string>
namespace
boost
{
template <class Tag,class T> class error_info;
//Usage hint:
//BOOST_THROW_EXCEPTION(
// bad_type() <<
// errinfo_type_info_name(typeid(x).name()) );
typedef error_info<struct errinfo_type_info_name_,std::string> errinfo_type_info_name;
}
#endif
| 26.541667 | 90 | 0.742543 | 189569400 |
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 |
0b08f7507a5c8d9dbc4602e6e7ffccd4343cc915 | 3,181 | cpp | C++ | TAO/orbsvcs/orbsvcs/AV/Policy.cpp | cflowe/ACE | 5ff60b41adbe1772372d1a43bcc1f2726ff8f810 | [
"DOC"
] | 36 | 2015-01-10T07:27:33.000Z | 2022-03-07T03:32:08.000Z | TAO/orbsvcs/orbsvcs/AV/Policy.cpp | cflowe/ACE | 5ff60b41adbe1772372d1a43bcc1f2726ff8f810 | [
"DOC"
] | 2 | 2018-08-13T07:30:51.000Z | 2019-02-25T03:04:31.000Z | TAO/orbsvcs/orbsvcs/AV/Policy.cpp | cflowe/ACE | 5ff60b41adbe1772372d1a43bcc1f2726ff8f810 | [
"DOC"
] | 38 | 2015-01-08T14:12:06.000Z | 2022-01-19T08:33:00.000Z | // $Id: Policy.cpp 97014 2013-04-12 22:47:02Z mitza $
#include "orbsvcs/Log_Macros.h"
#include "orbsvcs/Log_Macros.h"
#include "orbsvcs/AV/FlowSpec_Entry.h"
#include "tao/debug.h"
#include "orbsvcs/AV/Policy.h"
#if !defined(__ACE_INLINE__)
#include "orbsvcs/AV/Policy.inl"
#endif /* __ACE_INLINE__ */
TAO_BEGIN_VERSIONED_NAMESPACE_DECL
TAO_AV_Policy::TAO_AV_Policy (CORBA::ULong type)
:type_ (type)
{
}
TAO_AV_SSRC_Policy::TAO_AV_SSRC_Policy (CORBA::ULong ssrc)
:TAO_AV_Policy (TAO_AV_SSRC_POLICY),
ssrc_ (ssrc)
{
}
TAO_AV_Payload_Type_Policy::TAO_AV_Payload_Type_Policy (int payload_type)
:TAO_AV_Policy (TAO_AV_PAYLOAD_TYPE_POLICY),
payload_type_ (payload_type)
{
}
// TAO_AV_RTP_Sdes_Policy
TAO_AV_RTCP_Sdes_Policy::TAO_AV_RTCP_Sdes_Policy (void)
:TAO_AV_Policy (TAO_AV_RTCP_SDES_POLICY)
{
}
TAO_AV_SFP_Credit_Policy::TAO_AV_SFP_Credit_Policy (void)
:TAO_AV_Policy (TAO_AV_SFP_CREDIT_POLICY)
{
}
// TAO_AV_Callback
TAO_AV_Callback::TAO_AV_Callback (void)
:protocol_object_ (0)
{
}
TAO_AV_Callback::~TAO_AV_Callback (void)
{
}
int
TAO_AV_Callback::open (TAO_AV_Protocol_Object *object,
TAO_AV_Flow_Handler *handler)
{
this->protocol_object_ = object;
this->handler_ = handler;
handler->callback (this);
return 0;
}
int
TAO_AV_Callback::handle_start (void)
{
if (TAO_debug_level > 0) ORBSVCS_DEBUG ((LM_DEBUG,"TAO_AV_Callback::handle_start\n"));
return -1;
}
int
TAO_AV_Callback::handle_stop (void)
{
if (TAO_debug_level > 0) ORBSVCS_DEBUG ((LM_DEBUG,"TAO_AV_Callback::handle_stop\n"));
return -1;
}
int
TAO_AV_Callback::receive_frame (ACE_Message_Block * /*frame*/,
TAO_AV_frame_info *,
const ACE_Addr &)
{
if (TAO_debug_level > 0) ORBSVCS_DEBUG ((LM_DEBUG,"TAO_AV_Callback::receive_frame\n"));
return -1;
}
int
TAO_AV_Callback::receive_control_frame (ACE_Message_Block *,
const ACE_Addr& )
{
return 0;
}
int
TAO_AV_Callback::handle_destroy (void)
{
if (TAO_debug_level > 0) ORBSVCS_DEBUG ((LM_DEBUG,"TAO_AV_Callback::handle_end_stream\n"));
return -1;
}
void
TAO_AV_Callback::get_timeout (ACE_Time_Value *& tv,
void *& /*arg*/)
{
if (TAO_debug_level > 0) ORBSVCS_DEBUG ((LM_DEBUG,"TAO_AV_Callback::get_timeout\n"));
tv = 0;
}
int
TAO_AV_Callback::handle_timeout (void * /*arg*/)
{
if (TAO_debug_level > 0) ORBSVCS_DEBUG ((LM_DEBUG,"TAO_AV_Callback::handle_timeout\n"));
return 0;
}
TAO_AV_PolicyList
TAO_AV_Callback::get_policies (void)
{
TAO_AV_PolicyList list;
return list;
}
// TAO_AV_Transport*
// TAO_AV_Callback::transport (void)
// {
// return this->transport_;
// }
// void
// TAO_AV_Callback::transport (TAO_AV_Transport *transport)
// {
// this->transport_ = transport;
// }
TAO_AV_Protocol_Object*
TAO_AV_Callback::protocol_object (void)
{
return this->protocol_object_;
}
// void
// TAO_AV_Callback::protocol_object (TAO_AV_Protocol_Object *object)
// {
// this->protocol_object_ = object;
// }
int
TAO_AV_Callback::schedule_timer (void)
{
return this->handler_->schedule_timer ();
}
TAO_END_VERSIONED_NAMESPACE_DECL
| 20.79085 | 93 | 0.710468 | cflowe |
0b0d8f7917328a85b50222a7c31c890ef288ef64 | 2,472 | cc | C++ | Laboratorio/Esercitazione 10/1006-statistiche.cc | alessiamarcolini/Programmazione1UniTN | fd1cbd54b9510e1ec7efb185b727a6fd49dd32f1 | [
"MIT"
] | 3 | 2021-11-05T16:25:50.000Z | 2022-02-10T14:06:00.000Z | Laboratorio/Esercitazione 10/1006-statistiche.cc | alessiamarcolini/Programmazione1UniTN | fd1cbd54b9510e1ec7efb185b727a6fd49dd32f1 | [
"MIT"
] | null | null | null | Laboratorio/Esercitazione 10/1006-statistiche.cc | alessiamarcolini/Programmazione1UniTN | fd1cbd54b9510e1ec7efb185b727a6fd49dd32f1 | [
"MIT"
] | 2 | 2018-10-31T14:53:40.000Z | 2020-01-09T22:34:37.000Z | /*
Implementare un programma che, acquisito dall'utente un numero
intero di anni, generi in maniera casuale delle statistiche
mese per mese relative ad un certo indicatore, per tutti gli anni
considerati, e che calcoli e stampi la media dei valori su ciascun
anno per ogni mese.
Si considerino i valori mensili distribuiti uniformemente
sull'intervallo [50, 100).
*/
#include <cstdlib>
#include <iomanip>
#include <iostream>
using namespace std;
const int MESI = 12;
const int MIN_RANDOM = 50;
const int MAX_RANDOM = 100;
int main(int argc, char* argv[]) {
int anni;
cout << "Quanti anni considerare? ";
// Test di controllo sull'input
do {
cin >> anni;
if (anni < 1) {
cout << "Introdurre un numero positivo.\nn = ";
}
} while (anni < 1);
// Allocazione dinamica: prima si allocano "anni" righe
float** risultati = new float*[anni];
for (int i = 0; i < anni; i++) {
// Successivamente, ogni riga avra' "MESI" colonne
risultati[i] = new float[MESI];
}
// Popoliamo la matrice dinamica con valori casuali
// Inizializzo il generatore dei numeri casuali
srand(time(NULL));
for (int i = 0; i < anni; i++) {
for (int j = 0; j < MESI; j++) {
// Genera un valore casuale compreso tra
// "MIN_RANDOM.00" e "MAX_RANDOM.00"
risultati[i][j] = (rand() % (MAX_RANDOM - MIN_RANDOM) + MIN_RANDOM) / 100.0;
}
}
// Ora calcoliamo le medie mensili sul periodo
// preso in considerazione
float medie[MESI] = {};
// Attenzione, qui scorriamo per colonne e per righe
for (int i = 0; i < MESI; i++) {
// Prima sommiamo tutti i valori del mese corrispondente
for (int j = 0; j < anni; j++) {
medie[i] += risultati[j][i];
}
// Poi dividiamo per il numero di anni trascorso
medie[i] /= (float)anni;
}
// Stampiamo i risultati
cout << "Medie periodo: \nGen Feb Mar Apr "
<< "Mag Giu Lug Ago Set "
<< "Ott Nov Dic\n";
int i;
for (i = 0; i < MESI - 1; i++) {
cout << setw(7) << medie[i] << " ";
}
cout << setw(7) << medie[i] << "\n";
// Deallocazione dinamica: prima si deallocano le righe
for (int i = 0; i < anni; i++) {
delete risultati[i];
}
// Poi si dealloca la matrice
delete[] risultati;
return 0;
}
| 32.526316 | 88 | 0.571602 | alessiamarcolini |
0b114f6c954e6c63cf222b71e85f9725168a292a | 2,595 | cpp | C++ | modules/TLopen.cpp | rbondesan/loop_htbl_arn | 26f9c580ae6f36ca8f7ac86cdc8339923df56f9b | [
"MIT"
] | null | null | null | modules/TLopen.cpp | rbondesan/loop_htbl_arn | 26f9c580ae6f36ca8f7ac86cdc8339923df56f9b | [
"MIT"
] | null | null | null | modules/TLopen.cpp | rbondesan/loop_htbl_arn | 26f9c580ae6f36ca8f7ac86cdc8339923df56f9b | [
"MIT"
] | null | null | null | #include "TLopen.hpp"
//////////////////////////////////////////////////////////////
// //
// Methods of class TLopen //
// //
//////////////////////////////////////////////////////////////
// ----------> Class: TLopen
// ----------> Function name: TLopen
// ----------> Description: Calls Hamiltonian constructor with pars
//
TLopen::TLopen(const Parameters& pars) : Hamiltonian (pars)
{
cout << "Inside TLopen constructor" << endl;
}
// ----------> Class: TLopen
// ----------> Function name: ~TLopen
// ----------> Description: Destructor
//
TLopen::~TLopen()
{
cout << "Inside TLopen destructor" << endl;
}
// ----------> Class: TLopen
// ----------> Function name: act
// ----------> Description: act with the Hamiltonian, on states of position
// cur_state. Then update states and add the non
// zero element in tmp_nzval, tmp_irow and tmp_col
//
//
int TLopen::act(size_t cur_state, LoopHtblStates &states,
vector< complex<double> > &tmp_nzval, vector<int> &tmp_irow,
vector<int> &tmp_pcol)
{
VecIntCoeff in_conf_coeff;
VecIntCoeff out_conf_coeff;
size_t start, end;
size_t i;
int first_pos_col;
// Set tmp_col: it is the pointer to the values of tmp_nzval and
// tmp_irow in column cur_state.
// Hamiltonian::act acts on the given column cur_state
tmp_pcol.push_back(tmp_nzval.size());
first_pos_col = tmp_pcol.at( tmp_pcol.size()-1 );
//If lbndles_symm symmetrize before acting with H
in_conf_coeff.conf = states.get_conf_at(cur_state);
in_conf_coeff.coeff = 1;
start = 0;
end = 2*L-1;
for (i = start; i < end; i ++)
{
actTL(i, i+1, in_conf_coeff, out_conf_coeff,-1);
#ifdef DEBUG
for (size_t j = 0; j < n_conf; j++)
cout << "in_conf[" << j << "] = " << (in_conf_coeff.conf).at(j)
<< endl;
cout << "in coeff " << (in_conf_coeff).coeff << endl;
for (size_t j = 0; j < n_conf; j++)
cout << "act TL " << i << ": out_conf[" << j << "] = "
<< (out_conf_coeff.conf).at(j) << endl;
cout << "coeff " << out_conf_coeff.coeff << endl;
#endif
fill_nzval(states, (out_conf_coeff).conf, (out_conf_coeff).coeff,
tmp_nzval, tmp_irow, first_pos_col);
}
// Sort tmp_irow and adjust corresponding nzval,
// needed by the diagonalization routines
quicksort_array_val(tmp_irow, tmp_nzval, tmp_pcol.at(cur_state), tmp_irow.size()-1);
return 0;
}
| 32.4375 | 86 | 0.541426 | rbondesan |
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 |
0b177a0b7195a89514558fc79e9d7c9fbef46604 | 877 | cc | C++ | src/nn/nnjm_abstract.cc | nrc-cnrc/Portage-SMT-TAS | 73f5a65de4adfa13008ea9a01758385c97526059 | [
"MIT"
] | null | null | null | src/nn/nnjm_abstract.cc | nrc-cnrc/Portage-SMT-TAS | 73f5a65de4adfa13008ea9a01758385c97526059 | [
"MIT"
] | null | null | null | src/nn/nnjm_abstract.cc | nrc-cnrc/Portage-SMT-TAS | 73f5a65de4adfa13008ea9a01758385c97526059 | [
"MIT"
] | null | null | null | /**
* @author Colin Cherry
* @file nnjm_abstract.cc Interface to evaluate an nnjm
*
* Technologies langagieres interactives / Interactive Language Technologies
* Inst. de technologie de l'information / Institute for Information Technology
* Conseil national de recherches Canada / National Research Council Canada
* Copyright 2014, Sa Majeste la Reine du Chef du Canada /
* Copyright 2014, Her Majesty in Right of Canada
*/
#include "nnjm_abstract.h"
//#include "nnjm_pywrap.h"
#include "nnjm_native.h"
using namespace Portage;
/*
NNJMAbstract* NNJMs::new_PyWrap(const std::string& modelfile, Uint swin_size, Uint ng_size, Uint format) {
return new NNJMPyWrap(modelfile, swin_size, ng_size, format);
}
*/
NNJMAbstract* NNJMs::new_Native(const std::string& modelfile, bool selfnorm, bool useLookup) {
return new NNJMNative(modelfile, selfnorm, useLookup);
}
| 32.481481 | 106 | 0.761688 | nrc-cnrc |
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 |
0b1efb0d841b9ce6349d0438fa7eb825c18491f4 | 516 | cpp | C++ | Algorithms/503.Next-Greater-Element-II/solution.cpp | moranzcw/LeetCode_Solutions | 49a7e33b83d8d9ce449c758717f74a69e72f808e | [
"MIT"
] | 178 | 2017-07-09T23:13:11.000Z | 2022-02-26T13:35:06.000Z | Algorithms/503.Next-Greater-Element-II/solution.cpp | cfhyxxj/LeetCode-NOTES | 455d33aae54d065635d28ebf37f815dc4ace7e63 | [
"MIT"
] | 1 | 2020-10-10T16:38:03.000Z | 2020-10-10T16:38:03.000Z | Algorithms/503.Next-Greater-Element-II/solution.cpp | cfhyxxj/LeetCode-NOTES | 455d33aae54d065635d28ebf37f815dc4ace7e63 | [
"MIT"
] | 82 | 2017-08-19T07:14:39.000Z | 2022-02-17T14:07:55.000Z | class Solution {
public:
vector<int> nextGreaterElements(vector<int>& nums) {
vector<int> max;
for(int i=0;i<nums.size();i++){
int find = false;
for(int j=(i+1)%nums.size();j!=i;j=(j+1)%nums.size()){
if(nums[j] > nums[i]){
max.push_back(nums[j]);
find = true;
break;
}
}
if(!find)
max.push_back( -1);
}
return max;
}
};
| 25.8 | 66 | 0.391473 | moranzcw |
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 (song@eecs.berkeley.edu)
* 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 |
0b233bce7a075cb95712345e135987d7efe1129e | 4,133 | cc | C++ | src/connectivity/overnet/deprecated/lib/links/packet_stuffer_test.cc | OpenTrustGroup/fuchsia | 647e593ea661b8bf98dcad2096e20e8950b24a97 | [
"BSD-3-Clause"
] | 1 | 2019-04-21T18:02:26.000Z | 2019-04-21T18:02:26.000Z | src/connectivity/overnet/deprecated/lib/links/packet_stuffer_test.cc | OpenTrustGroup/fuchsia | 647e593ea661b8bf98dcad2096e20e8950b24a97 | [
"BSD-3-Clause"
] | 16 | 2020-09-04T19:01:11.000Z | 2021-05-28T03:23:09.000Z | src/connectivity/overnet/deprecated/lib/links/packet_stuffer_test.cc | OpenTrustGroup/fuchsia | 647e593ea661b8bf98dcad2096e20e8950b24a97 | [
"BSD-3-Clause"
] | null | null | null | // Copyright 2019 The Fuchsia Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "src/connectivity/overnet/deprecated/lib/links/packet_stuffer.h"
#include <gtest/gtest.h>
#include "src/connectivity/overnet/deprecated/lib/testing/test_timer.h"
namespace overnet {
namespace packet_stuffer_test {
constexpr TimeStamp kDummyTimestamp123 = TimeStamp::AfterEpoch(TimeDelta::FromMicroseconds(123));
Message DummyMessage() {
return Message{
std::move(RoutableMessage(NodeId(1)).AddDestination(NodeId(2), StreamId(1), SeqNum(1, 1))),
ForwardingPayloadFactory(Slice::FromContainer({1, 2, 3})), kDummyTimestamp123};
}
template <class T>
void IgnoreResult(T&& value) {}
TEST(PacketStuffer, NoOp) { PacketStuffer stuffer(NodeId(1), NodeId(2)); }
TEST(PacketStuffer, ForwardReturnValue) {
PacketStuffer stuffer(NodeId(1), NodeId(2));
EXPECT_TRUE(stuffer.Forward(DummyMessage()));
EXPECT_FALSE(stuffer.Forward(DummyMessage()));
}
TEST(PacketStuffer, CanDropMessages) {
PacketStuffer stuffer(NodeId(1), NodeId(2));
EXPECT_FALSE(stuffer.HasPendingMessages());
EXPECT_TRUE(stuffer.Forward(DummyMessage()));
EXPECT_TRUE(stuffer.HasPendingMessages());
stuffer.DropPendingMessages();
EXPECT_FALSE(stuffer.HasPendingMessages());
}
struct PacketVerificationArgs {
std::vector<Slice> messages;
size_t max_serialize_length;
Slice expected_bytes;
};
struct PacketStufferSerialization : public ::testing::TestWithParam<PacketVerificationArgs> {};
TEST_P(PacketStufferSerialization, Write) {
PacketStuffer stuffer(NodeId(1), NodeId(2));
int i = 0;
for (auto msg : GetParam().messages) {
IgnoreResult(stuffer.Forward(
Message{std::move(RoutableMessage(NodeId(1)).AddDestination(
NodeId(3), StreamId(1), SeqNum(i++, GetParam().messages.size()))),
ForwardingPayloadFactory(msg), kDummyTimestamp123}));
}
EXPECT_EQ(stuffer.BuildPacket(LazySliceArgs{Border::None(), GetParam().max_serialize_length}),
GetParam().expected_bytes);
}
TEST_P(PacketStufferSerialization, Read) {
TestTimer timer;
Router router(&timer, NodeId(2), false);
std::vector<Slice> got_messages;
class MockLink final : public Link {
public:
MockLink(std::vector<Slice>* got_messages) : got_messages_(got_messages) {}
void Close(Callback<void> quiesced) override {}
fuchsia::overnet::protocol::LinkStatus GetLinkStatus() override {
return fuchsia::overnet::protocol::LinkStatus{NodeId(2).as_fidl(), NodeId(3).as_fidl(), 1, 1};
}
const LinkStats* GetStats() const override { return nullptr; }
void Forward(Message message) override {
EXPECT_EQ(message.header.src(), NodeId(1));
EXPECT_EQ(message.header.destinations().size(), size_t(1));
EXPECT_EQ(message.header.destinations()[0].dst(), NodeId(3));
got_messages_->emplace_back(
message.make_payload(LazySliceArgs{Border::None(), std::numeric_limits<size_t>::max()}));
}
private:
std::vector<Slice>* const got_messages_;
};
router.RegisterLink(MakeLink<MockLink>(&got_messages));
while (!router.HasRouteTo(NodeId(3))) {
timer.StepUntilNextEvent();
}
auto status = PacketStuffer(NodeId(1), NodeId(2))
.ParseAndForwardTo(kDummyTimestamp123, GetParam().expected_bytes, &router);
EXPECT_TRUE(status.is_ok()) << status;
EXPECT_EQ(got_messages, GetParam().messages);
}
INSTANTIATE_TEST_SUITE_P(PacketStufferSerializationSuite, PacketStufferSerialization,
::testing::Values(PacketVerificationArgs{
{Slice::FromContainer({1, 2, 3})},
256,
Slice::FromContainer({
0x16, 0x10, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x01, 0x00, 0x01, 0x02, 0x03,
})}));
} // namespace packet_stuffer_test
} // namespace overnet
| 35.62931 | 100 | 0.681103 | OpenTrustGroup |
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 |
0b268403cdbb95efaf20a42f05522bfd9b967b3f | 9,192 | cxx | C++ | main/svtools/source/edit/textdata.cxx | Grosskopf/openoffice | 93df6e8a695d5e3eac16f3ad5e9ade1b963ab8d7 | [
"Apache-2.0"
] | 679 | 2015-01-06T06:34:58.000Z | 2022-03-30T01:06:03.000Z | main/svtools/source/edit/textdata.cxx | Grosskopf/openoffice | 93df6e8a695d5e3eac16f3ad5e9ade1b963ab8d7 | [
"Apache-2.0"
] | 102 | 2017-11-07T08:51:31.000Z | 2022-03-17T12:13:49.000Z | main/svtools/source/edit/textdata.cxx | Grosskopf/openoffice | 93df6e8a695d5e3eac16f3ad5e9ade1b963ab8d7 | [
"Apache-2.0"
] | 331 | 2015-01-06T11:40:55.000Z | 2022-03-14T04:07:51.000Z | /**************************************************************
*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you 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.
*
*************************************************************/
// MARKER(update_precomp.py): autogen include statement, do not remove
#include "precompiled_svtools.hxx"
#include <svtools/textdata.hxx>
#include <textdat2.hxx>
#include <tools/debug.hxx>
SV_IMPL_PTRARR( TextLines, TextLinePtr );
SV_IMPL_VARARR( TEWritingDirectionInfos, TEWritingDirectionInfo );
// -------------------------------------------------------------------------
// (+) class TextSelection
// -------------------------------------------------------------------------
TextSelection::TextSelection()
{
}
TextSelection::TextSelection( const TextPaM& rPaM ) :
maStartPaM( rPaM ), maEndPaM( rPaM )
{
}
TextSelection::TextSelection( const TextPaM& rStart, const TextPaM& rEnd ) :
maStartPaM( rStart ), maEndPaM( rEnd )
{
}
void TextSelection::Justify()
{
if ( maEndPaM < maStartPaM )
{
TextPaM aTemp( maStartPaM );
maStartPaM = maEndPaM;
maEndPaM = aTemp;
}
}
// -------------------------------------------------------------------------
// (+) class TETextPortionList
// -------------------------------------------------------------------------
TETextPortionList::TETextPortionList()
{
}
TETextPortionList::~TETextPortionList()
{
Reset();
}
void TETextPortionList::Reset()
{
for ( sal_uInt16 nPortion = 0; nPortion < Count(); nPortion++ )
delete GetObject( nPortion );
Remove( 0, Count() );
}
void TETextPortionList::DeleteFromPortion( sal_uInt16 nDelFrom )
{
DBG_ASSERT( ( nDelFrom < Count() ) || ( (nDelFrom == 0) && (Count() == 0) ), "DeleteFromPortion: Out of range" );
for ( sal_uInt16 nP = nDelFrom; nP < Count(); nP++ )
delete GetObject( nP );
Remove( nDelFrom, Count()-nDelFrom );
}
sal_uInt16 TETextPortionList::FindPortion( sal_uInt16 nCharPos, sal_uInt16& nPortionStart, sal_Bool bPreferStartingPortion )
{
// Bei nCharPos an Portion-Grenze wird die linke Portion gefunden
sal_uInt16 nTmpPos = 0;
for ( sal_uInt16 nPortion = 0; nPortion < Count(); nPortion++ )
{
TETextPortion* pPortion = GetObject( nPortion );
nTmpPos = nTmpPos + pPortion->GetLen();
if ( nTmpPos >= nCharPos )
{
// take this one if we don't prefer the starting portion, or if it's the last one
if ( ( nTmpPos != nCharPos ) || !bPreferStartingPortion || ( nPortion == Count() - 1 ) )
{
nPortionStart = nTmpPos - pPortion->GetLen();
return nPortion;
}
}
}
DBG_ERROR( "FindPortion: Nicht gefunden!" );
return ( Count() - 1 );
}
/*
sal_uInt16 TETextPortionList::GetPortionStartIndex( sal_uInt16 nPortion )
{
sal_uInt16 nPos = 0;
for ( sal_uInt16 nP = 0; nP < nPortion; nP++ )
{
TETextPortion* pPortion = GetObject( nP );
nPos += pPortion->GetLen();
}
return nPos;
}
*/
// -------------------------------------------------------------------------
// (+) class TEParaPortion
// -------------------------------------------------------------------------
TEParaPortion::TEParaPortion( TextNode* pN )
{
mpNode = pN;
mnInvalidPosStart = mnInvalidDiff = 0;
mbInvalid = sal_True;
mbSimple = sal_False;
}
TEParaPortion::~TEParaPortion()
{
}
void TEParaPortion::MarkInvalid( sal_uInt16 nStart, short nDiff )
{
if ( mbInvalid == sal_False )
{
mnInvalidPosStart = ( nDiff >= 0 ) ? nStart : ( nStart + nDiff );
mnInvalidDiff = nDiff;
}
else
{
// Einfaches hintereinander tippen
if ( ( nDiff > 0 ) && ( mnInvalidDiff > 0 ) &&
( ( mnInvalidPosStart+mnInvalidDiff ) == nStart ) )
{
mnInvalidDiff = mnInvalidDiff + nDiff;
}
// Einfaches hintereinander loeschen
else if ( ( nDiff < 0 ) && ( mnInvalidDiff < 0 ) && ( mnInvalidPosStart == nStart ) )
{
mnInvalidPosStart = mnInvalidPosStart + nDiff;
mnInvalidDiff = mnInvalidDiff + nDiff;
}
else
{
DBG_ASSERT( ( nDiff >= 0 ) || ( (nStart+nDiff) >= 0 ), "MarkInvalid: Diff out of Range" );
mnInvalidPosStart = Min( mnInvalidPosStart, (sal_uInt16) ( (nDiff < 0) ? nStart+nDiff : nDiff ) );
mnInvalidDiff = 0;
mbSimple = sal_False;
}
}
maWritingDirectionInfos.Remove( 0, maWritingDirectionInfos.Count() );
mbInvalid = sal_True;
}
void TEParaPortion::MarkSelectionInvalid( sal_uInt16 nStart, sal_uInt16 /*nEnd*/ )
{
if ( mbInvalid == sal_False )
{
mnInvalidPosStart = nStart;
// nInvalidPosEnd = nEnd;
}
else
{
mnInvalidPosStart = Min( mnInvalidPosStart, nStart );
// nInvalidPosEnd = pNode->Len();
}
maWritingDirectionInfos.Remove( 0, maWritingDirectionInfos.Count() );
mnInvalidDiff = 0;
mbInvalid = sal_True;
mbSimple = sal_False;
}
sal_uInt16 TEParaPortion::GetLineNumber( sal_uInt16 nChar, sal_Bool bInclEnd )
{
for ( sal_uInt16 nLine = 0; nLine < maLines.Count(); nLine++ )
{
TextLine* pLine = maLines.GetObject( nLine );
if ( ( bInclEnd && ( pLine->GetEnd() >= nChar ) ) ||
( pLine->GetEnd() > nChar ) )
{
return nLine;
}
}
// Dann sollte es am Ende der letzten Zeile sein!
DBG_ASSERT( nChar == maLines[ maLines.Count() - 1 ]->GetEnd(), "Index voll daneben!" );
DBG_ASSERT( !bInclEnd, "Zeile nicht gefunden: FindLine" );
return ( maLines.Count() - 1 );
}
void TEParaPortion::CorrectValuesBehindLastFormattedLine( sal_uInt16 nLastFormattedLine )
{
sal_uInt16 nLines = maLines.Count();
DBG_ASSERT( nLines, "CorrectPortionNumbersFromLine: Leere Portion?" );
if ( nLastFormattedLine < ( nLines - 1 ) )
{
const TextLine* pLastFormatted = maLines[ nLastFormattedLine ];
const TextLine* pUnformatted = maLines[ nLastFormattedLine+1 ];
short nPortionDiff = pUnformatted->GetStartPortion() - pLastFormatted->GetEndPortion();
short nTextDiff = pUnformatted->GetStart() - pLastFormatted->GetEnd();
nTextDiff++; // LastFormatted->GetEnd() war incl. => 1 zuviel abgezogen!
// Die erste unformatierte muss genau eine Portion hinter der letzten der
// formatierten beginnen:
// Wenn in der geaenderten Zeile eine Portion gesplittet wurde,
// kann nLastEnd > nNextStart sein!
short nPDiff = sal::static_int_cast< short >(-( nPortionDiff-1 ));
short nTDiff = sal::static_int_cast< short >(-( nTextDiff-1 ));
if ( nPDiff || nTDiff )
{
for ( sal_uInt16 nL = nLastFormattedLine+1; nL < nLines; nL++ )
{
TextLine* pLine = maLines[ nL ];
pLine->GetStartPortion() = pLine->GetStartPortion() + nPDiff;
pLine->GetEndPortion() = pLine->GetEndPortion() + nPDiff;
pLine->GetStart() = pLine->GetStart() + nTDiff;
pLine->GetEnd() = pLine->GetEnd() + nTDiff;
pLine->SetValid();
}
}
}
}
// -------------------------------------------------------------------------
// (+) class TEParaPortions
// -------------------------------------------------------------------------
TEParaPortions::TEParaPortions()
{
}
TEParaPortions::~TEParaPortions()
{
Reset();
}
void TEParaPortions::Reset()
{
TEParaPortions::iterator aIter( begin() );
while ( aIter != end() )
delete *aIter++;
clear();
}
// -------------------------------------------------------------------------
// (+) class IdleFormatter
// -------------------------------------------------------------------------
IdleFormatter::IdleFormatter()
{
mpView = 0;
mnRestarts = 0;
}
IdleFormatter::~IdleFormatter()
{
mpView = 0;
}
void IdleFormatter::DoIdleFormat( TextView* pV, sal_uInt16 nMaxRestarts )
{
mpView = pV;
if ( IsActive() )
mnRestarts++;
if ( mnRestarts > nMaxRestarts )
{
mnRestarts = 0;
((Link&)GetTimeoutHdl()).Call( this );
}
else
{
Start();
}
}
void IdleFormatter::ForceTimeout()
{
if ( IsActive() )
{
Stop();
mnRestarts = 0;
((Link&)GetTimeoutHdl()).Call( this );
}
}
TYPEINIT1( TextHint, SfxSimpleHint );
TextHint::TextHint( sal_uLong Id ) : SfxSimpleHint( Id )
{
mnValue = 0;
}
TextHint::TextHint( sal_uLong Id, sal_uLong nValue ) : SfxSimpleHint( Id )
{
mnValue = nValue;
}
TEIMEInfos::TEIMEInfos( const TextPaM& rPos, const String& rOldTextAfterStartPos )
: aOldTextAfterStartPos( rOldTextAfterStartPos )
{
aPos = rPos;
nLen = 0;
bCursor = sal_True;
pAttribs = NULL;
bWasCursorOverwrite = sal_False;
}
TEIMEInfos::~TEIMEInfos()
{
delete[] pAttribs;
}
void TEIMEInfos::CopyAttribs( const sal_uInt16* pA, sal_uInt16 nL )
{
nLen = nL;
delete pAttribs;
pAttribs = new sal_uInt16[ nL ];
memcpy( pAttribs, pA, nL*sizeof(sal_uInt16) );
}
void TEIMEInfos::DestroyAttribs()
{
delete pAttribs;
pAttribs = NULL;
nLen = 0;
}
| 25.675978 | 124 | 0.617276 | Grosskopf |
0b269991f950ae63a424762905050e3cee4b88a5 | 393 | cpp | C++ | cpp/recurs.cpp | lindsayad/misc_programming | 60d4056a99d52e247bc1ae08b9eaaf0b13cc1b2e | [
"MIT"
] | null | null | null | cpp/recurs.cpp | lindsayad/misc_programming | 60d4056a99d52e247bc1ae08b9eaaf0b13cc1b2e | [
"MIT"
] | null | null | null | cpp/recurs.cpp | lindsayad/misc_programming | 60d4056a99d52e247bc1ae08b9eaaf0b13cc1b2e | [
"MIT"
] | null | null | null | #include <iostream>
using namespace std;
long factorial (long a);
int main()
{
long number;
do {
cout << "Please, enter positive integer (0 to exit): ";
cin >> number;
factorial(number);
cout << number << " factorial is: " << factorial(number) << endl;
} while (number != 0);
return 0;
}
long factorial (long a)
{
if (a > 1)
return (a * factorial(a-1));
else
return 1;
}
| 15.115385 | 67 | 0.610687 | lindsayad |
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 |
0b33235a75c132e00f35da344c64ec729a11e473 | 12,010 | cpp | C++ | cpp/pybind/ml/contrib/contrib_nns.cpp | bing-jian/Open3D | 4ad5d1c75f91159bd5050af51bc35009343141e1 | [
"MIT"
] | 1 | 2020-09-24T10:09:22.000Z | 2020-09-24T10:09:22.000Z | cpp/pybind/ml/contrib/contrib_nns.cpp | LinkonBSMRSTU/Open3D | 7f02137cef52b6ad0f67fe72ae5bc0a795d77117 | [
"MIT"
] | null | null | null | cpp/pybind/ml/contrib/contrib_nns.cpp | LinkonBSMRSTU/Open3D | 7f02137cef52b6ad0f67fe72ae5bc0a795d77117 | [
"MIT"
] | 1 | 2022-01-25T20:23:11.000Z | 2022-01-25T20:23:11.000Z | // ----------------------------------------------------------------------------
// - Open3D: www.open3d.org -
// ----------------------------------------------------------------------------
// The MIT License (MIT)
//
// Copyright (c) 2018 www.open3d.org
//
// 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 "open3d/core/nns/NearestNeighborSearch.h"
#include "pybind/core/core.h"
#include "pybind/docstring.h"
#include "pybind/ml/contrib/contrib.h"
#include "pybind/open3d_pybind.h"
#include "pybind/pybind_utils.h"
namespace open3d {
namespace ml {
namespace contrib {
/// TOOD: This is a temory wrapper for 3DML repositiory use. In the future, the
/// native Open3D Python API should be improved and used.
///
/// TOOD: Currently, open3d::core::NearestNeighborSearch supports Float64
/// and Int64 only. NearestNeighborSearch will support Float32 and Int32 in the
/// future. For now, we do a convertion manually.
///
/// \param query_points Tensor of shape {n_query_points, d}, dtype Float32.
/// \param dataset_points Tensor of shape {n_dataset_points, d}, dtype Float32.
/// \param knn Int.
/// \return Tensor of shape (n_query_points, knn), dtype Int32.
const core::Tensor KnnSearch(const core::Tensor& query_points,
const core::Tensor& dataset_points,
int knn) {
// Check dtype.
if (query_points.GetDtype() != core::Dtype::Float32) {
utility::LogError("query_points must be of dtype Float32.");
}
if (dataset_points.GetDtype() != core::Dtype::Float32) {
utility::LogError("dataset_points must be of dtype Float32.");
}
// Check shape.
if (query_points.NumDims() != 2) {
utility::LogError("query_points must be of shape {n_query_points, d}.");
}
if (dataset_points.NumDims() != 2) {
utility::LogError(
"dataset_points must be of shape {n_dataset_points, d}.");
}
if (query_points.GetShape()[1] != dataset_points.GetShape()[1]) {
utility::LogError("Point dimensions mismatch {} != {}.",
query_points.GetShape()[1],
dataset_points.GetShape()[1]);
}
// Call NNS.
// TODO: remove dytpe convertion.
core::nns::NearestNeighborSearch nns(
dataset_points.To(core::Dtype::Float64));
nns.KnnIndex();
core::Tensor indices;
core::Tensor distances;
std::tie(indices, distances) =
nns.KnnSearch(query_points.To(core::Dtype::Float64), knn);
return indices.To(core::Dtype::Int32);
}
/// TOOD: This is a temory wrapper for 3DML repositiory use. In the future, the
/// native Open3D Python API should be improved and used.
///
/// \param query_points Tensor of shape {n_query_points, d}, dtype Float32.
/// \param dataset_points Tensor of shape {n_dataset_points, d}, dtype Float32.
/// \param query_batches Tensor of shape {n_batches,}, dtype Int32. It is
/// required that sum(query_batches) == n_query_points.
/// \param dataset_batches Tensor of shape {n_batches,}, dtype Int32. It is
/// required that that sum(dataset_batches) == n_dataset_points.
/// \param radius The radius to search.
/// \return Tensor of shape {n_query_points, max_neighbor}, dtype Int32, where
/// max_neighbor is the maximum number neighbor of neighbors for all query
/// points. For query points with less than max_neighbor neighbors, the neighbor
/// index will be padded by -1.
const core::Tensor RadiusSearch(const core::Tensor& query_points,
const core::Tensor& dataset_points,
const core::Tensor& query_batches,
const core::Tensor& dataset_batches,
double radius) {
// Check dtype.
if (query_points.GetDtype() != core::Dtype::Float32) {
utility::LogError("query_points must be of dtype Float32.");
}
if (dataset_points.GetDtype() != core::Dtype::Float32) {
utility::LogError("dataset_points must be of dtype Float32.");
}
if (query_batches.GetDtype() != core::Dtype::Int32) {
utility::LogError("query_batches must be of dtype Int32.");
}
if (dataset_batches.GetDtype() != core::Dtype::Int32) {
utility::LogError("dataset_batches must be of dtype Int32.");
}
// Check shapes.
if (query_points.NumDims() != 2) {
utility::LogError("query_points must be of shape {n_query_points, d}.");
}
if (dataset_points.NumDims() != 2) {
utility::LogError(
"dataset_points must be of shape {n_dataset_points, d}.");
}
if (query_points.GetShape()[1] != dataset_points.GetShape()[1]) {
utility::LogError("Point dimensions mismatch {} != {}.",
query_points.GetShape()[1],
dataset_points.GetShape()[1]);
}
if (query_batches.NumDims() != 1) {
utility::LogError("query_batches must be of shape {n_batches,}.");
}
if (dataset_batches.NumDims() != 1) {
utility::LogError("dataset_batches must be of shape {n_batches,}.");
}
if (query_batches.GetShape()[0] != dataset_batches.GetShape()[0]) {
utility::LogError("Number of batches lengths not the same: {} != {}.",
query_batches.GetShape()[0],
dataset_batches.GetShape()[0]);
}
int64_t num_batches = query_batches.GetShape()[0];
// Check consistentency of batch sizes with total number of points.
if (query_batches.Sum({0}).Item<int32_t>() != query_points.GetShape()[0]) {
utility::LogError(
"query_batches is not consistent with query_points: {} != {}.",
query_batches.Sum({0}).Item<int32_t>(),
query_points.GetShape()[0]);
}
if (dataset_batches.Sum({0}).Item<int32_t>() !=
dataset_points.GetShape()[0]) {
utility::LogError(
"dataset_batches is not consistent with dataset_points: {} != "
"{}.",
dataset_batches.Sum({0}).Item<int32_t>(),
dataset_points.GetShape()[0]);
}
int64_t num_query_points = query_points.GetShape()[0];
// Call radius search for each batch.
std::vector<core::Tensor> batched_indices(num_batches);
std::vector<core::Tensor> batched_num_neighbors(num_batches);
#ifdef _OPENMP
#pragma omp parallel for schedule(static)
#endif
for (int64_t batch_idx = 0; batch_idx < num_batches; ++batch_idx) {
// TODO: we need a prefix-sum for 1D Tensor.
// start_idx: inclusive
// end_idx: exclusive
int32_t query_start_idx =
query_batches.Slice(0, 0, batch_idx).Sum({0}).Item<int32_t>();
int32_t query_end_idx = query_batches.Slice(0, 0, batch_idx + 1)
.Sum({0})
.Item<int32_t>();
core::Tensor current_query_points =
query_points.Slice(0, query_start_idx, query_end_idx)
.To(core::Dtype::Float64);
int32_t dataset_start_idx =
dataset_batches.Slice(0, 0, batch_idx).Sum({0}).Item<int32_t>();
int32_t dataset_end_idx = dataset_batches.Slice(0, 0, batch_idx + 1)
.Sum({0})
.Item<int32_t>();
core::Tensor current_dataset_points =
dataset_points.Slice(0, dataset_start_idx, dataset_end_idx)
.To(core::Dtype::Float64);
// Call radius search.
// TODO: remove dytpe convertion.
core::nns::NearestNeighborSearch nns(current_dataset_points);
nns.FixedRadiusIndex();
core::Tensor indices;
core::Tensor distances;
core::Tensor num_neighbors;
std::tie(indices, distances, num_neighbors) =
nns.FixedRadiusSearch(current_query_points, radius);
batched_indices[batch_idx] = indices;
batched_num_neighbors[batch_idx] = num_neighbors;
}
// Find global maximum number of neighbors.
int64_t max_num_neighbors = 0;
for (const auto& num_neighbors : batched_num_neighbors) {
max_num_neighbors = std::max(num_neighbors.Max({0}).Item<int64_t>(),
max_num_neighbors);
}
// Convert to the required output format. Pad with -1.
core::Tensor result = core::Tensor::Ones(
{num_query_points, max_num_neighbors}, core::Dtype::Int64);
result *= -1;
#ifdef _OPENMP
#pragma omp parallel for schedule(static)
#endif
for (int64_t batch_idx = 0; batch_idx < num_batches; ++batch_idx) {
// TODO: we need a prefix-sum for 1D Tensor.
// start_idx: inclusive
// end_idx: exclusive
int32_t result_start_idx =
query_batches.Slice(0, 0, batch_idx).Sum({0}).Item<int32_t>();
int32_t result_end_idx = query_batches.Slice(0, 0, batch_idx + 1)
.Sum({0})
.Item<int32_t>();
core::Tensor indices = batched_indices[batch_idx].Add(
dataset_batches.Slice(0, 0, batch_idx)
.Sum({0})
.Item<int32_t>());
core::Tensor num_neighbors = batched_num_neighbors[batch_idx];
// Sanity check.
int64_t batch_size =
result_end_idx - result_start_idx; // Exclusive result_end_idx.
if (num_neighbors.GetShape()[0] != batch_size) {
utility::LogError(
"Sanity check failed, batch_id {}: {} != batchsize {}.",
batch_idx, num_neighbors.GetShape()[0], batch_size);
}
int64_t indices_start_idx = 0;
for (int64_t i = 0; i < batch_size; i++) {
int64_t num_neighbor = num_neighbors[i].Item<int64_t>();
core::Tensor result_slice = result.Slice(0, result_start_idx + i,
result_start_idx + i + 1)
.Slice(1, 0, num_neighbor);
core::Tensor indices_slice = indices.Slice(
0, indices_start_idx, indices_start_idx + num_neighbor);
result_slice.AsRvalue() = indices_slice.View({1, num_neighbor});
indices_start_idx += num_neighbor;
}
}
return result.To(core::Dtype::Int32);
}
void pybind_contrib_nns(py::module& m_contrib) {
m_contrib.def("knn_search", &KnnSearch, "query_points"_a,
"dataset_points"_a, "knn"_a);
m_contrib.def("radius_search", &RadiusSearch, "query_points"_a,
"dataset_points"_a, "query_batches"_a, "dataset_batches"_a,
"radius"_a);
}
} // namespace contrib
} // namespace ml
} // namespace open3d
| 44.481481 | 80 | 0.60025 | bing-jian |
0b33b6f1eb57ba2ed6c18a0b02fc4714dab647f7 | 543 | cpp | C++ | WebFramework/src/WebNetwork/WebFrameworkHTTPSNetwork.cpp | LazyPanda07/WebFramework | 9488065caa0efebe0b63590b67b99ea99f295b53 | [
"MIT"
] | 1 | 2021-02-17T13:41:37.000Z | 2021-02-17T13:41:37.000Z | WebFramework/src/WebNetwork/WebFrameworkHTTPSNetwork.cpp | LazyPanda07/WebFramework | 9488065caa0efebe0b63590b67b99ea99f295b53 | [
"MIT"
] | 16 | 2020-12-16T19:49:05.000Z | 2022-01-25T17:11:40.000Z | WebFramework/src/WebNetwork/WebFrameworkHTTPSNetwork.cpp | LazyPanda07/WebFramework | 9488065caa0efebe0b63590b67b99ea99f295b53 | [
"MIT"
] | null | null | null | #include "WebFrameworkHTTPSNetwork.h"
using namespace std;
namespace framework
{
WebFrameworkHTTPSNetwork::WebFrameworkHTTPSNetwork(SOCKET clientSocket, SSL* ssl, SSL_CTX* context) :
HTTPSNetwork
(
clientSocket,
ssl,
context
)
{
}
WebFrameworkHTTPSNetwork::WebFrameworkHTTPSNetwork(const string& ip, const string& port) :
HTTPSNetwork
(
ip,
port
)
{
}
WebFrameworkHTTPSNetwork::WebFrameworkHTTPSNetwork(const utility::baseConnectionData& data) :
HTTPSNetwork
(
data.ip,
data.port
)
{
}
}
| 14.289474 | 102 | 0.71639 | LazyPanda07 |
0b3432b9cbd3e2de0c5977ea0600db70d3cc0922 | 37,515 | cpp | C++ | c/lib/adtl/AVL.cpp | knowm/nSpace | 1e5380a8778e013f7e8c44c130ba32e9668755ed | [
"BSD-3-Clause"
] | 2 | 2020-05-06T21:45:13.000Z | 2020-06-14T11:48:03.000Z | c/lib/adtl/AVL.cpp | knowm/nSpace | 1e5380a8778e013f7e8c44c130ba32e9668755ed | [
"BSD-3-Clause"
] | null | null | null | c/lib/adtl/AVL.cpp | knowm/nSpace | 1e5380a8778e013f7e8c44c130ba32e9668755ed | [
"BSD-3-Clause"
] | 3 | 2017-09-18T14:46:03.000Z | 2021-09-26T17:10:36.000Z | ////////////////////////////////////////////////////////////////////////
//
// AVL.CPP
//
// Implementation of an AVL binary search tree (dictionary)
//
////////////////////////////////////////////////////////////////////////
#include "adtl_.h"
#include <stdio.h>
AVL :: AVL ( void )
{
////////////////////////////////////////////////////////////////////////
//
// OVERLOAD
// FROM IContainer
//
// PURPOSE
// - Constructor for the object.
//
////////////////////////////////////////////////////////////////////////
// Setup
pRoot = NULL;
numnodes = 0;
pDctIt = NULL;
pKeyIt = NULL;
//WCHAR wBfr[100];
//swprintf ( wBfr, L"Dictionary::Dictionary:Size %d Node %d ValueImpl %d (%d) CCLObject %d\n",
// sizeof(Dictionary), sizeof(AVLNode), sizeof(adtValueImpl), sizeof(adtValue), sizeof(CCLObject) );
//OutputDebugString ( wBfr );
} // Dictionary
HRESULT AVL :: clear ( void )
{
////////////////////////////////////////////////////////////////////////
//
// OVERLOAD
// FROM IContainer
//
// PURPOSE
// - Resets the container.
//
////////////////////////////////////////////////////////////////////////
// Thread safety
if (cs.enter())
{
// Delete all nodes
deleteNode ( &pRoot );
numnodes = 0;
// Thread safety
cs.leave();
} // if
return S_OK;
} // clear
HRESULT AVL :: clone ( IUnknown **ppUnk )
{
////////////////////////////////////////////////////////////////////////
//
// OVERLOAD
// FROM ICloneable
//
// PURPOSE
// - Clones the object.
//
// PARAMETERS
// - ppUnk will receive the clone
//
// RETURN
// S_OK if successful
//
////////////////////////////////////////////////////////////////////////
HRESULT hr = S_OK;
AVL *pDct = NULL;
IIt *pIt = NULL;
// Create target object
// CCLTRY ( COCREATE ( L"Adt.Dictionary", IID_IDictionary, &pDct ) );
CCLTRYE( (pDct = new AVL()) != NULL, E_OUTOFMEMORY );
CCLOK ( pDct->AddRef(); )
CCLTRY ( pDct->construct() );
// Iterate and store values into target
CCLTRY ( keys ( &pIt ) );
while (hr == S_OK && pIt->read ( vK ) == S_OK)
{
// Value for key
CCLTRY ( load ( vK, vV ) );
// Perform a 'deep' copy so clone the key and values as well.
CCLTRY ( adtValue::clone ( vK, vKc ) );
CCLTRY ( adtValue::clone ( vV, vVc ) );
// Store pair in target
CCLTRY ( pDct->store ( vKc, vVc ) );
// Next key
pIt->next();
} // while
// Result
(*ppUnk) = (IDictionary *)pDct;
_ADDREF(*ppUnk);
// Clean up
_RELEASE(pIt);
_RELEASE(pDct);
return hr;
} // clone
HRESULT AVL :: copyNode ( AVLNode *pNode, IDictionary *pDst )
{
////////////////////////////////////////////////////////////////////////
//
// PURPOSE
// - Copies the key/value pair into the given dictionary.
//
// PARAMETERS
// - pNode is the current node
// - pDst will receive the pair
//
// RETURN VALUE
// S_OK if successful
//
////////////////////////////////////////////////////////////////////////
HRESULT hr = S_OK;
// Base case
if (pNode == NULL) return S_OK;
// Copy nodes
CCLTRY ( pDst->store ( pNode->key, pNode->value ) );
CCLTRY ( copyNode ( pNode->pLeft, pDst ) );
CCLTRY ( copyNode ( pNode->pRight, pDst ) );
return hr;
} // copyNode
HRESULT AVL :: copyTo ( IContainer *pCont )
{
////////////////////////////////////////////////////////////////////////
//
// OVERLOAD
// FROM ICopyTo
//
// PURPOSE
// - Copies values from this container to another container.
//
// PARAMETERS
// - pCont will receive the values
//
// RETURN VALUE
// S_OK if successful
//
////////////////////////////////////////////////////////////////////////
HRESULT hr = S_OK;
IDictionary *pDict = NULL;
// Thread safety
if (cs.enter())
{
// Must be dictionary
CCLTRY ( _QISAFE(pCont,IID_IDictionary,&pDict) );
// Copy nodes
CCLTRY ( copyNode ( pRoot, pDict ) );
// Clean up
_RELEASE(pDict);
// Thread safety
cs.leave();
} // if
return hr;
} // copyTo
void AVL :: deleteNode ( AVLNode **ppNode )
{
////////////////////////////////////////////////////////////////////////
//
// PURPOSE
// - Deletes the specified node from the tree.
//
// PARAMETERS
// - ppNode is the node to delete.
//
////////////////////////////////////////////////////////////////////////
// Base case
if (*ppNode == NULL) return;
// Delete children
deleteNode ( &((*ppNode)->pLeft) );
deleteNode ( &((*ppNode)->pRight) );
// Debug
// if((*ppNode) != NULL &&
// adtValue::type((*ppNode)->key) == VTYPE_STR &&
// (*ppNode)->key.pstr != NULL)
// dbgprintf(L"AVL::deleteNode:%s\r\n", (*ppNode)->key.pstr );
// if ( adtValue::type ( (*ppNode)->key ) == VTYPE_STR &&
// (*ppNode)->key.pstr != NULL &&
// !WCASECMP((*ppNode)->key.pstr,L"OnNext") )
// dbgprintf ( L"Hi\r\n" );
// Done
(*ppNode)->pParent = NULL;
(*ppNode)->pLeft = NULL;
(*ppNode)->pRight = NULL;
_AVLRELEASE((*ppNode));
} // deleteNode
void AVL :: destruct ( void )
{
////////////////////////////////////////////////////////////////////////
//
// PURPOSE
// - Called when the object is being destroyed.
//
////////////////////////////////////////////////////////////////////////
// Iterators
if (pDctIt != NULL)
pDctIt->reset();
_RELEASE(pDctIt);
if (pKeyIt != NULL)
pKeyIt->reset();
_RELEASE(pKeyIt);
// Empty container
clear();
} // destruct
int AVL :: findHighest ( AVLNode *pTarget, AVLNode **ppNode,
AVL_RES *res )
{
////////////////////////////////////////////////////////////////////////
//
// PURPOSE
// - Replace a node with a subtree's highest-ranking item.
//
// PARAMETERS
// - pTarget is the node to be replaced
// - ppNode is the subtree
// - res will receive the return value
//
// RETURN VALUE
// 1 means target was found and replaced
// 0 means subtree was empty
//
////////////////////////////////////////////////////////////////////////
AVLNode *pTmp;
// Setup
*res = AVL_RES_BALANCE;
// Base class
if ((*ppNode) == NULL) return 0;
// Check next right child
if ((*ppNode)->pRight != NULL)
{
if (!findHighest ( pTarget, &((*ppNode)->pRight), res ))
return 0;
if ((*res) == AVL_RES_BALANCE)
*res = shrunkRight ( ppNode );
return 1;
} // if
// Copy node information
adtValue::copy ( (*ppNode)->key, pTarget->key );
adtValue::copy ( (*ppNode)->value, pTarget->value );
// Replace
pTmp = (*ppNode);
(*ppNode) = (*ppNode)->pLeft;
// Update node children of new parent
if ((*ppNode) != NULL)
(*ppNode)->pParent = pTmp->pParent;
// Remove node from tree
pTmp->pParent = NULL;
pTmp->pLeft = NULL;
pTmp->pRight = NULL;
_AVLRELEASE(pTmp);
--numnodes;
return 1;
} // findHighest
int AVL :: findLowest ( AVLNode *pTarget, AVLNode **ppNode,
AVL_RES *res )
{
////////////////////////////////////////////////////////////////////////
//
// PURPOSE
// - Replace a node with a subtree's lowest-ranking item.
//
// PARAMETERS
// - pTarget is the node to be replaced
// - ppNode is the subtree
// - res will receive the return value
//
// RETURN VALUE
// 1 means target was found and replaced
// 0 means subtree was empty
//
////////////////////////////////////////////////////////////////////////
AVLNode *pTmp;
// Setup
*res = AVL_RES_BALANCE;
// Base class
if ((*ppNode) == NULL) return 0;
// Check next leftt child
if ((*ppNode)->pLeft != NULL)
{
if (!findLowest ( pTarget, &((*ppNode)->pLeft), res ))
return 0;
if ((*res) == AVL_RES_BALANCE)
*res = shrunkLeft ( ppNode );
return 1;
} // if
// Copy node information
adtValue::copy ( (*ppNode)->key, pTarget->key );
adtValue::copy ( (*ppNode)->value, pTarget->value );
// Replace
pTmp = (*ppNode);
(*ppNode) = (*ppNode)->pRight;
// Update node children of new parent
if ((*ppNode) != NULL)
(*ppNode)->pParent = pTmp->pParent;
// Remove node from tree
pTmp->pParent = NULL;
pTmp->pLeft = NULL;
pTmp->pRight = NULL;
_AVLRELEASE(pTmp);
--numnodes;
return 1;
} // findLowest
AVL_RES AVL :: findNode ( AVLNode *pNode, const ADTVALUE &Key,
AVLNode **ppFound )
{
////////////////////////////////////////////////////////////////////////
//
// PURPOSE
// - Recursively searches the tree for the node with the specified
// key.
//
// PARAMETERS
// - pNode is the currnet node to search
// - Key is the key
// - ppFound will receive the found node.
//
// RETURN VALUE
// AVL_RES_OK if found
//
////////////////////////////////////////////////////////////////////////
AVL_RES res = AVL_RES_ERROR;
// Base case
if (pNode == NULL) return AVL_RES_ERROR;
// This node ?
int c = adtValue::compare ( pNode->key, Key );
switch (c)
{
// Found !
case 0 :
(*ppFound) = pNode;
res = AVL_RES_OK;
break;
// Key lies to left
case 1 :
res = findNode ( pNode->pLeft, Key, ppFound );
break;
// Key lies to right
case -1 :
res = findNode ( pNode->pRight, Key, ppFound );
break;
// Error
default :
res = AVL_RES_ERROR;
} // switch
return res;
} // findNode
AVL_RES AVL :: grewLeft ( AVLNode **ppNode )
{
////////////////////////////////////////////////////////////////////////
//
// PURPOSE
// - Called when the specified node has grew in height down the
// left side.
//
// PARAMETERS
// - ppNode is the node that has grew.
//
// RETURN VALUE
// AVL_RES_OK if no further action required
//
////////////////////////////////////////////////////////////////////////
AVL_RES res = AVL_RES_BALANCE;
// Process action based on current skew of node
switch ((*ppNode)->skew)
{
// If skew is already left, need to balance nodes
case AVL_SKEW_LEFT :
res = AVL_RES_OK; // Will be balanced
// If left side is also skewed left, a right rotation will
// balance nodes
if ((*ppNode)->pLeft->skew == AVL_SKEW_LEFT)
{
// Rotation
(*ppNode)->skew = (*ppNode)->pLeft->skew = AVL_SKEW_NONE;
rotateRight ( ppNode );
} // if
// Otherwise, need other rotations
else
{
// Update skew flags of left side
switch ((*ppNode)->pLeft->pRight->skew)
{
case AVL_SKEW_LEFT :
(*ppNode)->skew = AVL_SKEW_RIGHT;
(*ppNode)->pLeft->skew = AVL_SKEW_NONE;
break;
case AVL_SKEW_RIGHT :
(*ppNode)->skew = AVL_SKEW_NONE;
(*ppNode)->pLeft->skew = AVL_SKEW_LEFT;
break;
default :
(*ppNode)->skew = AVL_SKEW_NONE;
(*ppNode)->pLeft->skew = AVL_SKEW_NONE;
} // switch
// Perform rotation to balance nodes
(*ppNode)->pLeft->pRight->skew = AVL_SKEW_NONE;
rotateLeft ( &((*ppNode)->pLeft) );
rotateRight ( ppNode );
} // else
break;
// If skew is right, left growth balances node
case AVL_SKEW_RIGHT :
(*ppNode)->skew = AVL_SKEW_NONE;
res = AVL_RES_OK;
break;
// If skew is none, now left side is skewed
case AVL_SKEW_NONE :
(*ppNode)->skew = AVL_SKEW_LEFT;
res = AVL_RES_BALANCE; // Need balancing
break;
} // switch
return res;
} // grewLeft
AVL_RES AVL :: grewRight ( AVLNode **ppNode )
{
////////////////////////////////////////////////////////////////////////
//
// PURPOSE
// - Called when the specified node has grew in height down the
// rigth side.
//
// PARAMETERS
// - ppNode is the node that has grew.
//
// RETURN VALUE
// AVL_RES_OK if no further action required
//
////////////////////////////////////////////////////////////////////////
AVL_RES res = AVL_RES_BALANCE;
// Process action based on current skew of node
switch ((*ppNode)->skew)
{
// If skew is already right, need to balance nodes
case AVL_SKEW_RIGHT :
res = AVL_RES_OK; // Will be balanced
// If right side is also skewed right, a left rotation will
// balance nodes
if ((*ppNode)->pRight->skew == AVL_SKEW_RIGHT)
{
// Rotation
(*ppNode)->skew = (*ppNode)->pRight->skew = AVL_SKEW_NONE;
rotateLeft ( ppNode );
} // if
// Otherwise, need other rotations
else
{
// Update skew flags of right side
switch ((*ppNode)->pRight->pLeft->skew)
{
case AVL_SKEW_RIGHT :
(*ppNode)->skew = AVL_SKEW_LEFT;
(*ppNode)->pRight->skew = AVL_SKEW_NONE;
break;
case AVL_SKEW_LEFT :
(*ppNode)->skew = AVL_SKEW_NONE;
(*ppNode)->pRight->skew = AVL_SKEW_RIGHT;
break;
default :
(*ppNode)->skew = AVL_SKEW_NONE;
(*ppNode)->pRight->skew = AVL_SKEW_NONE;
} // switch
// Perform rotation to balance nodes
(*ppNode)->pRight->pLeft->skew = AVL_SKEW_NONE;
rotateRight ( &((*ppNode)->pRight) );
rotateLeft ( ppNode );
} // else
break;
// If skew is left, right growth balances node
case AVL_SKEW_LEFT :
(*ppNode)->skew = AVL_SKEW_NONE;
res = AVL_RES_OK;
break;
// If skew is none, now right side is skewed
case AVL_SKEW_NONE :
(*ppNode)->skew = AVL_SKEW_RIGHT;
res = AVL_RES_BALANCE; // Need balancing
break;
} // switch
return res;
} // grewRight
AVL_RES AVL :: insertNode ( AVLNode **ppNode, AVLNode *pParent,
const ADTVALUE &Key, const ADTVALUE &Value )
{
////////////////////////////////////////////////////////////////////////
//
// PURPOSE
// - Inserts a node in the tree with the specified key value.
//
// PARAMETERS
// - ppNode starts with the current node, ends with new node.
// - pParent is the parent node
// - Key is the key value
// - Value is the node value
//
// RETURN VALUE
// AVL_RES_OK if successful
//
////////////////////////////////////////////////////////////////////////
AVL_RES res = AVL_RES_ERROR;
int c;
// If ppNode is NULL then we have reached the end of the current
// search path, add the node here.
if (*ppNode == NULL)
{
// Create a node to contain value
if ( ((*ppNode) = (AVLNode *) _ALLOCMEM ( sizeof(AVLNode) )) != NULL )
{
// Node information
_AVLINIT((*ppNode));
adtValue::copy ( Key, (*ppNode)->key );
adtValue::copy ( Value, (*ppNode)->value );
(*ppNode)->pParent = pParent;
res = AVL_RES_BALANCE;
++numnodes;
} // if
} // if
// Continue...
else
{
// Compare keys
c = adtValue::compare ( (*ppNode)->key, Key );
// Continue down correct path
// Go down left side...
if ( c == 1 )
{
// Insert node
res = insertNode ( &((*ppNode)->pLeft), (*ppNode), Key, Value );
// Balance ?
if (res == AVL_RES_BALANCE)
res = grewLeft ( ppNode );
}
// Go down right side...
else if ( c == -1 )
{
// Insert node
res = insertNode ( &((*ppNode)->pRight), (*ppNode), Key, Value );
// Balance ?
if (res == AVL_RES_BALANCE)
res = grewRight ( ppNode );
} // else if
// Keys equal, replace value
else if ( c == 0 )
{
adtValue::copy ( Value, (*ppNode)->value );
res = AVL_RES_OK;
} // else if
else
{
// Debug
#ifdef _DEBUG
// WCHAR dbgbufr[MAX_PATH];
// swprintf ( dbgbufr, L"Dictionary::insertNode:Compare error 0x%x\n", c );
// OutputDebugString ( dbgbufr );
#endif
} // else
} // else
return res;
} // insertNode
HRESULT AVL :: isEmpty ( void )
{
////////////////////////////////////////////////////////////////////////
//
// OVERLOAD
// FROM IContainer
//
// PURPOSE
// - Returns the empty state of the container
//
// RETURN VALUE
// S_OK if container is empty
//
////////////////////////////////////////////////////////////////////////
return (pRoot == NULL) ? S_OK : S_FALSE;
} // isEmpty
HRESULT AVL :: iterate ( IIt **ppIt )
{
////////////////////////////////////////////////////////////////////////
//
// OVERLOAD
// FROM IContainer
//
// PURPOSE
// - Returns an iterator for the container.
//
// PARAMETERS
// - ppIt will receive a ptr. to the iterator
//
// RETURN VALUE
// S_OK if successful
//
////////////////////////////////////////////////////////////////////////
return iterators ( false, ppIt );
} // iterate
HRESULT AVL :: iterators ( bool bKeys, IIt **ppIt )
{
////////////////////////////////////////////////////////////////////////
//
// PURPOSE
// - Handles management of iterators.
//
// PARAMETERS
// - bKeys is true for keys, false for values.
// - ppIt will receive a ptr. to the iterator
//
// RETURN VALUE
// S_OK if successful
//
////////////////////////////////////////////////////////////////////////
HRESULT hr = S_OK;
AVLIt *pIt = NULL;
// Setup
(*ppIt) = NULL;
// Internal iterators. A pre-allocated iterator is kept ready for
// fast back to back iterations.
if ((bKeys && pKeyIt == NULL) || (!bKeys && pDctIt == NULL))
{
// Pre-create iterator
CCLTRYE ( (pIt = new AVLIt(bKeys)) != NULL, E_OUTOFMEMORY );
CCLTRY ( pIt->construct() );
CCLOK ( pIt->AddRef(); )
// Manually assign tree (no reference count)
CCLOK ( pIt->pTree = this; )
// Cache ptr.
if (hr == S_OK && bKeys)
pKeyIt = pIt;
else if (hr == S_OK && !bKeys)
pDctIt = pIt;
} // if
// If internal iterator has a reference count of 1 then it is not
// currently in use, use that
if (hr == S_OK && (
(bKeys && pKeyIt->lRefCnt == 1) ||
(!bKeys && pDctIt->lRefCnt == 1) ) )
{
(*ppIt) = (bKeys) ? pKeyIt : pDctIt;
(*ppIt)->begin();
_ADDREF((*ppIt));
} // if
// Otherwise create a new iterator
else
{
// Detached iterator
CCLOK ( pIt = new AVLIt(this,bKeys); )
CCLTRY( pIt->construct() );
// Result ?
CCLOK ( (*ppIt) = pIt; )
_ADDREF((*ppIt));
} // else
return hr;
} // iterators
HRESULT AVL :: keys ( IIt **ppKeys )
{
////////////////////////////////////////////////////////////////////////
//
// OVERLOAD
// FROM IDictionary
//
// PURPOSE
// - Returns an object to iterate through the keys in the tree.
//
// PARAMETERS
// - ppKeys will receive the iterator
//
// RETURN VALUE
// S_OK if successful
//
////////////////////////////////////////////////////////////////////////
return iterators ( true, ppKeys );
} // keys
HRESULT AVL :: load ( const ADTVALUE &vKey, ADTVALUE &vValue )
{
////////////////////////////////////////////////////////////////////////
//
// OVERLOAD
// FROM IDictionary
//
// PURPOSE
// - Loads a value from the dictionary with the given key.
//
// PARAMETERS
// - vKey is the key
// - vValue will receive the value
//
// RETURN VALUE
// S_OK if successful
//
////////////////////////////////////////////////////////////////////////
HRESULT hr = S_OK;
AVLNode *pNode = NULL;
// Thread safety
if (cs.enter())
{
// To support the loading of 'paths', support key conversion to
// same type as root key.
if ( pRoot != NULL &&
adtValue::type(pRoot->key) != adtValue::type(vKey) &&
adtValue::type(vKey) == VTYPE_STR )
{
adtValue vKeyAlt;
// Convert to the same type as the root key
CCLTRY ( adtValue::fromString ( vKey.pstr, (VALUETYPE) pRoot->key.vtype, vKeyAlt ) );
// Find node with alternate key
CCLTRYE ( findNode ( pRoot, vKeyAlt, &pNode ) == AVL_RES_OK, ERROR_NOT_FOUND );
} // if
else
{
// Find node for key (if it exists)
CCLTRYE ( findNode ( pRoot, vKey, &pNode ) == AVL_RES_OK, ERROR_NOT_FOUND );
} // else
// Return vlaue
CCLOK ( adtValue::copy ( pNode->value, vValue ); )
// Thread safe
cs.leave();
} // if
return hr;
} // load
HRESULT AVL :: remove ( const ADTVALUE &v )
{
////////////////////////////////////////////////////////////////////////
//
// OVERLOAD
// FROM IContainer
//
// PURPOSE
// - Removes an item from the container identified by the specified
// value.
//
// PARAMETERS
// - v identifies the key to remove
//
// RETURN VALUE
// S_OK if successful
//
////////////////////////////////////////////////////////////////////////
HRESULT hr = S_OK;
// Thread safe
if (cs.enter())
{
// Remove key
CCLTRYE ( (removeNode ( &pRoot, NULL, v ) != AVL_RES_ERROR), S_FALSE );
// Thread safe
cs.leave();
} // if
return hr;
} // remove
AVL_RES AVL :: removeNode ( AVLNode **ppNode, AVLNode *pParent,
const ADTVALUE &Key )
{
////////////////////////////////////////////////////////////////////////
//
// PURPOSE
// - Removes a node in the tree with the specified key value.
//
// PARAMETERS
// - ppNode starts with the current node, ends with removed node.
// - pParent is the parent node
// - Key is the key value
//
// RETURN VALUE
// AVL_RES_OK if successful
//
////////////////////////////////////////////////////////////////////////
AVL_RES res = AVL_RES_BALANCE;
int c;
// If ppNode is NULL then we have reached the end of the current
// search path, that would be an error (key not found)
if (*ppNode == NULL)
{
res = AVL_RES_ERROR;
} // if
// Continue...
else
{
// Compare keys
c = adtValue::compare ( (*ppNode)->key, Key );
// Continue down correct path
// Go down left side...
if ( c == 1 )
{
// Remove node
res = removeNode ( &((*ppNode)->pLeft), (*ppNode), Key );
// Balance ?
if (res == AVL_RES_BALANCE)
res = shrunkLeft ( ppNode );
}
// Go down right side...
else if ( c == -1 )
{
// Remove node
res = removeNode ( &((*ppNode)->pRight), (*ppNode), Key );
// Balance ?
if (res == AVL_RES_BALANCE)
res = shrunkRight ( ppNode );
} // else if
// Keys equal. Found node to remove.
else if ( c == 0 )
{
// Standard AVL tree adjustment on removal
// Node has left child ?
if ( ((*ppNode)->pLeft != NULL) &&
findHighest ( (*ppNode), &((*ppNode)->pLeft), &res ) )
{
if (res == AVL_RES_BALANCE)
res = shrunkLeft ( ppNode );
} // if
// Node has right child ?
else if ( ((*ppNode)->pRight != NULL) &&
findLowest ( (*ppNode), &((*ppNode)->pRight), &res ) )
{
if (res == AVL_RES_BALANCE)
res = shrunkRight ( ppNode );
} // if
else
{
// Node to release. Updating parent will NULL ptr.
AVLNode *pRel = (*ppNode);
// Update parent
if ((*ppNode)->pParent != NULL)
{
if ((*ppNode)->pParent->pLeft == (*ppNode))
(*ppNode)->pParent->pLeft = NULL;
else if ((*ppNode)->pParent->pRight == (*ppNode))
(*ppNode)->pParent->pRight = NULL;
} // if
// Clean up
(*ppNode) = NULL;
pRel->pLeft = NULL;
pRel->pRight = NULL;
pRel->pParent = NULL;
_AVLRELEASE(pRel);
res = AVL_RES_BALANCE;
--numnodes;
} // else
} // else if
else
{
// Debug
#ifdef _DEBUG
// WCHAR dbgbufr[MAX_PATH];
// swprintf ( dbgbufr, L"Dictionary::removeNode:Compare error 0x%x\n", c );
// OutputDebugString ( dbgbufr );
#endif
} // else
} // else
return res;
} // removeNode
void AVL :: rotateLeft ( AVLNode **ppNode )
{
////////////////////////////////////////////////////////////////////////
//
// PURPOSE
// - Performs a 'left' rotation of a sub-tree.
//
// PARAMETERS
// - ppNode is the root node
//
////////////////////////////////////////////////////////////////////////
AVLNode *pTmp = (*ppNode);
// Rotate
(*ppNode) = (*ppNode)->pRight;
pTmp->pRight = (*ppNode)->pLeft;
(*ppNode)->pLeft = pTmp;
// Parent nodes
(*ppNode)->pParent = pTmp->pParent;
pTmp->pParent = (*ppNode);
if (pTmp->pRight != NULL)
pTmp->pRight->pParent = pTmp;
} // rotateLeft
void AVL :: rotateRight ( AVLNode **ppNode )
{
////////////////////////////////////////////////////////////////////////
//
// PURPOSE
// - Performs a 'right' rotation of a sub-tree.
//
// PARAMETERS
// - ppNode is the root node
//
////////////////////////////////////////////////////////////////////////
AVLNode *pTmp = (*ppNode);
// Rotate
(*ppNode) = (*ppNode)->pLeft;
pTmp->pLeft = (*ppNode)->pRight;
(*ppNode)->pRight = pTmp;
// Parent nodes
(*ppNode)->pParent = pTmp->pParent;
pTmp->pParent = (*ppNode);
if (pTmp->pLeft != NULL)
pTmp->pLeft->pParent = pTmp;
} // rotateRight
HRESULT AVL :: size ( U32 *s )
{
////////////////////////////////////////////////////////////////////////
//
// OVERLOAD
// FROM IContainer
//
// PURPOSE
// - Returns the # of items in the container.
//
// PARAMETERS
// - s will return the size of the container
//
// RETURN VALUE
// S_OK if successful
//
////////////////////////////////////////////////////////////////////////
(*s) = numnodes;
return S_OK;
} // size
AVL_RES AVL :: shrunkLeft ( AVLNode **ppNode )
{
////////////////////////////////////////////////////////////////////////
//
// PURPOSE
// - Called when the specified node has shrunk in height down the
// left side.
//
// PARAMETERS
// - ppNode is the node that has shrunk.
//
// RETURN VALUE
// AVL_RES_OK if no further action required
//
////////////////////////////////////////////////////////////////////////
AVL_RES res = AVL_RES_BALANCE;
// Process action based on current skew of node
switch ((*ppNode)->skew)
{
// If skew is already left, left shrink balances node
case AVL_SKEW_LEFT :
(*ppNode)->skew = AVL_SKEW_NONE;
res = AVL_RES_BALANCE; // Need balancing
break;
// Right skew.
case AVL_SKEW_RIGHT :
// Right child also right skewed
if ((*ppNode)->pRight->skew == AVL_SKEW_RIGHT)
{
(*ppNode)->skew = (*ppNode)->pRight->skew = AVL_SKEW_NONE;
rotateLeft ( ppNode ); // Rotate
res = AVL_RES_BALANCE; // Need balancing
} // if
// Right child not skewed
else if ((*ppNode)->pRight->skew == AVL_SKEW_NONE)
{
(*ppNode)->skew = AVL_SKEW_RIGHT;
(*ppNode)->pRight->skew = AVL_SKEW_LEFT;
rotateLeft ( ppNode );
res = AVL_RES_OK;
} // else if
// More complicated cases
else
{
// Skew of left child of right child
switch ( (*ppNode)->pRight->pLeft->skew )
{
case AVL_SKEW_LEFT :
(*ppNode)->skew = AVL_SKEW_NONE;
(*ppNode)->pRight->skew = AVL_SKEW_RIGHT;
break;
case AVL_SKEW_RIGHT :
(*ppNode)->skew = AVL_SKEW_LEFT;
(*ppNode)->pRight->skew = AVL_SKEW_NONE;
break;
default :
(*ppNode)->skew = AVL_SKEW_NONE;
(*ppNode)->pRight->skew = AVL_SKEW_NONE;
} // switch
// Adjust
(*ppNode)->pRight->pLeft->skew = AVL_SKEW_NONE;
rotateRight ( & ((*ppNode)->pRight) );
rotateLeft ( ppNode );
res = AVL_RES_BALANCE;
} // else
break;
// If skew is none, now skewed left
default :
(*ppNode)->skew = AVL_SKEW_RIGHT;
res = AVL_RES_OK;
break;
} // switch
return res;
} // shrunkLeft
AVL_RES AVL :: shrunkRight ( AVLNode **ppNode )
{
////////////////////////////////////////////////////////////////////////
//
// PURPOSE
// - Called when the specified node has shrunk in height down the
// right side.
//
// PARAMETERS
// - ppNode is the node that has shrunk.
//
// RETURN VALUE
// AVL_RES_OK if no further action required
//
////////////////////////////////////////////////////////////////////////
AVL_RES res = AVL_RES_BALANCE;
// Process action based on current skew of node
switch ((*ppNode)->skew)
{
// If skew is already right, right shrink balances node
case AVL_SKEW_RIGHT :
(*ppNode)->skew = AVL_SKEW_NONE;
res = AVL_RES_BALANCE; // Need balancing
break;
// Left skew.
case AVL_SKEW_LEFT :
// Left child also left skewed
if ((*ppNode)->pLeft->skew == AVL_SKEW_LEFT)
{
(*ppNode)->skew = (*ppNode)->pLeft->skew = AVL_SKEW_NONE;
rotateRight ( ppNode ); // Rotate
res = AVL_RES_BALANCE; // Need balancing
} // if
// Left child not skewed
else if ((*ppNode)->pLeft->skew == AVL_SKEW_NONE)
{
(*ppNode)->skew = AVL_SKEW_LEFT;
(*ppNode)->pLeft->skew = AVL_SKEW_RIGHT;
rotateRight ( ppNode );
res = AVL_RES_OK;
} // else if
// More complicated cases
else
{
// Skew of right child of left child
switch ( (*ppNode)->pLeft->pRight->skew )
{
case AVL_SKEW_LEFT :
(*ppNode)->skew = AVL_SKEW_RIGHT;
(*ppNode)->pLeft->skew = AVL_SKEW_NONE;
break;
case AVL_SKEW_RIGHT :
(*ppNode)->skew = AVL_SKEW_NONE;
(*ppNode)->pLeft->skew = AVL_SKEW_LEFT;
break;
default :
(*ppNode)->skew = AVL_SKEW_NONE;
(*ppNode)->pLeft->skew = AVL_SKEW_NONE;
} // switch
// Adjust
(*ppNode)->pLeft->pRight->skew = AVL_SKEW_NONE;
rotateLeft ( & ((*ppNode)->pLeft) );
rotateRight ( ppNode );
res = AVL_RES_BALANCE;
} // else
break;
// If skew is none, now skewed left
default :
(*ppNode)->skew = AVL_SKEW_LEFT;
res = AVL_RES_OK;
break;
} // switch
return res;
} // shrunkRight
HRESULT AVL :: store ( const ADTVALUE &vKey, const ADTVALUE &vValue )
{
////////////////////////////////////////////////////////////////////////
//
// OVERLOAD
// FROM IDictionary
//
// PURPOSE
// - Stores a value in the dictionary with the given key.
//
// PARAMETERS
// - vKey is the key
// - vValue is the value
//
// RETURN VALUE
// S_OK if successful
//
////////////////////////////////////////////////////////////////////////
HRESULT hr = S_OK;
// Thread safe
if (cs.enter())
{
// Add value
CCLTRYE ( (insertNode ( &pRoot, NULL, vKey, vValue ) != AVL_RES_ERROR), S_FALSE );
cs.leave();
} // if
return hr;
} // store
///////////
// 'AVLIt'
///////////
AVLIt :: AVLIt ( AVL *_tree, bool _bKeys )
{
////////////////////////////////////////////////////////////////////////
//
// OVERLOAD
// FROM IIt
//
// PURPOSE
// - Constructor for the object.
//
// PARAMETERS
// - _tree is a ptr. to the container for this iterator.
// - _bKeys is true to iterate keys, false for values
//
////////////////////////////////////////////////////////////////////////
pTree = _tree; pTree->AddRef(); // Keep container alive
bKeys = _bKeys;
pPos = NULL;
bRef = true;
// Start iterator at beginning
begin();
} // DictionaryIt
AVLIt :: AVLIt ( bool _bKeys )
{
////////////////////////////////////////////////////////////////////////
//
// OVERLOAD
// FROM IIt
//
// PURPOSE
// - Constructor for the object.
//
// PARAMETERS
// - _bKeys is true to iterate keys, false for values
//
////////////////////////////////////////////////////////////////////////
pTree = NULL; // Parent assigns object
bKeys = _bKeys;
pPos = NULL;
bRef = false;
} // DictionaryIt
HRESULT AVLIt :: begin ( void )
{
////////////////////////////////////////////////////////////////////////
//
// OVERLOAD
// FROM IIt
//
// PURPOSE
// - Resets the iterator position within the container.
//
// RETURN VALUE
// S_OK if successful
//
////////////////////////////////////////////////////////////////////////
HRESULT hr = S_OK;
AVLNode *pNode;
// State check
CCLTRYE ( pTree != NULL, ERROR_INVALID_STATE );
// Thread safe
if (hr == S_OK && pTree->cs.enter())
{
// Start at the 'left' most node.
_AVLRELEASE(pPos);
for ( pNode = pTree->pRoot; pNode != NULL; pNode = pNode->pLeft )
pPos = pNode;
_AVLADDREF(pPos);
pTree->cs.leave();
} // if
return hr;
} // begin
void AVLIt :: destruct ( void )
{
////////////////////////////////////////////////////////////////////////
//
// PURPOSE
// - Called when the object is being destroyed.
//
////////////////////////////////////////////////////////////////////////
_AVLRELEASE(pPos);
if (bRef)
pTree->Release();
} // destruct
HRESULT AVLIt :: end ( void )
{
////////////////////////////////////////////////////////////////////////
//
// OVERLOAD
// FROM IIt
//
// PURPOSE
// - Resets the iterator position within the container.
//
// RETURN VALUE
// S_OK if successful
//
////////////////////////////////////////////////////////////////////////
HRESULT hr = S_OK;
// State check
CCLTRYE ( pTree != NULL, ERROR_INVALID_STATE );
// Thread safe
if (hr == S_OK && pTree->cs.enter())
{
// NULL = end position
_AVLRELEASE(pPos);
pTree->cs.leave();
} // if
return hr;
} // end
ULONG AVLIt :: InnerAddRef ( void )
{
////////////////////////////////////////////////////////////////////////
//
// OVERLOAD
// FROM IInnerUnknown
//
// PURPOSE
// - Increments the reference count on the object.
//
// RETURN VALUE
// New reference count
//
////////////////////////////////////////////////////////////////////////
return (lRefCnt = CCLObject::InnerAddRef());
} // InnerAddRef
ULONG AVLIt :: InnerRelease ( void )
{
////////////////////////////////////////////////////////////////////////
//
// OVERLOAD
// FROM IInnertUnknown
//
// PURPOSE
// - Decrements the reference count on the object.
//
// RETURN VALUE
// New reference count
//
////////////////////////////////////////////////////////////////////////
ULONG lCnt = CCLObject::InnerRelease();
if (lCnt > 0)
{
lRefCnt = lCnt;
if (lRefCnt == 1)
reset();
} // if
return lCnt;
} // InnerRelease
HRESULT AVLIt :: next ( void )
{
////////////////////////////////////////////////////////////////////////
//
// OVERLOAD
// FROM IIt
//
// PURPOSE
// - Moves to the next position within the container.
//
// RETURN VALUE
// S_OK if successful
//
////////////////////////////////////////////////////////////////////////
HRESULT hr = S_OK;
AVLNode *pLast = NULL;
AVLNode *pNode = NULL;
// State check
CCLTRYE ( pTree != NULL, ERROR_INVALID_STATE );
// Thread safe
if (hr == S_OK && pTree->cs.enter())
{
// Sanity check
CCLTRYE ( (pPos != NULL), ERROR_NOT_FOUND );
// Travel down the left side of the right child (if exists)
if (hr == S_OK)
{
CCLOK ( pNode = pPos->pRight; )
if (pNode != NULL)
{
// Follow path
while ( pNode != NULL )
{
pLast = pNode;
pNode = pNode->pLeft;
} // while
// New node
_AVLRELEASE(pPos);
pPos = pLast;
_AVLADDREF(pPos);
} // if
// No right child. Move up until a parent is found for which we were
// just in the left tree of...
else
{
CCLOK ( pLast = pPos; )
CCLOK ( pNode = pPos->pParent; )
while (pNode != NULL)
{
// Left of parent ?
if ( pNode->pLeft == pLast )
break;
// Next parent
pLast = pNode;
pNode = pNode->pParent;
} // while
// New node
_AVLRELEASE(pPos);
pPos = pNode;
_AVLADDREF(pPos);
} // else
} // if
// Valid position ?
CCLTRYE ( (pPos != NULL), ERROR_NOT_FOUND );
pTree->cs.leave();
} // if
return hr;
} // next
HRESULT AVLIt :: prev ( void )
{
////////////////////////////////////////////////////////////////////////
//
// OVERLOAD
// FROM IIt
//
// PURPOSE
// - Moves to the previous position within the container.
//
// RETURN VALUE
// S_OK if successful
//
////////////////////////////////////////////////////////////////////////
HRESULT hr = S_OK;
AVLNode *pNode = NULL;
AVLNode *pLast = NULL;
// State check
CCLTRYE ( pTree != NULL, ERROR_INVALID_STATE );
// Thread safe
if (hr == S_OK && pTree->cs.enter())
{
// No position means end of tree... follow right path from root to get
// the last node
if (pPos == NULL)
{
CCLOK ( pPos = pTree->pRoot; )
CCLOK ( pLast = pPos; )
while (pPos != NULL)
{
pLast = pPos;
pPos = pPos->pRight;
} // while
// New position
_AVLRELEASE(pPos);
pPos = pLast;
_AVLADDREF(pPos);
} // if
// Travel down the right side of the left child (if exists)
else
{
CCLOK ( pNode = pPos->pLeft; )
if (pNode != NULL)
{
// Follow path
while ( pNode != NULL )
{
pLast = pNode;
pNode = pNode->pRight;
} // while
// New node
_AVLRELEASE(pPos);
pPos = pLast;
_AVLADDREF(pPos);
} // if
// No left child. Move up until a parent is found for which we were
// just in the right tree of...
else
{
CCLOK ( pLast = pPos; )
CCLOK ( pNode = pPos->pParent; )
while (pNode != NULL)
{
// Right of parent ?
if ( pNode->pRight == pLast )
break;
// Next parent
pLast = pNode;
pNode = pNode->pParent;
} // while
// New node (don't fall off front...)
_AVLRELEASE(pPos);
pPos = pNode;
_AVLADDREF(pPos);
} // else
} // else
// Valid position ?
CCLTRYE ( (pPos != NULL), ERROR_NOT_FOUND );
// Clean up
pTree->cs.leave();
} // if
return hr;
} // prev
HRESULT AVLIt :: read ( ADTVALUE &v )
{
////////////////////////////////////////////////////////////////////////
//
// OVERLOAD
// FROM IIt
//
// PURPOSE
// - Reads the current item from the container.
//
// PARAMETERS
// - v will receive the value
//
// RETURN VALUE
// S_OK if successful
//
////////////////////////////////////////////////////////////////////////
HRESULT hr = S_OK;
// State check
CCLTRYE ( pTree != NULL, ERROR_INVALID_STATE );
// Thread safe
if (hr == S_OK && pTree->cs.enter())
{
// Copy value
CCLTRYE ( pPos != NULL, ERROR_NOT_FOUND );
if (hr == S_OK)
{
if (bKeys) hr = adtValue::copy ( pPos->key, v );
else hr = adtValue::copy ( pPos->value, v );
} // if
pTree->cs.leave();
} // if
return hr;
} // read
HRESULT AVLIt :: reset ( void )
{
////////////////////////////////////////////////////////////////////////
//
// PURPOSE
// - Reset internal state, called by parent.
//
// RETURN VALUE
// S_OK if successful
//
////////////////////////////////////////////////////////////////////////
// Clean up
if (pPos != NULL)
{
_AVLRELEASE(pPos);
} // if
return S_OK;
} // reset
| 22.61302 | 103 | 0.500866 | knowm |
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 |
0b3617ece6204d159ca1e22f7754b194cd04593c | 3,492 | cc | C++ | src/libs/stdc++/legacy/sinst.cc | Kirishikesan/haiku | 835565c55830f2dab01e6e332cc7e2d9c015b51e | [
"MIT"
] | 1,338 | 2015-01-03T20:06:56.000Z | 2022-03-26T13:49:54.000Z | src/libs/stdc++/legacy/sinst.cc | Kirishikesan/haiku | 835565c55830f2dab01e6e332cc7e2d9c015b51e | [
"MIT"
] | 15 | 2015-01-17T22:19:32.000Z | 2021-12-20T12:35:00.000Z | src/libs/stdc++/legacy/sinst.cc | Kirishikesan/haiku | 835565c55830f2dab01e6e332cc7e2d9c015b51e | [
"MIT"
] | 350 | 2015-01-08T14:15:27.000Z | 2022-03-21T18:14:35.000Z | // Instantiation file for the -*- C++ -*- string classes.
// Copyright (C) 1994 Free Software Foundation
// This file is part of the GNU ANSI C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 2, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License
// along with this library; see the file COPYING. If not, write to the Free
// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
// As a special exception, if you link this library with files
// compiled with a GNU compiler to produce an executable, this does not cause
// the resulting executable to be covered by the GNU General Public License.
// This exception does not however invalidate any other reasons why
// the executable file might be covered by the GNU General Public License.
// Written by Jason Merrill based upon the specification by Takanori Adachi
// in ANSI X3J16/94-0013R2.
#ifdef __GNUG__
#ifdef TRAITS
#ifdef C
#pragma implementation "std/straits.h"
#endif
#endif
#endif
#include <string>
#ifdef C
typedef char c;
#endif
#ifdef W
typedef wchar_t c;
#endif
#if defined(TRAITS) && !defined(C)
template class string_char_traits <c>;
#else
/* string_char_traits<char> is already explicitly specialized in
std/straits.h. */
#endif
typedef basic_string <c> s;
#ifdef MAIN
template class basic_string <c>;
#endif
#ifdef ADDSS
template s operator+ (const s&, const s&);
#endif
#ifdef ADDPS
template s operator+ (const c*, const s&);
#endif
#ifdef ADDCS
template s operator+ (c, const s&);
#endif
#ifdef ADDSP
template s operator+ (const s&, const c*);
#endif
#ifdef ADDSC
template s operator+ (const s&, c);
#endif
#ifdef EQSS
template bool operator== (const s&, const s&);
#endif
#ifdef EQPS
template bool operator== (const c*, const s&);
#endif
#ifdef EQSP
template bool operator== (const s&, const c*);
#endif
#ifdef NESS
template bool operator!= (const s&, const s&);
#endif
#ifdef NEPS
template bool operator!= (const c*, const s&);
#endif
#ifdef NESP
template bool operator!= (const s&, const c*);
#endif
#ifdef LTSS
template bool operator< (const s&, const s&);
#endif
#ifdef LTPS
template bool operator< (const c*, const s&);
#endif
#ifdef LTSP
template bool operator< (const s&, const c*);
#endif
#ifdef GTSS
template bool operator> (const s&, const s&);
#endif
#ifdef GTPS
template bool operator> (const c*, const s&);
#endif
#ifdef GTSP
template bool operator> (const s&, const c*);
#endif
#ifdef LESS
template bool operator<= (const s&, const s&);
#endif
#ifdef LEPS
template bool operator<= (const c*, const s&);
#endif
#ifdef LESP
template bool operator<= (const s&, const c*);
#endif
#ifdef GESS
template bool operator>= (const s&, const s&);
#endif
#ifdef GEPS
template bool operator>= (const c*, const s&);
#endif
#ifdef GESP
template bool operator>= (const s&, const c*);
#endif
#ifdef EXTRACT
template istream& operator>> (istream&, s&);
#endif // EXTRACT
#ifdef INSERT
template ostream& operator<< (ostream&, const s&);
#endif // INSERT
#ifdef GETLINE
template istream& getline (istream&, s&, c);
#endif
| 25.676471 | 81 | 0.72709 | Kirishikesan |
0b37e140815bc72a6df39464ff41f162a46de731 | 1,389 | cpp | C++ | src/quality_filter.cpp | chrismile/HexaLab | dc3dbd14ed7db3c34439d1f4d0e5db15d045a9f3 | [
"MIT"
] | null | null | null | src/quality_filter.cpp | chrismile/HexaLab | dc3dbd14ed7db3c34439d1f4d0e5db15d045a9f3 | [
"MIT"
] | null | null | null | src/quality_filter.cpp | chrismile/HexaLab | dc3dbd14ed7db3c34439d1f4d0e5db15d045a9f3 | [
"MIT"
] | null | null | null | #include <quality_filter.h>
#define HL_QUALITY_FILTER_DEFAULT_ENABLED true
#define HL_QUALITY_FILTER_DEFAULT_MIN 0.f
#define HL_QUALITY_FILTER_DEFAULT_MAX 1.f
#define HL_QUALITY_FILTER_DEFAULT_OP Operator::Inside
namespace HexaLab {
void QualityFilter::on_mesh_set ( Mesh& mesh ) {
this->enabled = HL_QUALITY_FILTER_DEFAULT_ENABLED;
this->quality_threshold_min = HL_QUALITY_FILTER_DEFAULT_MIN;
this->quality_threshold_max = HL_QUALITY_FILTER_DEFAULT_MAX;
this->op = HL_QUALITY_FILTER_DEFAULT_OP;
}
void QualityFilter::filter ( Mesh& mesh ) {
if ( !this->enabled ) {
return;
}
for ( size_t i = 0; i < mesh.cells.size(); ++i ) {
bool is_filtered;
switch ( this->op ) {
case Operator::Inside:
is_filtered = mesh.normalized_hexa_quality[i] < quality_threshold_min || mesh.normalized_hexa_quality[i] > quality_threshold_max;
break;
case Operator::Outside:
is_filtered = mesh.normalized_hexa_quality[i] > quality_threshold_min && mesh.normalized_hexa_quality[i] < quality_threshold_max;
break;
}
if ( is_filtered ) {
mesh.mark ( mesh.cells[i] );
}
}
}
}
| 34.725 | 149 | 0.593233 | chrismile |
0b3ca1df7ce41517c2c9311ac796f0722367fe68 | 2,999 | cpp | C++ | Messy_Test-master/demo/CppBaseTest/data_type_convert.cpp | shenjl/Cplusplus | 345c2f582bf160d663c8accfafbcabc2ff011e57 | [
"MIT"
] | 1 | 2019-11-10T08:23:00.000Z | 2019-11-10T08:23:00.000Z | Messy_Test-master/demo/CppBaseTest/data_type_convert.cpp | selonsy/Cplusplus | 345c2f582bf160d663c8accfafbcabc2ff011e57 | [
"MIT"
] | null | null | null | Messy_Test-master/demo/CppBaseTest/data_type_convert.cpp | selonsy/Cplusplus | 345c2f582bf160d663c8accfafbcabc2ff011e57 | [
"MIT"
] | null | null | null | #include "data_type_convert.hpp"
#include <stdio.h>
#include <stdlib.h>
#include <iostream>
#include <string>
#include <string.h>
#include <vector>
// Blog: http://blog.csdn.net/fengbingchun/article/details/49404293
int test_data_type_convert()
{
// 1--> int to char[]
int tmp1 = 100;
char ch1[15];
sprintf(ch1, "%d", tmp1);
std::cout << ch1 << std::endl;
// 2--> int to string
int tmp2 = 111;
char ch2[15];
sprintf(ch2, "%d", tmp2);
std::string str2;
str2 = std::string(ch2);
std::cout << str2 << std::endl;
// 3--> int to enum
enum enum3 {
A,
B
};
int tmp3 = 222;
enum3 val3 = static_cast<enum3>(tmp3);
std::cout << val3 << std::endl;
// 4--> char[] to string
char arr4[] = "this is a sample";
std::string str4;
str4 = std::string(arr4);
std::cout << str4 << std::endl;
std::string str4_;
str4_.assign(arr4);
std::cout << str4_ << std::endl;
// 5--> char to int
char ch5 = '8';
int val5 = ch5 - '0';// val5 is bounded by 0 to 9
std::cout << val5 << std::endl;
// 6--> char[] to int
char arr6[] = "12345";
int tmp6;
sscanf(arr6, "%d", &tmp6);
std::cout << tmp6 << std::endl;
// 7--> char* to int
char* pch7 = "444";
int tmp7;
tmp7 = atoi(pch7);
std::cout << tmp7 << std::endl;
// 8--> char* to float
char* pch8 = "55.5";
float tmp8;
tmp8 = (float)atof(pch8);
std::cout << tmp8 << std::endl;
// 9--> char* to double
char* pch9 = "66.666";
double tmp9;
tmp9 = atof(pch9);
std::cout << tmp9 << std::endl;
// 10--> float to char[]
float tmp10 = 11.11;
char ch10[20];
sprintf(ch10, "%f", tmp10);
std::cout << ch10 << std::endl;
// 11-> int to char*
int tmp11 = 777;
char* pch11;
char ch11[20];
sprintf(ch11, "%d", tmp11);
pch11 = ch11;
std::cout << pch11 << std::endl;
// 12--> double to char[]
double tmp12 = 8.888;
char arr12[20];
sprintf(arr12, "%f", tmp12);
std::cout << arr12 << std::endl;
// 13--> char* to string
char* pch13 = "hello, world";
std::string str13;
str13 = std::string(pch13);
std::cout << str13 << std::endl;
// 14--> string to char[]
std::string str14 = "dog, cat";
char arr14[256];
strncpy(arr14, str14.c_str(), sizeof(arr14));
arr14[sizeof(arr14)-1] = 0;
std::cout << arr14 << std::endl;
char arr14_[256];
strcpy(arr14_, str14.c_str());
std::cout << arr14_ << std::endl;
// 15--> string to const char*
std::string str15 = "ha ha";
const char* pch15;
pch15 = str15.c_str();
std::cout << pch15 << std::endl;
// 16--> float to int
float ftmp16 = 99.99;
int tmp16;
tmp16 = static_cast<int>(ftmp16);// static_cast<int>(ftmp16 + 0.5)
std::cout << tmp16 << std::endl;
// 17--> vector<float> to float*
std::vector<float> vec;
for (int i = 0; i < 10; i++)
vec.push_back(i * 1.5);
float *p = &vec[0];
for (int i = 0; i < 10; i++)
std::cout << p[i] << std::endl;
// 18--> int[] to vector<int>
int x[5] = { 1, 2, 3, 4, 5 };
std::vector<int> v(x, x + sizeof(x) / sizeof(x[0]));
for (int i = 0; i < v.size(); i++)
std::cout << v[i] << std::endl;
return 0;
}
| 21.421429 | 67 | 0.58086 | shenjl |
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 |
0b3e10342f2dc2676af0fc2fb7604dd21d598ec1 | 1,846 | cc | C++ | src/statistics/KernelConditionalDensityEstimator.cc | revorg7/beliefbox | ba974b17fbb46ac98960f31dea66115be470000e | [
"OLDAP-2.3"
] | 4 | 2015-12-02T23:16:44.000Z | 2018-01-07T10:54:36.000Z | src/statistics/KernelConditionalDensityEstimator.cc | revorg7/beliefbox | ba974b17fbb46ac98960f31dea66115be470000e | [
"OLDAP-2.3"
] | 2 | 2015-12-02T19:47:57.000Z | 2018-10-14T13:08:40.000Z | src/statistics/KernelConditionalDensityEstimator.cc | revorg7/beliefbox | ba974b17fbb46ac98960f31dea66115be470000e | [
"OLDAP-2.3"
] | 4 | 2018-01-14T14:23:18.000Z | 2018-10-29T12:46:41.000Z | /* -*- Mode: C++; -*- */
// copyright (c) 2011 by Christos Dimitrakakis <christos.dimitrakakis@gmail.com>
/***************************************************************************
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 2 of the License, or *
* (at your option) any later version. *
* *
***************************************************************************/
#include "KernelConditionalDensityEstimator.h"
KernelConditionalDensityEstimator::KernelConditionalDensityEstimator(int n_x_dimensions,
int n_y_dimensions,
real initial_bandwidth,
int knn)
: n_x(n_x_dimensions),
n_y(n_y_dimensions),
p_xy(n_x + n_y, initial_bandwidth, knn),
p_x(n_x, initial_bandwidth, knn)
{
}
real KernelConditionalDensityEstimator::Observe(const Vector& x, const Vector& y)
{
real P_xy = p_xy.Observe(Concatenate(x, y));
real P_x = p_x.Observe(x);
return P_xy / P_x;
}
real KernelConditionalDensityEstimator::pdf(const Vector& x, const Vector& y)
{
return exp(log_pdf(x, y));
}
real KernelConditionalDensityEstimator::log_pdf(const Vector& x, const Vector& y)
{
real log_P_xy = p_xy.log_pdf(Concatenate(x, y));
real log_P_x = p_x.log_pdf(x);
return log_P_xy - log_P_x;
}
| 41.022222 | 92 | 0.476165 | revorg7 |
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 |
0b469249080199e9bcdf8396908b779b4f3e1d51 | 4,891 | cpp | C++ | ds/security/passport/common/lkrhash/irtldbg.cpp | npocmaka/Windows-Server-2003 | 5c6fe3db626b63a384230a1aa6b92ac416b0765f | [
"Unlicense"
] | 17 | 2020-11-13T13:42:52.000Z | 2021-09-16T09:13:13.000Z | ds/security/passport/common/lkrhash/irtldbg.cpp | sancho1952007/Windows-Server-2003 | 5c6fe3db626b63a384230a1aa6b92ac416b0765f | [
"Unlicense"
] | 2 | 2020-10-19T08:02:06.000Z | 2020-10-19T08:23:18.000Z | ds/security/passport/common/lkrhash/irtldbg.cpp | sancho1952007/Windows-Server-2003 | 5c6fe3db626b63a384230a1aa6b92ac416b0765f | [
"Unlicense"
] | 14 | 2020-11-14T09:43:20.000Z | 2021-08-28T08:59:57.000Z | /*++
Copyright (c) 1998-2002 Microsoft Corporation
Module Name :
IrtlDbg.cpp
Abstract:
Implementation of debug support functions
Author:
George V. Reilly (GeorgeRe) 06-Jan-1998
Environment:
Win32 - User Mode
Project:
LKRhash
Revision History:
--*/
#include "precomp.hxx"
#include <tchar.h>
#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>
#include <malloc.h>
#define DLL_IMPLEMENTATION
#define IMPLEMENTATION_EXPORT
#include <irtldbg.h>
IRTL_DLLEXP
void __cdecl
IrtlTrace(
LPCTSTR ptszFormat,
...)
{
TCHAR tszBuff[2048];
va_list args;
va_start(args, ptszFormat);
_vsntprintf(tszBuff, sizeof(tszBuff) / sizeof(TCHAR), ptszFormat, args);
tszBuff[2047] = TEXT('\0');
va_end(args);
OutputDebugString(tszBuff);
}
#ifdef IRTLDEBUG
# if defined(USE_DEBUG_CRTS) && defined(_MSC_VER) && (_MSC_VER >= 1000)
# ifdef IRTLDBG_RUNNING_AS_SERVICE
// The default assertion mechanism set up by Visual C++ 4 will not
// work with Active Server Pages because it's running inside a service
// and there is no desktop to interact with.
// Note: for this to work properly, #define _WIN32_WINNT 0x400 before
// including <winuser.h> or MB_SERVICE_NOTIFICATION won't be #define'd.
int __cdecl
AspAssertHandler(
int nReportType,
char* pszErrorText,
int* pnReturn)
{
const char szInfo[] = " (Press ABORT to terminate LKRhash,"
" RETRY to debug this failure,"
" or IGNORE to continue.)";
char* pszMessageTitle = NULL;
int nResult = FALSE;
*pnReturn = 0; // nothing for _CrtDbgReport to do
// These flags enable message boxes to show up on the user's console
switch (nReportType)
{
case _CRT_WARN:
// If using MFC's TRACE macro (AfxTrace), the report hook
// (AspAssertHandler) will get called with _CRT_WARN. Ignore.
pszMessageTitle = "Warning";
*pnReturn = 0;
return FALSE;
case _CRT_ERROR:
pszMessageTitle = "Fatal Error";
break;
case _CRT_ASSERT:
pszMessageTitle = "Assertion Failed";
break;
}
char* pszMessageText =
static_cast<char*>(malloc(strlen(pszErrorText) + strlen(szInfo) + 1));
if (NULL == pszMessageText)
return FALSE;
strcpy(pszMessageText, pszErrorText);
strcat(pszMessageText, szInfo);
const int n = MessageBoxA(NULL, pszMessageText, pszMessageTitle,
(MB_SERVICE_NOTIFICATION | MB_TOPMOST
| MB_ABORTRETRYIGNORE | MB_ICONEXCLAMATION));
if (n == IDABORT)
{
exit(1);
}
else if (n == IDRETRY)
{
*pnReturn = 1; // tell _CrtDbgReport to start the debugger
nResult = TRUE; // tell _CrtDbgReport to run
}
free(pszMessageText);
return nResult;
}
# endif // IRTLDBG_RUNNING_AS_SERVICE
# endif // _MSC_VER >= 1000
void
IrtlDebugInit()
{
# if defined(USE_DEBUG_CRTS) && defined(_MSC_VER) && (_MSC_VER >= 1000)
# ifdef IRTLDBG_RUNNING_AS_SERVICE
// If we end up in _CrtDbgReport, don't put up a message box
// _CrtSetReportMode(_CRT_WARN, _CRTDBG_MODE_DEBUG);
_CrtSetReportMode(_CRT_ASSERT, _CRTDBG_MODE_DEBUG);
_CrtSetReportMode(_CRT_ERROR, _CRTDBG_MODE_DEBUG);
// Use AspAssertHandler to put up a message box instead
_CrtSetReportHook(AspAssertHandler);
# endif // IRTLDBG_RUNNING_AS_SERVICE
// Enable debug heap allocations & check for memory leaks at program exit
// The memory leak check will not be performed if inetinfo.exe is
// run directly under a debugger, only if it is run as a service.
_CrtSetDbgFlag(_CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF
| _CrtSetDbgFlag(_CRTDBG_REPORT_FLAG));
# endif // _MSC_VER >= 1000
}
void
IrtlDebugTerm()
{
# if defined(USE_DEBUG_CRTS) && defined(_MSC_VER) && (_MSC_VER >= 1000)
# ifdef IRTLDBG_RUNNING_AS_SERVICE
// Turn off AspAssertHandler, so that we don't get numerous message boxes
// if there are memory leaks on shutdown
_CrtSetReportHook(NULL);
# endif // IRTLDBG_RUNNING_AS_SERVICE
# endif // _MSC_VER >= 1000
}
#endif //IRTLDEBUG
BOOL
IsValidString(
LPCTSTR ptsz,
int nLength /* =-1 */)
{
if (ptsz == NULL)
return FALSE;
return !IsBadStringPtr(ptsz, nLength);
}
BOOL
IsValidAddress(
LPCVOID pv,
UINT nBytes,
BOOL fReadWrite /* =TRUE */)
{
return (pv != NULL
&& !IsBadReadPtr(pv, nBytes)
&& (!fReadWrite || !IsBadWritePtr((LPVOID) pv, nBytes)));
}
| 24.455 | 79 | 0.61787 | npocmaka |
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 |
0b5783013d2d4798a0af17704b8f2b4dca8cebf5 | 6,231 | cpp | C++ | testing/adios2/bindings/C/TestBPWriteTypesHighLevel.cpp | williamfgc/ADIOS2 | 21b686d3737eeb21a3c10ab8de8dde8c5a2f9bb3 | [
"ECL-2.0",
"Apache-2.0"
] | null | null | null | testing/adios2/bindings/C/TestBPWriteTypesHighLevel.cpp | williamfgc/ADIOS2 | 21b686d3737eeb21a3c10ab8de8dde8c5a2f9bb3 | [
"ECL-2.0",
"Apache-2.0"
] | 4 | 2017-06-12T13:41:45.000Z | 2017-12-13T17:01:40.000Z | testing/adios2/bindings/C/TestBPWriteTypesHighLevel.cpp | williamfgc/ADIOS2 | 21b686d3737eeb21a3c10ab8de8dde8c5a2f9bb3 | [
"ECL-2.0",
"Apache-2.0"
] | 3 | 2017-08-16T17:06:04.000Z | 2017-08-17T14:29:38.000Z | /*
* Distributed under the OSI-approved Apache License, Version 2.0. See
* accompanying file Copyright.txt for details.
*
* TestBPWriteTypesHighLevel.cpp : C-bindings high-level stream API
*
* Created on: Feb 28, 2018
* Author: William F Godoy
*/
#include <adios2_c.h>
#ifdef ADIOS2_HAVE_MPI
#include <mpi.h>
#endif
#include <gtest/gtest.h>
#include "SmallTestData_c.h"
class BPWriteTypesHighLevel : public ::testing::Test
{
public:
BPWriteTypesHighLevel() = default;
};
TEST_F(BPWriteTypesHighLevel, ADIOS2BPWriteTypes)
{
int rank = 0;
int size = 1;
#ifdef ADIOS2_HAVE_MPI
MPI_Comm_rank(MPI_COMM_WORLD, &rank);
MPI_Comm_size(MPI_COMM_WORLD, &size);
adios2_FILE *fhw =
adios2_fopen("ctypes_hl.bp", adios2_mode_write, MPI_COMM_WORLD);
#else
adios2_FILE *fhw = adios2_fopen_nompi("ctypes_hl.bp", adios2_mode_write);
#endif
size_t shape[1];
shape[0] = (size_t)size * data_Nx;
size_t start[1];
start[0] = (size_t)rank * data_Nx;
size_t count[1];
count[0] = data_Nx;
adios2_fwrite(fhw, "varString", adios2_type_string, "hello stream", 1,
shape, start, count, 0);
adios2_fwrite(fhw, "varI8", adios2_type_int8_t, data_I8, 1, shape, start,
count, 0);
adios2_fwrite(fhw, "varI16", adios2_type_int16_t, data_I16, 1, shape, start,
count, 0);
adios2_fwrite(fhw, "varI32", adios2_type_int32_t, data_I32, 1, shape, start,
count, 0);
adios2_fwrite(fhw, "varI64", adios2_type_int64_t, data_I64, 1, shape, start,
count, 0);
adios2_fwrite(fhw, "varU8", adios2_type_uint8_t, data_U8, 1, shape, start,
count, 0);
adios2_fwrite(fhw, "varU16", adios2_type_uint16_t, data_U16, 1, shape,
start, count, 0);
adios2_fwrite(fhw, "varU32", adios2_type_uint32_t, data_U32, 1, shape,
start, count, 0);
adios2_fwrite(fhw, "varU64", adios2_type_uint64_t, data_U64, 1, shape,
start, count, 0);
adios2_fwrite(fhw, "varR32", adios2_type_float, data_R32, 1, shape, start,
count, 0);
adios2_fwrite(fhw, "varR64", adios2_type_double, data_R64, 1, shape, start,
count, 0);
adios2_fclose(fhw);
{
// for reading
#ifdef ADIOS2_HAVE_MPI
adios2_FILE *fhr =
adios2_fopen("ctypes_hl.bp", adios2_mode_read, MPI_COMM_WORLD);
#else
adios2_FILE *fhr = adios2_fopen_nompi("ctypes_hl.bp", adios2_mode_read);
#endif
const size_t data_size = 10;
char *idata_String = (char *)malloc(13);
int8_t *idata_I8 = (int8_t *)malloc(data_size * sizeof(int8_t));
int16_t *idata_I16 = (int16_t *)malloc(data_size * sizeof(int16_t));
int32_t *idata_I32 = (int32_t *)malloc(data_size * sizeof(int32_t));
int64_t *idata_I64 = (int64_t *)malloc(data_size * sizeof(int64_t));
uint8_t *idata_U8 = (uint8_t *)malloc(data_size * sizeof(uint8_t));
uint16_t *idata_U16 = (uint16_t *)malloc(data_size * sizeof(uint16_t));
uint32_t *idata_U32 = (uint32_t *)malloc(data_size * sizeof(uint32_t));
uint64_t *idata_U64 = (uint64_t *)malloc(data_size * sizeof(uint64_t));
float *idata_R32 = (float *)malloc(data_size * sizeof(float));
double *idata_R64 = (double *)malloc(data_size * sizeof(double));
size_t selection_start[1];
selection_start[0] = 0;
size_t selection_count[1];
selection_count[0] = data_size;
adios2_fread(fhr, "varString", adios2_type_string, idata_String, 1,
NULL, NULL, 0);
adios2_fread(fhr, "varI8", adios2_type_int8_t, idata_I8, 1,
selection_start, selection_count, 0);
adios2_fread(fhr, "varI16", adios2_type_int16_t, idata_I16, 1,
selection_start, selection_count, 0);
adios2_fread(fhr, "varI32", adios2_type_int32_t, idata_I32, 1,
selection_start, selection_count, 0);
adios2_fread(fhr, "varI64", adios2_type_int64_t, idata_I64, 1,
selection_start, selection_count, 0);
adios2_fread(fhr, "varU8", adios2_type_uint8_t, idata_U8, 1,
selection_start, selection_count, 0);
adios2_fread(fhr, "varU16", adios2_type_uint16_t, idata_U16, 1,
selection_start, selection_count, 0);
adios2_fread(fhr, "varU32", adios2_type_uint32_t, idata_U32, 1,
selection_start, selection_count, 0);
adios2_fread(fhr, "varU64", adios2_type_uint64_t, idata_U64, 1,
selection_start, selection_count, 0);
adios2_fread(fhr, "varR32", adios2_type_float, idata_R32, 1,
selection_start, selection_count, 0);
adios2_fread(fhr, "varR64", adios2_type_double, idata_R64, 1,
selection_start, selection_count, 0);
EXPECT_EQ(strcmp(idata_String, "hello stream"), 0);
for (size_t i = 0; i < data_size; ++i)
{
EXPECT_EQ(idata_I8[i], data_I8[i]);
EXPECT_EQ(idata_I16[i], data_I16[i]);
EXPECT_EQ(idata_I32[i], data_I32[i]);
EXPECT_EQ(idata_I64[i], data_I64[i]);
EXPECT_EQ(idata_U8[i], data_U8[i]);
EXPECT_EQ(idata_U16[i], data_U16[i]);
EXPECT_EQ(idata_U32[i], data_U32[i]);
EXPECT_EQ(idata_U64[i], data_U64[i]);
EXPECT_EQ(idata_R32[i], data_R32[i]);
EXPECT_EQ(idata_R64[i], data_R64[i]);
}
free(idata_String);
free(idata_I8);
free(idata_I16);
free(idata_I32);
free(idata_I64);
free(idata_U8);
free(idata_U16);
free(idata_U32);
free(idata_U64);
}
}
//******************************************************************************
// main
//******************************************************************************
int main(int argc, char **argv)
{
#ifdef ADIOS2_HAVE_MPI
MPI_Init(nullptr, nullptr);
#endif
int result;
::testing::InitGoogleTest(&argc, argv);
result = RUN_ALL_TESTS();
#ifdef ADIOS2_HAVE_MPI
MPI_Finalize();
#endif
return result;
}
| 34.616667 | 80 | 0.606805 | williamfgc |
0b57c6d958778b7c62380d4decc2ece2897a305a | 599,819 | cpp | C++ | message/generation/swift-mt-generation/repository/SR2018/parsers/SwiftMtParser_MT565Parser.cpp | Yanick-Salzmann/message-converter-c | 6dfdf56e12f19e0f0b63ee0354fda16968f36415 | [
"MIT"
] | null | null | null | message/generation/swift-mt-generation/repository/SR2018/parsers/SwiftMtParser_MT565Parser.cpp | Yanick-Salzmann/message-converter-c | 6dfdf56e12f19e0f0b63ee0354fda16968f36415 | [
"MIT"
] | null | null | null | message/generation/swift-mt-generation/repository/SR2018/parsers/SwiftMtParser_MT565Parser.cpp | Yanick-Salzmann/message-converter-c | 6dfdf56e12f19e0f0b63ee0354fda16968f36415 | [
"MIT"
] | null | null | null |
#include "repository/ISwiftMtParser.h"
#include "SwiftMtMessage.pb.h"
#include <vector>
#include <string>
#include "BaseErrorListener.h"
#include "SwiftMtParser_MT565Lexer.h"
// Generated from C:/programming/message-converter-c/message/generation/swift-mt-generation/repository/SR2018/grammars/SwiftMtParser_MT565.g4 by ANTLR 4.7.2
#include "SwiftMtParser_MT565Listener.h"
#include "SwiftMtParser_MT565Parser.h"
using namespace antlrcpp;
using namespace message::definition::swift::mt::parsers::sr2018;
using namespace antlr4;
SwiftMtParser_MT565Parser::SwiftMtParser_MT565Parser(TokenStream *input) : Parser(input) {
_interpreter = new atn::ParserATNSimulator(this, _atn, _decisionToDFA, _sharedContextCache);
}
SwiftMtParser_MT565Parser::~SwiftMtParser_MT565Parser() {
delete _interpreter;
}
std::string SwiftMtParser_MT565Parser::getGrammarFileName() const {
return "SwiftMtParser_MT565.g4";
}
const std::vector<std::string>& SwiftMtParser_MT565Parser::getRuleNames() const {
return _ruleNames;
}
dfa::Vocabulary& SwiftMtParser_MT565Parser::getVocabulary() const {
return _vocabulary;
}
//----------------- MessageContext ------------------------------------------------------------------
SwiftMtParser_MT565Parser::MessageContext::MessageContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
SwiftMtParser_MT565Parser::BhContext* SwiftMtParser_MT565Parser::MessageContext::bh() {
return getRuleContext<SwiftMtParser_MT565Parser::BhContext>(0);
}
SwiftMtParser_MT565Parser::AhContext* SwiftMtParser_MT565Parser::MessageContext::ah() {
return getRuleContext<SwiftMtParser_MT565Parser::AhContext>(0);
}
SwiftMtParser_MT565Parser::MtContext* SwiftMtParser_MT565Parser::MessageContext::mt() {
return getRuleContext<SwiftMtParser_MT565Parser::MtContext>(0);
}
tree::TerminalNode* SwiftMtParser_MT565Parser::MessageContext::EOF() {
return getToken(SwiftMtParser_MT565Parser::EOF, 0);
}
SwiftMtParser_MT565Parser::UhContext* SwiftMtParser_MT565Parser::MessageContext::uh() {
return getRuleContext<SwiftMtParser_MT565Parser::UhContext>(0);
}
SwiftMtParser_MT565Parser::TrContext* SwiftMtParser_MT565Parser::MessageContext::tr() {
return getRuleContext<SwiftMtParser_MT565Parser::TrContext>(0);
}
size_t SwiftMtParser_MT565Parser::MessageContext::getRuleIndex() const {
return SwiftMtParser_MT565Parser::RuleMessage;
}
void SwiftMtParser_MT565Parser::MessageContext::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->enterMessage(this);
}
void SwiftMtParser_MT565Parser::MessageContext::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->exitMessage(this);
}
SwiftMtParser_MT565Parser::MessageContext* SwiftMtParser_MT565Parser::message() {
MessageContext *_localctx = _tracker.createInstance<MessageContext>(_ctx, getState());
enterRule(_localctx, 0, SwiftMtParser_MT565Parser::RuleMessage);
size_t _la = 0;
auto onExit = finally([=] {
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(260);
bh();
setState(261);
ah();
setState(263);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == SwiftMtParser_MT565Parser::TAG_UH) {
setState(262);
uh();
}
setState(265);
mt();
setState(267);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == SwiftMtParser_MT565Parser::TAG_TR) {
setState(266);
tr();
}
setState(269);
match(SwiftMtParser_MT565Parser::EOF);
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- BhContext ------------------------------------------------------------------
SwiftMtParser_MT565Parser::BhContext::BhContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
tree::TerminalNode* SwiftMtParser_MT565Parser::BhContext::TAG_BH() {
return getToken(SwiftMtParser_MT565Parser::TAG_BH, 0);
}
SwiftMtParser_MT565Parser::Bh_contentContext* SwiftMtParser_MT565Parser::BhContext::bh_content() {
return getRuleContext<SwiftMtParser_MT565Parser::Bh_contentContext>(0);
}
tree::TerminalNode* SwiftMtParser_MT565Parser::BhContext::RBRACE() {
return getToken(SwiftMtParser_MT565Parser::RBRACE, 0);
}
size_t SwiftMtParser_MT565Parser::BhContext::getRuleIndex() const {
return SwiftMtParser_MT565Parser::RuleBh;
}
void SwiftMtParser_MT565Parser::BhContext::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->enterBh(this);
}
void SwiftMtParser_MT565Parser::BhContext::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->exitBh(this);
}
SwiftMtParser_MT565Parser::BhContext* SwiftMtParser_MT565Parser::bh() {
BhContext *_localctx = _tracker.createInstance<BhContext>(_ctx, getState());
enterRule(_localctx, 2, SwiftMtParser_MT565Parser::RuleBh);
auto onExit = finally([=] {
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(271);
match(SwiftMtParser_MT565Parser::TAG_BH);
setState(272);
bh_content();
setState(273);
match(SwiftMtParser_MT565Parser::RBRACE);
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- Bh_contentContext ------------------------------------------------------------------
SwiftMtParser_MT565Parser::Bh_contentContext::Bh_contentContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
std::vector<tree::TerminalNode *> SwiftMtParser_MT565Parser::Bh_contentContext::RBRACE() {
return getTokens(SwiftMtParser_MT565Parser::RBRACE);
}
tree::TerminalNode* SwiftMtParser_MT565Parser::Bh_contentContext::RBRACE(size_t i) {
return getToken(SwiftMtParser_MT565Parser::RBRACE, i);
}
size_t SwiftMtParser_MT565Parser::Bh_contentContext::getRuleIndex() const {
return SwiftMtParser_MT565Parser::RuleBh_content;
}
void SwiftMtParser_MT565Parser::Bh_contentContext::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->enterBh_content(this);
}
void SwiftMtParser_MT565Parser::Bh_contentContext::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->exitBh_content(this);
}
SwiftMtParser_MT565Parser::Bh_contentContext* SwiftMtParser_MT565Parser::bh_content() {
Bh_contentContext *_localctx = _tracker.createInstance<Bh_contentContext>(_ctx, getState());
enterRule(_localctx, 4, SwiftMtParser_MT565Parser::RuleBh_content);
size_t _la = 0;
auto onExit = finally([=] {
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(276);
_errHandler->sync(this);
_la = _input->LA(1);
do {
setState(275);
_la = _input->LA(1);
if (_la == 0 || _la == Token::EOF || (_la == SwiftMtParser_MT565Parser::RBRACE)) {
_errHandler->recoverInline(this);
}
else {
_errHandler->reportMatch(this);
consume();
}
setState(278);
_errHandler->sync(this);
_la = _input->LA(1);
} while ((((_la & ~ 0x3fULL) == 0) &&
((1ULL << _la) & ((1ULL << SwiftMtParser_MT565Parser::T__0)
| (1ULL << SwiftMtParser_MT565Parser::T__1)
| (1ULL << SwiftMtParser_MT565Parser::T__2)
| (1ULL << SwiftMtParser_MT565Parser::T__3)
| (1ULL << SwiftMtParser_MT565Parser::T__4)
| (1ULL << SwiftMtParser_MT565Parser::T__5)
| (1ULL << SwiftMtParser_MT565Parser::T__6)
| (1ULL << SwiftMtParser_MT565Parser::T__7)
| (1ULL << SwiftMtParser_MT565Parser::T__8)
| (1ULL << SwiftMtParser_MT565Parser::T__9)
| (1ULL << SwiftMtParser_MT565Parser::T__10)
| (1ULL << SwiftMtParser_MT565Parser::T__11)
| (1ULL << SwiftMtParser_MT565Parser::T__12)
| (1ULL << SwiftMtParser_MT565Parser::T__13)
| (1ULL << SwiftMtParser_MT565Parser::T__14)
| (1ULL << SwiftMtParser_MT565Parser::T__15)
| (1ULL << SwiftMtParser_MT565Parser::T__16)
| (1ULL << SwiftMtParser_MT565Parser::T__17)
| (1ULL << SwiftMtParser_MT565Parser::T__18)
| (1ULL << SwiftMtParser_MT565Parser::T__19)
| (1ULL << SwiftMtParser_MT565Parser::T__20)
| (1ULL << SwiftMtParser_MT565Parser::T__21)
| (1ULL << SwiftMtParser_MT565Parser::T__22)
| (1ULL << SwiftMtParser_MT565Parser::T__23)
| (1ULL << SwiftMtParser_MT565Parser::T__24)
| (1ULL << SwiftMtParser_MT565Parser::T__25)
| (1ULL << SwiftMtParser_MT565Parser::T__26)
| (1ULL << SwiftMtParser_MT565Parser::T__27)
| (1ULL << SwiftMtParser_MT565Parser::T__28)
| (1ULL << SwiftMtParser_MT565Parser::T__29)
| (1ULL << SwiftMtParser_MT565Parser::T__30)
| (1ULL << SwiftMtParser_MT565Parser::T__31)
| (1ULL << SwiftMtParser_MT565Parser::T__32)
| (1ULL << SwiftMtParser_MT565Parser::T__33)
| (1ULL << SwiftMtParser_MT565Parser::T__34)
| (1ULL << SwiftMtParser_MT565Parser::T__35)
| (1ULL << SwiftMtParser_MT565Parser::T__36)
| (1ULL << SwiftMtParser_MT565Parser::T__37)
| (1ULL << SwiftMtParser_MT565Parser::TAG_BH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_AH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_UH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_MT)
| (1ULL << SwiftMtParser_MT565Parser::TAG_TR)
| (1ULL << SwiftMtParser_MT565Parser::MT_END)
| (1ULL << SwiftMtParser_MT565Parser::LBRACE)
| (1ULL << SwiftMtParser_MT565Parser::COLON)
| (1ULL << SwiftMtParser_MT565Parser::START_OF_FIELD)
| (1ULL << SwiftMtParser_MT565Parser::ANY))) != 0));
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- AhContext ------------------------------------------------------------------
SwiftMtParser_MT565Parser::AhContext::AhContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
tree::TerminalNode* SwiftMtParser_MT565Parser::AhContext::TAG_AH() {
return getToken(SwiftMtParser_MT565Parser::TAG_AH, 0);
}
SwiftMtParser_MT565Parser::Ah_contentContext* SwiftMtParser_MT565Parser::AhContext::ah_content() {
return getRuleContext<SwiftMtParser_MT565Parser::Ah_contentContext>(0);
}
tree::TerminalNode* SwiftMtParser_MT565Parser::AhContext::RBRACE() {
return getToken(SwiftMtParser_MT565Parser::RBRACE, 0);
}
size_t SwiftMtParser_MT565Parser::AhContext::getRuleIndex() const {
return SwiftMtParser_MT565Parser::RuleAh;
}
void SwiftMtParser_MT565Parser::AhContext::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->enterAh(this);
}
void SwiftMtParser_MT565Parser::AhContext::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->exitAh(this);
}
SwiftMtParser_MT565Parser::AhContext* SwiftMtParser_MT565Parser::ah() {
AhContext *_localctx = _tracker.createInstance<AhContext>(_ctx, getState());
enterRule(_localctx, 6, SwiftMtParser_MT565Parser::RuleAh);
auto onExit = finally([=] {
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(280);
match(SwiftMtParser_MT565Parser::TAG_AH);
setState(281);
ah_content();
setState(282);
match(SwiftMtParser_MT565Parser::RBRACE);
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- Ah_contentContext ------------------------------------------------------------------
SwiftMtParser_MT565Parser::Ah_contentContext::Ah_contentContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
std::vector<tree::TerminalNode *> SwiftMtParser_MT565Parser::Ah_contentContext::RBRACE() {
return getTokens(SwiftMtParser_MT565Parser::RBRACE);
}
tree::TerminalNode* SwiftMtParser_MT565Parser::Ah_contentContext::RBRACE(size_t i) {
return getToken(SwiftMtParser_MT565Parser::RBRACE, i);
}
size_t SwiftMtParser_MT565Parser::Ah_contentContext::getRuleIndex() const {
return SwiftMtParser_MT565Parser::RuleAh_content;
}
void SwiftMtParser_MT565Parser::Ah_contentContext::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->enterAh_content(this);
}
void SwiftMtParser_MT565Parser::Ah_contentContext::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->exitAh_content(this);
}
SwiftMtParser_MT565Parser::Ah_contentContext* SwiftMtParser_MT565Parser::ah_content() {
Ah_contentContext *_localctx = _tracker.createInstance<Ah_contentContext>(_ctx, getState());
enterRule(_localctx, 8, SwiftMtParser_MT565Parser::RuleAh_content);
size_t _la = 0;
auto onExit = finally([=] {
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(285);
_errHandler->sync(this);
_la = _input->LA(1);
do {
setState(284);
_la = _input->LA(1);
if (_la == 0 || _la == Token::EOF || (_la == SwiftMtParser_MT565Parser::RBRACE)) {
_errHandler->recoverInline(this);
}
else {
_errHandler->reportMatch(this);
consume();
}
setState(287);
_errHandler->sync(this);
_la = _input->LA(1);
} while ((((_la & ~ 0x3fULL) == 0) &&
((1ULL << _la) & ((1ULL << SwiftMtParser_MT565Parser::T__0)
| (1ULL << SwiftMtParser_MT565Parser::T__1)
| (1ULL << SwiftMtParser_MT565Parser::T__2)
| (1ULL << SwiftMtParser_MT565Parser::T__3)
| (1ULL << SwiftMtParser_MT565Parser::T__4)
| (1ULL << SwiftMtParser_MT565Parser::T__5)
| (1ULL << SwiftMtParser_MT565Parser::T__6)
| (1ULL << SwiftMtParser_MT565Parser::T__7)
| (1ULL << SwiftMtParser_MT565Parser::T__8)
| (1ULL << SwiftMtParser_MT565Parser::T__9)
| (1ULL << SwiftMtParser_MT565Parser::T__10)
| (1ULL << SwiftMtParser_MT565Parser::T__11)
| (1ULL << SwiftMtParser_MT565Parser::T__12)
| (1ULL << SwiftMtParser_MT565Parser::T__13)
| (1ULL << SwiftMtParser_MT565Parser::T__14)
| (1ULL << SwiftMtParser_MT565Parser::T__15)
| (1ULL << SwiftMtParser_MT565Parser::T__16)
| (1ULL << SwiftMtParser_MT565Parser::T__17)
| (1ULL << SwiftMtParser_MT565Parser::T__18)
| (1ULL << SwiftMtParser_MT565Parser::T__19)
| (1ULL << SwiftMtParser_MT565Parser::T__20)
| (1ULL << SwiftMtParser_MT565Parser::T__21)
| (1ULL << SwiftMtParser_MT565Parser::T__22)
| (1ULL << SwiftMtParser_MT565Parser::T__23)
| (1ULL << SwiftMtParser_MT565Parser::T__24)
| (1ULL << SwiftMtParser_MT565Parser::T__25)
| (1ULL << SwiftMtParser_MT565Parser::T__26)
| (1ULL << SwiftMtParser_MT565Parser::T__27)
| (1ULL << SwiftMtParser_MT565Parser::T__28)
| (1ULL << SwiftMtParser_MT565Parser::T__29)
| (1ULL << SwiftMtParser_MT565Parser::T__30)
| (1ULL << SwiftMtParser_MT565Parser::T__31)
| (1ULL << SwiftMtParser_MT565Parser::T__32)
| (1ULL << SwiftMtParser_MT565Parser::T__33)
| (1ULL << SwiftMtParser_MT565Parser::T__34)
| (1ULL << SwiftMtParser_MT565Parser::T__35)
| (1ULL << SwiftMtParser_MT565Parser::T__36)
| (1ULL << SwiftMtParser_MT565Parser::T__37)
| (1ULL << SwiftMtParser_MT565Parser::TAG_BH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_AH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_UH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_MT)
| (1ULL << SwiftMtParser_MT565Parser::TAG_TR)
| (1ULL << SwiftMtParser_MT565Parser::MT_END)
| (1ULL << SwiftMtParser_MT565Parser::LBRACE)
| (1ULL << SwiftMtParser_MT565Parser::COLON)
| (1ULL << SwiftMtParser_MT565Parser::START_OF_FIELD)
| (1ULL << SwiftMtParser_MT565Parser::ANY))) != 0));
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- UhContext ------------------------------------------------------------------
SwiftMtParser_MT565Parser::UhContext::UhContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
tree::TerminalNode* SwiftMtParser_MT565Parser::UhContext::TAG_UH() {
return getToken(SwiftMtParser_MT565Parser::TAG_UH, 0);
}
SwiftMtParser_MT565Parser::Sys_blockContext* SwiftMtParser_MT565Parser::UhContext::sys_block() {
return getRuleContext<SwiftMtParser_MT565Parser::Sys_blockContext>(0);
}
tree::TerminalNode* SwiftMtParser_MT565Parser::UhContext::RBRACE() {
return getToken(SwiftMtParser_MT565Parser::RBRACE, 0);
}
size_t SwiftMtParser_MT565Parser::UhContext::getRuleIndex() const {
return SwiftMtParser_MT565Parser::RuleUh;
}
void SwiftMtParser_MT565Parser::UhContext::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->enterUh(this);
}
void SwiftMtParser_MT565Parser::UhContext::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->exitUh(this);
}
SwiftMtParser_MT565Parser::UhContext* SwiftMtParser_MT565Parser::uh() {
UhContext *_localctx = _tracker.createInstance<UhContext>(_ctx, getState());
enterRule(_localctx, 10, SwiftMtParser_MT565Parser::RuleUh);
auto onExit = finally([=] {
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(289);
match(SwiftMtParser_MT565Parser::TAG_UH);
setState(290);
sys_block();
setState(291);
match(SwiftMtParser_MT565Parser::RBRACE);
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- TrContext ------------------------------------------------------------------
SwiftMtParser_MT565Parser::TrContext::TrContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
tree::TerminalNode* SwiftMtParser_MT565Parser::TrContext::TAG_TR() {
return getToken(SwiftMtParser_MT565Parser::TAG_TR, 0);
}
SwiftMtParser_MT565Parser::Sys_blockContext* SwiftMtParser_MT565Parser::TrContext::sys_block() {
return getRuleContext<SwiftMtParser_MT565Parser::Sys_blockContext>(0);
}
tree::TerminalNode* SwiftMtParser_MT565Parser::TrContext::RBRACE() {
return getToken(SwiftMtParser_MT565Parser::RBRACE, 0);
}
size_t SwiftMtParser_MT565Parser::TrContext::getRuleIndex() const {
return SwiftMtParser_MT565Parser::RuleTr;
}
void SwiftMtParser_MT565Parser::TrContext::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->enterTr(this);
}
void SwiftMtParser_MT565Parser::TrContext::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->exitTr(this);
}
SwiftMtParser_MT565Parser::TrContext* SwiftMtParser_MT565Parser::tr() {
TrContext *_localctx = _tracker.createInstance<TrContext>(_ctx, getState());
enterRule(_localctx, 12, SwiftMtParser_MT565Parser::RuleTr);
auto onExit = finally([=] {
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(293);
match(SwiftMtParser_MT565Parser::TAG_TR);
setState(294);
sys_block();
setState(295);
match(SwiftMtParser_MT565Parser::RBRACE);
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- Sys_blockContext ------------------------------------------------------------------
SwiftMtParser_MT565Parser::Sys_blockContext::Sys_blockContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
std::vector<SwiftMtParser_MT565Parser::Sys_elementContext *> SwiftMtParser_MT565Parser::Sys_blockContext::sys_element() {
return getRuleContexts<SwiftMtParser_MT565Parser::Sys_elementContext>();
}
SwiftMtParser_MT565Parser::Sys_elementContext* SwiftMtParser_MT565Parser::Sys_blockContext::sys_element(size_t i) {
return getRuleContext<SwiftMtParser_MT565Parser::Sys_elementContext>(i);
}
size_t SwiftMtParser_MT565Parser::Sys_blockContext::getRuleIndex() const {
return SwiftMtParser_MT565Parser::RuleSys_block;
}
void SwiftMtParser_MT565Parser::Sys_blockContext::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->enterSys_block(this);
}
void SwiftMtParser_MT565Parser::Sys_blockContext::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->exitSys_block(this);
}
SwiftMtParser_MT565Parser::Sys_blockContext* SwiftMtParser_MT565Parser::sys_block() {
Sys_blockContext *_localctx = _tracker.createInstance<Sys_blockContext>(_ctx, getState());
enterRule(_localctx, 14, SwiftMtParser_MT565Parser::RuleSys_block);
size_t _la = 0;
auto onExit = finally([=] {
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(298);
_errHandler->sync(this);
_la = _input->LA(1);
do {
setState(297);
sys_element();
setState(300);
_errHandler->sync(this);
_la = _input->LA(1);
} while (_la == SwiftMtParser_MT565Parser::LBRACE);
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- Sys_elementContext ------------------------------------------------------------------
SwiftMtParser_MT565Parser::Sys_elementContext::Sys_elementContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
tree::TerminalNode* SwiftMtParser_MT565Parser::Sys_elementContext::LBRACE() {
return getToken(SwiftMtParser_MT565Parser::LBRACE, 0);
}
SwiftMtParser_MT565Parser::Sys_element_keyContext* SwiftMtParser_MT565Parser::Sys_elementContext::sys_element_key() {
return getRuleContext<SwiftMtParser_MT565Parser::Sys_element_keyContext>(0);
}
tree::TerminalNode* SwiftMtParser_MT565Parser::Sys_elementContext::COLON() {
return getToken(SwiftMtParser_MT565Parser::COLON, 0);
}
SwiftMtParser_MT565Parser::Sys_element_contentContext* SwiftMtParser_MT565Parser::Sys_elementContext::sys_element_content() {
return getRuleContext<SwiftMtParser_MT565Parser::Sys_element_contentContext>(0);
}
tree::TerminalNode* SwiftMtParser_MT565Parser::Sys_elementContext::RBRACE() {
return getToken(SwiftMtParser_MT565Parser::RBRACE, 0);
}
size_t SwiftMtParser_MT565Parser::Sys_elementContext::getRuleIndex() const {
return SwiftMtParser_MT565Parser::RuleSys_element;
}
void SwiftMtParser_MT565Parser::Sys_elementContext::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->enterSys_element(this);
}
void SwiftMtParser_MT565Parser::Sys_elementContext::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->exitSys_element(this);
}
SwiftMtParser_MT565Parser::Sys_elementContext* SwiftMtParser_MT565Parser::sys_element() {
Sys_elementContext *_localctx = _tracker.createInstance<Sys_elementContext>(_ctx, getState());
enterRule(_localctx, 16, SwiftMtParser_MT565Parser::RuleSys_element);
auto onExit = finally([=] {
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(302);
match(SwiftMtParser_MT565Parser::LBRACE);
setState(303);
sys_element_key();
setState(304);
match(SwiftMtParser_MT565Parser::COLON);
setState(305);
sys_element_content();
setState(306);
match(SwiftMtParser_MT565Parser::RBRACE);
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- Sys_element_keyContext ------------------------------------------------------------------
SwiftMtParser_MT565Parser::Sys_element_keyContext::Sys_element_keyContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
std::vector<tree::TerminalNode *> SwiftMtParser_MT565Parser::Sys_element_keyContext::COLON() {
return getTokens(SwiftMtParser_MT565Parser::COLON);
}
tree::TerminalNode* SwiftMtParser_MT565Parser::Sys_element_keyContext::COLON(size_t i) {
return getToken(SwiftMtParser_MT565Parser::COLON, i);
}
std::vector<tree::TerminalNode *> SwiftMtParser_MT565Parser::Sys_element_keyContext::RBRACE() {
return getTokens(SwiftMtParser_MT565Parser::RBRACE);
}
tree::TerminalNode* SwiftMtParser_MT565Parser::Sys_element_keyContext::RBRACE(size_t i) {
return getToken(SwiftMtParser_MT565Parser::RBRACE, i);
}
size_t SwiftMtParser_MT565Parser::Sys_element_keyContext::getRuleIndex() const {
return SwiftMtParser_MT565Parser::RuleSys_element_key;
}
void SwiftMtParser_MT565Parser::Sys_element_keyContext::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->enterSys_element_key(this);
}
void SwiftMtParser_MT565Parser::Sys_element_keyContext::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->exitSys_element_key(this);
}
SwiftMtParser_MT565Parser::Sys_element_keyContext* SwiftMtParser_MT565Parser::sys_element_key() {
Sys_element_keyContext *_localctx = _tracker.createInstance<Sys_element_keyContext>(_ctx, getState());
enterRule(_localctx, 18, SwiftMtParser_MT565Parser::RuleSys_element_key);
size_t _la = 0;
auto onExit = finally([=] {
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(309);
_errHandler->sync(this);
_la = _input->LA(1);
do {
setState(308);
_la = _input->LA(1);
if (_la == 0 || _la == Token::EOF || (_la == SwiftMtParser_MT565Parser::RBRACE
|| _la == SwiftMtParser_MT565Parser::COLON)) {
_errHandler->recoverInline(this);
}
else {
_errHandler->reportMatch(this);
consume();
}
setState(311);
_errHandler->sync(this);
_la = _input->LA(1);
} while ((((_la & ~ 0x3fULL) == 0) &&
((1ULL << _la) & ((1ULL << SwiftMtParser_MT565Parser::T__0)
| (1ULL << SwiftMtParser_MT565Parser::T__1)
| (1ULL << SwiftMtParser_MT565Parser::T__2)
| (1ULL << SwiftMtParser_MT565Parser::T__3)
| (1ULL << SwiftMtParser_MT565Parser::T__4)
| (1ULL << SwiftMtParser_MT565Parser::T__5)
| (1ULL << SwiftMtParser_MT565Parser::T__6)
| (1ULL << SwiftMtParser_MT565Parser::T__7)
| (1ULL << SwiftMtParser_MT565Parser::T__8)
| (1ULL << SwiftMtParser_MT565Parser::T__9)
| (1ULL << SwiftMtParser_MT565Parser::T__10)
| (1ULL << SwiftMtParser_MT565Parser::T__11)
| (1ULL << SwiftMtParser_MT565Parser::T__12)
| (1ULL << SwiftMtParser_MT565Parser::T__13)
| (1ULL << SwiftMtParser_MT565Parser::T__14)
| (1ULL << SwiftMtParser_MT565Parser::T__15)
| (1ULL << SwiftMtParser_MT565Parser::T__16)
| (1ULL << SwiftMtParser_MT565Parser::T__17)
| (1ULL << SwiftMtParser_MT565Parser::T__18)
| (1ULL << SwiftMtParser_MT565Parser::T__19)
| (1ULL << SwiftMtParser_MT565Parser::T__20)
| (1ULL << SwiftMtParser_MT565Parser::T__21)
| (1ULL << SwiftMtParser_MT565Parser::T__22)
| (1ULL << SwiftMtParser_MT565Parser::T__23)
| (1ULL << SwiftMtParser_MT565Parser::T__24)
| (1ULL << SwiftMtParser_MT565Parser::T__25)
| (1ULL << SwiftMtParser_MT565Parser::T__26)
| (1ULL << SwiftMtParser_MT565Parser::T__27)
| (1ULL << SwiftMtParser_MT565Parser::T__28)
| (1ULL << SwiftMtParser_MT565Parser::T__29)
| (1ULL << SwiftMtParser_MT565Parser::T__30)
| (1ULL << SwiftMtParser_MT565Parser::T__31)
| (1ULL << SwiftMtParser_MT565Parser::T__32)
| (1ULL << SwiftMtParser_MT565Parser::T__33)
| (1ULL << SwiftMtParser_MT565Parser::T__34)
| (1ULL << SwiftMtParser_MT565Parser::T__35)
| (1ULL << SwiftMtParser_MT565Parser::T__36)
| (1ULL << SwiftMtParser_MT565Parser::T__37)
| (1ULL << SwiftMtParser_MT565Parser::TAG_BH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_AH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_UH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_MT)
| (1ULL << SwiftMtParser_MT565Parser::TAG_TR)
| (1ULL << SwiftMtParser_MT565Parser::MT_END)
| (1ULL << SwiftMtParser_MT565Parser::LBRACE)
| (1ULL << SwiftMtParser_MT565Parser::START_OF_FIELD)
| (1ULL << SwiftMtParser_MT565Parser::ANY))) != 0));
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- Sys_element_contentContext ------------------------------------------------------------------
SwiftMtParser_MT565Parser::Sys_element_contentContext::Sys_element_contentContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
std::vector<tree::TerminalNode *> SwiftMtParser_MT565Parser::Sys_element_contentContext::RBRACE() {
return getTokens(SwiftMtParser_MT565Parser::RBRACE);
}
tree::TerminalNode* SwiftMtParser_MT565Parser::Sys_element_contentContext::RBRACE(size_t i) {
return getToken(SwiftMtParser_MT565Parser::RBRACE, i);
}
size_t SwiftMtParser_MT565Parser::Sys_element_contentContext::getRuleIndex() const {
return SwiftMtParser_MT565Parser::RuleSys_element_content;
}
void SwiftMtParser_MT565Parser::Sys_element_contentContext::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->enterSys_element_content(this);
}
void SwiftMtParser_MT565Parser::Sys_element_contentContext::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->exitSys_element_content(this);
}
SwiftMtParser_MT565Parser::Sys_element_contentContext* SwiftMtParser_MT565Parser::sys_element_content() {
Sys_element_contentContext *_localctx = _tracker.createInstance<Sys_element_contentContext>(_ctx, getState());
enterRule(_localctx, 20, SwiftMtParser_MT565Parser::RuleSys_element_content);
size_t _la = 0;
auto onExit = finally([=] {
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(314);
_errHandler->sync(this);
_la = _input->LA(1);
do {
setState(313);
_la = _input->LA(1);
if (_la == 0 || _la == Token::EOF || (_la == SwiftMtParser_MT565Parser::RBRACE)) {
_errHandler->recoverInline(this);
}
else {
_errHandler->reportMatch(this);
consume();
}
setState(316);
_errHandler->sync(this);
_la = _input->LA(1);
} while ((((_la & ~ 0x3fULL) == 0) &&
((1ULL << _la) & ((1ULL << SwiftMtParser_MT565Parser::T__0)
| (1ULL << SwiftMtParser_MT565Parser::T__1)
| (1ULL << SwiftMtParser_MT565Parser::T__2)
| (1ULL << SwiftMtParser_MT565Parser::T__3)
| (1ULL << SwiftMtParser_MT565Parser::T__4)
| (1ULL << SwiftMtParser_MT565Parser::T__5)
| (1ULL << SwiftMtParser_MT565Parser::T__6)
| (1ULL << SwiftMtParser_MT565Parser::T__7)
| (1ULL << SwiftMtParser_MT565Parser::T__8)
| (1ULL << SwiftMtParser_MT565Parser::T__9)
| (1ULL << SwiftMtParser_MT565Parser::T__10)
| (1ULL << SwiftMtParser_MT565Parser::T__11)
| (1ULL << SwiftMtParser_MT565Parser::T__12)
| (1ULL << SwiftMtParser_MT565Parser::T__13)
| (1ULL << SwiftMtParser_MT565Parser::T__14)
| (1ULL << SwiftMtParser_MT565Parser::T__15)
| (1ULL << SwiftMtParser_MT565Parser::T__16)
| (1ULL << SwiftMtParser_MT565Parser::T__17)
| (1ULL << SwiftMtParser_MT565Parser::T__18)
| (1ULL << SwiftMtParser_MT565Parser::T__19)
| (1ULL << SwiftMtParser_MT565Parser::T__20)
| (1ULL << SwiftMtParser_MT565Parser::T__21)
| (1ULL << SwiftMtParser_MT565Parser::T__22)
| (1ULL << SwiftMtParser_MT565Parser::T__23)
| (1ULL << SwiftMtParser_MT565Parser::T__24)
| (1ULL << SwiftMtParser_MT565Parser::T__25)
| (1ULL << SwiftMtParser_MT565Parser::T__26)
| (1ULL << SwiftMtParser_MT565Parser::T__27)
| (1ULL << SwiftMtParser_MT565Parser::T__28)
| (1ULL << SwiftMtParser_MT565Parser::T__29)
| (1ULL << SwiftMtParser_MT565Parser::T__30)
| (1ULL << SwiftMtParser_MT565Parser::T__31)
| (1ULL << SwiftMtParser_MT565Parser::T__32)
| (1ULL << SwiftMtParser_MT565Parser::T__33)
| (1ULL << SwiftMtParser_MT565Parser::T__34)
| (1ULL << SwiftMtParser_MT565Parser::T__35)
| (1ULL << SwiftMtParser_MT565Parser::T__36)
| (1ULL << SwiftMtParser_MT565Parser::T__37)
| (1ULL << SwiftMtParser_MT565Parser::TAG_BH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_AH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_UH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_MT)
| (1ULL << SwiftMtParser_MT565Parser::TAG_TR)
| (1ULL << SwiftMtParser_MT565Parser::MT_END)
| (1ULL << SwiftMtParser_MT565Parser::LBRACE)
| (1ULL << SwiftMtParser_MT565Parser::COLON)
| (1ULL << SwiftMtParser_MT565Parser::START_OF_FIELD)
| (1ULL << SwiftMtParser_MT565Parser::ANY))) != 0));
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- MtContext ------------------------------------------------------------------
SwiftMtParser_MT565Parser::MtContext::MtContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
tree::TerminalNode* SwiftMtParser_MT565Parser::MtContext::TAG_MT() {
return getToken(SwiftMtParser_MT565Parser::TAG_MT, 0);
}
SwiftMtParser_MT565Parser::Seq_AContext* SwiftMtParser_MT565Parser::MtContext::seq_A() {
return getRuleContext<SwiftMtParser_MT565Parser::Seq_AContext>(0);
}
SwiftMtParser_MT565Parser::Seq_BContext* SwiftMtParser_MT565Parser::MtContext::seq_B() {
return getRuleContext<SwiftMtParser_MT565Parser::Seq_BContext>(0);
}
SwiftMtParser_MT565Parser::Seq_DContext* SwiftMtParser_MT565Parser::MtContext::seq_D() {
return getRuleContext<SwiftMtParser_MT565Parser::Seq_DContext>(0);
}
tree::TerminalNode* SwiftMtParser_MT565Parser::MtContext::MT_END() {
return getToken(SwiftMtParser_MT565Parser::MT_END, 0);
}
std::vector<SwiftMtParser_MT565Parser::Seq_CContext *> SwiftMtParser_MT565Parser::MtContext::seq_C() {
return getRuleContexts<SwiftMtParser_MT565Parser::Seq_CContext>();
}
SwiftMtParser_MT565Parser::Seq_CContext* SwiftMtParser_MT565Parser::MtContext::seq_C(size_t i) {
return getRuleContext<SwiftMtParser_MT565Parser::Seq_CContext>(i);
}
SwiftMtParser_MT565Parser::Seq_EContext* SwiftMtParser_MT565Parser::MtContext::seq_E() {
return getRuleContext<SwiftMtParser_MT565Parser::Seq_EContext>(0);
}
size_t SwiftMtParser_MT565Parser::MtContext::getRuleIndex() const {
return SwiftMtParser_MT565Parser::RuleMt;
}
void SwiftMtParser_MT565Parser::MtContext::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->enterMt(this);
}
void SwiftMtParser_MT565Parser::MtContext::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->exitMt(this);
}
SwiftMtParser_MT565Parser::MtContext* SwiftMtParser_MT565Parser::mt() {
MtContext *_localctx = _tracker.createInstance<MtContext>(_ctx, getState());
enterRule(_localctx, 22, SwiftMtParser_MT565Parser::RuleMt);
size_t _la = 0;
auto onExit = finally([=] {
exitRule();
});
try {
size_t alt;
enterOuterAlt(_localctx, 1);
setState(318);
match(SwiftMtParser_MT565Parser::TAG_MT);
setState(319);
seq_A();
setState(320);
seq_B();
setState(324);
_errHandler->sync(this);
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 7, _ctx);
while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
if (alt == 1) {
setState(321);
seq_C();
}
setState(326);
_errHandler->sync(this);
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 7, _ctx);
}
setState(327);
seq_D();
setState(329);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == SwiftMtParser_MT565Parser::START_OF_FIELD) {
setState(328);
seq_E();
}
setState(331);
match(SwiftMtParser_MT565Parser::MT_END);
_ctx->stop = _input->LT(-1);
_message_builder.mutable_msg_text()->MergeFrom(_localctx->elem);
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- Seq_AContext ------------------------------------------------------------------
SwiftMtParser_MT565Parser::Seq_AContext::Seq_AContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
SwiftMtParser_MT565Parser::Fld_16R_AContext* SwiftMtParser_MT565Parser::Seq_AContext::fld_16R_A() {
return getRuleContext<SwiftMtParser_MT565Parser::Fld_16R_AContext>(0);
}
SwiftMtParser_MT565Parser::Fld_23G_AContext* SwiftMtParser_MT565Parser::Seq_AContext::fld_23G_A() {
return getRuleContext<SwiftMtParser_MT565Parser::Fld_23G_AContext>(0);
}
SwiftMtParser_MT565Parser::Fld_22F_AContext* SwiftMtParser_MT565Parser::Seq_AContext::fld_22F_A() {
return getRuleContext<SwiftMtParser_MT565Parser::Fld_22F_AContext>(0);
}
SwiftMtParser_MT565Parser::Fld_16S_AContext* SwiftMtParser_MT565Parser::Seq_AContext::fld_16S_A() {
return getRuleContext<SwiftMtParser_MT565Parser::Fld_16S_AContext>(0);
}
std::vector<SwiftMtParser_MT565Parser::Fld_20C_AContext *> SwiftMtParser_MT565Parser::Seq_AContext::fld_20C_A() {
return getRuleContexts<SwiftMtParser_MT565Parser::Fld_20C_AContext>();
}
SwiftMtParser_MT565Parser::Fld_20C_AContext* SwiftMtParser_MT565Parser::Seq_AContext::fld_20C_A(size_t i) {
return getRuleContext<SwiftMtParser_MT565Parser::Fld_20C_AContext>(i);
}
SwiftMtParser_MT565Parser::Fld_98a_AContext* SwiftMtParser_MT565Parser::Seq_AContext::fld_98a_A() {
return getRuleContext<SwiftMtParser_MT565Parser::Fld_98a_AContext>(0);
}
std::vector<SwiftMtParser_MT565Parser::Seq_A1Context *> SwiftMtParser_MT565Parser::Seq_AContext::seq_A1() {
return getRuleContexts<SwiftMtParser_MT565Parser::Seq_A1Context>();
}
SwiftMtParser_MT565Parser::Seq_A1Context* SwiftMtParser_MT565Parser::Seq_AContext::seq_A1(size_t i) {
return getRuleContext<SwiftMtParser_MT565Parser::Seq_A1Context>(i);
}
size_t SwiftMtParser_MT565Parser::Seq_AContext::getRuleIndex() const {
return SwiftMtParser_MT565Parser::RuleSeq_A;
}
void SwiftMtParser_MT565Parser::Seq_AContext::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->enterSeq_A(this);
}
void SwiftMtParser_MT565Parser::Seq_AContext::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->exitSeq_A(this);
}
SwiftMtParser_MT565Parser::Seq_AContext* SwiftMtParser_MT565Parser::seq_A() {
Seq_AContext *_localctx = _tracker.createInstance<Seq_AContext>(_ctx, getState());
enterRule(_localctx, 24, SwiftMtParser_MT565Parser::RuleSeq_A);
_localctx->elem.set_tag("A");
auto onExit = finally([=] {
exitRule();
});
try {
size_t alt;
enterOuterAlt(_localctx, 1);
setState(333);
dynamic_cast<Seq_AContext *>(_localctx)->fld_16R_AContext = fld_16R_A();
_localctx->elem.mutable_objects()->Add()->mutable_field()->MergeFrom(dynamic_cast<Seq_AContext *>(_localctx)->fld_16R_AContext->fld);
setState(336);
_errHandler->sync(this);
alt = 1;
do {
switch (alt) {
case 1: {
setState(335);
dynamic_cast<Seq_AContext *>(_localctx)->fld_20C_AContext = fld_20C_A();
break;
}
default:
throw NoViableAltException(this);
}
setState(338);
_errHandler->sync(this);
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 9, _ctx);
} while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER);
_localctx->elem.mutable_objects()->Add()->mutable_field()->MergeFrom(dynamic_cast<Seq_AContext *>(_localctx)->fld_20C_AContext->fld);
setState(341);
dynamic_cast<Seq_AContext *>(_localctx)->fld_23G_AContext = fld_23G_A();
_localctx->elem.mutable_objects()->Add()->mutable_field()->MergeFrom(dynamic_cast<Seq_AContext *>(_localctx)->fld_23G_AContext->fld);
setState(343);
dynamic_cast<Seq_AContext *>(_localctx)->fld_22F_AContext = fld_22F_A();
_localctx->elem.mutable_objects()->Add()->mutable_field()->MergeFrom(dynamic_cast<Seq_AContext *>(_localctx)->fld_22F_AContext->fld);
setState(346);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 10, _ctx)) {
case 1: {
setState(345);
dynamic_cast<Seq_AContext *>(_localctx)->fld_98a_AContext = fld_98a_A();
break;
}
}
_localctx->elem.mutable_objects()->Add()->mutable_field()->MergeFrom(dynamic_cast<Seq_AContext *>(_localctx)->fld_98a_AContext->fld);
setState(352);
_errHandler->sync(this);
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 11, _ctx);
while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
if (alt == 1) {
setState(349);
dynamic_cast<Seq_AContext *>(_localctx)->seq_A1Context = seq_A1();
}
setState(354);
_errHandler->sync(this);
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 11, _ctx);
}
_localctx->elem.mutable_objects()->Add()->mutable_sequence()->MergeFrom(dynamic_cast<Seq_AContext *>(_localctx)->seq_A1Context->elem);
setState(356);
dynamic_cast<Seq_AContext *>(_localctx)->fld_16S_AContext = fld_16S_A();
_localctx->elem.mutable_objects()->Add()->mutable_field()->MergeFrom(dynamic_cast<Seq_AContext *>(_localctx)->fld_16S_AContext->fld);
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- Seq_A1Context ------------------------------------------------------------------
SwiftMtParser_MT565Parser::Seq_A1Context::Seq_A1Context(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
SwiftMtParser_MT565Parser::Fld_16R_A1Context* SwiftMtParser_MT565Parser::Seq_A1Context::fld_16R_A1() {
return getRuleContext<SwiftMtParser_MT565Parser::Fld_16R_A1Context>(0);
}
SwiftMtParser_MT565Parser::Fld_20C_A1Context* SwiftMtParser_MT565Parser::Seq_A1Context::fld_20C_A1() {
return getRuleContext<SwiftMtParser_MT565Parser::Fld_20C_A1Context>(0);
}
SwiftMtParser_MT565Parser::Fld_16S_A1Context* SwiftMtParser_MT565Parser::Seq_A1Context::fld_16S_A1() {
return getRuleContext<SwiftMtParser_MT565Parser::Fld_16S_A1Context>(0);
}
SwiftMtParser_MT565Parser::Fld_22F_A1Context* SwiftMtParser_MT565Parser::Seq_A1Context::fld_22F_A1() {
return getRuleContext<SwiftMtParser_MT565Parser::Fld_22F_A1Context>(0);
}
SwiftMtParser_MT565Parser::Fld_13a_A1Context* SwiftMtParser_MT565Parser::Seq_A1Context::fld_13a_A1() {
return getRuleContext<SwiftMtParser_MT565Parser::Fld_13a_A1Context>(0);
}
size_t SwiftMtParser_MT565Parser::Seq_A1Context::getRuleIndex() const {
return SwiftMtParser_MT565Parser::RuleSeq_A1;
}
void SwiftMtParser_MT565Parser::Seq_A1Context::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->enterSeq_A1(this);
}
void SwiftMtParser_MT565Parser::Seq_A1Context::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->exitSeq_A1(this);
}
SwiftMtParser_MT565Parser::Seq_A1Context* SwiftMtParser_MT565Parser::seq_A1() {
Seq_A1Context *_localctx = _tracker.createInstance<Seq_A1Context>(_ctx, getState());
enterRule(_localctx, 26, SwiftMtParser_MT565Parser::RuleSeq_A1);
_localctx->elem.set_tag("A1");
auto onExit = finally([=] {
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(359);
dynamic_cast<Seq_A1Context *>(_localctx)->fld_16R_A1Context = fld_16R_A1();
_localctx->elem.mutable_objects()->Add()->mutable_field()->MergeFrom(dynamic_cast<Seq_A1Context *>(_localctx)->fld_16R_A1Context->fld);
setState(362);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 12, _ctx)) {
case 1: {
setState(361);
dynamic_cast<Seq_A1Context *>(_localctx)->fld_22F_A1Context = fld_22F_A1();
break;
}
}
_localctx->elem.mutable_objects()->Add()->mutable_field()->MergeFrom(dynamic_cast<Seq_A1Context *>(_localctx)->fld_22F_A1Context->fld);
setState(366);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 13, _ctx)) {
case 1: {
setState(365);
dynamic_cast<Seq_A1Context *>(_localctx)->fld_13a_A1Context = fld_13a_A1();
break;
}
}
_localctx->elem.mutable_objects()->Add()->mutable_field()->MergeFrom(dynamic_cast<Seq_A1Context *>(_localctx)->fld_13a_A1Context->fld);
setState(369);
dynamic_cast<Seq_A1Context *>(_localctx)->fld_20C_A1Context = fld_20C_A1();
_localctx->elem.mutable_objects()->Add()->mutable_field()->MergeFrom(dynamic_cast<Seq_A1Context *>(_localctx)->fld_20C_A1Context->fld);
setState(371);
dynamic_cast<Seq_A1Context *>(_localctx)->fld_16S_A1Context = fld_16S_A1();
_localctx->elem.mutable_objects()->Add()->mutable_field()->MergeFrom(dynamic_cast<Seq_A1Context *>(_localctx)->fld_16S_A1Context->fld);
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- Seq_BContext ------------------------------------------------------------------
SwiftMtParser_MT565Parser::Seq_BContext::Seq_BContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
SwiftMtParser_MT565Parser::Fld_16R_BContext* SwiftMtParser_MT565Parser::Seq_BContext::fld_16R_B() {
return getRuleContext<SwiftMtParser_MT565Parser::Fld_16R_BContext>(0);
}
SwiftMtParser_MT565Parser::Seq_B2Context* SwiftMtParser_MT565Parser::Seq_BContext::seq_B2() {
return getRuleContext<SwiftMtParser_MT565Parser::Seq_B2Context>(0);
}
SwiftMtParser_MT565Parser::Fld_16S_BContext* SwiftMtParser_MT565Parser::Seq_BContext::fld_16S_B() {
return getRuleContext<SwiftMtParser_MT565Parser::Fld_16S_BContext>(0);
}
SwiftMtParser_MT565Parser::Fld_35B_BContext* SwiftMtParser_MT565Parser::Seq_BContext::fld_35B_B() {
return getRuleContext<SwiftMtParser_MT565Parser::Fld_35B_BContext>(0);
}
SwiftMtParser_MT565Parser::Seq_B1Context* SwiftMtParser_MT565Parser::Seq_BContext::seq_B1() {
return getRuleContext<SwiftMtParser_MT565Parser::Seq_B1Context>(0);
}
size_t SwiftMtParser_MT565Parser::Seq_BContext::getRuleIndex() const {
return SwiftMtParser_MT565Parser::RuleSeq_B;
}
void SwiftMtParser_MT565Parser::Seq_BContext::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->enterSeq_B(this);
}
void SwiftMtParser_MT565Parser::Seq_BContext::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->exitSeq_B(this);
}
SwiftMtParser_MT565Parser::Seq_BContext* SwiftMtParser_MT565Parser::seq_B() {
Seq_BContext *_localctx = _tracker.createInstance<Seq_BContext>(_ctx, getState());
enterRule(_localctx, 28, SwiftMtParser_MT565Parser::RuleSeq_B);
_localctx->elem.set_tag("B");
auto onExit = finally([=] {
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(374);
dynamic_cast<Seq_BContext *>(_localctx)->fld_16R_BContext = fld_16R_B();
_localctx->elem.mutable_objects()->Add()->mutable_field()->MergeFrom(dynamic_cast<Seq_BContext *>(_localctx)->fld_16R_BContext->fld);
setState(377);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 14, _ctx)) {
case 1: {
setState(376);
dynamic_cast<Seq_BContext *>(_localctx)->fld_35B_BContext = fld_35B_B();
break;
}
}
_localctx->elem.mutable_objects()->Add()->mutable_field()->MergeFrom(dynamic_cast<Seq_BContext *>(_localctx)->fld_35B_BContext->fld);
setState(381);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 15, _ctx)) {
case 1: {
setState(380);
dynamic_cast<Seq_BContext *>(_localctx)->seq_B1Context = seq_B1();
break;
}
}
_localctx->elem.mutable_objects()->Add()->mutable_sequence()->MergeFrom(dynamic_cast<Seq_BContext *>(_localctx)->seq_B1Context->elem);
setState(384);
dynamic_cast<Seq_BContext *>(_localctx)->seq_B2Context = seq_B2();
_localctx->elem.mutable_objects()->Add()->mutable_sequence()->MergeFrom(dynamic_cast<Seq_BContext *>(_localctx)->seq_B2Context->elem);
setState(386);
dynamic_cast<Seq_BContext *>(_localctx)->fld_16S_BContext = fld_16S_B();
_localctx->elem.mutable_objects()->Add()->mutable_field()->MergeFrom(dynamic_cast<Seq_BContext *>(_localctx)->fld_16S_BContext->fld);
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- Seq_B1Context ------------------------------------------------------------------
SwiftMtParser_MT565Parser::Seq_B1Context::Seq_B1Context(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
SwiftMtParser_MT565Parser::Fld_16R_B1Context* SwiftMtParser_MT565Parser::Seq_B1Context::fld_16R_B1() {
return getRuleContext<SwiftMtParser_MT565Parser::Fld_16R_B1Context>(0);
}
SwiftMtParser_MT565Parser::Fld_16S_B1Context* SwiftMtParser_MT565Parser::Seq_B1Context::fld_16S_B1() {
return getRuleContext<SwiftMtParser_MT565Parser::Fld_16S_B1Context>(0);
}
SwiftMtParser_MT565Parser::Fld_94B_B1Context* SwiftMtParser_MT565Parser::Seq_B1Context::fld_94B_B1() {
return getRuleContext<SwiftMtParser_MT565Parser::Fld_94B_B1Context>(0);
}
SwiftMtParser_MT565Parser::Fld_22F_B1Context* SwiftMtParser_MT565Parser::Seq_B1Context::fld_22F_B1() {
return getRuleContext<SwiftMtParser_MT565Parser::Fld_22F_B1Context>(0);
}
SwiftMtParser_MT565Parser::Fld_12a_B1Context* SwiftMtParser_MT565Parser::Seq_B1Context::fld_12a_B1() {
return getRuleContext<SwiftMtParser_MT565Parser::Fld_12a_B1Context>(0);
}
SwiftMtParser_MT565Parser::Fld_11A_B1Context* SwiftMtParser_MT565Parser::Seq_B1Context::fld_11A_B1() {
return getRuleContext<SwiftMtParser_MT565Parser::Fld_11A_B1Context>(0);
}
std::vector<SwiftMtParser_MT565Parser::Fld_98A_B1Context *> SwiftMtParser_MT565Parser::Seq_B1Context::fld_98A_B1() {
return getRuleContexts<SwiftMtParser_MT565Parser::Fld_98A_B1Context>();
}
SwiftMtParser_MT565Parser::Fld_98A_B1Context* SwiftMtParser_MT565Parser::Seq_B1Context::fld_98A_B1(size_t i) {
return getRuleContext<SwiftMtParser_MT565Parser::Fld_98A_B1Context>(i);
}
std::vector<SwiftMtParser_MT565Parser::Fld_92A_B1Context *> SwiftMtParser_MT565Parser::Seq_B1Context::fld_92A_B1() {
return getRuleContexts<SwiftMtParser_MT565Parser::Fld_92A_B1Context>();
}
SwiftMtParser_MT565Parser::Fld_92A_B1Context* SwiftMtParser_MT565Parser::Seq_B1Context::fld_92A_B1(size_t i) {
return getRuleContext<SwiftMtParser_MT565Parser::Fld_92A_B1Context>(i);
}
std::vector<SwiftMtParser_MT565Parser::Fld_36B_B1Context *> SwiftMtParser_MT565Parser::Seq_B1Context::fld_36B_B1() {
return getRuleContexts<SwiftMtParser_MT565Parser::Fld_36B_B1Context>();
}
SwiftMtParser_MT565Parser::Fld_36B_B1Context* SwiftMtParser_MT565Parser::Seq_B1Context::fld_36B_B1(size_t i) {
return getRuleContext<SwiftMtParser_MT565Parser::Fld_36B_B1Context>(i);
}
size_t SwiftMtParser_MT565Parser::Seq_B1Context::getRuleIndex() const {
return SwiftMtParser_MT565Parser::RuleSeq_B1;
}
void SwiftMtParser_MT565Parser::Seq_B1Context::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->enterSeq_B1(this);
}
void SwiftMtParser_MT565Parser::Seq_B1Context::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->exitSeq_B1(this);
}
SwiftMtParser_MT565Parser::Seq_B1Context* SwiftMtParser_MT565Parser::seq_B1() {
Seq_B1Context *_localctx = _tracker.createInstance<Seq_B1Context>(_ctx, getState());
enterRule(_localctx, 30, SwiftMtParser_MT565Parser::RuleSeq_B1);
_localctx->elem.set_tag("B1");
auto onExit = finally([=] {
exitRule();
});
try {
size_t alt;
enterOuterAlt(_localctx, 1);
setState(389);
dynamic_cast<Seq_B1Context *>(_localctx)->fld_16R_B1Context = fld_16R_B1();
_localctx->elem.mutable_objects()->Add()->mutable_field()->MergeFrom(dynamic_cast<Seq_B1Context *>(_localctx)->fld_16R_B1Context->fld);
setState(392);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 16, _ctx)) {
case 1: {
setState(391);
dynamic_cast<Seq_B1Context *>(_localctx)->fld_94B_B1Context = fld_94B_B1();
break;
}
}
_localctx->elem.mutable_objects()->Add()->mutable_field()->MergeFrom(dynamic_cast<Seq_B1Context *>(_localctx)->fld_94B_B1Context->fld);
setState(396);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 17, _ctx)) {
case 1: {
setState(395);
dynamic_cast<Seq_B1Context *>(_localctx)->fld_22F_B1Context = fld_22F_B1();
break;
}
}
_localctx->elem.mutable_objects()->Add()->mutable_field()->MergeFrom(dynamic_cast<Seq_B1Context *>(_localctx)->fld_22F_B1Context->fld);
setState(400);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 18, _ctx)) {
case 1: {
setState(399);
dynamic_cast<Seq_B1Context *>(_localctx)->fld_12a_B1Context = fld_12a_B1();
break;
}
}
_localctx->elem.mutable_objects()->Add()->mutable_field()->MergeFrom(dynamic_cast<Seq_B1Context *>(_localctx)->fld_12a_B1Context->fld);
setState(404);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 19, _ctx)) {
case 1: {
setState(403);
dynamic_cast<Seq_B1Context *>(_localctx)->fld_11A_B1Context = fld_11A_B1();
break;
}
}
_localctx->elem.mutable_objects()->Add()->mutable_field()->MergeFrom(dynamic_cast<Seq_B1Context *>(_localctx)->fld_11A_B1Context->fld);
setState(410);
_errHandler->sync(this);
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 20, _ctx);
while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
if (alt == 1) {
setState(407);
dynamic_cast<Seq_B1Context *>(_localctx)->fld_98A_B1Context = fld_98A_B1();
}
setState(412);
_errHandler->sync(this);
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 20, _ctx);
}
_localctx->elem.mutable_objects()->Add()->mutable_field()->MergeFrom(dynamic_cast<Seq_B1Context *>(_localctx)->fld_98A_B1Context->fld);
setState(417);
_errHandler->sync(this);
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 21, _ctx);
while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
if (alt == 1) {
setState(414);
dynamic_cast<Seq_B1Context *>(_localctx)->fld_92A_B1Context = fld_92A_B1();
}
setState(419);
_errHandler->sync(this);
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 21, _ctx);
}
_localctx->elem.mutable_objects()->Add()->mutable_field()->MergeFrom(dynamic_cast<Seq_B1Context *>(_localctx)->fld_92A_B1Context->fld);
setState(424);
_errHandler->sync(this);
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 22, _ctx);
while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
if (alt == 1) {
setState(421);
dynamic_cast<Seq_B1Context *>(_localctx)->fld_36B_B1Context = fld_36B_B1();
}
setState(426);
_errHandler->sync(this);
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 22, _ctx);
}
_localctx->elem.mutable_objects()->Add()->mutable_field()->MergeFrom(dynamic_cast<Seq_B1Context *>(_localctx)->fld_36B_B1Context->fld);
setState(428);
dynamic_cast<Seq_B1Context *>(_localctx)->fld_16S_B1Context = fld_16S_B1();
_localctx->elem.mutable_objects()->Add()->mutable_field()->MergeFrom(dynamic_cast<Seq_B1Context *>(_localctx)->fld_16S_B1Context->fld);
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- Seq_B2Context ------------------------------------------------------------------
SwiftMtParser_MT565Parser::Seq_B2Context::Seq_B2Context(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
SwiftMtParser_MT565Parser::Fld_16R_B2Context* SwiftMtParser_MT565Parser::Seq_B2Context::fld_16R_B2() {
return getRuleContext<SwiftMtParser_MT565Parser::Fld_16R_B2Context>(0);
}
SwiftMtParser_MT565Parser::Fld_97A_B2Context* SwiftMtParser_MT565Parser::Seq_B2Context::fld_97A_B2() {
return getRuleContext<SwiftMtParser_MT565Parser::Fld_97A_B2Context>(0);
}
SwiftMtParser_MT565Parser::Fld_16S_B2Context* SwiftMtParser_MT565Parser::Seq_B2Context::fld_16S_B2() {
return getRuleContext<SwiftMtParser_MT565Parser::Fld_16S_B2Context>(0);
}
SwiftMtParser_MT565Parser::Fld_95a_B2Context* SwiftMtParser_MT565Parser::Seq_B2Context::fld_95a_B2() {
return getRuleContext<SwiftMtParser_MT565Parser::Fld_95a_B2Context>(0);
}
SwiftMtParser_MT565Parser::Fld_94a_B2Context* SwiftMtParser_MT565Parser::Seq_B2Context::fld_94a_B2() {
return getRuleContext<SwiftMtParser_MT565Parser::Fld_94a_B2Context>(0);
}
std::vector<SwiftMtParser_MT565Parser::Fld_93a_B2Context *> SwiftMtParser_MT565Parser::Seq_B2Context::fld_93a_B2() {
return getRuleContexts<SwiftMtParser_MT565Parser::Fld_93a_B2Context>();
}
SwiftMtParser_MT565Parser::Fld_93a_B2Context* SwiftMtParser_MT565Parser::Seq_B2Context::fld_93a_B2(size_t i) {
return getRuleContext<SwiftMtParser_MT565Parser::Fld_93a_B2Context>(i);
}
size_t SwiftMtParser_MT565Parser::Seq_B2Context::getRuleIndex() const {
return SwiftMtParser_MT565Parser::RuleSeq_B2;
}
void SwiftMtParser_MT565Parser::Seq_B2Context::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->enterSeq_B2(this);
}
void SwiftMtParser_MT565Parser::Seq_B2Context::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->exitSeq_B2(this);
}
SwiftMtParser_MT565Parser::Seq_B2Context* SwiftMtParser_MT565Parser::seq_B2() {
Seq_B2Context *_localctx = _tracker.createInstance<Seq_B2Context>(_ctx, getState());
enterRule(_localctx, 32, SwiftMtParser_MT565Parser::RuleSeq_B2);
_localctx->elem.set_tag("B2");
auto onExit = finally([=] {
exitRule();
});
try {
size_t alt;
enterOuterAlt(_localctx, 1);
setState(431);
dynamic_cast<Seq_B2Context *>(_localctx)->fld_16R_B2Context = fld_16R_B2();
_localctx->elem.mutable_objects()->Add()->mutable_field()->MergeFrom(dynamic_cast<Seq_B2Context *>(_localctx)->fld_16R_B2Context->fld);
setState(434);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 23, _ctx)) {
case 1: {
setState(433);
dynamic_cast<Seq_B2Context *>(_localctx)->fld_95a_B2Context = fld_95a_B2();
break;
}
}
_localctx->elem.mutable_objects()->Add()->mutable_field()->MergeFrom(dynamic_cast<Seq_B2Context *>(_localctx)->fld_95a_B2Context->fld);
setState(437);
dynamic_cast<Seq_B2Context *>(_localctx)->fld_97A_B2Context = fld_97A_B2();
_localctx->elem.mutable_objects()->Add()->mutable_field()->MergeFrom(dynamic_cast<Seq_B2Context *>(_localctx)->fld_97A_B2Context->fld);
setState(440);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 24, _ctx)) {
case 1: {
setState(439);
dynamic_cast<Seq_B2Context *>(_localctx)->fld_94a_B2Context = fld_94a_B2();
break;
}
}
_localctx->elem.mutable_objects()->Add()->mutable_field()->MergeFrom(dynamic_cast<Seq_B2Context *>(_localctx)->fld_94a_B2Context->fld);
setState(446);
_errHandler->sync(this);
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 25, _ctx);
while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
if (alt == 1) {
setState(443);
dynamic_cast<Seq_B2Context *>(_localctx)->fld_93a_B2Context = fld_93a_B2();
}
setState(448);
_errHandler->sync(this);
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 25, _ctx);
}
_localctx->elem.mutable_objects()->Add()->mutable_field()->MergeFrom(dynamic_cast<Seq_B2Context *>(_localctx)->fld_93a_B2Context->fld);
setState(450);
dynamic_cast<Seq_B2Context *>(_localctx)->fld_16S_B2Context = fld_16S_B2();
_localctx->elem.mutable_objects()->Add()->mutable_field()->MergeFrom(dynamic_cast<Seq_B2Context *>(_localctx)->fld_16S_B2Context->fld);
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- Seq_CContext ------------------------------------------------------------------
SwiftMtParser_MT565Parser::Seq_CContext::Seq_CContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
SwiftMtParser_MT565Parser::Fld_16R_CContext* SwiftMtParser_MT565Parser::Seq_CContext::fld_16R_C() {
return getRuleContext<SwiftMtParser_MT565Parser::Fld_16R_CContext>(0);
}
SwiftMtParser_MT565Parser::Fld_36B_CContext* SwiftMtParser_MT565Parser::Seq_CContext::fld_36B_C() {
return getRuleContext<SwiftMtParser_MT565Parser::Fld_36B_CContext>(0);
}
SwiftMtParser_MT565Parser::Fld_16S_CContext* SwiftMtParser_MT565Parser::Seq_CContext::fld_16S_C() {
return getRuleContext<SwiftMtParser_MT565Parser::Fld_16S_CContext>(0);
}
std::vector<SwiftMtParser_MT565Parser::Fld_95a_CContext *> SwiftMtParser_MT565Parser::Seq_CContext::fld_95a_C() {
return getRuleContexts<SwiftMtParser_MT565Parser::Fld_95a_CContext>();
}
SwiftMtParser_MT565Parser::Fld_95a_CContext* SwiftMtParser_MT565Parser::Seq_CContext::fld_95a_C(size_t i) {
return getRuleContext<SwiftMtParser_MT565Parser::Fld_95a_CContext>(i);
}
std::vector<SwiftMtParser_MT565Parser::Fld_94C_CContext *> SwiftMtParser_MT565Parser::Seq_CContext::fld_94C_C() {
return getRuleContexts<SwiftMtParser_MT565Parser::Fld_94C_CContext>();
}
SwiftMtParser_MT565Parser::Fld_94C_CContext* SwiftMtParser_MT565Parser::Seq_CContext::fld_94C_C(size_t i) {
return getRuleContext<SwiftMtParser_MT565Parser::Fld_94C_CContext>(i);
}
std::vector<SwiftMtParser_MT565Parser::Fld_22F_CContext *> SwiftMtParser_MT565Parser::Seq_CContext::fld_22F_C() {
return getRuleContexts<SwiftMtParser_MT565Parser::Fld_22F_CContext>();
}
SwiftMtParser_MT565Parser::Fld_22F_CContext* SwiftMtParser_MT565Parser::Seq_CContext::fld_22F_C(size_t i) {
return getRuleContext<SwiftMtParser_MT565Parser::Fld_22F_CContext>(i);
}
std::vector<SwiftMtParser_MT565Parser::Fld_70E_CContext *> SwiftMtParser_MT565Parser::Seq_CContext::fld_70E_C() {
return getRuleContexts<SwiftMtParser_MT565Parser::Fld_70E_CContext>();
}
SwiftMtParser_MT565Parser::Fld_70E_CContext* SwiftMtParser_MT565Parser::Seq_CContext::fld_70E_C(size_t i) {
return getRuleContext<SwiftMtParser_MT565Parser::Fld_70E_CContext>(i);
}
size_t SwiftMtParser_MT565Parser::Seq_CContext::getRuleIndex() const {
return SwiftMtParser_MT565Parser::RuleSeq_C;
}
void SwiftMtParser_MT565Parser::Seq_CContext::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->enterSeq_C(this);
}
void SwiftMtParser_MT565Parser::Seq_CContext::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->exitSeq_C(this);
}
SwiftMtParser_MT565Parser::Seq_CContext* SwiftMtParser_MT565Parser::seq_C() {
Seq_CContext *_localctx = _tracker.createInstance<Seq_CContext>(_ctx, getState());
enterRule(_localctx, 34, SwiftMtParser_MT565Parser::RuleSeq_C);
_localctx->elem.set_tag("C");
auto onExit = finally([=] {
exitRule();
});
try {
size_t alt;
enterOuterAlt(_localctx, 1);
setState(453);
dynamic_cast<Seq_CContext *>(_localctx)->fld_16R_CContext = fld_16R_C();
_localctx->elem.mutable_objects()->Add()->mutable_field()->MergeFrom(dynamic_cast<Seq_CContext *>(_localctx)->fld_16R_CContext->fld);
setState(456);
_errHandler->sync(this);
alt = 1;
do {
switch (alt) {
case 1: {
setState(455);
dynamic_cast<Seq_CContext *>(_localctx)->fld_95a_CContext = fld_95a_C();
break;
}
default:
throw NoViableAltException(this);
}
setState(458);
_errHandler->sync(this);
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 26, _ctx);
} while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER);
_localctx->elem.mutable_objects()->Add()->mutable_field()->MergeFrom(dynamic_cast<Seq_CContext *>(_localctx)->fld_95a_CContext->fld);
setState(464);
_errHandler->sync(this);
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 27, _ctx);
while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
if (alt == 1) {
setState(461);
dynamic_cast<Seq_CContext *>(_localctx)->fld_94C_CContext = fld_94C_C();
}
setState(466);
_errHandler->sync(this);
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 27, _ctx);
}
_localctx->elem.mutable_objects()->Add()->mutable_field()->MergeFrom(dynamic_cast<Seq_CContext *>(_localctx)->fld_94C_CContext->fld);
setState(468);
dynamic_cast<Seq_CContext *>(_localctx)->fld_36B_CContext = fld_36B_C();
_localctx->elem.mutable_objects()->Add()->mutable_field()->MergeFrom(dynamic_cast<Seq_CContext *>(_localctx)->fld_36B_CContext->fld);
setState(473);
_errHandler->sync(this);
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 28, _ctx);
while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
if (alt == 1) {
setState(470);
dynamic_cast<Seq_CContext *>(_localctx)->fld_22F_CContext = fld_22F_C();
}
setState(475);
_errHandler->sync(this);
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 28, _ctx);
}
_localctx->elem.mutable_objects()->Add()->mutable_field()->MergeFrom(dynamic_cast<Seq_CContext *>(_localctx)->fld_22F_CContext->fld);
setState(480);
_errHandler->sync(this);
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 29, _ctx);
while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
if (alt == 1) {
setState(477);
dynamic_cast<Seq_CContext *>(_localctx)->fld_70E_CContext = fld_70E_C();
}
setState(482);
_errHandler->sync(this);
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 29, _ctx);
}
_localctx->elem.mutable_objects()->Add()->mutable_field()->MergeFrom(dynamic_cast<Seq_CContext *>(_localctx)->fld_70E_CContext->fld);
setState(484);
dynamic_cast<Seq_CContext *>(_localctx)->fld_16S_CContext = fld_16S_C();
_localctx->elem.mutable_objects()->Add()->mutable_field()->MergeFrom(dynamic_cast<Seq_CContext *>(_localctx)->fld_16S_CContext->fld);
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- Seq_DContext ------------------------------------------------------------------
SwiftMtParser_MT565Parser::Seq_DContext::Seq_DContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
SwiftMtParser_MT565Parser::Fld_16R_DContext* SwiftMtParser_MT565Parser::Seq_DContext::fld_16R_D() {
return getRuleContext<SwiftMtParser_MT565Parser::Fld_16R_DContext>(0);
}
SwiftMtParser_MT565Parser::Fld_13A_DContext* SwiftMtParser_MT565Parser::Seq_DContext::fld_13A_D() {
return getRuleContext<SwiftMtParser_MT565Parser::Fld_13A_DContext>(0);
}
SwiftMtParser_MT565Parser::Fld_16S_DContext* SwiftMtParser_MT565Parser::Seq_DContext::fld_16S_D() {
return getRuleContext<SwiftMtParser_MT565Parser::Fld_16S_DContext>(0);
}
std::vector<SwiftMtParser_MT565Parser::Fld_22a_DContext *> SwiftMtParser_MT565Parser::Seq_DContext::fld_22a_D() {
return getRuleContexts<SwiftMtParser_MT565Parser::Fld_22a_DContext>();
}
SwiftMtParser_MT565Parser::Fld_22a_DContext* SwiftMtParser_MT565Parser::Seq_DContext::fld_22a_D(size_t i) {
return getRuleContext<SwiftMtParser_MT565Parser::Fld_22a_DContext>(i);
}
std::vector<SwiftMtParser_MT565Parser::Fld_11A_DContext *> SwiftMtParser_MT565Parser::Seq_DContext::fld_11A_D() {
return getRuleContexts<SwiftMtParser_MT565Parser::Fld_11A_DContext>();
}
SwiftMtParser_MT565Parser::Fld_11A_DContext* SwiftMtParser_MT565Parser::Seq_DContext::fld_11A_D(size_t i) {
return getRuleContext<SwiftMtParser_MT565Parser::Fld_11A_DContext>(i);
}
SwiftMtParser_MT565Parser::Fld_35B_DContext* SwiftMtParser_MT565Parser::Seq_DContext::fld_35B_D() {
return getRuleContext<SwiftMtParser_MT565Parser::Fld_35B_DContext>(0);
}
std::vector<SwiftMtParser_MT565Parser::Fld_36a_DContext *> SwiftMtParser_MT565Parser::Seq_DContext::fld_36a_D() {
return getRuleContexts<SwiftMtParser_MT565Parser::Fld_36a_DContext>();
}
SwiftMtParser_MT565Parser::Fld_36a_DContext* SwiftMtParser_MT565Parser::Seq_DContext::fld_36a_D(size_t i) {
return getRuleContext<SwiftMtParser_MT565Parser::Fld_36a_DContext>(i);
}
SwiftMtParser_MT565Parser::Fld_19B_DContext* SwiftMtParser_MT565Parser::Seq_DContext::fld_19B_D() {
return getRuleContext<SwiftMtParser_MT565Parser::Fld_19B_DContext>(0);
}
SwiftMtParser_MT565Parser::Fld_98a_DContext* SwiftMtParser_MT565Parser::Seq_DContext::fld_98a_D() {
return getRuleContext<SwiftMtParser_MT565Parser::Fld_98a_DContext>(0);
}
std::vector<SwiftMtParser_MT565Parser::Fld_92a_DContext *> SwiftMtParser_MT565Parser::Seq_DContext::fld_92a_D() {
return getRuleContexts<SwiftMtParser_MT565Parser::Fld_92a_DContext>();
}
SwiftMtParser_MT565Parser::Fld_92a_DContext* SwiftMtParser_MT565Parser::Seq_DContext::fld_92a_D(size_t i) {
return getRuleContext<SwiftMtParser_MT565Parser::Fld_92a_DContext>(i);
}
std::vector<SwiftMtParser_MT565Parser::Fld_90a_DContext *> SwiftMtParser_MT565Parser::Seq_DContext::fld_90a_D() {
return getRuleContexts<SwiftMtParser_MT565Parser::Fld_90a_DContext>();
}
SwiftMtParser_MT565Parser::Fld_90a_DContext* SwiftMtParser_MT565Parser::Seq_DContext::fld_90a_D(size_t i) {
return getRuleContext<SwiftMtParser_MT565Parser::Fld_90a_DContext>(i);
}
std::vector<SwiftMtParser_MT565Parser::Fld_70E_DContext *> SwiftMtParser_MT565Parser::Seq_DContext::fld_70E_D() {
return getRuleContexts<SwiftMtParser_MT565Parser::Fld_70E_DContext>();
}
SwiftMtParser_MT565Parser::Fld_70E_DContext* SwiftMtParser_MT565Parser::Seq_DContext::fld_70E_D(size_t i) {
return getRuleContext<SwiftMtParser_MT565Parser::Fld_70E_DContext>(i);
}
size_t SwiftMtParser_MT565Parser::Seq_DContext::getRuleIndex() const {
return SwiftMtParser_MT565Parser::RuleSeq_D;
}
void SwiftMtParser_MT565Parser::Seq_DContext::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->enterSeq_D(this);
}
void SwiftMtParser_MT565Parser::Seq_DContext::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->exitSeq_D(this);
}
SwiftMtParser_MT565Parser::Seq_DContext* SwiftMtParser_MT565Parser::seq_D() {
Seq_DContext *_localctx = _tracker.createInstance<Seq_DContext>(_ctx, getState());
enterRule(_localctx, 36, SwiftMtParser_MT565Parser::RuleSeq_D);
_localctx->elem.set_tag("D");
auto onExit = finally([=] {
exitRule();
});
try {
size_t alt;
enterOuterAlt(_localctx, 1);
setState(487);
dynamic_cast<Seq_DContext *>(_localctx)->fld_16R_DContext = fld_16R_D();
_localctx->elem.mutable_objects()->Add()->mutable_field()->MergeFrom(dynamic_cast<Seq_DContext *>(_localctx)->fld_16R_DContext->fld);
setState(489);
dynamic_cast<Seq_DContext *>(_localctx)->fld_13A_DContext = fld_13A_D();
_localctx->elem.mutable_objects()->Add()->mutable_field()->MergeFrom(dynamic_cast<Seq_DContext *>(_localctx)->fld_13A_DContext->fld);
setState(492);
_errHandler->sync(this);
alt = 1;
do {
switch (alt) {
case 1: {
setState(491);
dynamic_cast<Seq_DContext *>(_localctx)->fld_22a_DContext = fld_22a_D();
break;
}
default:
throw NoViableAltException(this);
}
setState(494);
_errHandler->sync(this);
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 30, _ctx);
} while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER);
_localctx->elem.mutable_objects()->Add()->mutable_field()->MergeFrom(dynamic_cast<Seq_DContext *>(_localctx)->fld_22a_DContext->fld);
setState(500);
_errHandler->sync(this);
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 31, _ctx);
while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
if (alt == 1) {
setState(497);
dynamic_cast<Seq_DContext *>(_localctx)->fld_11A_DContext = fld_11A_D();
}
setState(502);
_errHandler->sync(this);
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 31, _ctx);
}
_localctx->elem.mutable_objects()->Add()->mutable_field()->MergeFrom(dynamic_cast<Seq_DContext *>(_localctx)->fld_11A_DContext->fld);
setState(505);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 32, _ctx)) {
case 1: {
setState(504);
dynamic_cast<Seq_DContext *>(_localctx)->fld_35B_DContext = fld_35B_D();
break;
}
}
_localctx->elem.mutable_objects()->Add()->mutable_field()->MergeFrom(dynamic_cast<Seq_DContext *>(_localctx)->fld_35B_DContext->fld);
setState(511);
_errHandler->sync(this);
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 33, _ctx);
while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
if (alt == 1) {
setState(508);
dynamic_cast<Seq_DContext *>(_localctx)->fld_36a_DContext = fld_36a_D();
}
setState(513);
_errHandler->sync(this);
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 33, _ctx);
}
_localctx->elem.mutable_objects()->Add()->mutable_field()->MergeFrom(dynamic_cast<Seq_DContext *>(_localctx)->fld_36a_DContext->fld);
setState(516);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 34, _ctx)) {
case 1: {
setState(515);
dynamic_cast<Seq_DContext *>(_localctx)->fld_19B_DContext = fld_19B_D();
break;
}
}
_localctx->elem.mutable_objects()->Add()->mutable_field()->MergeFrom(dynamic_cast<Seq_DContext *>(_localctx)->fld_19B_DContext->fld);
setState(520);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 35, _ctx)) {
case 1: {
setState(519);
dynamic_cast<Seq_DContext *>(_localctx)->fld_98a_DContext = fld_98a_D();
break;
}
}
_localctx->elem.mutable_objects()->Add()->mutable_field()->MergeFrom(dynamic_cast<Seq_DContext *>(_localctx)->fld_98a_DContext->fld);
setState(526);
_errHandler->sync(this);
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 36, _ctx);
while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
if (alt == 1) {
setState(523);
dynamic_cast<Seq_DContext *>(_localctx)->fld_92a_DContext = fld_92a_D();
}
setState(528);
_errHandler->sync(this);
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 36, _ctx);
}
_localctx->elem.mutable_objects()->Add()->mutable_field()->MergeFrom(dynamic_cast<Seq_DContext *>(_localctx)->fld_92a_DContext->fld);
setState(533);
_errHandler->sync(this);
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 37, _ctx);
while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
if (alt == 1) {
setState(530);
dynamic_cast<Seq_DContext *>(_localctx)->fld_90a_DContext = fld_90a_D();
}
setState(535);
_errHandler->sync(this);
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 37, _ctx);
}
_localctx->elem.mutable_objects()->Add()->mutable_field()->MergeFrom(dynamic_cast<Seq_DContext *>(_localctx)->fld_90a_DContext->fld);
setState(540);
_errHandler->sync(this);
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 38, _ctx);
while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
if (alt == 1) {
setState(537);
dynamic_cast<Seq_DContext *>(_localctx)->fld_70E_DContext = fld_70E_D();
}
setState(542);
_errHandler->sync(this);
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 38, _ctx);
}
_localctx->elem.mutable_objects()->Add()->mutable_field()->MergeFrom(dynamic_cast<Seq_DContext *>(_localctx)->fld_70E_DContext->fld);
setState(544);
dynamic_cast<Seq_DContext *>(_localctx)->fld_16S_DContext = fld_16S_D();
_localctx->elem.mutable_objects()->Add()->mutable_field()->MergeFrom(dynamic_cast<Seq_DContext *>(_localctx)->fld_16S_DContext->fld);
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- Seq_EContext ------------------------------------------------------------------
SwiftMtParser_MT565Parser::Seq_EContext::Seq_EContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
SwiftMtParser_MT565Parser::Fld_16R_EContext* SwiftMtParser_MT565Parser::Seq_EContext::fld_16R_E() {
return getRuleContext<SwiftMtParser_MT565Parser::Fld_16R_EContext>(0);
}
SwiftMtParser_MT565Parser::Fld_16S_EContext* SwiftMtParser_MT565Parser::Seq_EContext::fld_16S_E() {
return getRuleContext<SwiftMtParser_MT565Parser::Fld_16S_EContext>(0);
}
std::vector<SwiftMtParser_MT565Parser::Fld_70E_EContext *> SwiftMtParser_MT565Parser::Seq_EContext::fld_70E_E() {
return getRuleContexts<SwiftMtParser_MT565Parser::Fld_70E_EContext>();
}
SwiftMtParser_MT565Parser::Fld_70E_EContext* SwiftMtParser_MT565Parser::Seq_EContext::fld_70E_E(size_t i) {
return getRuleContext<SwiftMtParser_MT565Parser::Fld_70E_EContext>(i);
}
std::vector<SwiftMtParser_MT565Parser::Fld_95a_EContext *> SwiftMtParser_MT565Parser::Seq_EContext::fld_95a_E() {
return getRuleContexts<SwiftMtParser_MT565Parser::Fld_95a_EContext>();
}
SwiftMtParser_MT565Parser::Fld_95a_EContext* SwiftMtParser_MT565Parser::Seq_EContext::fld_95a_E(size_t i) {
return getRuleContext<SwiftMtParser_MT565Parser::Fld_95a_EContext>(i);
}
size_t SwiftMtParser_MT565Parser::Seq_EContext::getRuleIndex() const {
return SwiftMtParser_MT565Parser::RuleSeq_E;
}
void SwiftMtParser_MT565Parser::Seq_EContext::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->enterSeq_E(this);
}
void SwiftMtParser_MT565Parser::Seq_EContext::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->exitSeq_E(this);
}
SwiftMtParser_MT565Parser::Seq_EContext* SwiftMtParser_MT565Parser::seq_E() {
Seq_EContext *_localctx = _tracker.createInstance<Seq_EContext>(_ctx, getState());
enterRule(_localctx, 38, SwiftMtParser_MT565Parser::RuleSeq_E);
_localctx->elem.set_tag("E");
auto onExit = finally([=] {
exitRule();
});
try {
size_t alt;
enterOuterAlt(_localctx, 1);
setState(547);
dynamic_cast<Seq_EContext *>(_localctx)->fld_16R_EContext = fld_16R_E();
_localctx->elem.mutable_objects()->Add()->mutable_field()->MergeFrom(dynamic_cast<Seq_EContext *>(_localctx)->fld_16R_EContext->fld);
setState(552);
_errHandler->sync(this);
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 39, _ctx);
while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
if (alt == 1) {
setState(549);
dynamic_cast<Seq_EContext *>(_localctx)->fld_70E_EContext = fld_70E_E();
}
setState(554);
_errHandler->sync(this);
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 39, _ctx);
}
_localctx->elem.mutable_objects()->Add()->mutable_field()->MergeFrom(dynamic_cast<Seq_EContext *>(_localctx)->fld_70E_EContext->fld);
setState(559);
_errHandler->sync(this);
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 40, _ctx);
while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
if (alt == 1) {
setState(556);
dynamic_cast<Seq_EContext *>(_localctx)->fld_95a_EContext = fld_95a_E();
}
setState(561);
_errHandler->sync(this);
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 40, _ctx);
}
_localctx->elem.mutable_objects()->Add()->mutable_field()->MergeFrom(dynamic_cast<Seq_EContext *>(_localctx)->fld_95a_EContext->fld);
setState(563);
dynamic_cast<Seq_EContext *>(_localctx)->fld_16S_EContext = fld_16S_E();
_localctx->elem.mutable_objects()->Add()->mutable_field()->MergeFrom(dynamic_cast<Seq_EContext *>(_localctx)->fld_16S_EContext->fld);
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- Fld_16R_AContext ------------------------------------------------------------------
SwiftMtParser_MT565Parser::Fld_16R_AContext::Fld_16R_AContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
std::vector<tree::TerminalNode *> SwiftMtParser_MT565Parser::Fld_16R_AContext::START_OF_FIELD() {
return getTokens(SwiftMtParser_MT565Parser::START_OF_FIELD);
}
tree::TerminalNode* SwiftMtParser_MT565Parser::Fld_16R_AContext::START_OF_FIELD(size_t i) {
return getToken(SwiftMtParser_MT565Parser::START_OF_FIELD, i);
}
size_t SwiftMtParser_MT565Parser::Fld_16R_AContext::getRuleIndex() const {
return SwiftMtParser_MT565Parser::RuleFld_16R_A;
}
void SwiftMtParser_MT565Parser::Fld_16R_AContext::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->enterFld_16R_A(this);
}
void SwiftMtParser_MT565Parser::Fld_16R_AContext::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->exitFld_16R_A(this);
}
SwiftMtParser_MT565Parser::Fld_16R_AContext* SwiftMtParser_MT565Parser::fld_16R_A() {
Fld_16R_AContext *_localctx = _tracker.createInstance<Fld_16R_AContext>(_ctx, getState());
enterRule(_localctx, 40, SwiftMtParser_MT565Parser::RuleFld_16R_A);
_localctx->fld.set_tag("16R");
size_t _la = 0;
auto onExit = finally([=] {
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(566);
match(SwiftMtParser_MT565Parser::START_OF_FIELD);
setState(567);
match(SwiftMtParser_MT565Parser::T__0);
setState(569);
_errHandler->sync(this);
_la = _input->LA(1);
do {
setState(568);
_la = _input->LA(1);
if (_la == 0 || _la == Token::EOF || (_la == SwiftMtParser_MT565Parser::START_OF_FIELD)) {
_errHandler->recoverInline(this);
}
else {
_errHandler->reportMatch(this);
consume();
}
setState(571);
_errHandler->sync(this);
_la = _input->LA(1);
} while ((((_la & ~ 0x3fULL) == 0) &&
((1ULL << _la) & ((1ULL << SwiftMtParser_MT565Parser::T__0)
| (1ULL << SwiftMtParser_MT565Parser::T__1)
| (1ULL << SwiftMtParser_MT565Parser::T__2)
| (1ULL << SwiftMtParser_MT565Parser::T__3)
| (1ULL << SwiftMtParser_MT565Parser::T__4)
| (1ULL << SwiftMtParser_MT565Parser::T__5)
| (1ULL << SwiftMtParser_MT565Parser::T__6)
| (1ULL << SwiftMtParser_MT565Parser::T__7)
| (1ULL << SwiftMtParser_MT565Parser::T__8)
| (1ULL << SwiftMtParser_MT565Parser::T__9)
| (1ULL << SwiftMtParser_MT565Parser::T__10)
| (1ULL << SwiftMtParser_MT565Parser::T__11)
| (1ULL << SwiftMtParser_MT565Parser::T__12)
| (1ULL << SwiftMtParser_MT565Parser::T__13)
| (1ULL << SwiftMtParser_MT565Parser::T__14)
| (1ULL << SwiftMtParser_MT565Parser::T__15)
| (1ULL << SwiftMtParser_MT565Parser::T__16)
| (1ULL << SwiftMtParser_MT565Parser::T__17)
| (1ULL << SwiftMtParser_MT565Parser::T__18)
| (1ULL << SwiftMtParser_MT565Parser::T__19)
| (1ULL << SwiftMtParser_MT565Parser::T__20)
| (1ULL << SwiftMtParser_MT565Parser::T__21)
| (1ULL << SwiftMtParser_MT565Parser::T__22)
| (1ULL << SwiftMtParser_MT565Parser::T__23)
| (1ULL << SwiftMtParser_MT565Parser::T__24)
| (1ULL << SwiftMtParser_MT565Parser::T__25)
| (1ULL << SwiftMtParser_MT565Parser::T__26)
| (1ULL << SwiftMtParser_MT565Parser::T__27)
| (1ULL << SwiftMtParser_MT565Parser::T__28)
| (1ULL << SwiftMtParser_MT565Parser::T__29)
| (1ULL << SwiftMtParser_MT565Parser::T__30)
| (1ULL << SwiftMtParser_MT565Parser::T__31)
| (1ULL << SwiftMtParser_MT565Parser::T__32)
| (1ULL << SwiftMtParser_MT565Parser::T__33)
| (1ULL << SwiftMtParser_MT565Parser::T__34)
| (1ULL << SwiftMtParser_MT565Parser::T__35)
| (1ULL << SwiftMtParser_MT565Parser::T__36)
| (1ULL << SwiftMtParser_MT565Parser::T__37)
| (1ULL << SwiftMtParser_MT565Parser::TAG_BH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_AH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_UH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_MT)
| (1ULL << SwiftMtParser_MT565Parser::TAG_TR)
| (1ULL << SwiftMtParser_MT565Parser::MT_END)
| (1ULL << SwiftMtParser_MT565Parser::LBRACE)
| (1ULL << SwiftMtParser_MT565Parser::RBRACE)
| (1ULL << SwiftMtParser_MT565Parser::COLON)
| (1ULL << SwiftMtParser_MT565Parser::ANY))) != 0));
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- Fld_20C_AContext ------------------------------------------------------------------
SwiftMtParser_MT565Parser::Fld_20C_AContext::Fld_20C_AContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
SwiftMtParser_MT565Parser::Fld_20C_A_CContext* SwiftMtParser_MT565Parser::Fld_20C_AContext::fld_20C_A_C() {
return getRuleContext<SwiftMtParser_MT565Parser::Fld_20C_A_CContext>(0);
}
size_t SwiftMtParser_MT565Parser::Fld_20C_AContext::getRuleIndex() const {
return SwiftMtParser_MT565Parser::RuleFld_20C_A;
}
void SwiftMtParser_MT565Parser::Fld_20C_AContext::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->enterFld_20C_A(this);
}
void SwiftMtParser_MT565Parser::Fld_20C_AContext::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->exitFld_20C_A(this);
}
SwiftMtParser_MT565Parser::Fld_20C_AContext* SwiftMtParser_MT565Parser::fld_20C_A() {
Fld_20C_AContext *_localctx = _tracker.createInstance<Fld_20C_AContext>(_ctx, getState());
enterRule(_localctx, 42, SwiftMtParser_MT565Parser::RuleFld_20C_A);
auto onExit = finally([=] {
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(573);
dynamic_cast<Fld_20C_AContext *>(_localctx)->fld_20C_A_CContext = fld_20C_A_C();
_localctx->fld.MergeFrom(dynamic_cast<Fld_20C_AContext *>(_localctx)->fld_20C_A_CContext->fld);
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- Fld_23G_AContext ------------------------------------------------------------------
SwiftMtParser_MT565Parser::Fld_23G_AContext::Fld_23G_AContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
SwiftMtParser_MT565Parser::Fld_23G_A_GContext* SwiftMtParser_MT565Parser::Fld_23G_AContext::fld_23G_A_G() {
return getRuleContext<SwiftMtParser_MT565Parser::Fld_23G_A_GContext>(0);
}
size_t SwiftMtParser_MT565Parser::Fld_23G_AContext::getRuleIndex() const {
return SwiftMtParser_MT565Parser::RuleFld_23G_A;
}
void SwiftMtParser_MT565Parser::Fld_23G_AContext::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->enterFld_23G_A(this);
}
void SwiftMtParser_MT565Parser::Fld_23G_AContext::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->exitFld_23G_A(this);
}
SwiftMtParser_MT565Parser::Fld_23G_AContext* SwiftMtParser_MT565Parser::fld_23G_A() {
Fld_23G_AContext *_localctx = _tracker.createInstance<Fld_23G_AContext>(_ctx, getState());
enterRule(_localctx, 44, SwiftMtParser_MT565Parser::RuleFld_23G_A);
auto onExit = finally([=] {
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(576);
dynamic_cast<Fld_23G_AContext *>(_localctx)->fld_23G_A_GContext = fld_23G_A_G();
_localctx->fld.MergeFrom(dynamic_cast<Fld_23G_AContext *>(_localctx)->fld_23G_A_GContext->fld);
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- Fld_22F_AContext ------------------------------------------------------------------
SwiftMtParser_MT565Parser::Fld_22F_AContext::Fld_22F_AContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
SwiftMtParser_MT565Parser::Fld_22F_A_FContext* SwiftMtParser_MT565Parser::Fld_22F_AContext::fld_22F_A_F() {
return getRuleContext<SwiftMtParser_MT565Parser::Fld_22F_A_FContext>(0);
}
size_t SwiftMtParser_MT565Parser::Fld_22F_AContext::getRuleIndex() const {
return SwiftMtParser_MT565Parser::RuleFld_22F_A;
}
void SwiftMtParser_MT565Parser::Fld_22F_AContext::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->enterFld_22F_A(this);
}
void SwiftMtParser_MT565Parser::Fld_22F_AContext::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->exitFld_22F_A(this);
}
SwiftMtParser_MT565Parser::Fld_22F_AContext* SwiftMtParser_MT565Parser::fld_22F_A() {
Fld_22F_AContext *_localctx = _tracker.createInstance<Fld_22F_AContext>(_ctx, getState());
enterRule(_localctx, 46, SwiftMtParser_MT565Parser::RuleFld_22F_A);
auto onExit = finally([=] {
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(579);
dynamic_cast<Fld_22F_AContext *>(_localctx)->fld_22F_A_FContext = fld_22F_A_F();
_localctx->fld.MergeFrom(dynamic_cast<Fld_22F_AContext *>(_localctx)->fld_22F_A_FContext->fld);
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- Fld_98a_AContext ------------------------------------------------------------------
SwiftMtParser_MT565Parser::Fld_98a_AContext::Fld_98a_AContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
SwiftMtParser_MT565Parser::Fld_98a_A_AContext* SwiftMtParser_MT565Parser::Fld_98a_AContext::fld_98a_A_A() {
return getRuleContext<SwiftMtParser_MT565Parser::Fld_98a_A_AContext>(0);
}
SwiftMtParser_MT565Parser::Fld_98a_A_CContext* SwiftMtParser_MT565Parser::Fld_98a_AContext::fld_98a_A_C() {
return getRuleContext<SwiftMtParser_MT565Parser::Fld_98a_A_CContext>(0);
}
size_t SwiftMtParser_MT565Parser::Fld_98a_AContext::getRuleIndex() const {
return SwiftMtParser_MT565Parser::RuleFld_98a_A;
}
void SwiftMtParser_MT565Parser::Fld_98a_AContext::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->enterFld_98a_A(this);
}
void SwiftMtParser_MT565Parser::Fld_98a_AContext::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->exitFld_98a_A(this);
}
SwiftMtParser_MT565Parser::Fld_98a_AContext* SwiftMtParser_MT565Parser::fld_98a_A() {
Fld_98a_AContext *_localctx = _tracker.createInstance<Fld_98a_AContext>(_ctx, getState());
enterRule(_localctx, 48, SwiftMtParser_MT565Parser::RuleFld_98a_A);
auto onExit = finally([=] {
exitRule();
});
try {
setState(588);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 42, _ctx)) {
case 1: {
enterOuterAlt(_localctx, 1);
setState(582);
dynamic_cast<Fld_98a_AContext *>(_localctx)->fld_98a_A_AContext = fld_98a_A_A();
_localctx->fld.MergeFrom(dynamic_cast<Fld_98a_AContext *>(_localctx)->fld_98a_A_AContext->fld);
break;
}
case 2: {
enterOuterAlt(_localctx, 2);
setState(585);
dynamic_cast<Fld_98a_AContext *>(_localctx)->fld_98a_A_CContext = fld_98a_A_C();
_localctx->fld.MergeFrom(dynamic_cast<Fld_98a_AContext *>(_localctx)->fld_98a_A_CContext->fld);
break;
}
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- Fld_16R_A1Context ------------------------------------------------------------------
SwiftMtParser_MT565Parser::Fld_16R_A1Context::Fld_16R_A1Context(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
std::vector<tree::TerminalNode *> SwiftMtParser_MT565Parser::Fld_16R_A1Context::START_OF_FIELD() {
return getTokens(SwiftMtParser_MT565Parser::START_OF_FIELD);
}
tree::TerminalNode* SwiftMtParser_MT565Parser::Fld_16R_A1Context::START_OF_FIELD(size_t i) {
return getToken(SwiftMtParser_MT565Parser::START_OF_FIELD, i);
}
size_t SwiftMtParser_MT565Parser::Fld_16R_A1Context::getRuleIndex() const {
return SwiftMtParser_MT565Parser::RuleFld_16R_A1;
}
void SwiftMtParser_MT565Parser::Fld_16R_A1Context::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->enterFld_16R_A1(this);
}
void SwiftMtParser_MT565Parser::Fld_16R_A1Context::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->exitFld_16R_A1(this);
}
SwiftMtParser_MT565Parser::Fld_16R_A1Context* SwiftMtParser_MT565Parser::fld_16R_A1() {
Fld_16R_A1Context *_localctx = _tracker.createInstance<Fld_16R_A1Context>(_ctx, getState());
enterRule(_localctx, 50, SwiftMtParser_MT565Parser::RuleFld_16R_A1);
_localctx->fld.set_tag("16R");
size_t _la = 0;
auto onExit = finally([=] {
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(590);
match(SwiftMtParser_MT565Parser::START_OF_FIELD);
setState(591);
match(SwiftMtParser_MT565Parser::T__0);
setState(593);
_errHandler->sync(this);
_la = _input->LA(1);
do {
setState(592);
_la = _input->LA(1);
if (_la == 0 || _la == Token::EOF || (_la == SwiftMtParser_MT565Parser::START_OF_FIELD)) {
_errHandler->recoverInline(this);
}
else {
_errHandler->reportMatch(this);
consume();
}
setState(595);
_errHandler->sync(this);
_la = _input->LA(1);
} while ((((_la & ~ 0x3fULL) == 0) &&
((1ULL << _la) & ((1ULL << SwiftMtParser_MT565Parser::T__0)
| (1ULL << SwiftMtParser_MT565Parser::T__1)
| (1ULL << SwiftMtParser_MT565Parser::T__2)
| (1ULL << SwiftMtParser_MT565Parser::T__3)
| (1ULL << SwiftMtParser_MT565Parser::T__4)
| (1ULL << SwiftMtParser_MT565Parser::T__5)
| (1ULL << SwiftMtParser_MT565Parser::T__6)
| (1ULL << SwiftMtParser_MT565Parser::T__7)
| (1ULL << SwiftMtParser_MT565Parser::T__8)
| (1ULL << SwiftMtParser_MT565Parser::T__9)
| (1ULL << SwiftMtParser_MT565Parser::T__10)
| (1ULL << SwiftMtParser_MT565Parser::T__11)
| (1ULL << SwiftMtParser_MT565Parser::T__12)
| (1ULL << SwiftMtParser_MT565Parser::T__13)
| (1ULL << SwiftMtParser_MT565Parser::T__14)
| (1ULL << SwiftMtParser_MT565Parser::T__15)
| (1ULL << SwiftMtParser_MT565Parser::T__16)
| (1ULL << SwiftMtParser_MT565Parser::T__17)
| (1ULL << SwiftMtParser_MT565Parser::T__18)
| (1ULL << SwiftMtParser_MT565Parser::T__19)
| (1ULL << SwiftMtParser_MT565Parser::T__20)
| (1ULL << SwiftMtParser_MT565Parser::T__21)
| (1ULL << SwiftMtParser_MT565Parser::T__22)
| (1ULL << SwiftMtParser_MT565Parser::T__23)
| (1ULL << SwiftMtParser_MT565Parser::T__24)
| (1ULL << SwiftMtParser_MT565Parser::T__25)
| (1ULL << SwiftMtParser_MT565Parser::T__26)
| (1ULL << SwiftMtParser_MT565Parser::T__27)
| (1ULL << SwiftMtParser_MT565Parser::T__28)
| (1ULL << SwiftMtParser_MT565Parser::T__29)
| (1ULL << SwiftMtParser_MT565Parser::T__30)
| (1ULL << SwiftMtParser_MT565Parser::T__31)
| (1ULL << SwiftMtParser_MT565Parser::T__32)
| (1ULL << SwiftMtParser_MT565Parser::T__33)
| (1ULL << SwiftMtParser_MT565Parser::T__34)
| (1ULL << SwiftMtParser_MT565Parser::T__35)
| (1ULL << SwiftMtParser_MT565Parser::T__36)
| (1ULL << SwiftMtParser_MT565Parser::T__37)
| (1ULL << SwiftMtParser_MT565Parser::TAG_BH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_AH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_UH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_MT)
| (1ULL << SwiftMtParser_MT565Parser::TAG_TR)
| (1ULL << SwiftMtParser_MT565Parser::MT_END)
| (1ULL << SwiftMtParser_MT565Parser::LBRACE)
| (1ULL << SwiftMtParser_MT565Parser::RBRACE)
| (1ULL << SwiftMtParser_MT565Parser::COLON)
| (1ULL << SwiftMtParser_MT565Parser::ANY))) != 0));
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- Fld_22F_A1Context ------------------------------------------------------------------
SwiftMtParser_MT565Parser::Fld_22F_A1Context::Fld_22F_A1Context(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
SwiftMtParser_MT565Parser::Fld_22F_A1_FContext* SwiftMtParser_MT565Parser::Fld_22F_A1Context::fld_22F_A1_F() {
return getRuleContext<SwiftMtParser_MT565Parser::Fld_22F_A1_FContext>(0);
}
size_t SwiftMtParser_MT565Parser::Fld_22F_A1Context::getRuleIndex() const {
return SwiftMtParser_MT565Parser::RuleFld_22F_A1;
}
void SwiftMtParser_MT565Parser::Fld_22F_A1Context::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->enterFld_22F_A1(this);
}
void SwiftMtParser_MT565Parser::Fld_22F_A1Context::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->exitFld_22F_A1(this);
}
SwiftMtParser_MT565Parser::Fld_22F_A1Context* SwiftMtParser_MT565Parser::fld_22F_A1() {
Fld_22F_A1Context *_localctx = _tracker.createInstance<Fld_22F_A1Context>(_ctx, getState());
enterRule(_localctx, 52, SwiftMtParser_MT565Parser::RuleFld_22F_A1);
auto onExit = finally([=] {
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(597);
dynamic_cast<Fld_22F_A1Context *>(_localctx)->fld_22F_A1_FContext = fld_22F_A1_F();
_localctx->fld.MergeFrom(dynamic_cast<Fld_22F_A1Context *>(_localctx)->fld_22F_A1_FContext->fld);
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- Fld_13a_A1Context ------------------------------------------------------------------
SwiftMtParser_MT565Parser::Fld_13a_A1Context::Fld_13a_A1Context(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
SwiftMtParser_MT565Parser::Fld_13a_A1_AContext* SwiftMtParser_MT565Parser::Fld_13a_A1Context::fld_13a_A1_A() {
return getRuleContext<SwiftMtParser_MT565Parser::Fld_13a_A1_AContext>(0);
}
SwiftMtParser_MT565Parser::Fld_13a_A1_BContext* SwiftMtParser_MT565Parser::Fld_13a_A1Context::fld_13a_A1_B() {
return getRuleContext<SwiftMtParser_MT565Parser::Fld_13a_A1_BContext>(0);
}
size_t SwiftMtParser_MT565Parser::Fld_13a_A1Context::getRuleIndex() const {
return SwiftMtParser_MT565Parser::RuleFld_13a_A1;
}
void SwiftMtParser_MT565Parser::Fld_13a_A1Context::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->enterFld_13a_A1(this);
}
void SwiftMtParser_MT565Parser::Fld_13a_A1Context::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->exitFld_13a_A1(this);
}
SwiftMtParser_MT565Parser::Fld_13a_A1Context* SwiftMtParser_MT565Parser::fld_13a_A1() {
Fld_13a_A1Context *_localctx = _tracker.createInstance<Fld_13a_A1Context>(_ctx, getState());
enterRule(_localctx, 54, SwiftMtParser_MT565Parser::RuleFld_13a_A1);
auto onExit = finally([=] {
exitRule();
});
try {
setState(606);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 44, _ctx)) {
case 1: {
enterOuterAlt(_localctx, 1);
setState(600);
dynamic_cast<Fld_13a_A1Context *>(_localctx)->fld_13a_A1_AContext = fld_13a_A1_A();
_localctx->fld.MergeFrom(dynamic_cast<Fld_13a_A1Context *>(_localctx)->fld_13a_A1_AContext->fld);
break;
}
case 2: {
enterOuterAlt(_localctx, 2);
setState(603);
dynamic_cast<Fld_13a_A1Context *>(_localctx)->fld_13a_A1_BContext = fld_13a_A1_B();
_localctx->fld.MergeFrom(dynamic_cast<Fld_13a_A1Context *>(_localctx)->fld_13a_A1_BContext->fld);
break;
}
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- Fld_20C_A1Context ------------------------------------------------------------------
SwiftMtParser_MT565Parser::Fld_20C_A1Context::Fld_20C_A1Context(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
SwiftMtParser_MT565Parser::Fld_20C_A1_CContext* SwiftMtParser_MT565Parser::Fld_20C_A1Context::fld_20C_A1_C() {
return getRuleContext<SwiftMtParser_MT565Parser::Fld_20C_A1_CContext>(0);
}
size_t SwiftMtParser_MT565Parser::Fld_20C_A1Context::getRuleIndex() const {
return SwiftMtParser_MT565Parser::RuleFld_20C_A1;
}
void SwiftMtParser_MT565Parser::Fld_20C_A1Context::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->enterFld_20C_A1(this);
}
void SwiftMtParser_MT565Parser::Fld_20C_A1Context::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->exitFld_20C_A1(this);
}
SwiftMtParser_MT565Parser::Fld_20C_A1Context* SwiftMtParser_MT565Parser::fld_20C_A1() {
Fld_20C_A1Context *_localctx = _tracker.createInstance<Fld_20C_A1Context>(_ctx, getState());
enterRule(_localctx, 56, SwiftMtParser_MT565Parser::RuleFld_20C_A1);
auto onExit = finally([=] {
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(608);
dynamic_cast<Fld_20C_A1Context *>(_localctx)->fld_20C_A1_CContext = fld_20C_A1_C();
_localctx->fld.MergeFrom(dynamic_cast<Fld_20C_A1Context *>(_localctx)->fld_20C_A1_CContext->fld);
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- Fld_16S_A1Context ------------------------------------------------------------------
SwiftMtParser_MT565Parser::Fld_16S_A1Context::Fld_16S_A1Context(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
std::vector<tree::TerminalNode *> SwiftMtParser_MT565Parser::Fld_16S_A1Context::START_OF_FIELD() {
return getTokens(SwiftMtParser_MT565Parser::START_OF_FIELD);
}
tree::TerminalNode* SwiftMtParser_MT565Parser::Fld_16S_A1Context::START_OF_FIELD(size_t i) {
return getToken(SwiftMtParser_MT565Parser::START_OF_FIELD, i);
}
size_t SwiftMtParser_MT565Parser::Fld_16S_A1Context::getRuleIndex() const {
return SwiftMtParser_MT565Parser::RuleFld_16S_A1;
}
void SwiftMtParser_MT565Parser::Fld_16S_A1Context::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->enterFld_16S_A1(this);
}
void SwiftMtParser_MT565Parser::Fld_16S_A1Context::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->exitFld_16S_A1(this);
}
SwiftMtParser_MT565Parser::Fld_16S_A1Context* SwiftMtParser_MT565Parser::fld_16S_A1() {
Fld_16S_A1Context *_localctx = _tracker.createInstance<Fld_16S_A1Context>(_ctx, getState());
enterRule(_localctx, 58, SwiftMtParser_MT565Parser::RuleFld_16S_A1);
_localctx->fld.set_tag("16S");
size_t _la = 0;
auto onExit = finally([=] {
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(611);
match(SwiftMtParser_MT565Parser::START_OF_FIELD);
setState(612);
match(SwiftMtParser_MT565Parser::T__1);
setState(614);
_errHandler->sync(this);
_la = _input->LA(1);
do {
setState(613);
_la = _input->LA(1);
if (_la == 0 || _la == Token::EOF || (_la == SwiftMtParser_MT565Parser::START_OF_FIELD)) {
_errHandler->recoverInline(this);
}
else {
_errHandler->reportMatch(this);
consume();
}
setState(616);
_errHandler->sync(this);
_la = _input->LA(1);
} while ((((_la & ~ 0x3fULL) == 0) &&
((1ULL << _la) & ((1ULL << SwiftMtParser_MT565Parser::T__0)
| (1ULL << SwiftMtParser_MT565Parser::T__1)
| (1ULL << SwiftMtParser_MT565Parser::T__2)
| (1ULL << SwiftMtParser_MT565Parser::T__3)
| (1ULL << SwiftMtParser_MT565Parser::T__4)
| (1ULL << SwiftMtParser_MT565Parser::T__5)
| (1ULL << SwiftMtParser_MT565Parser::T__6)
| (1ULL << SwiftMtParser_MT565Parser::T__7)
| (1ULL << SwiftMtParser_MT565Parser::T__8)
| (1ULL << SwiftMtParser_MT565Parser::T__9)
| (1ULL << SwiftMtParser_MT565Parser::T__10)
| (1ULL << SwiftMtParser_MT565Parser::T__11)
| (1ULL << SwiftMtParser_MT565Parser::T__12)
| (1ULL << SwiftMtParser_MT565Parser::T__13)
| (1ULL << SwiftMtParser_MT565Parser::T__14)
| (1ULL << SwiftMtParser_MT565Parser::T__15)
| (1ULL << SwiftMtParser_MT565Parser::T__16)
| (1ULL << SwiftMtParser_MT565Parser::T__17)
| (1ULL << SwiftMtParser_MT565Parser::T__18)
| (1ULL << SwiftMtParser_MT565Parser::T__19)
| (1ULL << SwiftMtParser_MT565Parser::T__20)
| (1ULL << SwiftMtParser_MT565Parser::T__21)
| (1ULL << SwiftMtParser_MT565Parser::T__22)
| (1ULL << SwiftMtParser_MT565Parser::T__23)
| (1ULL << SwiftMtParser_MT565Parser::T__24)
| (1ULL << SwiftMtParser_MT565Parser::T__25)
| (1ULL << SwiftMtParser_MT565Parser::T__26)
| (1ULL << SwiftMtParser_MT565Parser::T__27)
| (1ULL << SwiftMtParser_MT565Parser::T__28)
| (1ULL << SwiftMtParser_MT565Parser::T__29)
| (1ULL << SwiftMtParser_MT565Parser::T__30)
| (1ULL << SwiftMtParser_MT565Parser::T__31)
| (1ULL << SwiftMtParser_MT565Parser::T__32)
| (1ULL << SwiftMtParser_MT565Parser::T__33)
| (1ULL << SwiftMtParser_MT565Parser::T__34)
| (1ULL << SwiftMtParser_MT565Parser::T__35)
| (1ULL << SwiftMtParser_MT565Parser::T__36)
| (1ULL << SwiftMtParser_MT565Parser::T__37)
| (1ULL << SwiftMtParser_MT565Parser::TAG_BH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_AH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_UH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_MT)
| (1ULL << SwiftMtParser_MT565Parser::TAG_TR)
| (1ULL << SwiftMtParser_MT565Parser::MT_END)
| (1ULL << SwiftMtParser_MT565Parser::LBRACE)
| (1ULL << SwiftMtParser_MT565Parser::RBRACE)
| (1ULL << SwiftMtParser_MT565Parser::COLON)
| (1ULL << SwiftMtParser_MT565Parser::ANY))) != 0));
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- Fld_16S_AContext ------------------------------------------------------------------
SwiftMtParser_MT565Parser::Fld_16S_AContext::Fld_16S_AContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
std::vector<tree::TerminalNode *> SwiftMtParser_MT565Parser::Fld_16S_AContext::START_OF_FIELD() {
return getTokens(SwiftMtParser_MT565Parser::START_OF_FIELD);
}
tree::TerminalNode* SwiftMtParser_MT565Parser::Fld_16S_AContext::START_OF_FIELD(size_t i) {
return getToken(SwiftMtParser_MT565Parser::START_OF_FIELD, i);
}
size_t SwiftMtParser_MT565Parser::Fld_16S_AContext::getRuleIndex() const {
return SwiftMtParser_MT565Parser::RuleFld_16S_A;
}
void SwiftMtParser_MT565Parser::Fld_16S_AContext::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->enterFld_16S_A(this);
}
void SwiftMtParser_MT565Parser::Fld_16S_AContext::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->exitFld_16S_A(this);
}
SwiftMtParser_MT565Parser::Fld_16S_AContext* SwiftMtParser_MT565Parser::fld_16S_A() {
Fld_16S_AContext *_localctx = _tracker.createInstance<Fld_16S_AContext>(_ctx, getState());
enterRule(_localctx, 60, SwiftMtParser_MT565Parser::RuleFld_16S_A);
_localctx->fld.set_tag("16S");
size_t _la = 0;
auto onExit = finally([=] {
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(618);
match(SwiftMtParser_MT565Parser::START_OF_FIELD);
setState(619);
match(SwiftMtParser_MT565Parser::T__1);
setState(621);
_errHandler->sync(this);
_la = _input->LA(1);
do {
setState(620);
_la = _input->LA(1);
if (_la == 0 || _la == Token::EOF || (_la == SwiftMtParser_MT565Parser::START_OF_FIELD)) {
_errHandler->recoverInline(this);
}
else {
_errHandler->reportMatch(this);
consume();
}
setState(623);
_errHandler->sync(this);
_la = _input->LA(1);
} while ((((_la & ~ 0x3fULL) == 0) &&
((1ULL << _la) & ((1ULL << SwiftMtParser_MT565Parser::T__0)
| (1ULL << SwiftMtParser_MT565Parser::T__1)
| (1ULL << SwiftMtParser_MT565Parser::T__2)
| (1ULL << SwiftMtParser_MT565Parser::T__3)
| (1ULL << SwiftMtParser_MT565Parser::T__4)
| (1ULL << SwiftMtParser_MT565Parser::T__5)
| (1ULL << SwiftMtParser_MT565Parser::T__6)
| (1ULL << SwiftMtParser_MT565Parser::T__7)
| (1ULL << SwiftMtParser_MT565Parser::T__8)
| (1ULL << SwiftMtParser_MT565Parser::T__9)
| (1ULL << SwiftMtParser_MT565Parser::T__10)
| (1ULL << SwiftMtParser_MT565Parser::T__11)
| (1ULL << SwiftMtParser_MT565Parser::T__12)
| (1ULL << SwiftMtParser_MT565Parser::T__13)
| (1ULL << SwiftMtParser_MT565Parser::T__14)
| (1ULL << SwiftMtParser_MT565Parser::T__15)
| (1ULL << SwiftMtParser_MT565Parser::T__16)
| (1ULL << SwiftMtParser_MT565Parser::T__17)
| (1ULL << SwiftMtParser_MT565Parser::T__18)
| (1ULL << SwiftMtParser_MT565Parser::T__19)
| (1ULL << SwiftMtParser_MT565Parser::T__20)
| (1ULL << SwiftMtParser_MT565Parser::T__21)
| (1ULL << SwiftMtParser_MT565Parser::T__22)
| (1ULL << SwiftMtParser_MT565Parser::T__23)
| (1ULL << SwiftMtParser_MT565Parser::T__24)
| (1ULL << SwiftMtParser_MT565Parser::T__25)
| (1ULL << SwiftMtParser_MT565Parser::T__26)
| (1ULL << SwiftMtParser_MT565Parser::T__27)
| (1ULL << SwiftMtParser_MT565Parser::T__28)
| (1ULL << SwiftMtParser_MT565Parser::T__29)
| (1ULL << SwiftMtParser_MT565Parser::T__30)
| (1ULL << SwiftMtParser_MT565Parser::T__31)
| (1ULL << SwiftMtParser_MT565Parser::T__32)
| (1ULL << SwiftMtParser_MT565Parser::T__33)
| (1ULL << SwiftMtParser_MT565Parser::T__34)
| (1ULL << SwiftMtParser_MT565Parser::T__35)
| (1ULL << SwiftMtParser_MT565Parser::T__36)
| (1ULL << SwiftMtParser_MT565Parser::T__37)
| (1ULL << SwiftMtParser_MT565Parser::TAG_BH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_AH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_UH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_MT)
| (1ULL << SwiftMtParser_MT565Parser::TAG_TR)
| (1ULL << SwiftMtParser_MT565Parser::MT_END)
| (1ULL << SwiftMtParser_MT565Parser::LBRACE)
| (1ULL << SwiftMtParser_MT565Parser::RBRACE)
| (1ULL << SwiftMtParser_MT565Parser::COLON)
| (1ULL << SwiftMtParser_MT565Parser::ANY))) != 0));
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- Fld_16R_BContext ------------------------------------------------------------------
SwiftMtParser_MT565Parser::Fld_16R_BContext::Fld_16R_BContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
std::vector<tree::TerminalNode *> SwiftMtParser_MT565Parser::Fld_16R_BContext::START_OF_FIELD() {
return getTokens(SwiftMtParser_MT565Parser::START_OF_FIELD);
}
tree::TerminalNode* SwiftMtParser_MT565Parser::Fld_16R_BContext::START_OF_FIELD(size_t i) {
return getToken(SwiftMtParser_MT565Parser::START_OF_FIELD, i);
}
size_t SwiftMtParser_MT565Parser::Fld_16R_BContext::getRuleIndex() const {
return SwiftMtParser_MT565Parser::RuleFld_16R_B;
}
void SwiftMtParser_MT565Parser::Fld_16R_BContext::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->enterFld_16R_B(this);
}
void SwiftMtParser_MT565Parser::Fld_16R_BContext::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->exitFld_16R_B(this);
}
SwiftMtParser_MT565Parser::Fld_16R_BContext* SwiftMtParser_MT565Parser::fld_16R_B() {
Fld_16R_BContext *_localctx = _tracker.createInstance<Fld_16R_BContext>(_ctx, getState());
enterRule(_localctx, 62, SwiftMtParser_MT565Parser::RuleFld_16R_B);
_localctx->fld.set_tag("16R");
size_t _la = 0;
auto onExit = finally([=] {
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(625);
match(SwiftMtParser_MT565Parser::START_OF_FIELD);
setState(626);
match(SwiftMtParser_MT565Parser::T__0);
setState(628);
_errHandler->sync(this);
_la = _input->LA(1);
do {
setState(627);
_la = _input->LA(1);
if (_la == 0 || _la == Token::EOF || (_la == SwiftMtParser_MT565Parser::START_OF_FIELD)) {
_errHandler->recoverInline(this);
}
else {
_errHandler->reportMatch(this);
consume();
}
setState(630);
_errHandler->sync(this);
_la = _input->LA(1);
} while ((((_la & ~ 0x3fULL) == 0) &&
((1ULL << _la) & ((1ULL << SwiftMtParser_MT565Parser::T__0)
| (1ULL << SwiftMtParser_MT565Parser::T__1)
| (1ULL << SwiftMtParser_MT565Parser::T__2)
| (1ULL << SwiftMtParser_MT565Parser::T__3)
| (1ULL << SwiftMtParser_MT565Parser::T__4)
| (1ULL << SwiftMtParser_MT565Parser::T__5)
| (1ULL << SwiftMtParser_MT565Parser::T__6)
| (1ULL << SwiftMtParser_MT565Parser::T__7)
| (1ULL << SwiftMtParser_MT565Parser::T__8)
| (1ULL << SwiftMtParser_MT565Parser::T__9)
| (1ULL << SwiftMtParser_MT565Parser::T__10)
| (1ULL << SwiftMtParser_MT565Parser::T__11)
| (1ULL << SwiftMtParser_MT565Parser::T__12)
| (1ULL << SwiftMtParser_MT565Parser::T__13)
| (1ULL << SwiftMtParser_MT565Parser::T__14)
| (1ULL << SwiftMtParser_MT565Parser::T__15)
| (1ULL << SwiftMtParser_MT565Parser::T__16)
| (1ULL << SwiftMtParser_MT565Parser::T__17)
| (1ULL << SwiftMtParser_MT565Parser::T__18)
| (1ULL << SwiftMtParser_MT565Parser::T__19)
| (1ULL << SwiftMtParser_MT565Parser::T__20)
| (1ULL << SwiftMtParser_MT565Parser::T__21)
| (1ULL << SwiftMtParser_MT565Parser::T__22)
| (1ULL << SwiftMtParser_MT565Parser::T__23)
| (1ULL << SwiftMtParser_MT565Parser::T__24)
| (1ULL << SwiftMtParser_MT565Parser::T__25)
| (1ULL << SwiftMtParser_MT565Parser::T__26)
| (1ULL << SwiftMtParser_MT565Parser::T__27)
| (1ULL << SwiftMtParser_MT565Parser::T__28)
| (1ULL << SwiftMtParser_MT565Parser::T__29)
| (1ULL << SwiftMtParser_MT565Parser::T__30)
| (1ULL << SwiftMtParser_MT565Parser::T__31)
| (1ULL << SwiftMtParser_MT565Parser::T__32)
| (1ULL << SwiftMtParser_MT565Parser::T__33)
| (1ULL << SwiftMtParser_MT565Parser::T__34)
| (1ULL << SwiftMtParser_MT565Parser::T__35)
| (1ULL << SwiftMtParser_MT565Parser::T__36)
| (1ULL << SwiftMtParser_MT565Parser::T__37)
| (1ULL << SwiftMtParser_MT565Parser::TAG_BH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_AH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_UH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_MT)
| (1ULL << SwiftMtParser_MT565Parser::TAG_TR)
| (1ULL << SwiftMtParser_MT565Parser::MT_END)
| (1ULL << SwiftMtParser_MT565Parser::LBRACE)
| (1ULL << SwiftMtParser_MT565Parser::RBRACE)
| (1ULL << SwiftMtParser_MT565Parser::COLON)
| (1ULL << SwiftMtParser_MT565Parser::ANY))) != 0));
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- Fld_35B_BContext ------------------------------------------------------------------
SwiftMtParser_MT565Parser::Fld_35B_BContext::Fld_35B_BContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
SwiftMtParser_MT565Parser::Fld_35B_B_BContext* SwiftMtParser_MT565Parser::Fld_35B_BContext::fld_35B_B_B() {
return getRuleContext<SwiftMtParser_MT565Parser::Fld_35B_B_BContext>(0);
}
size_t SwiftMtParser_MT565Parser::Fld_35B_BContext::getRuleIndex() const {
return SwiftMtParser_MT565Parser::RuleFld_35B_B;
}
void SwiftMtParser_MT565Parser::Fld_35B_BContext::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->enterFld_35B_B(this);
}
void SwiftMtParser_MT565Parser::Fld_35B_BContext::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->exitFld_35B_B(this);
}
SwiftMtParser_MT565Parser::Fld_35B_BContext* SwiftMtParser_MT565Parser::fld_35B_B() {
Fld_35B_BContext *_localctx = _tracker.createInstance<Fld_35B_BContext>(_ctx, getState());
enterRule(_localctx, 64, SwiftMtParser_MT565Parser::RuleFld_35B_B);
auto onExit = finally([=] {
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(632);
dynamic_cast<Fld_35B_BContext *>(_localctx)->fld_35B_B_BContext = fld_35B_B_B();
_localctx->fld.MergeFrom(dynamic_cast<Fld_35B_BContext *>(_localctx)->fld_35B_B_BContext->fld);
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- Fld_16R_B1Context ------------------------------------------------------------------
SwiftMtParser_MT565Parser::Fld_16R_B1Context::Fld_16R_B1Context(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
std::vector<tree::TerminalNode *> SwiftMtParser_MT565Parser::Fld_16R_B1Context::START_OF_FIELD() {
return getTokens(SwiftMtParser_MT565Parser::START_OF_FIELD);
}
tree::TerminalNode* SwiftMtParser_MT565Parser::Fld_16R_B1Context::START_OF_FIELD(size_t i) {
return getToken(SwiftMtParser_MT565Parser::START_OF_FIELD, i);
}
size_t SwiftMtParser_MT565Parser::Fld_16R_B1Context::getRuleIndex() const {
return SwiftMtParser_MT565Parser::RuleFld_16R_B1;
}
void SwiftMtParser_MT565Parser::Fld_16R_B1Context::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->enterFld_16R_B1(this);
}
void SwiftMtParser_MT565Parser::Fld_16R_B1Context::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->exitFld_16R_B1(this);
}
SwiftMtParser_MT565Parser::Fld_16R_B1Context* SwiftMtParser_MT565Parser::fld_16R_B1() {
Fld_16R_B1Context *_localctx = _tracker.createInstance<Fld_16R_B1Context>(_ctx, getState());
enterRule(_localctx, 66, SwiftMtParser_MT565Parser::RuleFld_16R_B1);
_localctx->fld.set_tag("16R");
size_t _la = 0;
auto onExit = finally([=] {
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(635);
match(SwiftMtParser_MT565Parser::START_OF_FIELD);
setState(636);
match(SwiftMtParser_MT565Parser::T__0);
setState(638);
_errHandler->sync(this);
_la = _input->LA(1);
do {
setState(637);
_la = _input->LA(1);
if (_la == 0 || _la == Token::EOF || (_la == SwiftMtParser_MT565Parser::START_OF_FIELD)) {
_errHandler->recoverInline(this);
}
else {
_errHandler->reportMatch(this);
consume();
}
setState(640);
_errHandler->sync(this);
_la = _input->LA(1);
} while ((((_la & ~ 0x3fULL) == 0) &&
((1ULL << _la) & ((1ULL << SwiftMtParser_MT565Parser::T__0)
| (1ULL << SwiftMtParser_MT565Parser::T__1)
| (1ULL << SwiftMtParser_MT565Parser::T__2)
| (1ULL << SwiftMtParser_MT565Parser::T__3)
| (1ULL << SwiftMtParser_MT565Parser::T__4)
| (1ULL << SwiftMtParser_MT565Parser::T__5)
| (1ULL << SwiftMtParser_MT565Parser::T__6)
| (1ULL << SwiftMtParser_MT565Parser::T__7)
| (1ULL << SwiftMtParser_MT565Parser::T__8)
| (1ULL << SwiftMtParser_MT565Parser::T__9)
| (1ULL << SwiftMtParser_MT565Parser::T__10)
| (1ULL << SwiftMtParser_MT565Parser::T__11)
| (1ULL << SwiftMtParser_MT565Parser::T__12)
| (1ULL << SwiftMtParser_MT565Parser::T__13)
| (1ULL << SwiftMtParser_MT565Parser::T__14)
| (1ULL << SwiftMtParser_MT565Parser::T__15)
| (1ULL << SwiftMtParser_MT565Parser::T__16)
| (1ULL << SwiftMtParser_MT565Parser::T__17)
| (1ULL << SwiftMtParser_MT565Parser::T__18)
| (1ULL << SwiftMtParser_MT565Parser::T__19)
| (1ULL << SwiftMtParser_MT565Parser::T__20)
| (1ULL << SwiftMtParser_MT565Parser::T__21)
| (1ULL << SwiftMtParser_MT565Parser::T__22)
| (1ULL << SwiftMtParser_MT565Parser::T__23)
| (1ULL << SwiftMtParser_MT565Parser::T__24)
| (1ULL << SwiftMtParser_MT565Parser::T__25)
| (1ULL << SwiftMtParser_MT565Parser::T__26)
| (1ULL << SwiftMtParser_MT565Parser::T__27)
| (1ULL << SwiftMtParser_MT565Parser::T__28)
| (1ULL << SwiftMtParser_MT565Parser::T__29)
| (1ULL << SwiftMtParser_MT565Parser::T__30)
| (1ULL << SwiftMtParser_MT565Parser::T__31)
| (1ULL << SwiftMtParser_MT565Parser::T__32)
| (1ULL << SwiftMtParser_MT565Parser::T__33)
| (1ULL << SwiftMtParser_MT565Parser::T__34)
| (1ULL << SwiftMtParser_MT565Parser::T__35)
| (1ULL << SwiftMtParser_MT565Parser::T__36)
| (1ULL << SwiftMtParser_MT565Parser::T__37)
| (1ULL << SwiftMtParser_MT565Parser::TAG_BH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_AH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_UH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_MT)
| (1ULL << SwiftMtParser_MT565Parser::TAG_TR)
| (1ULL << SwiftMtParser_MT565Parser::MT_END)
| (1ULL << SwiftMtParser_MT565Parser::LBRACE)
| (1ULL << SwiftMtParser_MT565Parser::RBRACE)
| (1ULL << SwiftMtParser_MT565Parser::COLON)
| (1ULL << SwiftMtParser_MT565Parser::ANY))) != 0));
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- Fld_94B_B1Context ------------------------------------------------------------------
SwiftMtParser_MT565Parser::Fld_94B_B1Context::Fld_94B_B1Context(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
SwiftMtParser_MT565Parser::Fld_94B_B1_BContext* SwiftMtParser_MT565Parser::Fld_94B_B1Context::fld_94B_B1_B() {
return getRuleContext<SwiftMtParser_MT565Parser::Fld_94B_B1_BContext>(0);
}
size_t SwiftMtParser_MT565Parser::Fld_94B_B1Context::getRuleIndex() const {
return SwiftMtParser_MT565Parser::RuleFld_94B_B1;
}
void SwiftMtParser_MT565Parser::Fld_94B_B1Context::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->enterFld_94B_B1(this);
}
void SwiftMtParser_MT565Parser::Fld_94B_B1Context::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->exitFld_94B_B1(this);
}
SwiftMtParser_MT565Parser::Fld_94B_B1Context* SwiftMtParser_MT565Parser::fld_94B_B1() {
Fld_94B_B1Context *_localctx = _tracker.createInstance<Fld_94B_B1Context>(_ctx, getState());
enterRule(_localctx, 68, SwiftMtParser_MT565Parser::RuleFld_94B_B1);
auto onExit = finally([=] {
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(642);
dynamic_cast<Fld_94B_B1Context *>(_localctx)->fld_94B_B1_BContext = fld_94B_B1_B();
_localctx->fld.MergeFrom(dynamic_cast<Fld_94B_B1Context *>(_localctx)->fld_94B_B1_BContext->fld);
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- Fld_22F_B1Context ------------------------------------------------------------------
SwiftMtParser_MT565Parser::Fld_22F_B1Context::Fld_22F_B1Context(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
SwiftMtParser_MT565Parser::Fld_22F_B1_FContext* SwiftMtParser_MT565Parser::Fld_22F_B1Context::fld_22F_B1_F() {
return getRuleContext<SwiftMtParser_MT565Parser::Fld_22F_B1_FContext>(0);
}
size_t SwiftMtParser_MT565Parser::Fld_22F_B1Context::getRuleIndex() const {
return SwiftMtParser_MT565Parser::RuleFld_22F_B1;
}
void SwiftMtParser_MT565Parser::Fld_22F_B1Context::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->enterFld_22F_B1(this);
}
void SwiftMtParser_MT565Parser::Fld_22F_B1Context::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->exitFld_22F_B1(this);
}
SwiftMtParser_MT565Parser::Fld_22F_B1Context* SwiftMtParser_MT565Parser::fld_22F_B1() {
Fld_22F_B1Context *_localctx = _tracker.createInstance<Fld_22F_B1Context>(_ctx, getState());
enterRule(_localctx, 70, SwiftMtParser_MT565Parser::RuleFld_22F_B1);
auto onExit = finally([=] {
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(645);
dynamic_cast<Fld_22F_B1Context *>(_localctx)->fld_22F_B1_FContext = fld_22F_B1_F();
_localctx->fld.MergeFrom(dynamic_cast<Fld_22F_B1Context *>(_localctx)->fld_22F_B1_FContext->fld);
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- Fld_12a_B1Context ------------------------------------------------------------------
SwiftMtParser_MT565Parser::Fld_12a_B1Context::Fld_12a_B1Context(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
SwiftMtParser_MT565Parser::Fld_12a_B1_AContext* SwiftMtParser_MT565Parser::Fld_12a_B1Context::fld_12a_B1_A() {
return getRuleContext<SwiftMtParser_MT565Parser::Fld_12a_B1_AContext>(0);
}
SwiftMtParser_MT565Parser::Fld_12a_B1_CContext* SwiftMtParser_MT565Parser::Fld_12a_B1Context::fld_12a_B1_C() {
return getRuleContext<SwiftMtParser_MT565Parser::Fld_12a_B1_CContext>(0);
}
size_t SwiftMtParser_MT565Parser::Fld_12a_B1Context::getRuleIndex() const {
return SwiftMtParser_MT565Parser::RuleFld_12a_B1;
}
void SwiftMtParser_MT565Parser::Fld_12a_B1Context::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->enterFld_12a_B1(this);
}
void SwiftMtParser_MT565Parser::Fld_12a_B1Context::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->exitFld_12a_B1(this);
}
SwiftMtParser_MT565Parser::Fld_12a_B1Context* SwiftMtParser_MT565Parser::fld_12a_B1() {
Fld_12a_B1Context *_localctx = _tracker.createInstance<Fld_12a_B1Context>(_ctx, getState());
enterRule(_localctx, 72, SwiftMtParser_MT565Parser::RuleFld_12a_B1);
auto onExit = finally([=] {
exitRule();
});
try {
setState(654);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 49, _ctx)) {
case 1: {
enterOuterAlt(_localctx, 1);
setState(648);
dynamic_cast<Fld_12a_B1Context *>(_localctx)->fld_12a_B1_AContext = fld_12a_B1_A();
_localctx->fld.MergeFrom(dynamic_cast<Fld_12a_B1Context *>(_localctx)->fld_12a_B1_AContext->fld);
break;
}
case 2: {
enterOuterAlt(_localctx, 2);
setState(651);
dynamic_cast<Fld_12a_B1Context *>(_localctx)->fld_12a_B1_CContext = fld_12a_B1_C();
_localctx->fld.MergeFrom(dynamic_cast<Fld_12a_B1Context *>(_localctx)->fld_12a_B1_CContext->fld);
break;
}
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- Fld_11A_B1Context ------------------------------------------------------------------
SwiftMtParser_MT565Parser::Fld_11A_B1Context::Fld_11A_B1Context(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
SwiftMtParser_MT565Parser::Fld_11A_B1_AContext* SwiftMtParser_MT565Parser::Fld_11A_B1Context::fld_11A_B1_A() {
return getRuleContext<SwiftMtParser_MT565Parser::Fld_11A_B1_AContext>(0);
}
size_t SwiftMtParser_MT565Parser::Fld_11A_B1Context::getRuleIndex() const {
return SwiftMtParser_MT565Parser::RuleFld_11A_B1;
}
void SwiftMtParser_MT565Parser::Fld_11A_B1Context::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->enterFld_11A_B1(this);
}
void SwiftMtParser_MT565Parser::Fld_11A_B1Context::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->exitFld_11A_B1(this);
}
SwiftMtParser_MT565Parser::Fld_11A_B1Context* SwiftMtParser_MT565Parser::fld_11A_B1() {
Fld_11A_B1Context *_localctx = _tracker.createInstance<Fld_11A_B1Context>(_ctx, getState());
enterRule(_localctx, 74, SwiftMtParser_MT565Parser::RuleFld_11A_B1);
auto onExit = finally([=] {
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(656);
dynamic_cast<Fld_11A_B1Context *>(_localctx)->fld_11A_B1_AContext = fld_11A_B1_A();
_localctx->fld.MergeFrom(dynamic_cast<Fld_11A_B1Context *>(_localctx)->fld_11A_B1_AContext->fld);
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- Fld_98A_B1Context ------------------------------------------------------------------
SwiftMtParser_MT565Parser::Fld_98A_B1Context::Fld_98A_B1Context(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
SwiftMtParser_MT565Parser::Fld_98A_B1_AContext* SwiftMtParser_MT565Parser::Fld_98A_B1Context::fld_98A_B1_A() {
return getRuleContext<SwiftMtParser_MT565Parser::Fld_98A_B1_AContext>(0);
}
size_t SwiftMtParser_MT565Parser::Fld_98A_B1Context::getRuleIndex() const {
return SwiftMtParser_MT565Parser::RuleFld_98A_B1;
}
void SwiftMtParser_MT565Parser::Fld_98A_B1Context::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->enterFld_98A_B1(this);
}
void SwiftMtParser_MT565Parser::Fld_98A_B1Context::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->exitFld_98A_B1(this);
}
SwiftMtParser_MT565Parser::Fld_98A_B1Context* SwiftMtParser_MT565Parser::fld_98A_B1() {
Fld_98A_B1Context *_localctx = _tracker.createInstance<Fld_98A_B1Context>(_ctx, getState());
enterRule(_localctx, 76, SwiftMtParser_MT565Parser::RuleFld_98A_B1);
auto onExit = finally([=] {
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(659);
dynamic_cast<Fld_98A_B1Context *>(_localctx)->fld_98A_B1_AContext = fld_98A_B1_A();
_localctx->fld.MergeFrom(dynamic_cast<Fld_98A_B1Context *>(_localctx)->fld_98A_B1_AContext->fld);
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- Fld_92A_B1Context ------------------------------------------------------------------
SwiftMtParser_MT565Parser::Fld_92A_B1Context::Fld_92A_B1Context(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
SwiftMtParser_MT565Parser::Fld_92A_B1_AContext* SwiftMtParser_MT565Parser::Fld_92A_B1Context::fld_92A_B1_A() {
return getRuleContext<SwiftMtParser_MT565Parser::Fld_92A_B1_AContext>(0);
}
size_t SwiftMtParser_MT565Parser::Fld_92A_B1Context::getRuleIndex() const {
return SwiftMtParser_MT565Parser::RuleFld_92A_B1;
}
void SwiftMtParser_MT565Parser::Fld_92A_B1Context::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->enterFld_92A_B1(this);
}
void SwiftMtParser_MT565Parser::Fld_92A_B1Context::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->exitFld_92A_B1(this);
}
SwiftMtParser_MT565Parser::Fld_92A_B1Context* SwiftMtParser_MT565Parser::fld_92A_B1() {
Fld_92A_B1Context *_localctx = _tracker.createInstance<Fld_92A_B1Context>(_ctx, getState());
enterRule(_localctx, 78, SwiftMtParser_MT565Parser::RuleFld_92A_B1);
auto onExit = finally([=] {
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(662);
dynamic_cast<Fld_92A_B1Context *>(_localctx)->fld_92A_B1_AContext = fld_92A_B1_A();
_localctx->fld.MergeFrom(dynamic_cast<Fld_92A_B1Context *>(_localctx)->fld_92A_B1_AContext->fld);
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- Fld_36B_B1Context ------------------------------------------------------------------
SwiftMtParser_MT565Parser::Fld_36B_B1Context::Fld_36B_B1Context(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
SwiftMtParser_MT565Parser::Fld_36B_B1_BContext* SwiftMtParser_MT565Parser::Fld_36B_B1Context::fld_36B_B1_B() {
return getRuleContext<SwiftMtParser_MT565Parser::Fld_36B_B1_BContext>(0);
}
size_t SwiftMtParser_MT565Parser::Fld_36B_B1Context::getRuleIndex() const {
return SwiftMtParser_MT565Parser::RuleFld_36B_B1;
}
void SwiftMtParser_MT565Parser::Fld_36B_B1Context::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->enterFld_36B_B1(this);
}
void SwiftMtParser_MT565Parser::Fld_36B_B1Context::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->exitFld_36B_B1(this);
}
SwiftMtParser_MT565Parser::Fld_36B_B1Context* SwiftMtParser_MT565Parser::fld_36B_B1() {
Fld_36B_B1Context *_localctx = _tracker.createInstance<Fld_36B_B1Context>(_ctx, getState());
enterRule(_localctx, 80, SwiftMtParser_MT565Parser::RuleFld_36B_B1);
auto onExit = finally([=] {
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(665);
dynamic_cast<Fld_36B_B1Context *>(_localctx)->fld_36B_B1_BContext = fld_36B_B1_B();
_localctx->fld.MergeFrom(dynamic_cast<Fld_36B_B1Context *>(_localctx)->fld_36B_B1_BContext->fld);
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- Fld_16S_B1Context ------------------------------------------------------------------
SwiftMtParser_MT565Parser::Fld_16S_B1Context::Fld_16S_B1Context(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
std::vector<tree::TerminalNode *> SwiftMtParser_MT565Parser::Fld_16S_B1Context::START_OF_FIELD() {
return getTokens(SwiftMtParser_MT565Parser::START_OF_FIELD);
}
tree::TerminalNode* SwiftMtParser_MT565Parser::Fld_16S_B1Context::START_OF_FIELD(size_t i) {
return getToken(SwiftMtParser_MT565Parser::START_OF_FIELD, i);
}
size_t SwiftMtParser_MT565Parser::Fld_16S_B1Context::getRuleIndex() const {
return SwiftMtParser_MT565Parser::RuleFld_16S_B1;
}
void SwiftMtParser_MT565Parser::Fld_16S_B1Context::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->enterFld_16S_B1(this);
}
void SwiftMtParser_MT565Parser::Fld_16S_B1Context::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->exitFld_16S_B1(this);
}
SwiftMtParser_MT565Parser::Fld_16S_B1Context* SwiftMtParser_MT565Parser::fld_16S_B1() {
Fld_16S_B1Context *_localctx = _tracker.createInstance<Fld_16S_B1Context>(_ctx, getState());
enterRule(_localctx, 82, SwiftMtParser_MT565Parser::RuleFld_16S_B1);
_localctx->fld.set_tag("16S");
size_t _la = 0;
auto onExit = finally([=] {
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(668);
match(SwiftMtParser_MT565Parser::START_OF_FIELD);
setState(669);
match(SwiftMtParser_MT565Parser::T__1);
setState(671);
_errHandler->sync(this);
_la = _input->LA(1);
do {
setState(670);
_la = _input->LA(1);
if (_la == 0 || _la == Token::EOF || (_la == SwiftMtParser_MT565Parser::START_OF_FIELD)) {
_errHandler->recoverInline(this);
}
else {
_errHandler->reportMatch(this);
consume();
}
setState(673);
_errHandler->sync(this);
_la = _input->LA(1);
} while ((((_la & ~ 0x3fULL) == 0) &&
((1ULL << _la) & ((1ULL << SwiftMtParser_MT565Parser::T__0)
| (1ULL << SwiftMtParser_MT565Parser::T__1)
| (1ULL << SwiftMtParser_MT565Parser::T__2)
| (1ULL << SwiftMtParser_MT565Parser::T__3)
| (1ULL << SwiftMtParser_MT565Parser::T__4)
| (1ULL << SwiftMtParser_MT565Parser::T__5)
| (1ULL << SwiftMtParser_MT565Parser::T__6)
| (1ULL << SwiftMtParser_MT565Parser::T__7)
| (1ULL << SwiftMtParser_MT565Parser::T__8)
| (1ULL << SwiftMtParser_MT565Parser::T__9)
| (1ULL << SwiftMtParser_MT565Parser::T__10)
| (1ULL << SwiftMtParser_MT565Parser::T__11)
| (1ULL << SwiftMtParser_MT565Parser::T__12)
| (1ULL << SwiftMtParser_MT565Parser::T__13)
| (1ULL << SwiftMtParser_MT565Parser::T__14)
| (1ULL << SwiftMtParser_MT565Parser::T__15)
| (1ULL << SwiftMtParser_MT565Parser::T__16)
| (1ULL << SwiftMtParser_MT565Parser::T__17)
| (1ULL << SwiftMtParser_MT565Parser::T__18)
| (1ULL << SwiftMtParser_MT565Parser::T__19)
| (1ULL << SwiftMtParser_MT565Parser::T__20)
| (1ULL << SwiftMtParser_MT565Parser::T__21)
| (1ULL << SwiftMtParser_MT565Parser::T__22)
| (1ULL << SwiftMtParser_MT565Parser::T__23)
| (1ULL << SwiftMtParser_MT565Parser::T__24)
| (1ULL << SwiftMtParser_MT565Parser::T__25)
| (1ULL << SwiftMtParser_MT565Parser::T__26)
| (1ULL << SwiftMtParser_MT565Parser::T__27)
| (1ULL << SwiftMtParser_MT565Parser::T__28)
| (1ULL << SwiftMtParser_MT565Parser::T__29)
| (1ULL << SwiftMtParser_MT565Parser::T__30)
| (1ULL << SwiftMtParser_MT565Parser::T__31)
| (1ULL << SwiftMtParser_MT565Parser::T__32)
| (1ULL << SwiftMtParser_MT565Parser::T__33)
| (1ULL << SwiftMtParser_MT565Parser::T__34)
| (1ULL << SwiftMtParser_MT565Parser::T__35)
| (1ULL << SwiftMtParser_MT565Parser::T__36)
| (1ULL << SwiftMtParser_MT565Parser::T__37)
| (1ULL << SwiftMtParser_MT565Parser::TAG_BH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_AH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_UH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_MT)
| (1ULL << SwiftMtParser_MT565Parser::TAG_TR)
| (1ULL << SwiftMtParser_MT565Parser::MT_END)
| (1ULL << SwiftMtParser_MT565Parser::LBRACE)
| (1ULL << SwiftMtParser_MT565Parser::RBRACE)
| (1ULL << SwiftMtParser_MT565Parser::COLON)
| (1ULL << SwiftMtParser_MT565Parser::ANY))) != 0));
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- Fld_16R_B2Context ------------------------------------------------------------------
SwiftMtParser_MT565Parser::Fld_16R_B2Context::Fld_16R_B2Context(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
std::vector<tree::TerminalNode *> SwiftMtParser_MT565Parser::Fld_16R_B2Context::START_OF_FIELD() {
return getTokens(SwiftMtParser_MT565Parser::START_OF_FIELD);
}
tree::TerminalNode* SwiftMtParser_MT565Parser::Fld_16R_B2Context::START_OF_FIELD(size_t i) {
return getToken(SwiftMtParser_MT565Parser::START_OF_FIELD, i);
}
size_t SwiftMtParser_MT565Parser::Fld_16R_B2Context::getRuleIndex() const {
return SwiftMtParser_MT565Parser::RuleFld_16R_B2;
}
void SwiftMtParser_MT565Parser::Fld_16R_B2Context::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->enterFld_16R_B2(this);
}
void SwiftMtParser_MT565Parser::Fld_16R_B2Context::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->exitFld_16R_B2(this);
}
SwiftMtParser_MT565Parser::Fld_16R_B2Context* SwiftMtParser_MT565Parser::fld_16R_B2() {
Fld_16R_B2Context *_localctx = _tracker.createInstance<Fld_16R_B2Context>(_ctx, getState());
enterRule(_localctx, 84, SwiftMtParser_MT565Parser::RuleFld_16R_B2);
_localctx->fld.set_tag("16R");
size_t _la = 0;
auto onExit = finally([=] {
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(675);
match(SwiftMtParser_MT565Parser::START_OF_FIELD);
setState(676);
match(SwiftMtParser_MT565Parser::T__0);
setState(678);
_errHandler->sync(this);
_la = _input->LA(1);
do {
setState(677);
_la = _input->LA(1);
if (_la == 0 || _la == Token::EOF || (_la == SwiftMtParser_MT565Parser::START_OF_FIELD)) {
_errHandler->recoverInline(this);
}
else {
_errHandler->reportMatch(this);
consume();
}
setState(680);
_errHandler->sync(this);
_la = _input->LA(1);
} while ((((_la & ~ 0x3fULL) == 0) &&
((1ULL << _la) & ((1ULL << SwiftMtParser_MT565Parser::T__0)
| (1ULL << SwiftMtParser_MT565Parser::T__1)
| (1ULL << SwiftMtParser_MT565Parser::T__2)
| (1ULL << SwiftMtParser_MT565Parser::T__3)
| (1ULL << SwiftMtParser_MT565Parser::T__4)
| (1ULL << SwiftMtParser_MT565Parser::T__5)
| (1ULL << SwiftMtParser_MT565Parser::T__6)
| (1ULL << SwiftMtParser_MT565Parser::T__7)
| (1ULL << SwiftMtParser_MT565Parser::T__8)
| (1ULL << SwiftMtParser_MT565Parser::T__9)
| (1ULL << SwiftMtParser_MT565Parser::T__10)
| (1ULL << SwiftMtParser_MT565Parser::T__11)
| (1ULL << SwiftMtParser_MT565Parser::T__12)
| (1ULL << SwiftMtParser_MT565Parser::T__13)
| (1ULL << SwiftMtParser_MT565Parser::T__14)
| (1ULL << SwiftMtParser_MT565Parser::T__15)
| (1ULL << SwiftMtParser_MT565Parser::T__16)
| (1ULL << SwiftMtParser_MT565Parser::T__17)
| (1ULL << SwiftMtParser_MT565Parser::T__18)
| (1ULL << SwiftMtParser_MT565Parser::T__19)
| (1ULL << SwiftMtParser_MT565Parser::T__20)
| (1ULL << SwiftMtParser_MT565Parser::T__21)
| (1ULL << SwiftMtParser_MT565Parser::T__22)
| (1ULL << SwiftMtParser_MT565Parser::T__23)
| (1ULL << SwiftMtParser_MT565Parser::T__24)
| (1ULL << SwiftMtParser_MT565Parser::T__25)
| (1ULL << SwiftMtParser_MT565Parser::T__26)
| (1ULL << SwiftMtParser_MT565Parser::T__27)
| (1ULL << SwiftMtParser_MT565Parser::T__28)
| (1ULL << SwiftMtParser_MT565Parser::T__29)
| (1ULL << SwiftMtParser_MT565Parser::T__30)
| (1ULL << SwiftMtParser_MT565Parser::T__31)
| (1ULL << SwiftMtParser_MT565Parser::T__32)
| (1ULL << SwiftMtParser_MT565Parser::T__33)
| (1ULL << SwiftMtParser_MT565Parser::T__34)
| (1ULL << SwiftMtParser_MT565Parser::T__35)
| (1ULL << SwiftMtParser_MT565Parser::T__36)
| (1ULL << SwiftMtParser_MT565Parser::T__37)
| (1ULL << SwiftMtParser_MT565Parser::TAG_BH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_AH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_UH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_MT)
| (1ULL << SwiftMtParser_MT565Parser::TAG_TR)
| (1ULL << SwiftMtParser_MT565Parser::MT_END)
| (1ULL << SwiftMtParser_MT565Parser::LBRACE)
| (1ULL << SwiftMtParser_MT565Parser::RBRACE)
| (1ULL << SwiftMtParser_MT565Parser::COLON)
| (1ULL << SwiftMtParser_MT565Parser::ANY))) != 0));
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- Fld_95a_B2Context ------------------------------------------------------------------
SwiftMtParser_MT565Parser::Fld_95a_B2Context::Fld_95a_B2Context(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
SwiftMtParser_MT565Parser::Fld_95a_B2_PContext* SwiftMtParser_MT565Parser::Fld_95a_B2Context::fld_95a_B2_P() {
return getRuleContext<SwiftMtParser_MT565Parser::Fld_95a_B2_PContext>(0);
}
SwiftMtParser_MT565Parser::Fld_95a_B2_RContext* SwiftMtParser_MT565Parser::Fld_95a_B2Context::fld_95a_B2_R() {
return getRuleContext<SwiftMtParser_MT565Parser::Fld_95a_B2_RContext>(0);
}
size_t SwiftMtParser_MT565Parser::Fld_95a_B2Context::getRuleIndex() const {
return SwiftMtParser_MT565Parser::RuleFld_95a_B2;
}
void SwiftMtParser_MT565Parser::Fld_95a_B2Context::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->enterFld_95a_B2(this);
}
void SwiftMtParser_MT565Parser::Fld_95a_B2Context::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->exitFld_95a_B2(this);
}
SwiftMtParser_MT565Parser::Fld_95a_B2Context* SwiftMtParser_MT565Parser::fld_95a_B2() {
Fld_95a_B2Context *_localctx = _tracker.createInstance<Fld_95a_B2Context>(_ctx, getState());
enterRule(_localctx, 86, SwiftMtParser_MT565Parser::RuleFld_95a_B2);
auto onExit = finally([=] {
exitRule();
});
try {
setState(688);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 52, _ctx)) {
case 1: {
enterOuterAlt(_localctx, 1);
setState(682);
dynamic_cast<Fld_95a_B2Context *>(_localctx)->fld_95a_B2_PContext = fld_95a_B2_P();
_localctx->fld.MergeFrom(dynamic_cast<Fld_95a_B2Context *>(_localctx)->fld_95a_B2_PContext->fld);
break;
}
case 2: {
enterOuterAlt(_localctx, 2);
setState(685);
dynamic_cast<Fld_95a_B2Context *>(_localctx)->fld_95a_B2_RContext = fld_95a_B2_R();
_localctx->fld.MergeFrom(dynamic_cast<Fld_95a_B2Context *>(_localctx)->fld_95a_B2_RContext->fld);
break;
}
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- Fld_97A_B2Context ------------------------------------------------------------------
SwiftMtParser_MT565Parser::Fld_97A_B2Context::Fld_97A_B2Context(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
SwiftMtParser_MT565Parser::Fld_97A_B2_AContext* SwiftMtParser_MT565Parser::Fld_97A_B2Context::fld_97A_B2_A() {
return getRuleContext<SwiftMtParser_MT565Parser::Fld_97A_B2_AContext>(0);
}
size_t SwiftMtParser_MT565Parser::Fld_97A_B2Context::getRuleIndex() const {
return SwiftMtParser_MT565Parser::RuleFld_97A_B2;
}
void SwiftMtParser_MT565Parser::Fld_97A_B2Context::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->enterFld_97A_B2(this);
}
void SwiftMtParser_MT565Parser::Fld_97A_B2Context::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->exitFld_97A_B2(this);
}
SwiftMtParser_MT565Parser::Fld_97A_B2Context* SwiftMtParser_MT565Parser::fld_97A_B2() {
Fld_97A_B2Context *_localctx = _tracker.createInstance<Fld_97A_B2Context>(_ctx, getState());
enterRule(_localctx, 88, SwiftMtParser_MT565Parser::RuleFld_97A_B2);
auto onExit = finally([=] {
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(690);
dynamic_cast<Fld_97A_B2Context *>(_localctx)->fld_97A_B2_AContext = fld_97A_B2_A();
_localctx->fld.MergeFrom(dynamic_cast<Fld_97A_B2Context *>(_localctx)->fld_97A_B2_AContext->fld);
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- Fld_94a_B2Context ------------------------------------------------------------------
SwiftMtParser_MT565Parser::Fld_94a_B2Context::Fld_94a_B2Context(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
SwiftMtParser_MT565Parser::Fld_94a_B2_BContext* SwiftMtParser_MT565Parser::Fld_94a_B2Context::fld_94a_B2_B() {
return getRuleContext<SwiftMtParser_MT565Parser::Fld_94a_B2_BContext>(0);
}
SwiftMtParser_MT565Parser::Fld_94a_B2_CContext* SwiftMtParser_MT565Parser::Fld_94a_B2Context::fld_94a_B2_C() {
return getRuleContext<SwiftMtParser_MT565Parser::Fld_94a_B2_CContext>(0);
}
SwiftMtParser_MT565Parser::Fld_94a_B2_FContext* SwiftMtParser_MT565Parser::Fld_94a_B2Context::fld_94a_B2_F() {
return getRuleContext<SwiftMtParser_MT565Parser::Fld_94a_B2_FContext>(0);
}
size_t SwiftMtParser_MT565Parser::Fld_94a_B2Context::getRuleIndex() const {
return SwiftMtParser_MT565Parser::RuleFld_94a_B2;
}
void SwiftMtParser_MT565Parser::Fld_94a_B2Context::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->enterFld_94a_B2(this);
}
void SwiftMtParser_MT565Parser::Fld_94a_B2Context::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->exitFld_94a_B2(this);
}
SwiftMtParser_MT565Parser::Fld_94a_B2Context* SwiftMtParser_MT565Parser::fld_94a_B2() {
Fld_94a_B2Context *_localctx = _tracker.createInstance<Fld_94a_B2Context>(_ctx, getState());
enterRule(_localctx, 90, SwiftMtParser_MT565Parser::RuleFld_94a_B2);
auto onExit = finally([=] {
exitRule();
});
try {
setState(702);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 53, _ctx)) {
case 1: {
enterOuterAlt(_localctx, 1);
setState(693);
dynamic_cast<Fld_94a_B2Context *>(_localctx)->fld_94a_B2_BContext = fld_94a_B2_B();
_localctx->fld.MergeFrom(dynamic_cast<Fld_94a_B2Context *>(_localctx)->fld_94a_B2_BContext->fld);
break;
}
case 2: {
enterOuterAlt(_localctx, 2);
setState(696);
dynamic_cast<Fld_94a_B2Context *>(_localctx)->fld_94a_B2_CContext = fld_94a_B2_C();
_localctx->fld.MergeFrom(dynamic_cast<Fld_94a_B2Context *>(_localctx)->fld_94a_B2_CContext->fld);
break;
}
case 3: {
enterOuterAlt(_localctx, 3);
setState(699);
dynamic_cast<Fld_94a_B2Context *>(_localctx)->fld_94a_B2_FContext = fld_94a_B2_F();
_localctx->fld.MergeFrom(dynamic_cast<Fld_94a_B2Context *>(_localctx)->fld_94a_B2_FContext->fld);
break;
}
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- Fld_93a_B2Context ------------------------------------------------------------------
SwiftMtParser_MT565Parser::Fld_93a_B2Context::Fld_93a_B2Context(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
SwiftMtParser_MT565Parser::Fld_93a_B2_BContext* SwiftMtParser_MT565Parser::Fld_93a_B2Context::fld_93a_B2_B() {
return getRuleContext<SwiftMtParser_MT565Parser::Fld_93a_B2_BContext>(0);
}
SwiftMtParser_MT565Parser::Fld_93a_B2_CContext* SwiftMtParser_MT565Parser::Fld_93a_B2Context::fld_93a_B2_C() {
return getRuleContext<SwiftMtParser_MT565Parser::Fld_93a_B2_CContext>(0);
}
size_t SwiftMtParser_MT565Parser::Fld_93a_B2Context::getRuleIndex() const {
return SwiftMtParser_MT565Parser::RuleFld_93a_B2;
}
void SwiftMtParser_MT565Parser::Fld_93a_B2Context::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->enterFld_93a_B2(this);
}
void SwiftMtParser_MT565Parser::Fld_93a_B2Context::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->exitFld_93a_B2(this);
}
SwiftMtParser_MT565Parser::Fld_93a_B2Context* SwiftMtParser_MT565Parser::fld_93a_B2() {
Fld_93a_B2Context *_localctx = _tracker.createInstance<Fld_93a_B2Context>(_ctx, getState());
enterRule(_localctx, 92, SwiftMtParser_MT565Parser::RuleFld_93a_B2);
auto onExit = finally([=] {
exitRule();
});
try {
setState(710);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 54, _ctx)) {
case 1: {
enterOuterAlt(_localctx, 1);
setState(704);
dynamic_cast<Fld_93a_B2Context *>(_localctx)->fld_93a_B2_BContext = fld_93a_B2_B();
_localctx->fld.MergeFrom(dynamic_cast<Fld_93a_B2Context *>(_localctx)->fld_93a_B2_BContext->fld);
break;
}
case 2: {
enterOuterAlt(_localctx, 2);
setState(707);
dynamic_cast<Fld_93a_B2Context *>(_localctx)->fld_93a_B2_CContext = fld_93a_B2_C();
_localctx->fld.MergeFrom(dynamic_cast<Fld_93a_B2Context *>(_localctx)->fld_93a_B2_CContext->fld);
break;
}
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- Fld_16S_B2Context ------------------------------------------------------------------
SwiftMtParser_MT565Parser::Fld_16S_B2Context::Fld_16S_B2Context(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
std::vector<tree::TerminalNode *> SwiftMtParser_MT565Parser::Fld_16S_B2Context::START_OF_FIELD() {
return getTokens(SwiftMtParser_MT565Parser::START_OF_FIELD);
}
tree::TerminalNode* SwiftMtParser_MT565Parser::Fld_16S_B2Context::START_OF_FIELD(size_t i) {
return getToken(SwiftMtParser_MT565Parser::START_OF_FIELD, i);
}
size_t SwiftMtParser_MT565Parser::Fld_16S_B2Context::getRuleIndex() const {
return SwiftMtParser_MT565Parser::RuleFld_16S_B2;
}
void SwiftMtParser_MT565Parser::Fld_16S_B2Context::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->enterFld_16S_B2(this);
}
void SwiftMtParser_MT565Parser::Fld_16S_B2Context::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->exitFld_16S_B2(this);
}
SwiftMtParser_MT565Parser::Fld_16S_B2Context* SwiftMtParser_MT565Parser::fld_16S_B2() {
Fld_16S_B2Context *_localctx = _tracker.createInstance<Fld_16S_B2Context>(_ctx, getState());
enterRule(_localctx, 94, SwiftMtParser_MT565Parser::RuleFld_16S_B2);
_localctx->fld.set_tag("16S");
size_t _la = 0;
auto onExit = finally([=] {
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(712);
match(SwiftMtParser_MT565Parser::START_OF_FIELD);
setState(713);
match(SwiftMtParser_MT565Parser::T__1);
setState(715);
_errHandler->sync(this);
_la = _input->LA(1);
do {
setState(714);
_la = _input->LA(1);
if (_la == 0 || _la == Token::EOF || (_la == SwiftMtParser_MT565Parser::START_OF_FIELD)) {
_errHandler->recoverInline(this);
}
else {
_errHandler->reportMatch(this);
consume();
}
setState(717);
_errHandler->sync(this);
_la = _input->LA(1);
} while ((((_la & ~ 0x3fULL) == 0) &&
((1ULL << _la) & ((1ULL << SwiftMtParser_MT565Parser::T__0)
| (1ULL << SwiftMtParser_MT565Parser::T__1)
| (1ULL << SwiftMtParser_MT565Parser::T__2)
| (1ULL << SwiftMtParser_MT565Parser::T__3)
| (1ULL << SwiftMtParser_MT565Parser::T__4)
| (1ULL << SwiftMtParser_MT565Parser::T__5)
| (1ULL << SwiftMtParser_MT565Parser::T__6)
| (1ULL << SwiftMtParser_MT565Parser::T__7)
| (1ULL << SwiftMtParser_MT565Parser::T__8)
| (1ULL << SwiftMtParser_MT565Parser::T__9)
| (1ULL << SwiftMtParser_MT565Parser::T__10)
| (1ULL << SwiftMtParser_MT565Parser::T__11)
| (1ULL << SwiftMtParser_MT565Parser::T__12)
| (1ULL << SwiftMtParser_MT565Parser::T__13)
| (1ULL << SwiftMtParser_MT565Parser::T__14)
| (1ULL << SwiftMtParser_MT565Parser::T__15)
| (1ULL << SwiftMtParser_MT565Parser::T__16)
| (1ULL << SwiftMtParser_MT565Parser::T__17)
| (1ULL << SwiftMtParser_MT565Parser::T__18)
| (1ULL << SwiftMtParser_MT565Parser::T__19)
| (1ULL << SwiftMtParser_MT565Parser::T__20)
| (1ULL << SwiftMtParser_MT565Parser::T__21)
| (1ULL << SwiftMtParser_MT565Parser::T__22)
| (1ULL << SwiftMtParser_MT565Parser::T__23)
| (1ULL << SwiftMtParser_MT565Parser::T__24)
| (1ULL << SwiftMtParser_MT565Parser::T__25)
| (1ULL << SwiftMtParser_MT565Parser::T__26)
| (1ULL << SwiftMtParser_MT565Parser::T__27)
| (1ULL << SwiftMtParser_MT565Parser::T__28)
| (1ULL << SwiftMtParser_MT565Parser::T__29)
| (1ULL << SwiftMtParser_MT565Parser::T__30)
| (1ULL << SwiftMtParser_MT565Parser::T__31)
| (1ULL << SwiftMtParser_MT565Parser::T__32)
| (1ULL << SwiftMtParser_MT565Parser::T__33)
| (1ULL << SwiftMtParser_MT565Parser::T__34)
| (1ULL << SwiftMtParser_MT565Parser::T__35)
| (1ULL << SwiftMtParser_MT565Parser::T__36)
| (1ULL << SwiftMtParser_MT565Parser::T__37)
| (1ULL << SwiftMtParser_MT565Parser::TAG_BH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_AH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_UH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_MT)
| (1ULL << SwiftMtParser_MT565Parser::TAG_TR)
| (1ULL << SwiftMtParser_MT565Parser::MT_END)
| (1ULL << SwiftMtParser_MT565Parser::LBRACE)
| (1ULL << SwiftMtParser_MT565Parser::RBRACE)
| (1ULL << SwiftMtParser_MT565Parser::COLON)
| (1ULL << SwiftMtParser_MT565Parser::ANY))) != 0));
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- Fld_16S_BContext ------------------------------------------------------------------
SwiftMtParser_MT565Parser::Fld_16S_BContext::Fld_16S_BContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
std::vector<tree::TerminalNode *> SwiftMtParser_MT565Parser::Fld_16S_BContext::START_OF_FIELD() {
return getTokens(SwiftMtParser_MT565Parser::START_OF_FIELD);
}
tree::TerminalNode* SwiftMtParser_MT565Parser::Fld_16S_BContext::START_OF_FIELD(size_t i) {
return getToken(SwiftMtParser_MT565Parser::START_OF_FIELD, i);
}
size_t SwiftMtParser_MT565Parser::Fld_16S_BContext::getRuleIndex() const {
return SwiftMtParser_MT565Parser::RuleFld_16S_B;
}
void SwiftMtParser_MT565Parser::Fld_16S_BContext::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->enterFld_16S_B(this);
}
void SwiftMtParser_MT565Parser::Fld_16S_BContext::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->exitFld_16S_B(this);
}
SwiftMtParser_MT565Parser::Fld_16S_BContext* SwiftMtParser_MT565Parser::fld_16S_B() {
Fld_16S_BContext *_localctx = _tracker.createInstance<Fld_16S_BContext>(_ctx, getState());
enterRule(_localctx, 96, SwiftMtParser_MT565Parser::RuleFld_16S_B);
_localctx->fld.set_tag("16S");
size_t _la = 0;
auto onExit = finally([=] {
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(719);
match(SwiftMtParser_MT565Parser::START_OF_FIELD);
setState(720);
match(SwiftMtParser_MT565Parser::T__1);
setState(722);
_errHandler->sync(this);
_la = _input->LA(1);
do {
setState(721);
_la = _input->LA(1);
if (_la == 0 || _la == Token::EOF || (_la == SwiftMtParser_MT565Parser::START_OF_FIELD)) {
_errHandler->recoverInline(this);
}
else {
_errHandler->reportMatch(this);
consume();
}
setState(724);
_errHandler->sync(this);
_la = _input->LA(1);
} while ((((_la & ~ 0x3fULL) == 0) &&
((1ULL << _la) & ((1ULL << SwiftMtParser_MT565Parser::T__0)
| (1ULL << SwiftMtParser_MT565Parser::T__1)
| (1ULL << SwiftMtParser_MT565Parser::T__2)
| (1ULL << SwiftMtParser_MT565Parser::T__3)
| (1ULL << SwiftMtParser_MT565Parser::T__4)
| (1ULL << SwiftMtParser_MT565Parser::T__5)
| (1ULL << SwiftMtParser_MT565Parser::T__6)
| (1ULL << SwiftMtParser_MT565Parser::T__7)
| (1ULL << SwiftMtParser_MT565Parser::T__8)
| (1ULL << SwiftMtParser_MT565Parser::T__9)
| (1ULL << SwiftMtParser_MT565Parser::T__10)
| (1ULL << SwiftMtParser_MT565Parser::T__11)
| (1ULL << SwiftMtParser_MT565Parser::T__12)
| (1ULL << SwiftMtParser_MT565Parser::T__13)
| (1ULL << SwiftMtParser_MT565Parser::T__14)
| (1ULL << SwiftMtParser_MT565Parser::T__15)
| (1ULL << SwiftMtParser_MT565Parser::T__16)
| (1ULL << SwiftMtParser_MT565Parser::T__17)
| (1ULL << SwiftMtParser_MT565Parser::T__18)
| (1ULL << SwiftMtParser_MT565Parser::T__19)
| (1ULL << SwiftMtParser_MT565Parser::T__20)
| (1ULL << SwiftMtParser_MT565Parser::T__21)
| (1ULL << SwiftMtParser_MT565Parser::T__22)
| (1ULL << SwiftMtParser_MT565Parser::T__23)
| (1ULL << SwiftMtParser_MT565Parser::T__24)
| (1ULL << SwiftMtParser_MT565Parser::T__25)
| (1ULL << SwiftMtParser_MT565Parser::T__26)
| (1ULL << SwiftMtParser_MT565Parser::T__27)
| (1ULL << SwiftMtParser_MT565Parser::T__28)
| (1ULL << SwiftMtParser_MT565Parser::T__29)
| (1ULL << SwiftMtParser_MT565Parser::T__30)
| (1ULL << SwiftMtParser_MT565Parser::T__31)
| (1ULL << SwiftMtParser_MT565Parser::T__32)
| (1ULL << SwiftMtParser_MT565Parser::T__33)
| (1ULL << SwiftMtParser_MT565Parser::T__34)
| (1ULL << SwiftMtParser_MT565Parser::T__35)
| (1ULL << SwiftMtParser_MT565Parser::T__36)
| (1ULL << SwiftMtParser_MT565Parser::T__37)
| (1ULL << SwiftMtParser_MT565Parser::TAG_BH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_AH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_UH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_MT)
| (1ULL << SwiftMtParser_MT565Parser::TAG_TR)
| (1ULL << SwiftMtParser_MT565Parser::MT_END)
| (1ULL << SwiftMtParser_MT565Parser::LBRACE)
| (1ULL << SwiftMtParser_MT565Parser::RBRACE)
| (1ULL << SwiftMtParser_MT565Parser::COLON)
| (1ULL << SwiftMtParser_MT565Parser::ANY))) != 0));
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- Fld_16R_CContext ------------------------------------------------------------------
SwiftMtParser_MT565Parser::Fld_16R_CContext::Fld_16R_CContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
std::vector<tree::TerminalNode *> SwiftMtParser_MT565Parser::Fld_16R_CContext::START_OF_FIELD() {
return getTokens(SwiftMtParser_MT565Parser::START_OF_FIELD);
}
tree::TerminalNode* SwiftMtParser_MT565Parser::Fld_16R_CContext::START_OF_FIELD(size_t i) {
return getToken(SwiftMtParser_MT565Parser::START_OF_FIELD, i);
}
size_t SwiftMtParser_MT565Parser::Fld_16R_CContext::getRuleIndex() const {
return SwiftMtParser_MT565Parser::RuleFld_16R_C;
}
void SwiftMtParser_MT565Parser::Fld_16R_CContext::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->enterFld_16R_C(this);
}
void SwiftMtParser_MT565Parser::Fld_16R_CContext::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->exitFld_16R_C(this);
}
SwiftMtParser_MT565Parser::Fld_16R_CContext* SwiftMtParser_MT565Parser::fld_16R_C() {
Fld_16R_CContext *_localctx = _tracker.createInstance<Fld_16R_CContext>(_ctx, getState());
enterRule(_localctx, 98, SwiftMtParser_MT565Parser::RuleFld_16R_C);
_localctx->fld.set_tag("16R");
size_t _la = 0;
auto onExit = finally([=] {
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(726);
match(SwiftMtParser_MT565Parser::START_OF_FIELD);
setState(727);
match(SwiftMtParser_MT565Parser::T__0);
setState(729);
_errHandler->sync(this);
_la = _input->LA(1);
do {
setState(728);
_la = _input->LA(1);
if (_la == 0 || _la == Token::EOF || (_la == SwiftMtParser_MT565Parser::START_OF_FIELD)) {
_errHandler->recoverInline(this);
}
else {
_errHandler->reportMatch(this);
consume();
}
setState(731);
_errHandler->sync(this);
_la = _input->LA(1);
} while ((((_la & ~ 0x3fULL) == 0) &&
((1ULL << _la) & ((1ULL << SwiftMtParser_MT565Parser::T__0)
| (1ULL << SwiftMtParser_MT565Parser::T__1)
| (1ULL << SwiftMtParser_MT565Parser::T__2)
| (1ULL << SwiftMtParser_MT565Parser::T__3)
| (1ULL << SwiftMtParser_MT565Parser::T__4)
| (1ULL << SwiftMtParser_MT565Parser::T__5)
| (1ULL << SwiftMtParser_MT565Parser::T__6)
| (1ULL << SwiftMtParser_MT565Parser::T__7)
| (1ULL << SwiftMtParser_MT565Parser::T__8)
| (1ULL << SwiftMtParser_MT565Parser::T__9)
| (1ULL << SwiftMtParser_MT565Parser::T__10)
| (1ULL << SwiftMtParser_MT565Parser::T__11)
| (1ULL << SwiftMtParser_MT565Parser::T__12)
| (1ULL << SwiftMtParser_MT565Parser::T__13)
| (1ULL << SwiftMtParser_MT565Parser::T__14)
| (1ULL << SwiftMtParser_MT565Parser::T__15)
| (1ULL << SwiftMtParser_MT565Parser::T__16)
| (1ULL << SwiftMtParser_MT565Parser::T__17)
| (1ULL << SwiftMtParser_MT565Parser::T__18)
| (1ULL << SwiftMtParser_MT565Parser::T__19)
| (1ULL << SwiftMtParser_MT565Parser::T__20)
| (1ULL << SwiftMtParser_MT565Parser::T__21)
| (1ULL << SwiftMtParser_MT565Parser::T__22)
| (1ULL << SwiftMtParser_MT565Parser::T__23)
| (1ULL << SwiftMtParser_MT565Parser::T__24)
| (1ULL << SwiftMtParser_MT565Parser::T__25)
| (1ULL << SwiftMtParser_MT565Parser::T__26)
| (1ULL << SwiftMtParser_MT565Parser::T__27)
| (1ULL << SwiftMtParser_MT565Parser::T__28)
| (1ULL << SwiftMtParser_MT565Parser::T__29)
| (1ULL << SwiftMtParser_MT565Parser::T__30)
| (1ULL << SwiftMtParser_MT565Parser::T__31)
| (1ULL << SwiftMtParser_MT565Parser::T__32)
| (1ULL << SwiftMtParser_MT565Parser::T__33)
| (1ULL << SwiftMtParser_MT565Parser::T__34)
| (1ULL << SwiftMtParser_MT565Parser::T__35)
| (1ULL << SwiftMtParser_MT565Parser::T__36)
| (1ULL << SwiftMtParser_MT565Parser::T__37)
| (1ULL << SwiftMtParser_MT565Parser::TAG_BH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_AH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_UH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_MT)
| (1ULL << SwiftMtParser_MT565Parser::TAG_TR)
| (1ULL << SwiftMtParser_MT565Parser::MT_END)
| (1ULL << SwiftMtParser_MT565Parser::LBRACE)
| (1ULL << SwiftMtParser_MT565Parser::RBRACE)
| (1ULL << SwiftMtParser_MT565Parser::COLON)
| (1ULL << SwiftMtParser_MT565Parser::ANY))) != 0));
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- Fld_95a_CContext ------------------------------------------------------------------
SwiftMtParser_MT565Parser::Fld_95a_CContext::Fld_95a_CContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
SwiftMtParser_MT565Parser::Fld_95a_C_PContext* SwiftMtParser_MT565Parser::Fld_95a_CContext::fld_95a_C_P() {
return getRuleContext<SwiftMtParser_MT565Parser::Fld_95a_C_PContext>(0);
}
SwiftMtParser_MT565Parser::Fld_95a_C_RContext* SwiftMtParser_MT565Parser::Fld_95a_CContext::fld_95a_C_R() {
return getRuleContext<SwiftMtParser_MT565Parser::Fld_95a_C_RContext>(0);
}
SwiftMtParser_MT565Parser::Fld_95a_C_SContext* SwiftMtParser_MT565Parser::Fld_95a_CContext::fld_95a_C_S() {
return getRuleContext<SwiftMtParser_MT565Parser::Fld_95a_C_SContext>(0);
}
SwiftMtParser_MT565Parser::Fld_95a_C_VContext* SwiftMtParser_MT565Parser::Fld_95a_CContext::fld_95a_C_V() {
return getRuleContext<SwiftMtParser_MT565Parser::Fld_95a_C_VContext>(0);
}
size_t SwiftMtParser_MT565Parser::Fld_95a_CContext::getRuleIndex() const {
return SwiftMtParser_MT565Parser::RuleFld_95a_C;
}
void SwiftMtParser_MT565Parser::Fld_95a_CContext::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->enterFld_95a_C(this);
}
void SwiftMtParser_MT565Parser::Fld_95a_CContext::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->exitFld_95a_C(this);
}
SwiftMtParser_MT565Parser::Fld_95a_CContext* SwiftMtParser_MT565Parser::fld_95a_C() {
Fld_95a_CContext *_localctx = _tracker.createInstance<Fld_95a_CContext>(_ctx, getState());
enterRule(_localctx, 100, SwiftMtParser_MT565Parser::RuleFld_95a_C);
auto onExit = finally([=] {
exitRule();
});
try {
setState(745);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 58, _ctx)) {
case 1: {
enterOuterAlt(_localctx, 1);
setState(733);
dynamic_cast<Fld_95a_CContext *>(_localctx)->fld_95a_C_PContext = fld_95a_C_P();
_localctx->fld.MergeFrom(dynamic_cast<Fld_95a_CContext *>(_localctx)->fld_95a_C_PContext->fld);
break;
}
case 2: {
enterOuterAlt(_localctx, 2);
setState(736);
dynamic_cast<Fld_95a_CContext *>(_localctx)->fld_95a_C_RContext = fld_95a_C_R();
_localctx->fld.MergeFrom(dynamic_cast<Fld_95a_CContext *>(_localctx)->fld_95a_C_RContext->fld);
break;
}
case 3: {
enterOuterAlt(_localctx, 3);
setState(739);
dynamic_cast<Fld_95a_CContext *>(_localctx)->fld_95a_C_SContext = fld_95a_C_S();
_localctx->fld.MergeFrom(dynamic_cast<Fld_95a_CContext *>(_localctx)->fld_95a_C_SContext->fld);
break;
}
case 4: {
enterOuterAlt(_localctx, 4);
setState(742);
dynamic_cast<Fld_95a_CContext *>(_localctx)->fld_95a_C_VContext = fld_95a_C_V();
_localctx->fld.MergeFrom(dynamic_cast<Fld_95a_CContext *>(_localctx)->fld_95a_C_VContext->fld);
break;
}
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- Fld_94C_CContext ------------------------------------------------------------------
SwiftMtParser_MT565Parser::Fld_94C_CContext::Fld_94C_CContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
SwiftMtParser_MT565Parser::Fld_94C_C_CContext* SwiftMtParser_MT565Parser::Fld_94C_CContext::fld_94C_C_C() {
return getRuleContext<SwiftMtParser_MT565Parser::Fld_94C_C_CContext>(0);
}
size_t SwiftMtParser_MT565Parser::Fld_94C_CContext::getRuleIndex() const {
return SwiftMtParser_MT565Parser::RuleFld_94C_C;
}
void SwiftMtParser_MT565Parser::Fld_94C_CContext::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->enterFld_94C_C(this);
}
void SwiftMtParser_MT565Parser::Fld_94C_CContext::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->exitFld_94C_C(this);
}
SwiftMtParser_MT565Parser::Fld_94C_CContext* SwiftMtParser_MT565Parser::fld_94C_C() {
Fld_94C_CContext *_localctx = _tracker.createInstance<Fld_94C_CContext>(_ctx, getState());
enterRule(_localctx, 102, SwiftMtParser_MT565Parser::RuleFld_94C_C);
auto onExit = finally([=] {
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(747);
dynamic_cast<Fld_94C_CContext *>(_localctx)->fld_94C_C_CContext = fld_94C_C_C();
_localctx->fld.MergeFrom(dynamic_cast<Fld_94C_CContext *>(_localctx)->fld_94C_C_CContext->fld);
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- Fld_36B_CContext ------------------------------------------------------------------
SwiftMtParser_MT565Parser::Fld_36B_CContext::Fld_36B_CContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
SwiftMtParser_MT565Parser::Fld_36B_C_BContext* SwiftMtParser_MT565Parser::Fld_36B_CContext::fld_36B_C_B() {
return getRuleContext<SwiftMtParser_MT565Parser::Fld_36B_C_BContext>(0);
}
size_t SwiftMtParser_MT565Parser::Fld_36B_CContext::getRuleIndex() const {
return SwiftMtParser_MT565Parser::RuleFld_36B_C;
}
void SwiftMtParser_MT565Parser::Fld_36B_CContext::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->enterFld_36B_C(this);
}
void SwiftMtParser_MT565Parser::Fld_36B_CContext::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->exitFld_36B_C(this);
}
SwiftMtParser_MT565Parser::Fld_36B_CContext* SwiftMtParser_MT565Parser::fld_36B_C() {
Fld_36B_CContext *_localctx = _tracker.createInstance<Fld_36B_CContext>(_ctx, getState());
enterRule(_localctx, 104, SwiftMtParser_MT565Parser::RuleFld_36B_C);
auto onExit = finally([=] {
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(750);
dynamic_cast<Fld_36B_CContext *>(_localctx)->fld_36B_C_BContext = fld_36B_C_B();
_localctx->fld.MergeFrom(dynamic_cast<Fld_36B_CContext *>(_localctx)->fld_36B_C_BContext->fld);
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- Fld_22F_CContext ------------------------------------------------------------------
SwiftMtParser_MT565Parser::Fld_22F_CContext::Fld_22F_CContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
SwiftMtParser_MT565Parser::Fld_22F_C_FContext* SwiftMtParser_MT565Parser::Fld_22F_CContext::fld_22F_C_F() {
return getRuleContext<SwiftMtParser_MT565Parser::Fld_22F_C_FContext>(0);
}
size_t SwiftMtParser_MT565Parser::Fld_22F_CContext::getRuleIndex() const {
return SwiftMtParser_MT565Parser::RuleFld_22F_C;
}
void SwiftMtParser_MT565Parser::Fld_22F_CContext::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->enterFld_22F_C(this);
}
void SwiftMtParser_MT565Parser::Fld_22F_CContext::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->exitFld_22F_C(this);
}
SwiftMtParser_MT565Parser::Fld_22F_CContext* SwiftMtParser_MT565Parser::fld_22F_C() {
Fld_22F_CContext *_localctx = _tracker.createInstance<Fld_22F_CContext>(_ctx, getState());
enterRule(_localctx, 106, SwiftMtParser_MT565Parser::RuleFld_22F_C);
auto onExit = finally([=] {
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(753);
dynamic_cast<Fld_22F_CContext *>(_localctx)->fld_22F_C_FContext = fld_22F_C_F();
_localctx->fld.MergeFrom(dynamic_cast<Fld_22F_CContext *>(_localctx)->fld_22F_C_FContext->fld);
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- Fld_70E_CContext ------------------------------------------------------------------
SwiftMtParser_MT565Parser::Fld_70E_CContext::Fld_70E_CContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
SwiftMtParser_MT565Parser::Fld_70E_C_EContext* SwiftMtParser_MT565Parser::Fld_70E_CContext::fld_70E_C_E() {
return getRuleContext<SwiftMtParser_MT565Parser::Fld_70E_C_EContext>(0);
}
size_t SwiftMtParser_MT565Parser::Fld_70E_CContext::getRuleIndex() const {
return SwiftMtParser_MT565Parser::RuleFld_70E_C;
}
void SwiftMtParser_MT565Parser::Fld_70E_CContext::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->enterFld_70E_C(this);
}
void SwiftMtParser_MT565Parser::Fld_70E_CContext::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->exitFld_70E_C(this);
}
SwiftMtParser_MT565Parser::Fld_70E_CContext* SwiftMtParser_MT565Parser::fld_70E_C() {
Fld_70E_CContext *_localctx = _tracker.createInstance<Fld_70E_CContext>(_ctx, getState());
enterRule(_localctx, 108, SwiftMtParser_MT565Parser::RuleFld_70E_C);
auto onExit = finally([=] {
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(756);
dynamic_cast<Fld_70E_CContext *>(_localctx)->fld_70E_C_EContext = fld_70E_C_E();
_localctx->fld.MergeFrom(dynamic_cast<Fld_70E_CContext *>(_localctx)->fld_70E_C_EContext->fld);
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- Fld_16S_CContext ------------------------------------------------------------------
SwiftMtParser_MT565Parser::Fld_16S_CContext::Fld_16S_CContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
std::vector<tree::TerminalNode *> SwiftMtParser_MT565Parser::Fld_16S_CContext::START_OF_FIELD() {
return getTokens(SwiftMtParser_MT565Parser::START_OF_FIELD);
}
tree::TerminalNode* SwiftMtParser_MT565Parser::Fld_16S_CContext::START_OF_FIELD(size_t i) {
return getToken(SwiftMtParser_MT565Parser::START_OF_FIELD, i);
}
size_t SwiftMtParser_MT565Parser::Fld_16S_CContext::getRuleIndex() const {
return SwiftMtParser_MT565Parser::RuleFld_16S_C;
}
void SwiftMtParser_MT565Parser::Fld_16S_CContext::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->enterFld_16S_C(this);
}
void SwiftMtParser_MT565Parser::Fld_16S_CContext::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->exitFld_16S_C(this);
}
SwiftMtParser_MT565Parser::Fld_16S_CContext* SwiftMtParser_MT565Parser::fld_16S_C() {
Fld_16S_CContext *_localctx = _tracker.createInstance<Fld_16S_CContext>(_ctx, getState());
enterRule(_localctx, 110, SwiftMtParser_MT565Parser::RuleFld_16S_C);
_localctx->fld.set_tag("16S");
size_t _la = 0;
auto onExit = finally([=] {
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(759);
match(SwiftMtParser_MT565Parser::START_OF_FIELD);
setState(760);
match(SwiftMtParser_MT565Parser::T__1);
setState(762);
_errHandler->sync(this);
_la = _input->LA(1);
do {
setState(761);
_la = _input->LA(1);
if (_la == 0 || _la == Token::EOF || (_la == SwiftMtParser_MT565Parser::START_OF_FIELD)) {
_errHandler->recoverInline(this);
}
else {
_errHandler->reportMatch(this);
consume();
}
setState(764);
_errHandler->sync(this);
_la = _input->LA(1);
} while ((((_la & ~ 0x3fULL) == 0) &&
((1ULL << _la) & ((1ULL << SwiftMtParser_MT565Parser::T__0)
| (1ULL << SwiftMtParser_MT565Parser::T__1)
| (1ULL << SwiftMtParser_MT565Parser::T__2)
| (1ULL << SwiftMtParser_MT565Parser::T__3)
| (1ULL << SwiftMtParser_MT565Parser::T__4)
| (1ULL << SwiftMtParser_MT565Parser::T__5)
| (1ULL << SwiftMtParser_MT565Parser::T__6)
| (1ULL << SwiftMtParser_MT565Parser::T__7)
| (1ULL << SwiftMtParser_MT565Parser::T__8)
| (1ULL << SwiftMtParser_MT565Parser::T__9)
| (1ULL << SwiftMtParser_MT565Parser::T__10)
| (1ULL << SwiftMtParser_MT565Parser::T__11)
| (1ULL << SwiftMtParser_MT565Parser::T__12)
| (1ULL << SwiftMtParser_MT565Parser::T__13)
| (1ULL << SwiftMtParser_MT565Parser::T__14)
| (1ULL << SwiftMtParser_MT565Parser::T__15)
| (1ULL << SwiftMtParser_MT565Parser::T__16)
| (1ULL << SwiftMtParser_MT565Parser::T__17)
| (1ULL << SwiftMtParser_MT565Parser::T__18)
| (1ULL << SwiftMtParser_MT565Parser::T__19)
| (1ULL << SwiftMtParser_MT565Parser::T__20)
| (1ULL << SwiftMtParser_MT565Parser::T__21)
| (1ULL << SwiftMtParser_MT565Parser::T__22)
| (1ULL << SwiftMtParser_MT565Parser::T__23)
| (1ULL << SwiftMtParser_MT565Parser::T__24)
| (1ULL << SwiftMtParser_MT565Parser::T__25)
| (1ULL << SwiftMtParser_MT565Parser::T__26)
| (1ULL << SwiftMtParser_MT565Parser::T__27)
| (1ULL << SwiftMtParser_MT565Parser::T__28)
| (1ULL << SwiftMtParser_MT565Parser::T__29)
| (1ULL << SwiftMtParser_MT565Parser::T__30)
| (1ULL << SwiftMtParser_MT565Parser::T__31)
| (1ULL << SwiftMtParser_MT565Parser::T__32)
| (1ULL << SwiftMtParser_MT565Parser::T__33)
| (1ULL << SwiftMtParser_MT565Parser::T__34)
| (1ULL << SwiftMtParser_MT565Parser::T__35)
| (1ULL << SwiftMtParser_MT565Parser::T__36)
| (1ULL << SwiftMtParser_MT565Parser::T__37)
| (1ULL << SwiftMtParser_MT565Parser::TAG_BH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_AH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_UH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_MT)
| (1ULL << SwiftMtParser_MT565Parser::TAG_TR)
| (1ULL << SwiftMtParser_MT565Parser::MT_END)
| (1ULL << SwiftMtParser_MT565Parser::LBRACE)
| (1ULL << SwiftMtParser_MT565Parser::RBRACE)
| (1ULL << SwiftMtParser_MT565Parser::COLON)
| (1ULL << SwiftMtParser_MT565Parser::ANY))) != 0));
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- Fld_16R_DContext ------------------------------------------------------------------
SwiftMtParser_MT565Parser::Fld_16R_DContext::Fld_16R_DContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
std::vector<tree::TerminalNode *> SwiftMtParser_MT565Parser::Fld_16R_DContext::START_OF_FIELD() {
return getTokens(SwiftMtParser_MT565Parser::START_OF_FIELD);
}
tree::TerminalNode* SwiftMtParser_MT565Parser::Fld_16R_DContext::START_OF_FIELD(size_t i) {
return getToken(SwiftMtParser_MT565Parser::START_OF_FIELD, i);
}
size_t SwiftMtParser_MT565Parser::Fld_16R_DContext::getRuleIndex() const {
return SwiftMtParser_MT565Parser::RuleFld_16R_D;
}
void SwiftMtParser_MT565Parser::Fld_16R_DContext::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->enterFld_16R_D(this);
}
void SwiftMtParser_MT565Parser::Fld_16R_DContext::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->exitFld_16R_D(this);
}
SwiftMtParser_MT565Parser::Fld_16R_DContext* SwiftMtParser_MT565Parser::fld_16R_D() {
Fld_16R_DContext *_localctx = _tracker.createInstance<Fld_16R_DContext>(_ctx, getState());
enterRule(_localctx, 112, SwiftMtParser_MT565Parser::RuleFld_16R_D);
_localctx->fld.set_tag("16R");
size_t _la = 0;
auto onExit = finally([=] {
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(766);
match(SwiftMtParser_MT565Parser::START_OF_FIELD);
setState(767);
match(SwiftMtParser_MT565Parser::T__0);
setState(769);
_errHandler->sync(this);
_la = _input->LA(1);
do {
setState(768);
_la = _input->LA(1);
if (_la == 0 || _la == Token::EOF || (_la == SwiftMtParser_MT565Parser::START_OF_FIELD)) {
_errHandler->recoverInline(this);
}
else {
_errHandler->reportMatch(this);
consume();
}
setState(771);
_errHandler->sync(this);
_la = _input->LA(1);
} while ((((_la & ~ 0x3fULL) == 0) &&
((1ULL << _la) & ((1ULL << SwiftMtParser_MT565Parser::T__0)
| (1ULL << SwiftMtParser_MT565Parser::T__1)
| (1ULL << SwiftMtParser_MT565Parser::T__2)
| (1ULL << SwiftMtParser_MT565Parser::T__3)
| (1ULL << SwiftMtParser_MT565Parser::T__4)
| (1ULL << SwiftMtParser_MT565Parser::T__5)
| (1ULL << SwiftMtParser_MT565Parser::T__6)
| (1ULL << SwiftMtParser_MT565Parser::T__7)
| (1ULL << SwiftMtParser_MT565Parser::T__8)
| (1ULL << SwiftMtParser_MT565Parser::T__9)
| (1ULL << SwiftMtParser_MT565Parser::T__10)
| (1ULL << SwiftMtParser_MT565Parser::T__11)
| (1ULL << SwiftMtParser_MT565Parser::T__12)
| (1ULL << SwiftMtParser_MT565Parser::T__13)
| (1ULL << SwiftMtParser_MT565Parser::T__14)
| (1ULL << SwiftMtParser_MT565Parser::T__15)
| (1ULL << SwiftMtParser_MT565Parser::T__16)
| (1ULL << SwiftMtParser_MT565Parser::T__17)
| (1ULL << SwiftMtParser_MT565Parser::T__18)
| (1ULL << SwiftMtParser_MT565Parser::T__19)
| (1ULL << SwiftMtParser_MT565Parser::T__20)
| (1ULL << SwiftMtParser_MT565Parser::T__21)
| (1ULL << SwiftMtParser_MT565Parser::T__22)
| (1ULL << SwiftMtParser_MT565Parser::T__23)
| (1ULL << SwiftMtParser_MT565Parser::T__24)
| (1ULL << SwiftMtParser_MT565Parser::T__25)
| (1ULL << SwiftMtParser_MT565Parser::T__26)
| (1ULL << SwiftMtParser_MT565Parser::T__27)
| (1ULL << SwiftMtParser_MT565Parser::T__28)
| (1ULL << SwiftMtParser_MT565Parser::T__29)
| (1ULL << SwiftMtParser_MT565Parser::T__30)
| (1ULL << SwiftMtParser_MT565Parser::T__31)
| (1ULL << SwiftMtParser_MT565Parser::T__32)
| (1ULL << SwiftMtParser_MT565Parser::T__33)
| (1ULL << SwiftMtParser_MT565Parser::T__34)
| (1ULL << SwiftMtParser_MT565Parser::T__35)
| (1ULL << SwiftMtParser_MT565Parser::T__36)
| (1ULL << SwiftMtParser_MT565Parser::T__37)
| (1ULL << SwiftMtParser_MT565Parser::TAG_BH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_AH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_UH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_MT)
| (1ULL << SwiftMtParser_MT565Parser::TAG_TR)
| (1ULL << SwiftMtParser_MT565Parser::MT_END)
| (1ULL << SwiftMtParser_MT565Parser::LBRACE)
| (1ULL << SwiftMtParser_MT565Parser::RBRACE)
| (1ULL << SwiftMtParser_MT565Parser::COLON)
| (1ULL << SwiftMtParser_MT565Parser::ANY))) != 0));
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- Fld_13A_DContext ------------------------------------------------------------------
SwiftMtParser_MT565Parser::Fld_13A_DContext::Fld_13A_DContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
SwiftMtParser_MT565Parser::Fld_13A_D_AContext* SwiftMtParser_MT565Parser::Fld_13A_DContext::fld_13A_D_A() {
return getRuleContext<SwiftMtParser_MT565Parser::Fld_13A_D_AContext>(0);
}
size_t SwiftMtParser_MT565Parser::Fld_13A_DContext::getRuleIndex() const {
return SwiftMtParser_MT565Parser::RuleFld_13A_D;
}
void SwiftMtParser_MT565Parser::Fld_13A_DContext::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->enterFld_13A_D(this);
}
void SwiftMtParser_MT565Parser::Fld_13A_DContext::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->exitFld_13A_D(this);
}
SwiftMtParser_MT565Parser::Fld_13A_DContext* SwiftMtParser_MT565Parser::fld_13A_D() {
Fld_13A_DContext *_localctx = _tracker.createInstance<Fld_13A_DContext>(_ctx, getState());
enterRule(_localctx, 114, SwiftMtParser_MT565Parser::RuleFld_13A_D);
auto onExit = finally([=] {
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(773);
dynamic_cast<Fld_13A_DContext *>(_localctx)->fld_13A_D_AContext = fld_13A_D_A();
_localctx->fld.MergeFrom(dynamic_cast<Fld_13A_DContext *>(_localctx)->fld_13A_D_AContext->fld);
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- Fld_22a_DContext ------------------------------------------------------------------
SwiftMtParser_MT565Parser::Fld_22a_DContext::Fld_22a_DContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
SwiftMtParser_MT565Parser::Fld_22a_D_FContext* SwiftMtParser_MT565Parser::Fld_22a_DContext::fld_22a_D_F() {
return getRuleContext<SwiftMtParser_MT565Parser::Fld_22a_D_FContext>(0);
}
SwiftMtParser_MT565Parser::Fld_22a_D_HContext* SwiftMtParser_MT565Parser::Fld_22a_DContext::fld_22a_D_H() {
return getRuleContext<SwiftMtParser_MT565Parser::Fld_22a_D_HContext>(0);
}
size_t SwiftMtParser_MT565Parser::Fld_22a_DContext::getRuleIndex() const {
return SwiftMtParser_MT565Parser::RuleFld_22a_D;
}
void SwiftMtParser_MT565Parser::Fld_22a_DContext::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->enterFld_22a_D(this);
}
void SwiftMtParser_MT565Parser::Fld_22a_DContext::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->exitFld_22a_D(this);
}
SwiftMtParser_MT565Parser::Fld_22a_DContext* SwiftMtParser_MT565Parser::fld_22a_D() {
Fld_22a_DContext *_localctx = _tracker.createInstance<Fld_22a_DContext>(_ctx, getState());
enterRule(_localctx, 116, SwiftMtParser_MT565Parser::RuleFld_22a_D);
auto onExit = finally([=] {
exitRule();
});
try {
setState(782);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 61, _ctx)) {
case 1: {
enterOuterAlt(_localctx, 1);
setState(776);
dynamic_cast<Fld_22a_DContext *>(_localctx)->fld_22a_D_FContext = fld_22a_D_F();
_localctx->fld.MergeFrom(dynamic_cast<Fld_22a_DContext *>(_localctx)->fld_22a_D_FContext->fld);
break;
}
case 2: {
enterOuterAlt(_localctx, 2);
setState(779);
dynamic_cast<Fld_22a_DContext *>(_localctx)->fld_22a_D_HContext = fld_22a_D_H();
_localctx->fld.MergeFrom(dynamic_cast<Fld_22a_DContext *>(_localctx)->fld_22a_D_HContext->fld);
break;
}
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- Fld_11A_DContext ------------------------------------------------------------------
SwiftMtParser_MT565Parser::Fld_11A_DContext::Fld_11A_DContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
SwiftMtParser_MT565Parser::Fld_11A_D_AContext* SwiftMtParser_MT565Parser::Fld_11A_DContext::fld_11A_D_A() {
return getRuleContext<SwiftMtParser_MT565Parser::Fld_11A_D_AContext>(0);
}
size_t SwiftMtParser_MT565Parser::Fld_11A_DContext::getRuleIndex() const {
return SwiftMtParser_MT565Parser::RuleFld_11A_D;
}
void SwiftMtParser_MT565Parser::Fld_11A_DContext::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->enterFld_11A_D(this);
}
void SwiftMtParser_MT565Parser::Fld_11A_DContext::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->exitFld_11A_D(this);
}
SwiftMtParser_MT565Parser::Fld_11A_DContext* SwiftMtParser_MT565Parser::fld_11A_D() {
Fld_11A_DContext *_localctx = _tracker.createInstance<Fld_11A_DContext>(_ctx, getState());
enterRule(_localctx, 118, SwiftMtParser_MT565Parser::RuleFld_11A_D);
auto onExit = finally([=] {
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(784);
dynamic_cast<Fld_11A_DContext *>(_localctx)->fld_11A_D_AContext = fld_11A_D_A();
_localctx->fld.MergeFrom(dynamic_cast<Fld_11A_DContext *>(_localctx)->fld_11A_D_AContext->fld);
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- Fld_35B_DContext ------------------------------------------------------------------
SwiftMtParser_MT565Parser::Fld_35B_DContext::Fld_35B_DContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
SwiftMtParser_MT565Parser::Fld_35B_D_BContext* SwiftMtParser_MT565Parser::Fld_35B_DContext::fld_35B_D_B() {
return getRuleContext<SwiftMtParser_MT565Parser::Fld_35B_D_BContext>(0);
}
size_t SwiftMtParser_MT565Parser::Fld_35B_DContext::getRuleIndex() const {
return SwiftMtParser_MT565Parser::RuleFld_35B_D;
}
void SwiftMtParser_MT565Parser::Fld_35B_DContext::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->enterFld_35B_D(this);
}
void SwiftMtParser_MT565Parser::Fld_35B_DContext::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->exitFld_35B_D(this);
}
SwiftMtParser_MT565Parser::Fld_35B_DContext* SwiftMtParser_MT565Parser::fld_35B_D() {
Fld_35B_DContext *_localctx = _tracker.createInstance<Fld_35B_DContext>(_ctx, getState());
enterRule(_localctx, 120, SwiftMtParser_MT565Parser::RuleFld_35B_D);
auto onExit = finally([=] {
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(787);
dynamic_cast<Fld_35B_DContext *>(_localctx)->fld_35B_D_BContext = fld_35B_D_B();
_localctx->fld.MergeFrom(dynamic_cast<Fld_35B_DContext *>(_localctx)->fld_35B_D_BContext->fld);
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- Fld_36a_DContext ------------------------------------------------------------------
SwiftMtParser_MT565Parser::Fld_36a_DContext::Fld_36a_DContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
SwiftMtParser_MT565Parser::Fld_36a_D_BContext* SwiftMtParser_MT565Parser::Fld_36a_DContext::fld_36a_D_B() {
return getRuleContext<SwiftMtParser_MT565Parser::Fld_36a_D_BContext>(0);
}
SwiftMtParser_MT565Parser::Fld_36a_D_CContext* SwiftMtParser_MT565Parser::Fld_36a_DContext::fld_36a_D_C() {
return getRuleContext<SwiftMtParser_MT565Parser::Fld_36a_D_CContext>(0);
}
size_t SwiftMtParser_MT565Parser::Fld_36a_DContext::getRuleIndex() const {
return SwiftMtParser_MT565Parser::RuleFld_36a_D;
}
void SwiftMtParser_MT565Parser::Fld_36a_DContext::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->enterFld_36a_D(this);
}
void SwiftMtParser_MT565Parser::Fld_36a_DContext::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->exitFld_36a_D(this);
}
SwiftMtParser_MT565Parser::Fld_36a_DContext* SwiftMtParser_MT565Parser::fld_36a_D() {
Fld_36a_DContext *_localctx = _tracker.createInstance<Fld_36a_DContext>(_ctx, getState());
enterRule(_localctx, 122, SwiftMtParser_MT565Parser::RuleFld_36a_D);
auto onExit = finally([=] {
exitRule();
});
try {
setState(796);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 62, _ctx)) {
case 1: {
enterOuterAlt(_localctx, 1);
setState(790);
dynamic_cast<Fld_36a_DContext *>(_localctx)->fld_36a_D_BContext = fld_36a_D_B();
_localctx->fld.MergeFrom(dynamic_cast<Fld_36a_DContext *>(_localctx)->fld_36a_D_BContext->fld);
break;
}
case 2: {
enterOuterAlt(_localctx, 2);
setState(793);
dynamic_cast<Fld_36a_DContext *>(_localctx)->fld_36a_D_CContext = fld_36a_D_C();
_localctx->fld.MergeFrom(dynamic_cast<Fld_36a_DContext *>(_localctx)->fld_36a_D_CContext->fld);
break;
}
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- Fld_19B_DContext ------------------------------------------------------------------
SwiftMtParser_MT565Parser::Fld_19B_DContext::Fld_19B_DContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
SwiftMtParser_MT565Parser::Fld_19B_D_BContext* SwiftMtParser_MT565Parser::Fld_19B_DContext::fld_19B_D_B() {
return getRuleContext<SwiftMtParser_MT565Parser::Fld_19B_D_BContext>(0);
}
size_t SwiftMtParser_MT565Parser::Fld_19B_DContext::getRuleIndex() const {
return SwiftMtParser_MT565Parser::RuleFld_19B_D;
}
void SwiftMtParser_MT565Parser::Fld_19B_DContext::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->enterFld_19B_D(this);
}
void SwiftMtParser_MT565Parser::Fld_19B_DContext::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->exitFld_19B_D(this);
}
SwiftMtParser_MT565Parser::Fld_19B_DContext* SwiftMtParser_MT565Parser::fld_19B_D() {
Fld_19B_DContext *_localctx = _tracker.createInstance<Fld_19B_DContext>(_ctx, getState());
enterRule(_localctx, 124, SwiftMtParser_MT565Parser::RuleFld_19B_D);
auto onExit = finally([=] {
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(798);
dynamic_cast<Fld_19B_DContext *>(_localctx)->fld_19B_D_BContext = fld_19B_D_B();
_localctx->fld.MergeFrom(dynamic_cast<Fld_19B_DContext *>(_localctx)->fld_19B_D_BContext->fld);
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- Fld_98a_DContext ------------------------------------------------------------------
SwiftMtParser_MT565Parser::Fld_98a_DContext::Fld_98a_DContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
SwiftMtParser_MT565Parser::Fld_98a_D_AContext* SwiftMtParser_MT565Parser::Fld_98a_DContext::fld_98a_D_A() {
return getRuleContext<SwiftMtParser_MT565Parser::Fld_98a_D_AContext>(0);
}
SwiftMtParser_MT565Parser::Fld_98a_D_CContext* SwiftMtParser_MT565Parser::Fld_98a_DContext::fld_98a_D_C() {
return getRuleContext<SwiftMtParser_MT565Parser::Fld_98a_D_CContext>(0);
}
size_t SwiftMtParser_MT565Parser::Fld_98a_DContext::getRuleIndex() const {
return SwiftMtParser_MT565Parser::RuleFld_98a_D;
}
void SwiftMtParser_MT565Parser::Fld_98a_DContext::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->enterFld_98a_D(this);
}
void SwiftMtParser_MT565Parser::Fld_98a_DContext::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->exitFld_98a_D(this);
}
SwiftMtParser_MT565Parser::Fld_98a_DContext* SwiftMtParser_MT565Parser::fld_98a_D() {
Fld_98a_DContext *_localctx = _tracker.createInstance<Fld_98a_DContext>(_ctx, getState());
enterRule(_localctx, 126, SwiftMtParser_MT565Parser::RuleFld_98a_D);
auto onExit = finally([=] {
exitRule();
});
try {
setState(807);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 63, _ctx)) {
case 1: {
enterOuterAlt(_localctx, 1);
setState(801);
dynamic_cast<Fld_98a_DContext *>(_localctx)->fld_98a_D_AContext = fld_98a_D_A();
_localctx->fld.MergeFrom(dynamic_cast<Fld_98a_DContext *>(_localctx)->fld_98a_D_AContext->fld);
break;
}
case 2: {
enterOuterAlt(_localctx, 2);
setState(804);
dynamic_cast<Fld_98a_DContext *>(_localctx)->fld_98a_D_CContext = fld_98a_D_C();
_localctx->fld.MergeFrom(dynamic_cast<Fld_98a_DContext *>(_localctx)->fld_98a_D_CContext->fld);
break;
}
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- Fld_92a_DContext ------------------------------------------------------------------
SwiftMtParser_MT565Parser::Fld_92a_DContext::Fld_92a_DContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
SwiftMtParser_MT565Parser::Fld_92a_D_AContext* SwiftMtParser_MT565Parser::Fld_92a_DContext::fld_92a_D_A() {
return getRuleContext<SwiftMtParser_MT565Parser::Fld_92a_D_AContext>(0);
}
SwiftMtParser_MT565Parser::Fld_92a_D_FContext* SwiftMtParser_MT565Parser::Fld_92a_DContext::fld_92a_D_F() {
return getRuleContext<SwiftMtParser_MT565Parser::Fld_92a_D_FContext>(0);
}
SwiftMtParser_MT565Parser::Fld_92a_D_RContext* SwiftMtParser_MT565Parser::Fld_92a_DContext::fld_92a_D_R() {
return getRuleContext<SwiftMtParser_MT565Parser::Fld_92a_D_RContext>(0);
}
size_t SwiftMtParser_MT565Parser::Fld_92a_DContext::getRuleIndex() const {
return SwiftMtParser_MT565Parser::RuleFld_92a_D;
}
void SwiftMtParser_MT565Parser::Fld_92a_DContext::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->enterFld_92a_D(this);
}
void SwiftMtParser_MT565Parser::Fld_92a_DContext::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->exitFld_92a_D(this);
}
SwiftMtParser_MT565Parser::Fld_92a_DContext* SwiftMtParser_MT565Parser::fld_92a_D() {
Fld_92a_DContext *_localctx = _tracker.createInstance<Fld_92a_DContext>(_ctx, getState());
enterRule(_localctx, 128, SwiftMtParser_MT565Parser::RuleFld_92a_D);
auto onExit = finally([=] {
exitRule();
});
try {
setState(818);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 64, _ctx)) {
case 1: {
enterOuterAlt(_localctx, 1);
setState(809);
dynamic_cast<Fld_92a_DContext *>(_localctx)->fld_92a_D_AContext = fld_92a_D_A();
_localctx->fld.MergeFrom(dynamic_cast<Fld_92a_DContext *>(_localctx)->fld_92a_D_AContext->fld);
break;
}
case 2: {
enterOuterAlt(_localctx, 2);
setState(812);
dynamic_cast<Fld_92a_DContext *>(_localctx)->fld_92a_D_FContext = fld_92a_D_F();
_localctx->fld.MergeFrom(dynamic_cast<Fld_92a_DContext *>(_localctx)->fld_92a_D_FContext->fld);
break;
}
case 3: {
enterOuterAlt(_localctx, 3);
setState(815);
dynamic_cast<Fld_92a_DContext *>(_localctx)->fld_92a_D_RContext = fld_92a_D_R();
_localctx->fld.MergeFrom(dynamic_cast<Fld_92a_DContext *>(_localctx)->fld_92a_D_RContext->fld);
break;
}
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- Fld_90a_DContext ------------------------------------------------------------------
SwiftMtParser_MT565Parser::Fld_90a_DContext::Fld_90a_DContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
SwiftMtParser_MT565Parser::Fld_90a_D_AContext* SwiftMtParser_MT565Parser::Fld_90a_DContext::fld_90a_D_A() {
return getRuleContext<SwiftMtParser_MT565Parser::Fld_90a_D_AContext>(0);
}
SwiftMtParser_MT565Parser::Fld_90a_D_BContext* SwiftMtParser_MT565Parser::Fld_90a_DContext::fld_90a_D_B() {
return getRuleContext<SwiftMtParser_MT565Parser::Fld_90a_D_BContext>(0);
}
SwiftMtParser_MT565Parser::Fld_90a_D_EContext* SwiftMtParser_MT565Parser::Fld_90a_DContext::fld_90a_D_E() {
return getRuleContext<SwiftMtParser_MT565Parser::Fld_90a_D_EContext>(0);
}
SwiftMtParser_MT565Parser::Fld_90a_D_FContext* SwiftMtParser_MT565Parser::Fld_90a_DContext::fld_90a_D_F() {
return getRuleContext<SwiftMtParser_MT565Parser::Fld_90a_D_FContext>(0);
}
SwiftMtParser_MT565Parser::Fld_90a_D_JContext* SwiftMtParser_MT565Parser::Fld_90a_DContext::fld_90a_D_J() {
return getRuleContext<SwiftMtParser_MT565Parser::Fld_90a_D_JContext>(0);
}
SwiftMtParser_MT565Parser::Fld_90a_D_LContext* SwiftMtParser_MT565Parser::Fld_90a_DContext::fld_90a_D_L() {
return getRuleContext<SwiftMtParser_MT565Parser::Fld_90a_D_LContext>(0);
}
size_t SwiftMtParser_MT565Parser::Fld_90a_DContext::getRuleIndex() const {
return SwiftMtParser_MT565Parser::RuleFld_90a_D;
}
void SwiftMtParser_MT565Parser::Fld_90a_DContext::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->enterFld_90a_D(this);
}
void SwiftMtParser_MT565Parser::Fld_90a_DContext::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->exitFld_90a_D(this);
}
SwiftMtParser_MT565Parser::Fld_90a_DContext* SwiftMtParser_MT565Parser::fld_90a_D() {
Fld_90a_DContext *_localctx = _tracker.createInstance<Fld_90a_DContext>(_ctx, getState());
enterRule(_localctx, 130, SwiftMtParser_MT565Parser::RuleFld_90a_D);
auto onExit = finally([=] {
exitRule();
});
try {
setState(838);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 65, _ctx)) {
case 1: {
enterOuterAlt(_localctx, 1);
setState(820);
dynamic_cast<Fld_90a_DContext *>(_localctx)->fld_90a_D_AContext = fld_90a_D_A();
_localctx->fld.MergeFrom(dynamic_cast<Fld_90a_DContext *>(_localctx)->fld_90a_D_AContext->fld);
break;
}
case 2: {
enterOuterAlt(_localctx, 2);
setState(823);
dynamic_cast<Fld_90a_DContext *>(_localctx)->fld_90a_D_BContext = fld_90a_D_B();
_localctx->fld.MergeFrom(dynamic_cast<Fld_90a_DContext *>(_localctx)->fld_90a_D_BContext->fld);
break;
}
case 3: {
enterOuterAlt(_localctx, 3);
setState(826);
dynamic_cast<Fld_90a_DContext *>(_localctx)->fld_90a_D_EContext = fld_90a_D_E();
_localctx->fld.MergeFrom(dynamic_cast<Fld_90a_DContext *>(_localctx)->fld_90a_D_EContext->fld);
break;
}
case 4: {
enterOuterAlt(_localctx, 4);
setState(829);
dynamic_cast<Fld_90a_DContext *>(_localctx)->fld_90a_D_FContext = fld_90a_D_F();
_localctx->fld.MergeFrom(dynamic_cast<Fld_90a_DContext *>(_localctx)->fld_90a_D_FContext->fld);
break;
}
case 5: {
enterOuterAlt(_localctx, 5);
setState(832);
dynamic_cast<Fld_90a_DContext *>(_localctx)->fld_90a_D_JContext = fld_90a_D_J();
_localctx->fld.MergeFrom(dynamic_cast<Fld_90a_DContext *>(_localctx)->fld_90a_D_JContext->fld);
break;
}
case 6: {
enterOuterAlt(_localctx, 6);
setState(835);
dynamic_cast<Fld_90a_DContext *>(_localctx)->fld_90a_D_LContext = fld_90a_D_L();
_localctx->fld.MergeFrom(dynamic_cast<Fld_90a_DContext *>(_localctx)->fld_90a_D_LContext->fld);
break;
}
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- Fld_70E_DContext ------------------------------------------------------------------
SwiftMtParser_MT565Parser::Fld_70E_DContext::Fld_70E_DContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
SwiftMtParser_MT565Parser::Fld_70E_D_EContext* SwiftMtParser_MT565Parser::Fld_70E_DContext::fld_70E_D_E() {
return getRuleContext<SwiftMtParser_MT565Parser::Fld_70E_D_EContext>(0);
}
size_t SwiftMtParser_MT565Parser::Fld_70E_DContext::getRuleIndex() const {
return SwiftMtParser_MT565Parser::RuleFld_70E_D;
}
void SwiftMtParser_MT565Parser::Fld_70E_DContext::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->enterFld_70E_D(this);
}
void SwiftMtParser_MT565Parser::Fld_70E_DContext::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->exitFld_70E_D(this);
}
SwiftMtParser_MT565Parser::Fld_70E_DContext* SwiftMtParser_MT565Parser::fld_70E_D() {
Fld_70E_DContext *_localctx = _tracker.createInstance<Fld_70E_DContext>(_ctx, getState());
enterRule(_localctx, 132, SwiftMtParser_MT565Parser::RuleFld_70E_D);
auto onExit = finally([=] {
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(840);
dynamic_cast<Fld_70E_DContext *>(_localctx)->fld_70E_D_EContext = fld_70E_D_E();
_localctx->fld.MergeFrom(dynamic_cast<Fld_70E_DContext *>(_localctx)->fld_70E_D_EContext->fld);
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- Fld_16S_DContext ------------------------------------------------------------------
SwiftMtParser_MT565Parser::Fld_16S_DContext::Fld_16S_DContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
std::vector<tree::TerminalNode *> SwiftMtParser_MT565Parser::Fld_16S_DContext::START_OF_FIELD() {
return getTokens(SwiftMtParser_MT565Parser::START_OF_FIELD);
}
tree::TerminalNode* SwiftMtParser_MT565Parser::Fld_16S_DContext::START_OF_FIELD(size_t i) {
return getToken(SwiftMtParser_MT565Parser::START_OF_FIELD, i);
}
size_t SwiftMtParser_MT565Parser::Fld_16S_DContext::getRuleIndex() const {
return SwiftMtParser_MT565Parser::RuleFld_16S_D;
}
void SwiftMtParser_MT565Parser::Fld_16S_DContext::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->enterFld_16S_D(this);
}
void SwiftMtParser_MT565Parser::Fld_16S_DContext::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->exitFld_16S_D(this);
}
SwiftMtParser_MT565Parser::Fld_16S_DContext* SwiftMtParser_MT565Parser::fld_16S_D() {
Fld_16S_DContext *_localctx = _tracker.createInstance<Fld_16S_DContext>(_ctx, getState());
enterRule(_localctx, 134, SwiftMtParser_MT565Parser::RuleFld_16S_D);
_localctx->fld.set_tag("16S");
size_t _la = 0;
auto onExit = finally([=] {
exitRule();
});
try {
size_t alt;
enterOuterAlt(_localctx, 1);
setState(843);
match(SwiftMtParser_MT565Parser::START_OF_FIELD);
setState(844);
match(SwiftMtParser_MT565Parser::T__1);
setState(846);
_errHandler->sync(this);
alt = 1;
do {
switch (alt) {
case 1: {
setState(845);
_la = _input->LA(1);
if (_la == 0 || _la == Token::EOF || (_la == SwiftMtParser_MT565Parser::START_OF_FIELD)) {
_errHandler->recoverInline(this);
}
else {
_errHandler->reportMatch(this);
consume();
}
break;
}
default:
throw NoViableAltException(this);
}
setState(848);
_errHandler->sync(this);
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 66, _ctx);
} while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER);
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- Fld_16R_EContext ------------------------------------------------------------------
SwiftMtParser_MT565Parser::Fld_16R_EContext::Fld_16R_EContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
std::vector<tree::TerminalNode *> SwiftMtParser_MT565Parser::Fld_16R_EContext::START_OF_FIELD() {
return getTokens(SwiftMtParser_MT565Parser::START_OF_FIELD);
}
tree::TerminalNode* SwiftMtParser_MT565Parser::Fld_16R_EContext::START_OF_FIELD(size_t i) {
return getToken(SwiftMtParser_MT565Parser::START_OF_FIELD, i);
}
size_t SwiftMtParser_MT565Parser::Fld_16R_EContext::getRuleIndex() const {
return SwiftMtParser_MT565Parser::RuleFld_16R_E;
}
void SwiftMtParser_MT565Parser::Fld_16R_EContext::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->enterFld_16R_E(this);
}
void SwiftMtParser_MT565Parser::Fld_16R_EContext::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->exitFld_16R_E(this);
}
SwiftMtParser_MT565Parser::Fld_16R_EContext* SwiftMtParser_MT565Parser::fld_16R_E() {
Fld_16R_EContext *_localctx = _tracker.createInstance<Fld_16R_EContext>(_ctx, getState());
enterRule(_localctx, 136, SwiftMtParser_MT565Parser::RuleFld_16R_E);
_localctx->fld.set_tag("16R");
size_t _la = 0;
auto onExit = finally([=] {
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(850);
match(SwiftMtParser_MT565Parser::START_OF_FIELD);
setState(851);
match(SwiftMtParser_MT565Parser::T__0);
setState(853);
_errHandler->sync(this);
_la = _input->LA(1);
do {
setState(852);
_la = _input->LA(1);
if (_la == 0 || _la == Token::EOF || (_la == SwiftMtParser_MT565Parser::START_OF_FIELD)) {
_errHandler->recoverInline(this);
}
else {
_errHandler->reportMatch(this);
consume();
}
setState(855);
_errHandler->sync(this);
_la = _input->LA(1);
} while ((((_la & ~ 0x3fULL) == 0) &&
((1ULL << _la) & ((1ULL << SwiftMtParser_MT565Parser::T__0)
| (1ULL << SwiftMtParser_MT565Parser::T__1)
| (1ULL << SwiftMtParser_MT565Parser::T__2)
| (1ULL << SwiftMtParser_MT565Parser::T__3)
| (1ULL << SwiftMtParser_MT565Parser::T__4)
| (1ULL << SwiftMtParser_MT565Parser::T__5)
| (1ULL << SwiftMtParser_MT565Parser::T__6)
| (1ULL << SwiftMtParser_MT565Parser::T__7)
| (1ULL << SwiftMtParser_MT565Parser::T__8)
| (1ULL << SwiftMtParser_MT565Parser::T__9)
| (1ULL << SwiftMtParser_MT565Parser::T__10)
| (1ULL << SwiftMtParser_MT565Parser::T__11)
| (1ULL << SwiftMtParser_MT565Parser::T__12)
| (1ULL << SwiftMtParser_MT565Parser::T__13)
| (1ULL << SwiftMtParser_MT565Parser::T__14)
| (1ULL << SwiftMtParser_MT565Parser::T__15)
| (1ULL << SwiftMtParser_MT565Parser::T__16)
| (1ULL << SwiftMtParser_MT565Parser::T__17)
| (1ULL << SwiftMtParser_MT565Parser::T__18)
| (1ULL << SwiftMtParser_MT565Parser::T__19)
| (1ULL << SwiftMtParser_MT565Parser::T__20)
| (1ULL << SwiftMtParser_MT565Parser::T__21)
| (1ULL << SwiftMtParser_MT565Parser::T__22)
| (1ULL << SwiftMtParser_MT565Parser::T__23)
| (1ULL << SwiftMtParser_MT565Parser::T__24)
| (1ULL << SwiftMtParser_MT565Parser::T__25)
| (1ULL << SwiftMtParser_MT565Parser::T__26)
| (1ULL << SwiftMtParser_MT565Parser::T__27)
| (1ULL << SwiftMtParser_MT565Parser::T__28)
| (1ULL << SwiftMtParser_MT565Parser::T__29)
| (1ULL << SwiftMtParser_MT565Parser::T__30)
| (1ULL << SwiftMtParser_MT565Parser::T__31)
| (1ULL << SwiftMtParser_MT565Parser::T__32)
| (1ULL << SwiftMtParser_MT565Parser::T__33)
| (1ULL << SwiftMtParser_MT565Parser::T__34)
| (1ULL << SwiftMtParser_MT565Parser::T__35)
| (1ULL << SwiftMtParser_MT565Parser::T__36)
| (1ULL << SwiftMtParser_MT565Parser::T__37)
| (1ULL << SwiftMtParser_MT565Parser::TAG_BH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_AH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_UH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_MT)
| (1ULL << SwiftMtParser_MT565Parser::TAG_TR)
| (1ULL << SwiftMtParser_MT565Parser::MT_END)
| (1ULL << SwiftMtParser_MT565Parser::LBRACE)
| (1ULL << SwiftMtParser_MT565Parser::RBRACE)
| (1ULL << SwiftMtParser_MT565Parser::COLON)
| (1ULL << SwiftMtParser_MT565Parser::ANY))) != 0));
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- Fld_70E_EContext ------------------------------------------------------------------
SwiftMtParser_MT565Parser::Fld_70E_EContext::Fld_70E_EContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
SwiftMtParser_MT565Parser::Fld_70E_E_EContext* SwiftMtParser_MT565Parser::Fld_70E_EContext::fld_70E_E_E() {
return getRuleContext<SwiftMtParser_MT565Parser::Fld_70E_E_EContext>(0);
}
size_t SwiftMtParser_MT565Parser::Fld_70E_EContext::getRuleIndex() const {
return SwiftMtParser_MT565Parser::RuleFld_70E_E;
}
void SwiftMtParser_MT565Parser::Fld_70E_EContext::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->enterFld_70E_E(this);
}
void SwiftMtParser_MT565Parser::Fld_70E_EContext::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->exitFld_70E_E(this);
}
SwiftMtParser_MT565Parser::Fld_70E_EContext* SwiftMtParser_MT565Parser::fld_70E_E() {
Fld_70E_EContext *_localctx = _tracker.createInstance<Fld_70E_EContext>(_ctx, getState());
enterRule(_localctx, 138, SwiftMtParser_MT565Parser::RuleFld_70E_E);
auto onExit = finally([=] {
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(857);
dynamic_cast<Fld_70E_EContext *>(_localctx)->fld_70E_E_EContext = fld_70E_E_E();
_localctx->fld.MergeFrom(dynamic_cast<Fld_70E_EContext *>(_localctx)->fld_70E_E_EContext->fld);
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- Fld_95a_EContext ------------------------------------------------------------------
SwiftMtParser_MT565Parser::Fld_95a_EContext::Fld_95a_EContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
SwiftMtParser_MT565Parser::Fld_95a_E_PContext* SwiftMtParser_MT565Parser::Fld_95a_EContext::fld_95a_E_P() {
return getRuleContext<SwiftMtParser_MT565Parser::Fld_95a_E_PContext>(0);
}
SwiftMtParser_MT565Parser::Fld_95a_E_QContext* SwiftMtParser_MT565Parser::Fld_95a_EContext::fld_95a_E_Q() {
return getRuleContext<SwiftMtParser_MT565Parser::Fld_95a_E_QContext>(0);
}
SwiftMtParser_MT565Parser::Fld_95a_E_RContext* SwiftMtParser_MT565Parser::Fld_95a_EContext::fld_95a_E_R() {
return getRuleContext<SwiftMtParser_MT565Parser::Fld_95a_E_RContext>(0);
}
size_t SwiftMtParser_MT565Parser::Fld_95a_EContext::getRuleIndex() const {
return SwiftMtParser_MT565Parser::RuleFld_95a_E;
}
void SwiftMtParser_MT565Parser::Fld_95a_EContext::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->enterFld_95a_E(this);
}
void SwiftMtParser_MT565Parser::Fld_95a_EContext::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->exitFld_95a_E(this);
}
SwiftMtParser_MT565Parser::Fld_95a_EContext* SwiftMtParser_MT565Parser::fld_95a_E() {
Fld_95a_EContext *_localctx = _tracker.createInstance<Fld_95a_EContext>(_ctx, getState());
enterRule(_localctx, 140, SwiftMtParser_MT565Parser::RuleFld_95a_E);
auto onExit = finally([=] {
exitRule();
});
try {
setState(869);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 68, _ctx)) {
case 1: {
enterOuterAlt(_localctx, 1);
setState(860);
dynamic_cast<Fld_95a_EContext *>(_localctx)->fld_95a_E_PContext = fld_95a_E_P();
_localctx->fld.MergeFrom(dynamic_cast<Fld_95a_EContext *>(_localctx)->fld_95a_E_PContext->fld);
break;
}
case 2: {
enterOuterAlt(_localctx, 2);
setState(863);
dynamic_cast<Fld_95a_EContext *>(_localctx)->fld_95a_E_QContext = fld_95a_E_Q();
_localctx->fld.MergeFrom(dynamic_cast<Fld_95a_EContext *>(_localctx)->fld_95a_E_QContext->fld);
break;
}
case 3: {
enterOuterAlt(_localctx, 3);
setState(866);
dynamic_cast<Fld_95a_EContext *>(_localctx)->fld_95a_E_RContext = fld_95a_E_R();
_localctx->fld.MergeFrom(dynamic_cast<Fld_95a_EContext *>(_localctx)->fld_95a_E_RContext->fld);
break;
}
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- Fld_16S_EContext ------------------------------------------------------------------
SwiftMtParser_MT565Parser::Fld_16S_EContext::Fld_16S_EContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
std::vector<tree::TerminalNode *> SwiftMtParser_MT565Parser::Fld_16S_EContext::START_OF_FIELD() {
return getTokens(SwiftMtParser_MT565Parser::START_OF_FIELD);
}
tree::TerminalNode* SwiftMtParser_MT565Parser::Fld_16S_EContext::START_OF_FIELD(size_t i) {
return getToken(SwiftMtParser_MT565Parser::START_OF_FIELD, i);
}
size_t SwiftMtParser_MT565Parser::Fld_16S_EContext::getRuleIndex() const {
return SwiftMtParser_MT565Parser::RuleFld_16S_E;
}
void SwiftMtParser_MT565Parser::Fld_16S_EContext::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->enterFld_16S_E(this);
}
void SwiftMtParser_MT565Parser::Fld_16S_EContext::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->exitFld_16S_E(this);
}
SwiftMtParser_MT565Parser::Fld_16S_EContext* SwiftMtParser_MT565Parser::fld_16S_E() {
Fld_16S_EContext *_localctx = _tracker.createInstance<Fld_16S_EContext>(_ctx, getState());
enterRule(_localctx, 142, SwiftMtParser_MT565Parser::RuleFld_16S_E);
_localctx->fld.set_tag("16S");
size_t _la = 0;
auto onExit = finally([=] {
exitRule();
});
try {
size_t alt;
enterOuterAlt(_localctx, 1);
setState(871);
match(SwiftMtParser_MT565Parser::START_OF_FIELD);
setState(872);
match(SwiftMtParser_MT565Parser::T__1);
setState(874);
_errHandler->sync(this);
alt = 1;
do {
switch (alt) {
case 1: {
setState(873);
_la = _input->LA(1);
if (_la == 0 || _la == Token::EOF || (_la == SwiftMtParser_MT565Parser::START_OF_FIELD)) {
_errHandler->recoverInline(this);
}
else {
_errHandler->reportMatch(this);
consume();
}
break;
}
default:
throw NoViableAltException(this);
}
setState(876);
_errHandler->sync(this);
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 69, _ctx);
} while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER);
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- Fld_20C_A_CContext ------------------------------------------------------------------
SwiftMtParser_MT565Parser::Fld_20C_A_CContext::Fld_20C_A_CContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
std::vector<tree::TerminalNode *> SwiftMtParser_MT565Parser::Fld_20C_A_CContext::START_OF_FIELD() {
return getTokens(SwiftMtParser_MT565Parser::START_OF_FIELD);
}
tree::TerminalNode* SwiftMtParser_MT565Parser::Fld_20C_A_CContext::START_OF_FIELD(size_t i) {
return getToken(SwiftMtParser_MT565Parser::START_OF_FIELD, i);
}
size_t SwiftMtParser_MT565Parser::Fld_20C_A_CContext::getRuleIndex() const {
return SwiftMtParser_MT565Parser::RuleFld_20C_A_C;
}
void SwiftMtParser_MT565Parser::Fld_20C_A_CContext::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->enterFld_20C_A_C(this);
}
void SwiftMtParser_MT565Parser::Fld_20C_A_CContext::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->exitFld_20C_A_C(this);
}
SwiftMtParser_MT565Parser::Fld_20C_A_CContext* SwiftMtParser_MT565Parser::fld_20C_A_C() {
Fld_20C_A_CContext *_localctx = _tracker.createInstance<Fld_20C_A_CContext>(_ctx, getState());
enterRule(_localctx, 144, SwiftMtParser_MT565Parser::RuleFld_20C_A_C);
_localctx->fld.set_tag("20C");
size_t _la = 0;
auto onExit = finally([=] {
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(878);
match(SwiftMtParser_MT565Parser::START_OF_FIELD);
setState(879);
match(SwiftMtParser_MT565Parser::T__2);
setState(881);
_errHandler->sync(this);
_la = _input->LA(1);
do {
setState(880);
_la = _input->LA(1);
if (_la == 0 || _la == Token::EOF || (_la == SwiftMtParser_MT565Parser::START_OF_FIELD)) {
_errHandler->recoverInline(this);
}
else {
_errHandler->reportMatch(this);
consume();
}
setState(883);
_errHandler->sync(this);
_la = _input->LA(1);
} while ((((_la & ~ 0x3fULL) == 0) &&
((1ULL << _la) & ((1ULL << SwiftMtParser_MT565Parser::T__0)
| (1ULL << SwiftMtParser_MT565Parser::T__1)
| (1ULL << SwiftMtParser_MT565Parser::T__2)
| (1ULL << SwiftMtParser_MT565Parser::T__3)
| (1ULL << SwiftMtParser_MT565Parser::T__4)
| (1ULL << SwiftMtParser_MT565Parser::T__5)
| (1ULL << SwiftMtParser_MT565Parser::T__6)
| (1ULL << SwiftMtParser_MT565Parser::T__7)
| (1ULL << SwiftMtParser_MT565Parser::T__8)
| (1ULL << SwiftMtParser_MT565Parser::T__9)
| (1ULL << SwiftMtParser_MT565Parser::T__10)
| (1ULL << SwiftMtParser_MT565Parser::T__11)
| (1ULL << SwiftMtParser_MT565Parser::T__12)
| (1ULL << SwiftMtParser_MT565Parser::T__13)
| (1ULL << SwiftMtParser_MT565Parser::T__14)
| (1ULL << SwiftMtParser_MT565Parser::T__15)
| (1ULL << SwiftMtParser_MT565Parser::T__16)
| (1ULL << SwiftMtParser_MT565Parser::T__17)
| (1ULL << SwiftMtParser_MT565Parser::T__18)
| (1ULL << SwiftMtParser_MT565Parser::T__19)
| (1ULL << SwiftMtParser_MT565Parser::T__20)
| (1ULL << SwiftMtParser_MT565Parser::T__21)
| (1ULL << SwiftMtParser_MT565Parser::T__22)
| (1ULL << SwiftMtParser_MT565Parser::T__23)
| (1ULL << SwiftMtParser_MT565Parser::T__24)
| (1ULL << SwiftMtParser_MT565Parser::T__25)
| (1ULL << SwiftMtParser_MT565Parser::T__26)
| (1ULL << SwiftMtParser_MT565Parser::T__27)
| (1ULL << SwiftMtParser_MT565Parser::T__28)
| (1ULL << SwiftMtParser_MT565Parser::T__29)
| (1ULL << SwiftMtParser_MT565Parser::T__30)
| (1ULL << SwiftMtParser_MT565Parser::T__31)
| (1ULL << SwiftMtParser_MT565Parser::T__32)
| (1ULL << SwiftMtParser_MT565Parser::T__33)
| (1ULL << SwiftMtParser_MT565Parser::T__34)
| (1ULL << SwiftMtParser_MT565Parser::T__35)
| (1ULL << SwiftMtParser_MT565Parser::T__36)
| (1ULL << SwiftMtParser_MT565Parser::T__37)
| (1ULL << SwiftMtParser_MT565Parser::TAG_BH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_AH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_UH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_MT)
| (1ULL << SwiftMtParser_MT565Parser::TAG_TR)
| (1ULL << SwiftMtParser_MT565Parser::MT_END)
| (1ULL << SwiftMtParser_MT565Parser::LBRACE)
| (1ULL << SwiftMtParser_MT565Parser::RBRACE)
| (1ULL << SwiftMtParser_MT565Parser::COLON)
| (1ULL << SwiftMtParser_MT565Parser::ANY))) != 0));
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- Fld_23G_A_GContext ------------------------------------------------------------------
SwiftMtParser_MT565Parser::Fld_23G_A_GContext::Fld_23G_A_GContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
std::vector<tree::TerminalNode *> SwiftMtParser_MT565Parser::Fld_23G_A_GContext::START_OF_FIELD() {
return getTokens(SwiftMtParser_MT565Parser::START_OF_FIELD);
}
tree::TerminalNode* SwiftMtParser_MT565Parser::Fld_23G_A_GContext::START_OF_FIELD(size_t i) {
return getToken(SwiftMtParser_MT565Parser::START_OF_FIELD, i);
}
size_t SwiftMtParser_MT565Parser::Fld_23G_A_GContext::getRuleIndex() const {
return SwiftMtParser_MT565Parser::RuleFld_23G_A_G;
}
void SwiftMtParser_MT565Parser::Fld_23G_A_GContext::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->enterFld_23G_A_G(this);
}
void SwiftMtParser_MT565Parser::Fld_23G_A_GContext::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->exitFld_23G_A_G(this);
}
SwiftMtParser_MT565Parser::Fld_23G_A_GContext* SwiftMtParser_MT565Parser::fld_23G_A_G() {
Fld_23G_A_GContext *_localctx = _tracker.createInstance<Fld_23G_A_GContext>(_ctx, getState());
enterRule(_localctx, 146, SwiftMtParser_MT565Parser::RuleFld_23G_A_G);
_localctx->fld.set_tag("23G");
size_t _la = 0;
auto onExit = finally([=] {
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(885);
match(SwiftMtParser_MT565Parser::START_OF_FIELD);
setState(886);
match(SwiftMtParser_MT565Parser::T__3);
setState(888);
_errHandler->sync(this);
_la = _input->LA(1);
do {
setState(887);
_la = _input->LA(1);
if (_la == 0 || _la == Token::EOF || (_la == SwiftMtParser_MT565Parser::START_OF_FIELD)) {
_errHandler->recoverInline(this);
}
else {
_errHandler->reportMatch(this);
consume();
}
setState(890);
_errHandler->sync(this);
_la = _input->LA(1);
} while ((((_la & ~ 0x3fULL) == 0) &&
((1ULL << _la) & ((1ULL << SwiftMtParser_MT565Parser::T__0)
| (1ULL << SwiftMtParser_MT565Parser::T__1)
| (1ULL << SwiftMtParser_MT565Parser::T__2)
| (1ULL << SwiftMtParser_MT565Parser::T__3)
| (1ULL << SwiftMtParser_MT565Parser::T__4)
| (1ULL << SwiftMtParser_MT565Parser::T__5)
| (1ULL << SwiftMtParser_MT565Parser::T__6)
| (1ULL << SwiftMtParser_MT565Parser::T__7)
| (1ULL << SwiftMtParser_MT565Parser::T__8)
| (1ULL << SwiftMtParser_MT565Parser::T__9)
| (1ULL << SwiftMtParser_MT565Parser::T__10)
| (1ULL << SwiftMtParser_MT565Parser::T__11)
| (1ULL << SwiftMtParser_MT565Parser::T__12)
| (1ULL << SwiftMtParser_MT565Parser::T__13)
| (1ULL << SwiftMtParser_MT565Parser::T__14)
| (1ULL << SwiftMtParser_MT565Parser::T__15)
| (1ULL << SwiftMtParser_MT565Parser::T__16)
| (1ULL << SwiftMtParser_MT565Parser::T__17)
| (1ULL << SwiftMtParser_MT565Parser::T__18)
| (1ULL << SwiftMtParser_MT565Parser::T__19)
| (1ULL << SwiftMtParser_MT565Parser::T__20)
| (1ULL << SwiftMtParser_MT565Parser::T__21)
| (1ULL << SwiftMtParser_MT565Parser::T__22)
| (1ULL << SwiftMtParser_MT565Parser::T__23)
| (1ULL << SwiftMtParser_MT565Parser::T__24)
| (1ULL << SwiftMtParser_MT565Parser::T__25)
| (1ULL << SwiftMtParser_MT565Parser::T__26)
| (1ULL << SwiftMtParser_MT565Parser::T__27)
| (1ULL << SwiftMtParser_MT565Parser::T__28)
| (1ULL << SwiftMtParser_MT565Parser::T__29)
| (1ULL << SwiftMtParser_MT565Parser::T__30)
| (1ULL << SwiftMtParser_MT565Parser::T__31)
| (1ULL << SwiftMtParser_MT565Parser::T__32)
| (1ULL << SwiftMtParser_MT565Parser::T__33)
| (1ULL << SwiftMtParser_MT565Parser::T__34)
| (1ULL << SwiftMtParser_MT565Parser::T__35)
| (1ULL << SwiftMtParser_MT565Parser::T__36)
| (1ULL << SwiftMtParser_MT565Parser::T__37)
| (1ULL << SwiftMtParser_MT565Parser::TAG_BH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_AH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_UH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_MT)
| (1ULL << SwiftMtParser_MT565Parser::TAG_TR)
| (1ULL << SwiftMtParser_MT565Parser::MT_END)
| (1ULL << SwiftMtParser_MT565Parser::LBRACE)
| (1ULL << SwiftMtParser_MT565Parser::RBRACE)
| (1ULL << SwiftMtParser_MT565Parser::COLON)
| (1ULL << SwiftMtParser_MT565Parser::ANY))) != 0));
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- Fld_22F_A_FContext ------------------------------------------------------------------
SwiftMtParser_MT565Parser::Fld_22F_A_FContext::Fld_22F_A_FContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
std::vector<tree::TerminalNode *> SwiftMtParser_MT565Parser::Fld_22F_A_FContext::START_OF_FIELD() {
return getTokens(SwiftMtParser_MT565Parser::START_OF_FIELD);
}
tree::TerminalNode* SwiftMtParser_MT565Parser::Fld_22F_A_FContext::START_OF_FIELD(size_t i) {
return getToken(SwiftMtParser_MT565Parser::START_OF_FIELD, i);
}
size_t SwiftMtParser_MT565Parser::Fld_22F_A_FContext::getRuleIndex() const {
return SwiftMtParser_MT565Parser::RuleFld_22F_A_F;
}
void SwiftMtParser_MT565Parser::Fld_22F_A_FContext::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->enterFld_22F_A_F(this);
}
void SwiftMtParser_MT565Parser::Fld_22F_A_FContext::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->exitFld_22F_A_F(this);
}
SwiftMtParser_MT565Parser::Fld_22F_A_FContext* SwiftMtParser_MT565Parser::fld_22F_A_F() {
Fld_22F_A_FContext *_localctx = _tracker.createInstance<Fld_22F_A_FContext>(_ctx, getState());
enterRule(_localctx, 148, SwiftMtParser_MT565Parser::RuleFld_22F_A_F);
_localctx->fld.set_tag("22F");
size_t _la = 0;
auto onExit = finally([=] {
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(892);
match(SwiftMtParser_MT565Parser::START_OF_FIELD);
setState(893);
match(SwiftMtParser_MT565Parser::T__4);
setState(895);
_errHandler->sync(this);
_la = _input->LA(1);
do {
setState(894);
_la = _input->LA(1);
if (_la == 0 || _la == Token::EOF || (_la == SwiftMtParser_MT565Parser::START_OF_FIELD)) {
_errHandler->recoverInline(this);
}
else {
_errHandler->reportMatch(this);
consume();
}
setState(897);
_errHandler->sync(this);
_la = _input->LA(1);
} while ((((_la & ~ 0x3fULL) == 0) &&
((1ULL << _la) & ((1ULL << SwiftMtParser_MT565Parser::T__0)
| (1ULL << SwiftMtParser_MT565Parser::T__1)
| (1ULL << SwiftMtParser_MT565Parser::T__2)
| (1ULL << SwiftMtParser_MT565Parser::T__3)
| (1ULL << SwiftMtParser_MT565Parser::T__4)
| (1ULL << SwiftMtParser_MT565Parser::T__5)
| (1ULL << SwiftMtParser_MT565Parser::T__6)
| (1ULL << SwiftMtParser_MT565Parser::T__7)
| (1ULL << SwiftMtParser_MT565Parser::T__8)
| (1ULL << SwiftMtParser_MT565Parser::T__9)
| (1ULL << SwiftMtParser_MT565Parser::T__10)
| (1ULL << SwiftMtParser_MT565Parser::T__11)
| (1ULL << SwiftMtParser_MT565Parser::T__12)
| (1ULL << SwiftMtParser_MT565Parser::T__13)
| (1ULL << SwiftMtParser_MT565Parser::T__14)
| (1ULL << SwiftMtParser_MT565Parser::T__15)
| (1ULL << SwiftMtParser_MT565Parser::T__16)
| (1ULL << SwiftMtParser_MT565Parser::T__17)
| (1ULL << SwiftMtParser_MT565Parser::T__18)
| (1ULL << SwiftMtParser_MT565Parser::T__19)
| (1ULL << SwiftMtParser_MT565Parser::T__20)
| (1ULL << SwiftMtParser_MT565Parser::T__21)
| (1ULL << SwiftMtParser_MT565Parser::T__22)
| (1ULL << SwiftMtParser_MT565Parser::T__23)
| (1ULL << SwiftMtParser_MT565Parser::T__24)
| (1ULL << SwiftMtParser_MT565Parser::T__25)
| (1ULL << SwiftMtParser_MT565Parser::T__26)
| (1ULL << SwiftMtParser_MT565Parser::T__27)
| (1ULL << SwiftMtParser_MT565Parser::T__28)
| (1ULL << SwiftMtParser_MT565Parser::T__29)
| (1ULL << SwiftMtParser_MT565Parser::T__30)
| (1ULL << SwiftMtParser_MT565Parser::T__31)
| (1ULL << SwiftMtParser_MT565Parser::T__32)
| (1ULL << SwiftMtParser_MT565Parser::T__33)
| (1ULL << SwiftMtParser_MT565Parser::T__34)
| (1ULL << SwiftMtParser_MT565Parser::T__35)
| (1ULL << SwiftMtParser_MT565Parser::T__36)
| (1ULL << SwiftMtParser_MT565Parser::T__37)
| (1ULL << SwiftMtParser_MT565Parser::TAG_BH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_AH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_UH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_MT)
| (1ULL << SwiftMtParser_MT565Parser::TAG_TR)
| (1ULL << SwiftMtParser_MT565Parser::MT_END)
| (1ULL << SwiftMtParser_MT565Parser::LBRACE)
| (1ULL << SwiftMtParser_MT565Parser::RBRACE)
| (1ULL << SwiftMtParser_MT565Parser::COLON)
| (1ULL << SwiftMtParser_MT565Parser::ANY))) != 0));
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- Fld_98a_A_AContext ------------------------------------------------------------------
SwiftMtParser_MT565Parser::Fld_98a_A_AContext::Fld_98a_A_AContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
std::vector<tree::TerminalNode *> SwiftMtParser_MT565Parser::Fld_98a_A_AContext::START_OF_FIELD() {
return getTokens(SwiftMtParser_MT565Parser::START_OF_FIELD);
}
tree::TerminalNode* SwiftMtParser_MT565Parser::Fld_98a_A_AContext::START_OF_FIELD(size_t i) {
return getToken(SwiftMtParser_MT565Parser::START_OF_FIELD, i);
}
size_t SwiftMtParser_MT565Parser::Fld_98a_A_AContext::getRuleIndex() const {
return SwiftMtParser_MT565Parser::RuleFld_98a_A_A;
}
void SwiftMtParser_MT565Parser::Fld_98a_A_AContext::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->enterFld_98a_A_A(this);
}
void SwiftMtParser_MT565Parser::Fld_98a_A_AContext::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->exitFld_98a_A_A(this);
}
SwiftMtParser_MT565Parser::Fld_98a_A_AContext* SwiftMtParser_MT565Parser::fld_98a_A_A() {
Fld_98a_A_AContext *_localctx = _tracker.createInstance<Fld_98a_A_AContext>(_ctx, getState());
enterRule(_localctx, 150, SwiftMtParser_MT565Parser::RuleFld_98a_A_A);
_localctx->fld.set_tag("98A");
size_t _la = 0;
auto onExit = finally([=] {
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(899);
match(SwiftMtParser_MT565Parser::START_OF_FIELD);
setState(900);
match(SwiftMtParser_MT565Parser::T__5);
setState(902);
_errHandler->sync(this);
_la = _input->LA(1);
do {
setState(901);
_la = _input->LA(1);
if (_la == 0 || _la == Token::EOF || (_la == SwiftMtParser_MT565Parser::START_OF_FIELD)) {
_errHandler->recoverInline(this);
}
else {
_errHandler->reportMatch(this);
consume();
}
setState(904);
_errHandler->sync(this);
_la = _input->LA(1);
} while ((((_la & ~ 0x3fULL) == 0) &&
((1ULL << _la) & ((1ULL << SwiftMtParser_MT565Parser::T__0)
| (1ULL << SwiftMtParser_MT565Parser::T__1)
| (1ULL << SwiftMtParser_MT565Parser::T__2)
| (1ULL << SwiftMtParser_MT565Parser::T__3)
| (1ULL << SwiftMtParser_MT565Parser::T__4)
| (1ULL << SwiftMtParser_MT565Parser::T__5)
| (1ULL << SwiftMtParser_MT565Parser::T__6)
| (1ULL << SwiftMtParser_MT565Parser::T__7)
| (1ULL << SwiftMtParser_MT565Parser::T__8)
| (1ULL << SwiftMtParser_MT565Parser::T__9)
| (1ULL << SwiftMtParser_MT565Parser::T__10)
| (1ULL << SwiftMtParser_MT565Parser::T__11)
| (1ULL << SwiftMtParser_MT565Parser::T__12)
| (1ULL << SwiftMtParser_MT565Parser::T__13)
| (1ULL << SwiftMtParser_MT565Parser::T__14)
| (1ULL << SwiftMtParser_MT565Parser::T__15)
| (1ULL << SwiftMtParser_MT565Parser::T__16)
| (1ULL << SwiftMtParser_MT565Parser::T__17)
| (1ULL << SwiftMtParser_MT565Parser::T__18)
| (1ULL << SwiftMtParser_MT565Parser::T__19)
| (1ULL << SwiftMtParser_MT565Parser::T__20)
| (1ULL << SwiftMtParser_MT565Parser::T__21)
| (1ULL << SwiftMtParser_MT565Parser::T__22)
| (1ULL << SwiftMtParser_MT565Parser::T__23)
| (1ULL << SwiftMtParser_MT565Parser::T__24)
| (1ULL << SwiftMtParser_MT565Parser::T__25)
| (1ULL << SwiftMtParser_MT565Parser::T__26)
| (1ULL << SwiftMtParser_MT565Parser::T__27)
| (1ULL << SwiftMtParser_MT565Parser::T__28)
| (1ULL << SwiftMtParser_MT565Parser::T__29)
| (1ULL << SwiftMtParser_MT565Parser::T__30)
| (1ULL << SwiftMtParser_MT565Parser::T__31)
| (1ULL << SwiftMtParser_MT565Parser::T__32)
| (1ULL << SwiftMtParser_MT565Parser::T__33)
| (1ULL << SwiftMtParser_MT565Parser::T__34)
| (1ULL << SwiftMtParser_MT565Parser::T__35)
| (1ULL << SwiftMtParser_MT565Parser::T__36)
| (1ULL << SwiftMtParser_MT565Parser::T__37)
| (1ULL << SwiftMtParser_MT565Parser::TAG_BH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_AH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_UH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_MT)
| (1ULL << SwiftMtParser_MT565Parser::TAG_TR)
| (1ULL << SwiftMtParser_MT565Parser::MT_END)
| (1ULL << SwiftMtParser_MT565Parser::LBRACE)
| (1ULL << SwiftMtParser_MT565Parser::RBRACE)
| (1ULL << SwiftMtParser_MT565Parser::COLON)
| (1ULL << SwiftMtParser_MT565Parser::ANY))) != 0));
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- Fld_98a_A_CContext ------------------------------------------------------------------
SwiftMtParser_MT565Parser::Fld_98a_A_CContext::Fld_98a_A_CContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
std::vector<tree::TerminalNode *> SwiftMtParser_MT565Parser::Fld_98a_A_CContext::START_OF_FIELD() {
return getTokens(SwiftMtParser_MT565Parser::START_OF_FIELD);
}
tree::TerminalNode* SwiftMtParser_MT565Parser::Fld_98a_A_CContext::START_OF_FIELD(size_t i) {
return getToken(SwiftMtParser_MT565Parser::START_OF_FIELD, i);
}
size_t SwiftMtParser_MT565Parser::Fld_98a_A_CContext::getRuleIndex() const {
return SwiftMtParser_MT565Parser::RuleFld_98a_A_C;
}
void SwiftMtParser_MT565Parser::Fld_98a_A_CContext::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->enterFld_98a_A_C(this);
}
void SwiftMtParser_MT565Parser::Fld_98a_A_CContext::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->exitFld_98a_A_C(this);
}
SwiftMtParser_MT565Parser::Fld_98a_A_CContext* SwiftMtParser_MT565Parser::fld_98a_A_C() {
Fld_98a_A_CContext *_localctx = _tracker.createInstance<Fld_98a_A_CContext>(_ctx, getState());
enterRule(_localctx, 152, SwiftMtParser_MT565Parser::RuleFld_98a_A_C);
_localctx->fld.set_tag("98C");
size_t _la = 0;
auto onExit = finally([=] {
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(906);
match(SwiftMtParser_MT565Parser::START_OF_FIELD);
setState(907);
match(SwiftMtParser_MT565Parser::T__6);
setState(909);
_errHandler->sync(this);
_la = _input->LA(1);
do {
setState(908);
_la = _input->LA(1);
if (_la == 0 || _la == Token::EOF || (_la == SwiftMtParser_MT565Parser::START_OF_FIELD)) {
_errHandler->recoverInline(this);
}
else {
_errHandler->reportMatch(this);
consume();
}
setState(911);
_errHandler->sync(this);
_la = _input->LA(1);
} while ((((_la & ~ 0x3fULL) == 0) &&
((1ULL << _la) & ((1ULL << SwiftMtParser_MT565Parser::T__0)
| (1ULL << SwiftMtParser_MT565Parser::T__1)
| (1ULL << SwiftMtParser_MT565Parser::T__2)
| (1ULL << SwiftMtParser_MT565Parser::T__3)
| (1ULL << SwiftMtParser_MT565Parser::T__4)
| (1ULL << SwiftMtParser_MT565Parser::T__5)
| (1ULL << SwiftMtParser_MT565Parser::T__6)
| (1ULL << SwiftMtParser_MT565Parser::T__7)
| (1ULL << SwiftMtParser_MT565Parser::T__8)
| (1ULL << SwiftMtParser_MT565Parser::T__9)
| (1ULL << SwiftMtParser_MT565Parser::T__10)
| (1ULL << SwiftMtParser_MT565Parser::T__11)
| (1ULL << SwiftMtParser_MT565Parser::T__12)
| (1ULL << SwiftMtParser_MT565Parser::T__13)
| (1ULL << SwiftMtParser_MT565Parser::T__14)
| (1ULL << SwiftMtParser_MT565Parser::T__15)
| (1ULL << SwiftMtParser_MT565Parser::T__16)
| (1ULL << SwiftMtParser_MT565Parser::T__17)
| (1ULL << SwiftMtParser_MT565Parser::T__18)
| (1ULL << SwiftMtParser_MT565Parser::T__19)
| (1ULL << SwiftMtParser_MT565Parser::T__20)
| (1ULL << SwiftMtParser_MT565Parser::T__21)
| (1ULL << SwiftMtParser_MT565Parser::T__22)
| (1ULL << SwiftMtParser_MT565Parser::T__23)
| (1ULL << SwiftMtParser_MT565Parser::T__24)
| (1ULL << SwiftMtParser_MT565Parser::T__25)
| (1ULL << SwiftMtParser_MT565Parser::T__26)
| (1ULL << SwiftMtParser_MT565Parser::T__27)
| (1ULL << SwiftMtParser_MT565Parser::T__28)
| (1ULL << SwiftMtParser_MT565Parser::T__29)
| (1ULL << SwiftMtParser_MT565Parser::T__30)
| (1ULL << SwiftMtParser_MT565Parser::T__31)
| (1ULL << SwiftMtParser_MT565Parser::T__32)
| (1ULL << SwiftMtParser_MT565Parser::T__33)
| (1ULL << SwiftMtParser_MT565Parser::T__34)
| (1ULL << SwiftMtParser_MT565Parser::T__35)
| (1ULL << SwiftMtParser_MT565Parser::T__36)
| (1ULL << SwiftMtParser_MT565Parser::T__37)
| (1ULL << SwiftMtParser_MT565Parser::TAG_BH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_AH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_UH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_MT)
| (1ULL << SwiftMtParser_MT565Parser::TAG_TR)
| (1ULL << SwiftMtParser_MT565Parser::MT_END)
| (1ULL << SwiftMtParser_MT565Parser::LBRACE)
| (1ULL << SwiftMtParser_MT565Parser::RBRACE)
| (1ULL << SwiftMtParser_MT565Parser::COLON)
| (1ULL << SwiftMtParser_MT565Parser::ANY))) != 0));
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- Fld_22F_A1_FContext ------------------------------------------------------------------
SwiftMtParser_MT565Parser::Fld_22F_A1_FContext::Fld_22F_A1_FContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
std::vector<tree::TerminalNode *> SwiftMtParser_MT565Parser::Fld_22F_A1_FContext::START_OF_FIELD() {
return getTokens(SwiftMtParser_MT565Parser::START_OF_FIELD);
}
tree::TerminalNode* SwiftMtParser_MT565Parser::Fld_22F_A1_FContext::START_OF_FIELD(size_t i) {
return getToken(SwiftMtParser_MT565Parser::START_OF_FIELD, i);
}
size_t SwiftMtParser_MT565Parser::Fld_22F_A1_FContext::getRuleIndex() const {
return SwiftMtParser_MT565Parser::RuleFld_22F_A1_F;
}
void SwiftMtParser_MT565Parser::Fld_22F_A1_FContext::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->enterFld_22F_A1_F(this);
}
void SwiftMtParser_MT565Parser::Fld_22F_A1_FContext::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->exitFld_22F_A1_F(this);
}
SwiftMtParser_MT565Parser::Fld_22F_A1_FContext* SwiftMtParser_MT565Parser::fld_22F_A1_F() {
Fld_22F_A1_FContext *_localctx = _tracker.createInstance<Fld_22F_A1_FContext>(_ctx, getState());
enterRule(_localctx, 154, SwiftMtParser_MT565Parser::RuleFld_22F_A1_F);
_localctx->fld.set_tag("22F");
size_t _la = 0;
auto onExit = finally([=] {
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(913);
match(SwiftMtParser_MT565Parser::START_OF_FIELD);
setState(914);
match(SwiftMtParser_MT565Parser::T__4);
setState(916);
_errHandler->sync(this);
_la = _input->LA(1);
do {
setState(915);
_la = _input->LA(1);
if (_la == 0 || _la == Token::EOF || (_la == SwiftMtParser_MT565Parser::START_OF_FIELD)) {
_errHandler->recoverInline(this);
}
else {
_errHandler->reportMatch(this);
consume();
}
setState(918);
_errHandler->sync(this);
_la = _input->LA(1);
} while ((((_la & ~ 0x3fULL) == 0) &&
((1ULL << _la) & ((1ULL << SwiftMtParser_MT565Parser::T__0)
| (1ULL << SwiftMtParser_MT565Parser::T__1)
| (1ULL << SwiftMtParser_MT565Parser::T__2)
| (1ULL << SwiftMtParser_MT565Parser::T__3)
| (1ULL << SwiftMtParser_MT565Parser::T__4)
| (1ULL << SwiftMtParser_MT565Parser::T__5)
| (1ULL << SwiftMtParser_MT565Parser::T__6)
| (1ULL << SwiftMtParser_MT565Parser::T__7)
| (1ULL << SwiftMtParser_MT565Parser::T__8)
| (1ULL << SwiftMtParser_MT565Parser::T__9)
| (1ULL << SwiftMtParser_MT565Parser::T__10)
| (1ULL << SwiftMtParser_MT565Parser::T__11)
| (1ULL << SwiftMtParser_MT565Parser::T__12)
| (1ULL << SwiftMtParser_MT565Parser::T__13)
| (1ULL << SwiftMtParser_MT565Parser::T__14)
| (1ULL << SwiftMtParser_MT565Parser::T__15)
| (1ULL << SwiftMtParser_MT565Parser::T__16)
| (1ULL << SwiftMtParser_MT565Parser::T__17)
| (1ULL << SwiftMtParser_MT565Parser::T__18)
| (1ULL << SwiftMtParser_MT565Parser::T__19)
| (1ULL << SwiftMtParser_MT565Parser::T__20)
| (1ULL << SwiftMtParser_MT565Parser::T__21)
| (1ULL << SwiftMtParser_MT565Parser::T__22)
| (1ULL << SwiftMtParser_MT565Parser::T__23)
| (1ULL << SwiftMtParser_MT565Parser::T__24)
| (1ULL << SwiftMtParser_MT565Parser::T__25)
| (1ULL << SwiftMtParser_MT565Parser::T__26)
| (1ULL << SwiftMtParser_MT565Parser::T__27)
| (1ULL << SwiftMtParser_MT565Parser::T__28)
| (1ULL << SwiftMtParser_MT565Parser::T__29)
| (1ULL << SwiftMtParser_MT565Parser::T__30)
| (1ULL << SwiftMtParser_MT565Parser::T__31)
| (1ULL << SwiftMtParser_MT565Parser::T__32)
| (1ULL << SwiftMtParser_MT565Parser::T__33)
| (1ULL << SwiftMtParser_MT565Parser::T__34)
| (1ULL << SwiftMtParser_MT565Parser::T__35)
| (1ULL << SwiftMtParser_MT565Parser::T__36)
| (1ULL << SwiftMtParser_MT565Parser::T__37)
| (1ULL << SwiftMtParser_MT565Parser::TAG_BH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_AH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_UH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_MT)
| (1ULL << SwiftMtParser_MT565Parser::TAG_TR)
| (1ULL << SwiftMtParser_MT565Parser::MT_END)
| (1ULL << SwiftMtParser_MT565Parser::LBRACE)
| (1ULL << SwiftMtParser_MT565Parser::RBRACE)
| (1ULL << SwiftMtParser_MT565Parser::COLON)
| (1ULL << SwiftMtParser_MT565Parser::ANY))) != 0));
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- Fld_13a_A1_AContext ------------------------------------------------------------------
SwiftMtParser_MT565Parser::Fld_13a_A1_AContext::Fld_13a_A1_AContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
std::vector<tree::TerminalNode *> SwiftMtParser_MT565Parser::Fld_13a_A1_AContext::START_OF_FIELD() {
return getTokens(SwiftMtParser_MT565Parser::START_OF_FIELD);
}
tree::TerminalNode* SwiftMtParser_MT565Parser::Fld_13a_A1_AContext::START_OF_FIELD(size_t i) {
return getToken(SwiftMtParser_MT565Parser::START_OF_FIELD, i);
}
size_t SwiftMtParser_MT565Parser::Fld_13a_A1_AContext::getRuleIndex() const {
return SwiftMtParser_MT565Parser::RuleFld_13a_A1_A;
}
void SwiftMtParser_MT565Parser::Fld_13a_A1_AContext::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->enterFld_13a_A1_A(this);
}
void SwiftMtParser_MT565Parser::Fld_13a_A1_AContext::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->exitFld_13a_A1_A(this);
}
SwiftMtParser_MT565Parser::Fld_13a_A1_AContext* SwiftMtParser_MT565Parser::fld_13a_A1_A() {
Fld_13a_A1_AContext *_localctx = _tracker.createInstance<Fld_13a_A1_AContext>(_ctx, getState());
enterRule(_localctx, 156, SwiftMtParser_MT565Parser::RuleFld_13a_A1_A);
_localctx->fld.set_tag("13A");
size_t _la = 0;
auto onExit = finally([=] {
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(920);
match(SwiftMtParser_MT565Parser::START_OF_FIELD);
setState(921);
match(SwiftMtParser_MT565Parser::T__7);
setState(923);
_errHandler->sync(this);
_la = _input->LA(1);
do {
setState(922);
_la = _input->LA(1);
if (_la == 0 || _la == Token::EOF || (_la == SwiftMtParser_MT565Parser::START_OF_FIELD)) {
_errHandler->recoverInline(this);
}
else {
_errHandler->reportMatch(this);
consume();
}
setState(925);
_errHandler->sync(this);
_la = _input->LA(1);
} while ((((_la & ~ 0x3fULL) == 0) &&
((1ULL << _la) & ((1ULL << SwiftMtParser_MT565Parser::T__0)
| (1ULL << SwiftMtParser_MT565Parser::T__1)
| (1ULL << SwiftMtParser_MT565Parser::T__2)
| (1ULL << SwiftMtParser_MT565Parser::T__3)
| (1ULL << SwiftMtParser_MT565Parser::T__4)
| (1ULL << SwiftMtParser_MT565Parser::T__5)
| (1ULL << SwiftMtParser_MT565Parser::T__6)
| (1ULL << SwiftMtParser_MT565Parser::T__7)
| (1ULL << SwiftMtParser_MT565Parser::T__8)
| (1ULL << SwiftMtParser_MT565Parser::T__9)
| (1ULL << SwiftMtParser_MT565Parser::T__10)
| (1ULL << SwiftMtParser_MT565Parser::T__11)
| (1ULL << SwiftMtParser_MT565Parser::T__12)
| (1ULL << SwiftMtParser_MT565Parser::T__13)
| (1ULL << SwiftMtParser_MT565Parser::T__14)
| (1ULL << SwiftMtParser_MT565Parser::T__15)
| (1ULL << SwiftMtParser_MT565Parser::T__16)
| (1ULL << SwiftMtParser_MT565Parser::T__17)
| (1ULL << SwiftMtParser_MT565Parser::T__18)
| (1ULL << SwiftMtParser_MT565Parser::T__19)
| (1ULL << SwiftMtParser_MT565Parser::T__20)
| (1ULL << SwiftMtParser_MT565Parser::T__21)
| (1ULL << SwiftMtParser_MT565Parser::T__22)
| (1ULL << SwiftMtParser_MT565Parser::T__23)
| (1ULL << SwiftMtParser_MT565Parser::T__24)
| (1ULL << SwiftMtParser_MT565Parser::T__25)
| (1ULL << SwiftMtParser_MT565Parser::T__26)
| (1ULL << SwiftMtParser_MT565Parser::T__27)
| (1ULL << SwiftMtParser_MT565Parser::T__28)
| (1ULL << SwiftMtParser_MT565Parser::T__29)
| (1ULL << SwiftMtParser_MT565Parser::T__30)
| (1ULL << SwiftMtParser_MT565Parser::T__31)
| (1ULL << SwiftMtParser_MT565Parser::T__32)
| (1ULL << SwiftMtParser_MT565Parser::T__33)
| (1ULL << SwiftMtParser_MT565Parser::T__34)
| (1ULL << SwiftMtParser_MT565Parser::T__35)
| (1ULL << SwiftMtParser_MT565Parser::T__36)
| (1ULL << SwiftMtParser_MT565Parser::T__37)
| (1ULL << SwiftMtParser_MT565Parser::TAG_BH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_AH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_UH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_MT)
| (1ULL << SwiftMtParser_MT565Parser::TAG_TR)
| (1ULL << SwiftMtParser_MT565Parser::MT_END)
| (1ULL << SwiftMtParser_MT565Parser::LBRACE)
| (1ULL << SwiftMtParser_MT565Parser::RBRACE)
| (1ULL << SwiftMtParser_MT565Parser::COLON)
| (1ULL << SwiftMtParser_MT565Parser::ANY))) != 0));
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- Fld_13a_A1_BContext ------------------------------------------------------------------
SwiftMtParser_MT565Parser::Fld_13a_A1_BContext::Fld_13a_A1_BContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
std::vector<tree::TerminalNode *> SwiftMtParser_MT565Parser::Fld_13a_A1_BContext::START_OF_FIELD() {
return getTokens(SwiftMtParser_MT565Parser::START_OF_FIELD);
}
tree::TerminalNode* SwiftMtParser_MT565Parser::Fld_13a_A1_BContext::START_OF_FIELD(size_t i) {
return getToken(SwiftMtParser_MT565Parser::START_OF_FIELD, i);
}
size_t SwiftMtParser_MT565Parser::Fld_13a_A1_BContext::getRuleIndex() const {
return SwiftMtParser_MT565Parser::RuleFld_13a_A1_B;
}
void SwiftMtParser_MT565Parser::Fld_13a_A1_BContext::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->enterFld_13a_A1_B(this);
}
void SwiftMtParser_MT565Parser::Fld_13a_A1_BContext::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->exitFld_13a_A1_B(this);
}
SwiftMtParser_MT565Parser::Fld_13a_A1_BContext* SwiftMtParser_MT565Parser::fld_13a_A1_B() {
Fld_13a_A1_BContext *_localctx = _tracker.createInstance<Fld_13a_A1_BContext>(_ctx, getState());
enterRule(_localctx, 158, SwiftMtParser_MT565Parser::RuleFld_13a_A1_B);
_localctx->fld.set_tag("13B");
size_t _la = 0;
auto onExit = finally([=] {
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(927);
match(SwiftMtParser_MT565Parser::START_OF_FIELD);
setState(928);
match(SwiftMtParser_MT565Parser::T__8);
setState(930);
_errHandler->sync(this);
_la = _input->LA(1);
do {
setState(929);
_la = _input->LA(1);
if (_la == 0 || _la == Token::EOF || (_la == SwiftMtParser_MT565Parser::START_OF_FIELD)) {
_errHandler->recoverInline(this);
}
else {
_errHandler->reportMatch(this);
consume();
}
setState(932);
_errHandler->sync(this);
_la = _input->LA(1);
} while ((((_la & ~ 0x3fULL) == 0) &&
((1ULL << _la) & ((1ULL << SwiftMtParser_MT565Parser::T__0)
| (1ULL << SwiftMtParser_MT565Parser::T__1)
| (1ULL << SwiftMtParser_MT565Parser::T__2)
| (1ULL << SwiftMtParser_MT565Parser::T__3)
| (1ULL << SwiftMtParser_MT565Parser::T__4)
| (1ULL << SwiftMtParser_MT565Parser::T__5)
| (1ULL << SwiftMtParser_MT565Parser::T__6)
| (1ULL << SwiftMtParser_MT565Parser::T__7)
| (1ULL << SwiftMtParser_MT565Parser::T__8)
| (1ULL << SwiftMtParser_MT565Parser::T__9)
| (1ULL << SwiftMtParser_MT565Parser::T__10)
| (1ULL << SwiftMtParser_MT565Parser::T__11)
| (1ULL << SwiftMtParser_MT565Parser::T__12)
| (1ULL << SwiftMtParser_MT565Parser::T__13)
| (1ULL << SwiftMtParser_MT565Parser::T__14)
| (1ULL << SwiftMtParser_MT565Parser::T__15)
| (1ULL << SwiftMtParser_MT565Parser::T__16)
| (1ULL << SwiftMtParser_MT565Parser::T__17)
| (1ULL << SwiftMtParser_MT565Parser::T__18)
| (1ULL << SwiftMtParser_MT565Parser::T__19)
| (1ULL << SwiftMtParser_MT565Parser::T__20)
| (1ULL << SwiftMtParser_MT565Parser::T__21)
| (1ULL << SwiftMtParser_MT565Parser::T__22)
| (1ULL << SwiftMtParser_MT565Parser::T__23)
| (1ULL << SwiftMtParser_MT565Parser::T__24)
| (1ULL << SwiftMtParser_MT565Parser::T__25)
| (1ULL << SwiftMtParser_MT565Parser::T__26)
| (1ULL << SwiftMtParser_MT565Parser::T__27)
| (1ULL << SwiftMtParser_MT565Parser::T__28)
| (1ULL << SwiftMtParser_MT565Parser::T__29)
| (1ULL << SwiftMtParser_MT565Parser::T__30)
| (1ULL << SwiftMtParser_MT565Parser::T__31)
| (1ULL << SwiftMtParser_MT565Parser::T__32)
| (1ULL << SwiftMtParser_MT565Parser::T__33)
| (1ULL << SwiftMtParser_MT565Parser::T__34)
| (1ULL << SwiftMtParser_MT565Parser::T__35)
| (1ULL << SwiftMtParser_MT565Parser::T__36)
| (1ULL << SwiftMtParser_MT565Parser::T__37)
| (1ULL << SwiftMtParser_MT565Parser::TAG_BH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_AH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_UH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_MT)
| (1ULL << SwiftMtParser_MT565Parser::TAG_TR)
| (1ULL << SwiftMtParser_MT565Parser::MT_END)
| (1ULL << SwiftMtParser_MT565Parser::LBRACE)
| (1ULL << SwiftMtParser_MT565Parser::RBRACE)
| (1ULL << SwiftMtParser_MT565Parser::COLON)
| (1ULL << SwiftMtParser_MT565Parser::ANY))) != 0));
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- Fld_20C_A1_CContext ------------------------------------------------------------------
SwiftMtParser_MT565Parser::Fld_20C_A1_CContext::Fld_20C_A1_CContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
std::vector<tree::TerminalNode *> SwiftMtParser_MT565Parser::Fld_20C_A1_CContext::START_OF_FIELD() {
return getTokens(SwiftMtParser_MT565Parser::START_OF_FIELD);
}
tree::TerminalNode* SwiftMtParser_MT565Parser::Fld_20C_A1_CContext::START_OF_FIELD(size_t i) {
return getToken(SwiftMtParser_MT565Parser::START_OF_FIELD, i);
}
size_t SwiftMtParser_MT565Parser::Fld_20C_A1_CContext::getRuleIndex() const {
return SwiftMtParser_MT565Parser::RuleFld_20C_A1_C;
}
void SwiftMtParser_MT565Parser::Fld_20C_A1_CContext::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->enterFld_20C_A1_C(this);
}
void SwiftMtParser_MT565Parser::Fld_20C_A1_CContext::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->exitFld_20C_A1_C(this);
}
SwiftMtParser_MT565Parser::Fld_20C_A1_CContext* SwiftMtParser_MT565Parser::fld_20C_A1_C() {
Fld_20C_A1_CContext *_localctx = _tracker.createInstance<Fld_20C_A1_CContext>(_ctx, getState());
enterRule(_localctx, 160, SwiftMtParser_MT565Parser::RuleFld_20C_A1_C);
_localctx->fld.set_tag("20C");
size_t _la = 0;
auto onExit = finally([=] {
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(934);
match(SwiftMtParser_MT565Parser::START_OF_FIELD);
setState(935);
match(SwiftMtParser_MT565Parser::T__2);
setState(937);
_errHandler->sync(this);
_la = _input->LA(1);
do {
setState(936);
_la = _input->LA(1);
if (_la == 0 || _la == Token::EOF || (_la == SwiftMtParser_MT565Parser::START_OF_FIELD)) {
_errHandler->recoverInline(this);
}
else {
_errHandler->reportMatch(this);
consume();
}
setState(939);
_errHandler->sync(this);
_la = _input->LA(1);
} while ((((_la & ~ 0x3fULL) == 0) &&
((1ULL << _la) & ((1ULL << SwiftMtParser_MT565Parser::T__0)
| (1ULL << SwiftMtParser_MT565Parser::T__1)
| (1ULL << SwiftMtParser_MT565Parser::T__2)
| (1ULL << SwiftMtParser_MT565Parser::T__3)
| (1ULL << SwiftMtParser_MT565Parser::T__4)
| (1ULL << SwiftMtParser_MT565Parser::T__5)
| (1ULL << SwiftMtParser_MT565Parser::T__6)
| (1ULL << SwiftMtParser_MT565Parser::T__7)
| (1ULL << SwiftMtParser_MT565Parser::T__8)
| (1ULL << SwiftMtParser_MT565Parser::T__9)
| (1ULL << SwiftMtParser_MT565Parser::T__10)
| (1ULL << SwiftMtParser_MT565Parser::T__11)
| (1ULL << SwiftMtParser_MT565Parser::T__12)
| (1ULL << SwiftMtParser_MT565Parser::T__13)
| (1ULL << SwiftMtParser_MT565Parser::T__14)
| (1ULL << SwiftMtParser_MT565Parser::T__15)
| (1ULL << SwiftMtParser_MT565Parser::T__16)
| (1ULL << SwiftMtParser_MT565Parser::T__17)
| (1ULL << SwiftMtParser_MT565Parser::T__18)
| (1ULL << SwiftMtParser_MT565Parser::T__19)
| (1ULL << SwiftMtParser_MT565Parser::T__20)
| (1ULL << SwiftMtParser_MT565Parser::T__21)
| (1ULL << SwiftMtParser_MT565Parser::T__22)
| (1ULL << SwiftMtParser_MT565Parser::T__23)
| (1ULL << SwiftMtParser_MT565Parser::T__24)
| (1ULL << SwiftMtParser_MT565Parser::T__25)
| (1ULL << SwiftMtParser_MT565Parser::T__26)
| (1ULL << SwiftMtParser_MT565Parser::T__27)
| (1ULL << SwiftMtParser_MT565Parser::T__28)
| (1ULL << SwiftMtParser_MT565Parser::T__29)
| (1ULL << SwiftMtParser_MT565Parser::T__30)
| (1ULL << SwiftMtParser_MT565Parser::T__31)
| (1ULL << SwiftMtParser_MT565Parser::T__32)
| (1ULL << SwiftMtParser_MT565Parser::T__33)
| (1ULL << SwiftMtParser_MT565Parser::T__34)
| (1ULL << SwiftMtParser_MT565Parser::T__35)
| (1ULL << SwiftMtParser_MT565Parser::T__36)
| (1ULL << SwiftMtParser_MT565Parser::T__37)
| (1ULL << SwiftMtParser_MT565Parser::TAG_BH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_AH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_UH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_MT)
| (1ULL << SwiftMtParser_MT565Parser::TAG_TR)
| (1ULL << SwiftMtParser_MT565Parser::MT_END)
| (1ULL << SwiftMtParser_MT565Parser::LBRACE)
| (1ULL << SwiftMtParser_MT565Parser::RBRACE)
| (1ULL << SwiftMtParser_MT565Parser::COLON)
| (1ULL << SwiftMtParser_MT565Parser::ANY))) != 0));
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- Fld_35B_B_BContext ------------------------------------------------------------------
SwiftMtParser_MT565Parser::Fld_35B_B_BContext::Fld_35B_B_BContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
std::vector<tree::TerminalNode *> SwiftMtParser_MT565Parser::Fld_35B_B_BContext::START_OF_FIELD() {
return getTokens(SwiftMtParser_MT565Parser::START_OF_FIELD);
}
tree::TerminalNode* SwiftMtParser_MT565Parser::Fld_35B_B_BContext::START_OF_FIELD(size_t i) {
return getToken(SwiftMtParser_MT565Parser::START_OF_FIELD, i);
}
size_t SwiftMtParser_MT565Parser::Fld_35B_B_BContext::getRuleIndex() const {
return SwiftMtParser_MT565Parser::RuleFld_35B_B_B;
}
void SwiftMtParser_MT565Parser::Fld_35B_B_BContext::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->enterFld_35B_B_B(this);
}
void SwiftMtParser_MT565Parser::Fld_35B_B_BContext::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->exitFld_35B_B_B(this);
}
SwiftMtParser_MT565Parser::Fld_35B_B_BContext* SwiftMtParser_MT565Parser::fld_35B_B_B() {
Fld_35B_B_BContext *_localctx = _tracker.createInstance<Fld_35B_B_BContext>(_ctx, getState());
enterRule(_localctx, 162, SwiftMtParser_MT565Parser::RuleFld_35B_B_B);
_localctx->fld.set_tag("35B");
size_t _la = 0;
auto onExit = finally([=] {
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(941);
match(SwiftMtParser_MT565Parser::START_OF_FIELD);
setState(942);
match(SwiftMtParser_MT565Parser::T__9);
setState(944);
_errHandler->sync(this);
_la = _input->LA(1);
do {
setState(943);
_la = _input->LA(1);
if (_la == 0 || _la == Token::EOF || (_la == SwiftMtParser_MT565Parser::START_OF_FIELD)) {
_errHandler->recoverInline(this);
}
else {
_errHandler->reportMatch(this);
consume();
}
setState(946);
_errHandler->sync(this);
_la = _input->LA(1);
} while ((((_la & ~ 0x3fULL) == 0) &&
((1ULL << _la) & ((1ULL << SwiftMtParser_MT565Parser::T__0)
| (1ULL << SwiftMtParser_MT565Parser::T__1)
| (1ULL << SwiftMtParser_MT565Parser::T__2)
| (1ULL << SwiftMtParser_MT565Parser::T__3)
| (1ULL << SwiftMtParser_MT565Parser::T__4)
| (1ULL << SwiftMtParser_MT565Parser::T__5)
| (1ULL << SwiftMtParser_MT565Parser::T__6)
| (1ULL << SwiftMtParser_MT565Parser::T__7)
| (1ULL << SwiftMtParser_MT565Parser::T__8)
| (1ULL << SwiftMtParser_MT565Parser::T__9)
| (1ULL << SwiftMtParser_MT565Parser::T__10)
| (1ULL << SwiftMtParser_MT565Parser::T__11)
| (1ULL << SwiftMtParser_MT565Parser::T__12)
| (1ULL << SwiftMtParser_MT565Parser::T__13)
| (1ULL << SwiftMtParser_MT565Parser::T__14)
| (1ULL << SwiftMtParser_MT565Parser::T__15)
| (1ULL << SwiftMtParser_MT565Parser::T__16)
| (1ULL << SwiftMtParser_MT565Parser::T__17)
| (1ULL << SwiftMtParser_MT565Parser::T__18)
| (1ULL << SwiftMtParser_MT565Parser::T__19)
| (1ULL << SwiftMtParser_MT565Parser::T__20)
| (1ULL << SwiftMtParser_MT565Parser::T__21)
| (1ULL << SwiftMtParser_MT565Parser::T__22)
| (1ULL << SwiftMtParser_MT565Parser::T__23)
| (1ULL << SwiftMtParser_MT565Parser::T__24)
| (1ULL << SwiftMtParser_MT565Parser::T__25)
| (1ULL << SwiftMtParser_MT565Parser::T__26)
| (1ULL << SwiftMtParser_MT565Parser::T__27)
| (1ULL << SwiftMtParser_MT565Parser::T__28)
| (1ULL << SwiftMtParser_MT565Parser::T__29)
| (1ULL << SwiftMtParser_MT565Parser::T__30)
| (1ULL << SwiftMtParser_MT565Parser::T__31)
| (1ULL << SwiftMtParser_MT565Parser::T__32)
| (1ULL << SwiftMtParser_MT565Parser::T__33)
| (1ULL << SwiftMtParser_MT565Parser::T__34)
| (1ULL << SwiftMtParser_MT565Parser::T__35)
| (1ULL << SwiftMtParser_MT565Parser::T__36)
| (1ULL << SwiftMtParser_MT565Parser::T__37)
| (1ULL << SwiftMtParser_MT565Parser::TAG_BH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_AH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_UH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_MT)
| (1ULL << SwiftMtParser_MT565Parser::TAG_TR)
| (1ULL << SwiftMtParser_MT565Parser::MT_END)
| (1ULL << SwiftMtParser_MT565Parser::LBRACE)
| (1ULL << SwiftMtParser_MT565Parser::RBRACE)
| (1ULL << SwiftMtParser_MT565Parser::COLON)
| (1ULL << SwiftMtParser_MT565Parser::ANY))) != 0));
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- Fld_94B_B1_BContext ------------------------------------------------------------------
SwiftMtParser_MT565Parser::Fld_94B_B1_BContext::Fld_94B_B1_BContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
std::vector<tree::TerminalNode *> SwiftMtParser_MT565Parser::Fld_94B_B1_BContext::START_OF_FIELD() {
return getTokens(SwiftMtParser_MT565Parser::START_OF_FIELD);
}
tree::TerminalNode* SwiftMtParser_MT565Parser::Fld_94B_B1_BContext::START_OF_FIELD(size_t i) {
return getToken(SwiftMtParser_MT565Parser::START_OF_FIELD, i);
}
size_t SwiftMtParser_MT565Parser::Fld_94B_B1_BContext::getRuleIndex() const {
return SwiftMtParser_MT565Parser::RuleFld_94B_B1_B;
}
void SwiftMtParser_MT565Parser::Fld_94B_B1_BContext::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->enterFld_94B_B1_B(this);
}
void SwiftMtParser_MT565Parser::Fld_94B_B1_BContext::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->exitFld_94B_B1_B(this);
}
SwiftMtParser_MT565Parser::Fld_94B_B1_BContext* SwiftMtParser_MT565Parser::fld_94B_B1_B() {
Fld_94B_B1_BContext *_localctx = _tracker.createInstance<Fld_94B_B1_BContext>(_ctx, getState());
enterRule(_localctx, 164, SwiftMtParser_MT565Parser::RuleFld_94B_B1_B);
_localctx->fld.set_tag("94B");
size_t _la = 0;
auto onExit = finally([=] {
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(948);
match(SwiftMtParser_MT565Parser::START_OF_FIELD);
setState(949);
match(SwiftMtParser_MT565Parser::T__10);
setState(951);
_errHandler->sync(this);
_la = _input->LA(1);
do {
setState(950);
_la = _input->LA(1);
if (_la == 0 || _la == Token::EOF || (_la == SwiftMtParser_MT565Parser::START_OF_FIELD)) {
_errHandler->recoverInline(this);
}
else {
_errHandler->reportMatch(this);
consume();
}
setState(953);
_errHandler->sync(this);
_la = _input->LA(1);
} while ((((_la & ~ 0x3fULL) == 0) &&
((1ULL << _la) & ((1ULL << SwiftMtParser_MT565Parser::T__0)
| (1ULL << SwiftMtParser_MT565Parser::T__1)
| (1ULL << SwiftMtParser_MT565Parser::T__2)
| (1ULL << SwiftMtParser_MT565Parser::T__3)
| (1ULL << SwiftMtParser_MT565Parser::T__4)
| (1ULL << SwiftMtParser_MT565Parser::T__5)
| (1ULL << SwiftMtParser_MT565Parser::T__6)
| (1ULL << SwiftMtParser_MT565Parser::T__7)
| (1ULL << SwiftMtParser_MT565Parser::T__8)
| (1ULL << SwiftMtParser_MT565Parser::T__9)
| (1ULL << SwiftMtParser_MT565Parser::T__10)
| (1ULL << SwiftMtParser_MT565Parser::T__11)
| (1ULL << SwiftMtParser_MT565Parser::T__12)
| (1ULL << SwiftMtParser_MT565Parser::T__13)
| (1ULL << SwiftMtParser_MT565Parser::T__14)
| (1ULL << SwiftMtParser_MT565Parser::T__15)
| (1ULL << SwiftMtParser_MT565Parser::T__16)
| (1ULL << SwiftMtParser_MT565Parser::T__17)
| (1ULL << SwiftMtParser_MT565Parser::T__18)
| (1ULL << SwiftMtParser_MT565Parser::T__19)
| (1ULL << SwiftMtParser_MT565Parser::T__20)
| (1ULL << SwiftMtParser_MT565Parser::T__21)
| (1ULL << SwiftMtParser_MT565Parser::T__22)
| (1ULL << SwiftMtParser_MT565Parser::T__23)
| (1ULL << SwiftMtParser_MT565Parser::T__24)
| (1ULL << SwiftMtParser_MT565Parser::T__25)
| (1ULL << SwiftMtParser_MT565Parser::T__26)
| (1ULL << SwiftMtParser_MT565Parser::T__27)
| (1ULL << SwiftMtParser_MT565Parser::T__28)
| (1ULL << SwiftMtParser_MT565Parser::T__29)
| (1ULL << SwiftMtParser_MT565Parser::T__30)
| (1ULL << SwiftMtParser_MT565Parser::T__31)
| (1ULL << SwiftMtParser_MT565Parser::T__32)
| (1ULL << SwiftMtParser_MT565Parser::T__33)
| (1ULL << SwiftMtParser_MT565Parser::T__34)
| (1ULL << SwiftMtParser_MT565Parser::T__35)
| (1ULL << SwiftMtParser_MT565Parser::T__36)
| (1ULL << SwiftMtParser_MT565Parser::T__37)
| (1ULL << SwiftMtParser_MT565Parser::TAG_BH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_AH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_UH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_MT)
| (1ULL << SwiftMtParser_MT565Parser::TAG_TR)
| (1ULL << SwiftMtParser_MT565Parser::MT_END)
| (1ULL << SwiftMtParser_MT565Parser::LBRACE)
| (1ULL << SwiftMtParser_MT565Parser::RBRACE)
| (1ULL << SwiftMtParser_MT565Parser::COLON)
| (1ULL << SwiftMtParser_MT565Parser::ANY))) != 0));
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- Fld_22F_B1_FContext ------------------------------------------------------------------
SwiftMtParser_MT565Parser::Fld_22F_B1_FContext::Fld_22F_B1_FContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
std::vector<tree::TerminalNode *> SwiftMtParser_MT565Parser::Fld_22F_B1_FContext::START_OF_FIELD() {
return getTokens(SwiftMtParser_MT565Parser::START_OF_FIELD);
}
tree::TerminalNode* SwiftMtParser_MT565Parser::Fld_22F_B1_FContext::START_OF_FIELD(size_t i) {
return getToken(SwiftMtParser_MT565Parser::START_OF_FIELD, i);
}
size_t SwiftMtParser_MT565Parser::Fld_22F_B1_FContext::getRuleIndex() const {
return SwiftMtParser_MT565Parser::RuleFld_22F_B1_F;
}
void SwiftMtParser_MT565Parser::Fld_22F_B1_FContext::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->enterFld_22F_B1_F(this);
}
void SwiftMtParser_MT565Parser::Fld_22F_B1_FContext::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->exitFld_22F_B1_F(this);
}
SwiftMtParser_MT565Parser::Fld_22F_B1_FContext* SwiftMtParser_MT565Parser::fld_22F_B1_F() {
Fld_22F_B1_FContext *_localctx = _tracker.createInstance<Fld_22F_B1_FContext>(_ctx, getState());
enterRule(_localctx, 166, SwiftMtParser_MT565Parser::RuleFld_22F_B1_F);
_localctx->fld.set_tag("22F");
size_t _la = 0;
auto onExit = finally([=] {
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(955);
match(SwiftMtParser_MT565Parser::START_OF_FIELD);
setState(956);
match(SwiftMtParser_MT565Parser::T__4);
setState(958);
_errHandler->sync(this);
_la = _input->LA(1);
do {
setState(957);
_la = _input->LA(1);
if (_la == 0 || _la == Token::EOF || (_la == SwiftMtParser_MT565Parser::START_OF_FIELD)) {
_errHandler->recoverInline(this);
}
else {
_errHandler->reportMatch(this);
consume();
}
setState(960);
_errHandler->sync(this);
_la = _input->LA(1);
} while ((((_la & ~ 0x3fULL) == 0) &&
((1ULL << _la) & ((1ULL << SwiftMtParser_MT565Parser::T__0)
| (1ULL << SwiftMtParser_MT565Parser::T__1)
| (1ULL << SwiftMtParser_MT565Parser::T__2)
| (1ULL << SwiftMtParser_MT565Parser::T__3)
| (1ULL << SwiftMtParser_MT565Parser::T__4)
| (1ULL << SwiftMtParser_MT565Parser::T__5)
| (1ULL << SwiftMtParser_MT565Parser::T__6)
| (1ULL << SwiftMtParser_MT565Parser::T__7)
| (1ULL << SwiftMtParser_MT565Parser::T__8)
| (1ULL << SwiftMtParser_MT565Parser::T__9)
| (1ULL << SwiftMtParser_MT565Parser::T__10)
| (1ULL << SwiftMtParser_MT565Parser::T__11)
| (1ULL << SwiftMtParser_MT565Parser::T__12)
| (1ULL << SwiftMtParser_MT565Parser::T__13)
| (1ULL << SwiftMtParser_MT565Parser::T__14)
| (1ULL << SwiftMtParser_MT565Parser::T__15)
| (1ULL << SwiftMtParser_MT565Parser::T__16)
| (1ULL << SwiftMtParser_MT565Parser::T__17)
| (1ULL << SwiftMtParser_MT565Parser::T__18)
| (1ULL << SwiftMtParser_MT565Parser::T__19)
| (1ULL << SwiftMtParser_MT565Parser::T__20)
| (1ULL << SwiftMtParser_MT565Parser::T__21)
| (1ULL << SwiftMtParser_MT565Parser::T__22)
| (1ULL << SwiftMtParser_MT565Parser::T__23)
| (1ULL << SwiftMtParser_MT565Parser::T__24)
| (1ULL << SwiftMtParser_MT565Parser::T__25)
| (1ULL << SwiftMtParser_MT565Parser::T__26)
| (1ULL << SwiftMtParser_MT565Parser::T__27)
| (1ULL << SwiftMtParser_MT565Parser::T__28)
| (1ULL << SwiftMtParser_MT565Parser::T__29)
| (1ULL << SwiftMtParser_MT565Parser::T__30)
| (1ULL << SwiftMtParser_MT565Parser::T__31)
| (1ULL << SwiftMtParser_MT565Parser::T__32)
| (1ULL << SwiftMtParser_MT565Parser::T__33)
| (1ULL << SwiftMtParser_MT565Parser::T__34)
| (1ULL << SwiftMtParser_MT565Parser::T__35)
| (1ULL << SwiftMtParser_MT565Parser::T__36)
| (1ULL << SwiftMtParser_MT565Parser::T__37)
| (1ULL << SwiftMtParser_MT565Parser::TAG_BH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_AH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_UH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_MT)
| (1ULL << SwiftMtParser_MT565Parser::TAG_TR)
| (1ULL << SwiftMtParser_MT565Parser::MT_END)
| (1ULL << SwiftMtParser_MT565Parser::LBRACE)
| (1ULL << SwiftMtParser_MT565Parser::RBRACE)
| (1ULL << SwiftMtParser_MT565Parser::COLON)
| (1ULL << SwiftMtParser_MT565Parser::ANY))) != 0));
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- Fld_12a_B1_AContext ------------------------------------------------------------------
SwiftMtParser_MT565Parser::Fld_12a_B1_AContext::Fld_12a_B1_AContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
std::vector<tree::TerminalNode *> SwiftMtParser_MT565Parser::Fld_12a_B1_AContext::START_OF_FIELD() {
return getTokens(SwiftMtParser_MT565Parser::START_OF_FIELD);
}
tree::TerminalNode* SwiftMtParser_MT565Parser::Fld_12a_B1_AContext::START_OF_FIELD(size_t i) {
return getToken(SwiftMtParser_MT565Parser::START_OF_FIELD, i);
}
size_t SwiftMtParser_MT565Parser::Fld_12a_B1_AContext::getRuleIndex() const {
return SwiftMtParser_MT565Parser::RuleFld_12a_B1_A;
}
void SwiftMtParser_MT565Parser::Fld_12a_B1_AContext::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->enterFld_12a_B1_A(this);
}
void SwiftMtParser_MT565Parser::Fld_12a_B1_AContext::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->exitFld_12a_B1_A(this);
}
SwiftMtParser_MT565Parser::Fld_12a_B1_AContext* SwiftMtParser_MT565Parser::fld_12a_B1_A() {
Fld_12a_B1_AContext *_localctx = _tracker.createInstance<Fld_12a_B1_AContext>(_ctx, getState());
enterRule(_localctx, 168, SwiftMtParser_MT565Parser::RuleFld_12a_B1_A);
_localctx->fld.set_tag("12A");
size_t _la = 0;
auto onExit = finally([=] {
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(962);
match(SwiftMtParser_MT565Parser::START_OF_FIELD);
setState(963);
match(SwiftMtParser_MT565Parser::T__11);
setState(965);
_errHandler->sync(this);
_la = _input->LA(1);
do {
setState(964);
_la = _input->LA(1);
if (_la == 0 || _la == Token::EOF || (_la == SwiftMtParser_MT565Parser::START_OF_FIELD)) {
_errHandler->recoverInline(this);
}
else {
_errHandler->reportMatch(this);
consume();
}
setState(967);
_errHandler->sync(this);
_la = _input->LA(1);
} while ((((_la & ~ 0x3fULL) == 0) &&
((1ULL << _la) & ((1ULL << SwiftMtParser_MT565Parser::T__0)
| (1ULL << SwiftMtParser_MT565Parser::T__1)
| (1ULL << SwiftMtParser_MT565Parser::T__2)
| (1ULL << SwiftMtParser_MT565Parser::T__3)
| (1ULL << SwiftMtParser_MT565Parser::T__4)
| (1ULL << SwiftMtParser_MT565Parser::T__5)
| (1ULL << SwiftMtParser_MT565Parser::T__6)
| (1ULL << SwiftMtParser_MT565Parser::T__7)
| (1ULL << SwiftMtParser_MT565Parser::T__8)
| (1ULL << SwiftMtParser_MT565Parser::T__9)
| (1ULL << SwiftMtParser_MT565Parser::T__10)
| (1ULL << SwiftMtParser_MT565Parser::T__11)
| (1ULL << SwiftMtParser_MT565Parser::T__12)
| (1ULL << SwiftMtParser_MT565Parser::T__13)
| (1ULL << SwiftMtParser_MT565Parser::T__14)
| (1ULL << SwiftMtParser_MT565Parser::T__15)
| (1ULL << SwiftMtParser_MT565Parser::T__16)
| (1ULL << SwiftMtParser_MT565Parser::T__17)
| (1ULL << SwiftMtParser_MT565Parser::T__18)
| (1ULL << SwiftMtParser_MT565Parser::T__19)
| (1ULL << SwiftMtParser_MT565Parser::T__20)
| (1ULL << SwiftMtParser_MT565Parser::T__21)
| (1ULL << SwiftMtParser_MT565Parser::T__22)
| (1ULL << SwiftMtParser_MT565Parser::T__23)
| (1ULL << SwiftMtParser_MT565Parser::T__24)
| (1ULL << SwiftMtParser_MT565Parser::T__25)
| (1ULL << SwiftMtParser_MT565Parser::T__26)
| (1ULL << SwiftMtParser_MT565Parser::T__27)
| (1ULL << SwiftMtParser_MT565Parser::T__28)
| (1ULL << SwiftMtParser_MT565Parser::T__29)
| (1ULL << SwiftMtParser_MT565Parser::T__30)
| (1ULL << SwiftMtParser_MT565Parser::T__31)
| (1ULL << SwiftMtParser_MT565Parser::T__32)
| (1ULL << SwiftMtParser_MT565Parser::T__33)
| (1ULL << SwiftMtParser_MT565Parser::T__34)
| (1ULL << SwiftMtParser_MT565Parser::T__35)
| (1ULL << SwiftMtParser_MT565Parser::T__36)
| (1ULL << SwiftMtParser_MT565Parser::T__37)
| (1ULL << SwiftMtParser_MT565Parser::TAG_BH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_AH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_UH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_MT)
| (1ULL << SwiftMtParser_MT565Parser::TAG_TR)
| (1ULL << SwiftMtParser_MT565Parser::MT_END)
| (1ULL << SwiftMtParser_MT565Parser::LBRACE)
| (1ULL << SwiftMtParser_MT565Parser::RBRACE)
| (1ULL << SwiftMtParser_MT565Parser::COLON)
| (1ULL << SwiftMtParser_MT565Parser::ANY))) != 0));
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- Fld_12a_B1_CContext ------------------------------------------------------------------
SwiftMtParser_MT565Parser::Fld_12a_B1_CContext::Fld_12a_B1_CContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
std::vector<tree::TerminalNode *> SwiftMtParser_MT565Parser::Fld_12a_B1_CContext::START_OF_FIELD() {
return getTokens(SwiftMtParser_MT565Parser::START_OF_FIELD);
}
tree::TerminalNode* SwiftMtParser_MT565Parser::Fld_12a_B1_CContext::START_OF_FIELD(size_t i) {
return getToken(SwiftMtParser_MT565Parser::START_OF_FIELD, i);
}
size_t SwiftMtParser_MT565Parser::Fld_12a_B1_CContext::getRuleIndex() const {
return SwiftMtParser_MT565Parser::RuleFld_12a_B1_C;
}
void SwiftMtParser_MT565Parser::Fld_12a_B1_CContext::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->enterFld_12a_B1_C(this);
}
void SwiftMtParser_MT565Parser::Fld_12a_B1_CContext::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->exitFld_12a_B1_C(this);
}
SwiftMtParser_MT565Parser::Fld_12a_B1_CContext* SwiftMtParser_MT565Parser::fld_12a_B1_C() {
Fld_12a_B1_CContext *_localctx = _tracker.createInstance<Fld_12a_B1_CContext>(_ctx, getState());
enterRule(_localctx, 170, SwiftMtParser_MT565Parser::RuleFld_12a_B1_C);
_localctx->fld.set_tag("12C");
size_t _la = 0;
auto onExit = finally([=] {
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(969);
match(SwiftMtParser_MT565Parser::START_OF_FIELD);
setState(970);
match(SwiftMtParser_MT565Parser::T__12);
setState(972);
_errHandler->sync(this);
_la = _input->LA(1);
do {
setState(971);
_la = _input->LA(1);
if (_la == 0 || _la == Token::EOF || (_la == SwiftMtParser_MT565Parser::START_OF_FIELD)) {
_errHandler->recoverInline(this);
}
else {
_errHandler->reportMatch(this);
consume();
}
setState(974);
_errHandler->sync(this);
_la = _input->LA(1);
} while ((((_la & ~ 0x3fULL) == 0) &&
((1ULL << _la) & ((1ULL << SwiftMtParser_MT565Parser::T__0)
| (1ULL << SwiftMtParser_MT565Parser::T__1)
| (1ULL << SwiftMtParser_MT565Parser::T__2)
| (1ULL << SwiftMtParser_MT565Parser::T__3)
| (1ULL << SwiftMtParser_MT565Parser::T__4)
| (1ULL << SwiftMtParser_MT565Parser::T__5)
| (1ULL << SwiftMtParser_MT565Parser::T__6)
| (1ULL << SwiftMtParser_MT565Parser::T__7)
| (1ULL << SwiftMtParser_MT565Parser::T__8)
| (1ULL << SwiftMtParser_MT565Parser::T__9)
| (1ULL << SwiftMtParser_MT565Parser::T__10)
| (1ULL << SwiftMtParser_MT565Parser::T__11)
| (1ULL << SwiftMtParser_MT565Parser::T__12)
| (1ULL << SwiftMtParser_MT565Parser::T__13)
| (1ULL << SwiftMtParser_MT565Parser::T__14)
| (1ULL << SwiftMtParser_MT565Parser::T__15)
| (1ULL << SwiftMtParser_MT565Parser::T__16)
| (1ULL << SwiftMtParser_MT565Parser::T__17)
| (1ULL << SwiftMtParser_MT565Parser::T__18)
| (1ULL << SwiftMtParser_MT565Parser::T__19)
| (1ULL << SwiftMtParser_MT565Parser::T__20)
| (1ULL << SwiftMtParser_MT565Parser::T__21)
| (1ULL << SwiftMtParser_MT565Parser::T__22)
| (1ULL << SwiftMtParser_MT565Parser::T__23)
| (1ULL << SwiftMtParser_MT565Parser::T__24)
| (1ULL << SwiftMtParser_MT565Parser::T__25)
| (1ULL << SwiftMtParser_MT565Parser::T__26)
| (1ULL << SwiftMtParser_MT565Parser::T__27)
| (1ULL << SwiftMtParser_MT565Parser::T__28)
| (1ULL << SwiftMtParser_MT565Parser::T__29)
| (1ULL << SwiftMtParser_MT565Parser::T__30)
| (1ULL << SwiftMtParser_MT565Parser::T__31)
| (1ULL << SwiftMtParser_MT565Parser::T__32)
| (1ULL << SwiftMtParser_MT565Parser::T__33)
| (1ULL << SwiftMtParser_MT565Parser::T__34)
| (1ULL << SwiftMtParser_MT565Parser::T__35)
| (1ULL << SwiftMtParser_MT565Parser::T__36)
| (1ULL << SwiftMtParser_MT565Parser::T__37)
| (1ULL << SwiftMtParser_MT565Parser::TAG_BH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_AH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_UH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_MT)
| (1ULL << SwiftMtParser_MT565Parser::TAG_TR)
| (1ULL << SwiftMtParser_MT565Parser::MT_END)
| (1ULL << SwiftMtParser_MT565Parser::LBRACE)
| (1ULL << SwiftMtParser_MT565Parser::RBRACE)
| (1ULL << SwiftMtParser_MT565Parser::COLON)
| (1ULL << SwiftMtParser_MT565Parser::ANY))) != 0));
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- Fld_11A_B1_AContext ------------------------------------------------------------------
SwiftMtParser_MT565Parser::Fld_11A_B1_AContext::Fld_11A_B1_AContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
std::vector<tree::TerminalNode *> SwiftMtParser_MT565Parser::Fld_11A_B1_AContext::START_OF_FIELD() {
return getTokens(SwiftMtParser_MT565Parser::START_OF_FIELD);
}
tree::TerminalNode* SwiftMtParser_MT565Parser::Fld_11A_B1_AContext::START_OF_FIELD(size_t i) {
return getToken(SwiftMtParser_MT565Parser::START_OF_FIELD, i);
}
size_t SwiftMtParser_MT565Parser::Fld_11A_B1_AContext::getRuleIndex() const {
return SwiftMtParser_MT565Parser::RuleFld_11A_B1_A;
}
void SwiftMtParser_MT565Parser::Fld_11A_B1_AContext::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->enterFld_11A_B1_A(this);
}
void SwiftMtParser_MT565Parser::Fld_11A_B1_AContext::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->exitFld_11A_B1_A(this);
}
SwiftMtParser_MT565Parser::Fld_11A_B1_AContext* SwiftMtParser_MT565Parser::fld_11A_B1_A() {
Fld_11A_B1_AContext *_localctx = _tracker.createInstance<Fld_11A_B1_AContext>(_ctx, getState());
enterRule(_localctx, 172, SwiftMtParser_MT565Parser::RuleFld_11A_B1_A);
_localctx->fld.set_tag("11A");
size_t _la = 0;
auto onExit = finally([=] {
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(976);
match(SwiftMtParser_MT565Parser::START_OF_FIELD);
setState(977);
match(SwiftMtParser_MT565Parser::T__13);
setState(979);
_errHandler->sync(this);
_la = _input->LA(1);
do {
setState(978);
_la = _input->LA(1);
if (_la == 0 || _la == Token::EOF || (_la == SwiftMtParser_MT565Parser::START_OF_FIELD)) {
_errHandler->recoverInline(this);
}
else {
_errHandler->reportMatch(this);
consume();
}
setState(981);
_errHandler->sync(this);
_la = _input->LA(1);
} while ((((_la & ~ 0x3fULL) == 0) &&
((1ULL << _la) & ((1ULL << SwiftMtParser_MT565Parser::T__0)
| (1ULL << SwiftMtParser_MT565Parser::T__1)
| (1ULL << SwiftMtParser_MT565Parser::T__2)
| (1ULL << SwiftMtParser_MT565Parser::T__3)
| (1ULL << SwiftMtParser_MT565Parser::T__4)
| (1ULL << SwiftMtParser_MT565Parser::T__5)
| (1ULL << SwiftMtParser_MT565Parser::T__6)
| (1ULL << SwiftMtParser_MT565Parser::T__7)
| (1ULL << SwiftMtParser_MT565Parser::T__8)
| (1ULL << SwiftMtParser_MT565Parser::T__9)
| (1ULL << SwiftMtParser_MT565Parser::T__10)
| (1ULL << SwiftMtParser_MT565Parser::T__11)
| (1ULL << SwiftMtParser_MT565Parser::T__12)
| (1ULL << SwiftMtParser_MT565Parser::T__13)
| (1ULL << SwiftMtParser_MT565Parser::T__14)
| (1ULL << SwiftMtParser_MT565Parser::T__15)
| (1ULL << SwiftMtParser_MT565Parser::T__16)
| (1ULL << SwiftMtParser_MT565Parser::T__17)
| (1ULL << SwiftMtParser_MT565Parser::T__18)
| (1ULL << SwiftMtParser_MT565Parser::T__19)
| (1ULL << SwiftMtParser_MT565Parser::T__20)
| (1ULL << SwiftMtParser_MT565Parser::T__21)
| (1ULL << SwiftMtParser_MT565Parser::T__22)
| (1ULL << SwiftMtParser_MT565Parser::T__23)
| (1ULL << SwiftMtParser_MT565Parser::T__24)
| (1ULL << SwiftMtParser_MT565Parser::T__25)
| (1ULL << SwiftMtParser_MT565Parser::T__26)
| (1ULL << SwiftMtParser_MT565Parser::T__27)
| (1ULL << SwiftMtParser_MT565Parser::T__28)
| (1ULL << SwiftMtParser_MT565Parser::T__29)
| (1ULL << SwiftMtParser_MT565Parser::T__30)
| (1ULL << SwiftMtParser_MT565Parser::T__31)
| (1ULL << SwiftMtParser_MT565Parser::T__32)
| (1ULL << SwiftMtParser_MT565Parser::T__33)
| (1ULL << SwiftMtParser_MT565Parser::T__34)
| (1ULL << SwiftMtParser_MT565Parser::T__35)
| (1ULL << SwiftMtParser_MT565Parser::T__36)
| (1ULL << SwiftMtParser_MT565Parser::T__37)
| (1ULL << SwiftMtParser_MT565Parser::TAG_BH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_AH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_UH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_MT)
| (1ULL << SwiftMtParser_MT565Parser::TAG_TR)
| (1ULL << SwiftMtParser_MT565Parser::MT_END)
| (1ULL << SwiftMtParser_MT565Parser::LBRACE)
| (1ULL << SwiftMtParser_MT565Parser::RBRACE)
| (1ULL << SwiftMtParser_MT565Parser::COLON)
| (1ULL << SwiftMtParser_MT565Parser::ANY))) != 0));
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- Fld_98A_B1_AContext ------------------------------------------------------------------
SwiftMtParser_MT565Parser::Fld_98A_B1_AContext::Fld_98A_B1_AContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
std::vector<tree::TerminalNode *> SwiftMtParser_MT565Parser::Fld_98A_B1_AContext::START_OF_FIELD() {
return getTokens(SwiftMtParser_MT565Parser::START_OF_FIELD);
}
tree::TerminalNode* SwiftMtParser_MT565Parser::Fld_98A_B1_AContext::START_OF_FIELD(size_t i) {
return getToken(SwiftMtParser_MT565Parser::START_OF_FIELD, i);
}
size_t SwiftMtParser_MT565Parser::Fld_98A_B1_AContext::getRuleIndex() const {
return SwiftMtParser_MT565Parser::RuleFld_98A_B1_A;
}
void SwiftMtParser_MT565Parser::Fld_98A_B1_AContext::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->enterFld_98A_B1_A(this);
}
void SwiftMtParser_MT565Parser::Fld_98A_B1_AContext::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->exitFld_98A_B1_A(this);
}
SwiftMtParser_MT565Parser::Fld_98A_B1_AContext* SwiftMtParser_MT565Parser::fld_98A_B1_A() {
Fld_98A_B1_AContext *_localctx = _tracker.createInstance<Fld_98A_B1_AContext>(_ctx, getState());
enterRule(_localctx, 174, SwiftMtParser_MT565Parser::RuleFld_98A_B1_A);
_localctx->fld.set_tag("98A");
size_t _la = 0;
auto onExit = finally([=] {
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(983);
match(SwiftMtParser_MT565Parser::START_OF_FIELD);
setState(984);
match(SwiftMtParser_MT565Parser::T__5);
setState(986);
_errHandler->sync(this);
_la = _input->LA(1);
do {
setState(985);
_la = _input->LA(1);
if (_la == 0 || _la == Token::EOF || (_la == SwiftMtParser_MT565Parser::START_OF_FIELD)) {
_errHandler->recoverInline(this);
}
else {
_errHandler->reportMatch(this);
consume();
}
setState(988);
_errHandler->sync(this);
_la = _input->LA(1);
} while ((((_la & ~ 0x3fULL) == 0) &&
((1ULL << _la) & ((1ULL << SwiftMtParser_MT565Parser::T__0)
| (1ULL << SwiftMtParser_MT565Parser::T__1)
| (1ULL << SwiftMtParser_MT565Parser::T__2)
| (1ULL << SwiftMtParser_MT565Parser::T__3)
| (1ULL << SwiftMtParser_MT565Parser::T__4)
| (1ULL << SwiftMtParser_MT565Parser::T__5)
| (1ULL << SwiftMtParser_MT565Parser::T__6)
| (1ULL << SwiftMtParser_MT565Parser::T__7)
| (1ULL << SwiftMtParser_MT565Parser::T__8)
| (1ULL << SwiftMtParser_MT565Parser::T__9)
| (1ULL << SwiftMtParser_MT565Parser::T__10)
| (1ULL << SwiftMtParser_MT565Parser::T__11)
| (1ULL << SwiftMtParser_MT565Parser::T__12)
| (1ULL << SwiftMtParser_MT565Parser::T__13)
| (1ULL << SwiftMtParser_MT565Parser::T__14)
| (1ULL << SwiftMtParser_MT565Parser::T__15)
| (1ULL << SwiftMtParser_MT565Parser::T__16)
| (1ULL << SwiftMtParser_MT565Parser::T__17)
| (1ULL << SwiftMtParser_MT565Parser::T__18)
| (1ULL << SwiftMtParser_MT565Parser::T__19)
| (1ULL << SwiftMtParser_MT565Parser::T__20)
| (1ULL << SwiftMtParser_MT565Parser::T__21)
| (1ULL << SwiftMtParser_MT565Parser::T__22)
| (1ULL << SwiftMtParser_MT565Parser::T__23)
| (1ULL << SwiftMtParser_MT565Parser::T__24)
| (1ULL << SwiftMtParser_MT565Parser::T__25)
| (1ULL << SwiftMtParser_MT565Parser::T__26)
| (1ULL << SwiftMtParser_MT565Parser::T__27)
| (1ULL << SwiftMtParser_MT565Parser::T__28)
| (1ULL << SwiftMtParser_MT565Parser::T__29)
| (1ULL << SwiftMtParser_MT565Parser::T__30)
| (1ULL << SwiftMtParser_MT565Parser::T__31)
| (1ULL << SwiftMtParser_MT565Parser::T__32)
| (1ULL << SwiftMtParser_MT565Parser::T__33)
| (1ULL << SwiftMtParser_MT565Parser::T__34)
| (1ULL << SwiftMtParser_MT565Parser::T__35)
| (1ULL << SwiftMtParser_MT565Parser::T__36)
| (1ULL << SwiftMtParser_MT565Parser::T__37)
| (1ULL << SwiftMtParser_MT565Parser::TAG_BH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_AH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_UH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_MT)
| (1ULL << SwiftMtParser_MT565Parser::TAG_TR)
| (1ULL << SwiftMtParser_MT565Parser::MT_END)
| (1ULL << SwiftMtParser_MT565Parser::LBRACE)
| (1ULL << SwiftMtParser_MT565Parser::RBRACE)
| (1ULL << SwiftMtParser_MT565Parser::COLON)
| (1ULL << SwiftMtParser_MT565Parser::ANY))) != 0));
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- Fld_92A_B1_AContext ------------------------------------------------------------------
SwiftMtParser_MT565Parser::Fld_92A_B1_AContext::Fld_92A_B1_AContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
std::vector<tree::TerminalNode *> SwiftMtParser_MT565Parser::Fld_92A_B1_AContext::START_OF_FIELD() {
return getTokens(SwiftMtParser_MT565Parser::START_OF_FIELD);
}
tree::TerminalNode* SwiftMtParser_MT565Parser::Fld_92A_B1_AContext::START_OF_FIELD(size_t i) {
return getToken(SwiftMtParser_MT565Parser::START_OF_FIELD, i);
}
size_t SwiftMtParser_MT565Parser::Fld_92A_B1_AContext::getRuleIndex() const {
return SwiftMtParser_MT565Parser::RuleFld_92A_B1_A;
}
void SwiftMtParser_MT565Parser::Fld_92A_B1_AContext::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->enterFld_92A_B1_A(this);
}
void SwiftMtParser_MT565Parser::Fld_92A_B1_AContext::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->exitFld_92A_B1_A(this);
}
SwiftMtParser_MT565Parser::Fld_92A_B1_AContext* SwiftMtParser_MT565Parser::fld_92A_B1_A() {
Fld_92A_B1_AContext *_localctx = _tracker.createInstance<Fld_92A_B1_AContext>(_ctx, getState());
enterRule(_localctx, 176, SwiftMtParser_MT565Parser::RuleFld_92A_B1_A);
_localctx->fld.set_tag("92A");
size_t _la = 0;
auto onExit = finally([=] {
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(990);
match(SwiftMtParser_MT565Parser::START_OF_FIELD);
setState(991);
match(SwiftMtParser_MT565Parser::T__14);
setState(993);
_errHandler->sync(this);
_la = _input->LA(1);
do {
setState(992);
_la = _input->LA(1);
if (_la == 0 || _la == Token::EOF || (_la == SwiftMtParser_MT565Parser::START_OF_FIELD)) {
_errHandler->recoverInline(this);
}
else {
_errHandler->reportMatch(this);
consume();
}
setState(995);
_errHandler->sync(this);
_la = _input->LA(1);
} while ((((_la & ~ 0x3fULL) == 0) &&
((1ULL << _la) & ((1ULL << SwiftMtParser_MT565Parser::T__0)
| (1ULL << SwiftMtParser_MT565Parser::T__1)
| (1ULL << SwiftMtParser_MT565Parser::T__2)
| (1ULL << SwiftMtParser_MT565Parser::T__3)
| (1ULL << SwiftMtParser_MT565Parser::T__4)
| (1ULL << SwiftMtParser_MT565Parser::T__5)
| (1ULL << SwiftMtParser_MT565Parser::T__6)
| (1ULL << SwiftMtParser_MT565Parser::T__7)
| (1ULL << SwiftMtParser_MT565Parser::T__8)
| (1ULL << SwiftMtParser_MT565Parser::T__9)
| (1ULL << SwiftMtParser_MT565Parser::T__10)
| (1ULL << SwiftMtParser_MT565Parser::T__11)
| (1ULL << SwiftMtParser_MT565Parser::T__12)
| (1ULL << SwiftMtParser_MT565Parser::T__13)
| (1ULL << SwiftMtParser_MT565Parser::T__14)
| (1ULL << SwiftMtParser_MT565Parser::T__15)
| (1ULL << SwiftMtParser_MT565Parser::T__16)
| (1ULL << SwiftMtParser_MT565Parser::T__17)
| (1ULL << SwiftMtParser_MT565Parser::T__18)
| (1ULL << SwiftMtParser_MT565Parser::T__19)
| (1ULL << SwiftMtParser_MT565Parser::T__20)
| (1ULL << SwiftMtParser_MT565Parser::T__21)
| (1ULL << SwiftMtParser_MT565Parser::T__22)
| (1ULL << SwiftMtParser_MT565Parser::T__23)
| (1ULL << SwiftMtParser_MT565Parser::T__24)
| (1ULL << SwiftMtParser_MT565Parser::T__25)
| (1ULL << SwiftMtParser_MT565Parser::T__26)
| (1ULL << SwiftMtParser_MT565Parser::T__27)
| (1ULL << SwiftMtParser_MT565Parser::T__28)
| (1ULL << SwiftMtParser_MT565Parser::T__29)
| (1ULL << SwiftMtParser_MT565Parser::T__30)
| (1ULL << SwiftMtParser_MT565Parser::T__31)
| (1ULL << SwiftMtParser_MT565Parser::T__32)
| (1ULL << SwiftMtParser_MT565Parser::T__33)
| (1ULL << SwiftMtParser_MT565Parser::T__34)
| (1ULL << SwiftMtParser_MT565Parser::T__35)
| (1ULL << SwiftMtParser_MT565Parser::T__36)
| (1ULL << SwiftMtParser_MT565Parser::T__37)
| (1ULL << SwiftMtParser_MT565Parser::TAG_BH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_AH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_UH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_MT)
| (1ULL << SwiftMtParser_MT565Parser::TAG_TR)
| (1ULL << SwiftMtParser_MT565Parser::MT_END)
| (1ULL << SwiftMtParser_MT565Parser::LBRACE)
| (1ULL << SwiftMtParser_MT565Parser::RBRACE)
| (1ULL << SwiftMtParser_MT565Parser::COLON)
| (1ULL << SwiftMtParser_MT565Parser::ANY))) != 0));
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- Fld_36B_B1_BContext ------------------------------------------------------------------
SwiftMtParser_MT565Parser::Fld_36B_B1_BContext::Fld_36B_B1_BContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
std::vector<tree::TerminalNode *> SwiftMtParser_MT565Parser::Fld_36B_B1_BContext::START_OF_FIELD() {
return getTokens(SwiftMtParser_MT565Parser::START_OF_FIELD);
}
tree::TerminalNode* SwiftMtParser_MT565Parser::Fld_36B_B1_BContext::START_OF_FIELD(size_t i) {
return getToken(SwiftMtParser_MT565Parser::START_OF_FIELD, i);
}
size_t SwiftMtParser_MT565Parser::Fld_36B_B1_BContext::getRuleIndex() const {
return SwiftMtParser_MT565Parser::RuleFld_36B_B1_B;
}
void SwiftMtParser_MT565Parser::Fld_36B_B1_BContext::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->enterFld_36B_B1_B(this);
}
void SwiftMtParser_MT565Parser::Fld_36B_B1_BContext::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->exitFld_36B_B1_B(this);
}
SwiftMtParser_MT565Parser::Fld_36B_B1_BContext* SwiftMtParser_MT565Parser::fld_36B_B1_B() {
Fld_36B_B1_BContext *_localctx = _tracker.createInstance<Fld_36B_B1_BContext>(_ctx, getState());
enterRule(_localctx, 178, SwiftMtParser_MT565Parser::RuleFld_36B_B1_B);
_localctx->fld.set_tag("36B");
size_t _la = 0;
auto onExit = finally([=] {
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(997);
match(SwiftMtParser_MT565Parser::START_OF_FIELD);
setState(998);
match(SwiftMtParser_MT565Parser::T__15);
setState(1000);
_errHandler->sync(this);
_la = _input->LA(1);
do {
setState(999);
_la = _input->LA(1);
if (_la == 0 || _la == Token::EOF || (_la == SwiftMtParser_MT565Parser::START_OF_FIELD)) {
_errHandler->recoverInline(this);
}
else {
_errHandler->reportMatch(this);
consume();
}
setState(1002);
_errHandler->sync(this);
_la = _input->LA(1);
} while ((((_la & ~ 0x3fULL) == 0) &&
((1ULL << _la) & ((1ULL << SwiftMtParser_MT565Parser::T__0)
| (1ULL << SwiftMtParser_MT565Parser::T__1)
| (1ULL << SwiftMtParser_MT565Parser::T__2)
| (1ULL << SwiftMtParser_MT565Parser::T__3)
| (1ULL << SwiftMtParser_MT565Parser::T__4)
| (1ULL << SwiftMtParser_MT565Parser::T__5)
| (1ULL << SwiftMtParser_MT565Parser::T__6)
| (1ULL << SwiftMtParser_MT565Parser::T__7)
| (1ULL << SwiftMtParser_MT565Parser::T__8)
| (1ULL << SwiftMtParser_MT565Parser::T__9)
| (1ULL << SwiftMtParser_MT565Parser::T__10)
| (1ULL << SwiftMtParser_MT565Parser::T__11)
| (1ULL << SwiftMtParser_MT565Parser::T__12)
| (1ULL << SwiftMtParser_MT565Parser::T__13)
| (1ULL << SwiftMtParser_MT565Parser::T__14)
| (1ULL << SwiftMtParser_MT565Parser::T__15)
| (1ULL << SwiftMtParser_MT565Parser::T__16)
| (1ULL << SwiftMtParser_MT565Parser::T__17)
| (1ULL << SwiftMtParser_MT565Parser::T__18)
| (1ULL << SwiftMtParser_MT565Parser::T__19)
| (1ULL << SwiftMtParser_MT565Parser::T__20)
| (1ULL << SwiftMtParser_MT565Parser::T__21)
| (1ULL << SwiftMtParser_MT565Parser::T__22)
| (1ULL << SwiftMtParser_MT565Parser::T__23)
| (1ULL << SwiftMtParser_MT565Parser::T__24)
| (1ULL << SwiftMtParser_MT565Parser::T__25)
| (1ULL << SwiftMtParser_MT565Parser::T__26)
| (1ULL << SwiftMtParser_MT565Parser::T__27)
| (1ULL << SwiftMtParser_MT565Parser::T__28)
| (1ULL << SwiftMtParser_MT565Parser::T__29)
| (1ULL << SwiftMtParser_MT565Parser::T__30)
| (1ULL << SwiftMtParser_MT565Parser::T__31)
| (1ULL << SwiftMtParser_MT565Parser::T__32)
| (1ULL << SwiftMtParser_MT565Parser::T__33)
| (1ULL << SwiftMtParser_MT565Parser::T__34)
| (1ULL << SwiftMtParser_MT565Parser::T__35)
| (1ULL << SwiftMtParser_MT565Parser::T__36)
| (1ULL << SwiftMtParser_MT565Parser::T__37)
| (1ULL << SwiftMtParser_MT565Parser::TAG_BH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_AH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_UH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_MT)
| (1ULL << SwiftMtParser_MT565Parser::TAG_TR)
| (1ULL << SwiftMtParser_MT565Parser::MT_END)
| (1ULL << SwiftMtParser_MT565Parser::LBRACE)
| (1ULL << SwiftMtParser_MT565Parser::RBRACE)
| (1ULL << SwiftMtParser_MT565Parser::COLON)
| (1ULL << SwiftMtParser_MT565Parser::ANY))) != 0));
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- Fld_95a_B2_PContext ------------------------------------------------------------------
SwiftMtParser_MT565Parser::Fld_95a_B2_PContext::Fld_95a_B2_PContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
std::vector<tree::TerminalNode *> SwiftMtParser_MT565Parser::Fld_95a_B2_PContext::START_OF_FIELD() {
return getTokens(SwiftMtParser_MT565Parser::START_OF_FIELD);
}
tree::TerminalNode* SwiftMtParser_MT565Parser::Fld_95a_B2_PContext::START_OF_FIELD(size_t i) {
return getToken(SwiftMtParser_MT565Parser::START_OF_FIELD, i);
}
size_t SwiftMtParser_MT565Parser::Fld_95a_B2_PContext::getRuleIndex() const {
return SwiftMtParser_MT565Parser::RuleFld_95a_B2_P;
}
void SwiftMtParser_MT565Parser::Fld_95a_B2_PContext::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->enterFld_95a_B2_P(this);
}
void SwiftMtParser_MT565Parser::Fld_95a_B2_PContext::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->exitFld_95a_B2_P(this);
}
SwiftMtParser_MT565Parser::Fld_95a_B2_PContext* SwiftMtParser_MT565Parser::fld_95a_B2_P() {
Fld_95a_B2_PContext *_localctx = _tracker.createInstance<Fld_95a_B2_PContext>(_ctx, getState());
enterRule(_localctx, 180, SwiftMtParser_MT565Parser::RuleFld_95a_B2_P);
_localctx->fld.set_tag("95P");
size_t _la = 0;
auto onExit = finally([=] {
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(1004);
match(SwiftMtParser_MT565Parser::START_OF_FIELD);
setState(1005);
match(SwiftMtParser_MT565Parser::T__16);
setState(1007);
_errHandler->sync(this);
_la = _input->LA(1);
do {
setState(1006);
_la = _input->LA(1);
if (_la == 0 || _la == Token::EOF || (_la == SwiftMtParser_MT565Parser::START_OF_FIELD)) {
_errHandler->recoverInline(this);
}
else {
_errHandler->reportMatch(this);
consume();
}
setState(1009);
_errHandler->sync(this);
_la = _input->LA(1);
} while ((((_la & ~ 0x3fULL) == 0) &&
((1ULL << _la) & ((1ULL << SwiftMtParser_MT565Parser::T__0)
| (1ULL << SwiftMtParser_MT565Parser::T__1)
| (1ULL << SwiftMtParser_MT565Parser::T__2)
| (1ULL << SwiftMtParser_MT565Parser::T__3)
| (1ULL << SwiftMtParser_MT565Parser::T__4)
| (1ULL << SwiftMtParser_MT565Parser::T__5)
| (1ULL << SwiftMtParser_MT565Parser::T__6)
| (1ULL << SwiftMtParser_MT565Parser::T__7)
| (1ULL << SwiftMtParser_MT565Parser::T__8)
| (1ULL << SwiftMtParser_MT565Parser::T__9)
| (1ULL << SwiftMtParser_MT565Parser::T__10)
| (1ULL << SwiftMtParser_MT565Parser::T__11)
| (1ULL << SwiftMtParser_MT565Parser::T__12)
| (1ULL << SwiftMtParser_MT565Parser::T__13)
| (1ULL << SwiftMtParser_MT565Parser::T__14)
| (1ULL << SwiftMtParser_MT565Parser::T__15)
| (1ULL << SwiftMtParser_MT565Parser::T__16)
| (1ULL << SwiftMtParser_MT565Parser::T__17)
| (1ULL << SwiftMtParser_MT565Parser::T__18)
| (1ULL << SwiftMtParser_MT565Parser::T__19)
| (1ULL << SwiftMtParser_MT565Parser::T__20)
| (1ULL << SwiftMtParser_MT565Parser::T__21)
| (1ULL << SwiftMtParser_MT565Parser::T__22)
| (1ULL << SwiftMtParser_MT565Parser::T__23)
| (1ULL << SwiftMtParser_MT565Parser::T__24)
| (1ULL << SwiftMtParser_MT565Parser::T__25)
| (1ULL << SwiftMtParser_MT565Parser::T__26)
| (1ULL << SwiftMtParser_MT565Parser::T__27)
| (1ULL << SwiftMtParser_MT565Parser::T__28)
| (1ULL << SwiftMtParser_MT565Parser::T__29)
| (1ULL << SwiftMtParser_MT565Parser::T__30)
| (1ULL << SwiftMtParser_MT565Parser::T__31)
| (1ULL << SwiftMtParser_MT565Parser::T__32)
| (1ULL << SwiftMtParser_MT565Parser::T__33)
| (1ULL << SwiftMtParser_MT565Parser::T__34)
| (1ULL << SwiftMtParser_MT565Parser::T__35)
| (1ULL << SwiftMtParser_MT565Parser::T__36)
| (1ULL << SwiftMtParser_MT565Parser::T__37)
| (1ULL << SwiftMtParser_MT565Parser::TAG_BH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_AH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_UH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_MT)
| (1ULL << SwiftMtParser_MT565Parser::TAG_TR)
| (1ULL << SwiftMtParser_MT565Parser::MT_END)
| (1ULL << SwiftMtParser_MT565Parser::LBRACE)
| (1ULL << SwiftMtParser_MT565Parser::RBRACE)
| (1ULL << SwiftMtParser_MT565Parser::COLON)
| (1ULL << SwiftMtParser_MT565Parser::ANY))) != 0));
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- Fld_95a_B2_RContext ------------------------------------------------------------------
SwiftMtParser_MT565Parser::Fld_95a_B2_RContext::Fld_95a_B2_RContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
std::vector<tree::TerminalNode *> SwiftMtParser_MT565Parser::Fld_95a_B2_RContext::START_OF_FIELD() {
return getTokens(SwiftMtParser_MT565Parser::START_OF_FIELD);
}
tree::TerminalNode* SwiftMtParser_MT565Parser::Fld_95a_B2_RContext::START_OF_FIELD(size_t i) {
return getToken(SwiftMtParser_MT565Parser::START_OF_FIELD, i);
}
size_t SwiftMtParser_MT565Parser::Fld_95a_B2_RContext::getRuleIndex() const {
return SwiftMtParser_MT565Parser::RuleFld_95a_B2_R;
}
void SwiftMtParser_MT565Parser::Fld_95a_B2_RContext::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->enterFld_95a_B2_R(this);
}
void SwiftMtParser_MT565Parser::Fld_95a_B2_RContext::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->exitFld_95a_B2_R(this);
}
SwiftMtParser_MT565Parser::Fld_95a_B2_RContext* SwiftMtParser_MT565Parser::fld_95a_B2_R() {
Fld_95a_B2_RContext *_localctx = _tracker.createInstance<Fld_95a_B2_RContext>(_ctx, getState());
enterRule(_localctx, 182, SwiftMtParser_MT565Parser::RuleFld_95a_B2_R);
_localctx->fld.set_tag("95R");
size_t _la = 0;
auto onExit = finally([=] {
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(1011);
match(SwiftMtParser_MT565Parser::START_OF_FIELD);
setState(1012);
match(SwiftMtParser_MT565Parser::T__17);
setState(1014);
_errHandler->sync(this);
_la = _input->LA(1);
do {
setState(1013);
_la = _input->LA(1);
if (_la == 0 || _la == Token::EOF || (_la == SwiftMtParser_MT565Parser::START_OF_FIELD)) {
_errHandler->recoverInline(this);
}
else {
_errHandler->reportMatch(this);
consume();
}
setState(1016);
_errHandler->sync(this);
_la = _input->LA(1);
} while ((((_la & ~ 0x3fULL) == 0) &&
((1ULL << _la) & ((1ULL << SwiftMtParser_MT565Parser::T__0)
| (1ULL << SwiftMtParser_MT565Parser::T__1)
| (1ULL << SwiftMtParser_MT565Parser::T__2)
| (1ULL << SwiftMtParser_MT565Parser::T__3)
| (1ULL << SwiftMtParser_MT565Parser::T__4)
| (1ULL << SwiftMtParser_MT565Parser::T__5)
| (1ULL << SwiftMtParser_MT565Parser::T__6)
| (1ULL << SwiftMtParser_MT565Parser::T__7)
| (1ULL << SwiftMtParser_MT565Parser::T__8)
| (1ULL << SwiftMtParser_MT565Parser::T__9)
| (1ULL << SwiftMtParser_MT565Parser::T__10)
| (1ULL << SwiftMtParser_MT565Parser::T__11)
| (1ULL << SwiftMtParser_MT565Parser::T__12)
| (1ULL << SwiftMtParser_MT565Parser::T__13)
| (1ULL << SwiftMtParser_MT565Parser::T__14)
| (1ULL << SwiftMtParser_MT565Parser::T__15)
| (1ULL << SwiftMtParser_MT565Parser::T__16)
| (1ULL << SwiftMtParser_MT565Parser::T__17)
| (1ULL << SwiftMtParser_MT565Parser::T__18)
| (1ULL << SwiftMtParser_MT565Parser::T__19)
| (1ULL << SwiftMtParser_MT565Parser::T__20)
| (1ULL << SwiftMtParser_MT565Parser::T__21)
| (1ULL << SwiftMtParser_MT565Parser::T__22)
| (1ULL << SwiftMtParser_MT565Parser::T__23)
| (1ULL << SwiftMtParser_MT565Parser::T__24)
| (1ULL << SwiftMtParser_MT565Parser::T__25)
| (1ULL << SwiftMtParser_MT565Parser::T__26)
| (1ULL << SwiftMtParser_MT565Parser::T__27)
| (1ULL << SwiftMtParser_MT565Parser::T__28)
| (1ULL << SwiftMtParser_MT565Parser::T__29)
| (1ULL << SwiftMtParser_MT565Parser::T__30)
| (1ULL << SwiftMtParser_MT565Parser::T__31)
| (1ULL << SwiftMtParser_MT565Parser::T__32)
| (1ULL << SwiftMtParser_MT565Parser::T__33)
| (1ULL << SwiftMtParser_MT565Parser::T__34)
| (1ULL << SwiftMtParser_MT565Parser::T__35)
| (1ULL << SwiftMtParser_MT565Parser::T__36)
| (1ULL << SwiftMtParser_MT565Parser::T__37)
| (1ULL << SwiftMtParser_MT565Parser::TAG_BH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_AH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_UH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_MT)
| (1ULL << SwiftMtParser_MT565Parser::TAG_TR)
| (1ULL << SwiftMtParser_MT565Parser::MT_END)
| (1ULL << SwiftMtParser_MT565Parser::LBRACE)
| (1ULL << SwiftMtParser_MT565Parser::RBRACE)
| (1ULL << SwiftMtParser_MT565Parser::COLON)
| (1ULL << SwiftMtParser_MT565Parser::ANY))) != 0));
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- Fld_97A_B2_AContext ------------------------------------------------------------------
SwiftMtParser_MT565Parser::Fld_97A_B2_AContext::Fld_97A_B2_AContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
std::vector<tree::TerminalNode *> SwiftMtParser_MT565Parser::Fld_97A_B2_AContext::START_OF_FIELD() {
return getTokens(SwiftMtParser_MT565Parser::START_OF_FIELD);
}
tree::TerminalNode* SwiftMtParser_MT565Parser::Fld_97A_B2_AContext::START_OF_FIELD(size_t i) {
return getToken(SwiftMtParser_MT565Parser::START_OF_FIELD, i);
}
size_t SwiftMtParser_MT565Parser::Fld_97A_B2_AContext::getRuleIndex() const {
return SwiftMtParser_MT565Parser::RuleFld_97A_B2_A;
}
void SwiftMtParser_MT565Parser::Fld_97A_B2_AContext::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->enterFld_97A_B2_A(this);
}
void SwiftMtParser_MT565Parser::Fld_97A_B2_AContext::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->exitFld_97A_B2_A(this);
}
SwiftMtParser_MT565Parser::Fld_97A_B2_AContext* SwiftMtParser_MT565Parser::fld_97A_B2_A() {
Fld_97A_B2_AContext *_localctx = _tracker.createInstance<Fld_97A_B2_AContext>(_ctx, getState());
enterRule(_localctx, 184, SwiftMtParser_MT565Parser::RuleFld_97A_B2_A);
_localctx->fld.set_tag("97A");
size_t _la = 0;
auto onExit = finally([=] {
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(1018);
match(SwiftMtParser_MT565Parser::START_OF_FIELD);
setState(1019);
match(SwiftMtParser_MT565Parser::T__18);
setState(1021);
_errHandler->sync(this);
_la = _input->LA(1);
do {
setState(1020);
_la = _input->LA(1);
if (_la == 0 || _la == Token::EOF || (_la == SwiftMtParser_MT565Parser::START_OF_FIELD)) {
_errHandler->recoverInline(this);
}
else {
_errHandler->reportMatch(this);
consume();
}
setState(1023);
_errHandler->sync(this);
_la = _input->LA(1);
} while ((((_la & ~ 0x3fULL) == 0) &&
((1ULL << _la) & ((1ULL << SwiftMtParser_MT565Parser::T__0)
| (1ULL << SwiftMtParser_MT565Parser::T__1)
| (1ULL << SwiftMtParser_MT565Parser::T__2)
| (1ULL << SwiftMtParser_MT565Parser::T__3)
| (1ULL << SwiftMtParser_MT565Parser::T__4)
| (1ULL << SwiftMtParser_MT565Parser::T__5)
| (1ULL << SwiftMtParser_MT565Parser::T__6)
| (1ULL << SwiftMtParser_MT565Parser::T__7)
| (1ULL << SwiftMtParser_MT565Parser::T__8)
| (1ULL << SwiftMtParser_MT565Parser::T__9)
| (1ULL << SwiftMtParser_MT565Parser::T__10)
| (1ULL << SwiftMtParser_MT565Parser::T__11)
| (1ULL << SwiftMtParser_MT565Parser::T__12)
| (1ULL << SwiftMtParser_MT565Parser::T__13)
| (1ULL << SwiftMtParser_MT565Parser::T__14)
| (1ULL << SwiftMtParser_MT565Parser::T__15)
| (1ULL << SwiftMtParser_MT565Parser::T__16)
| (1ULL << SwiftMtParser_MT565Parser::T__17)
| (1ULL << SwiftMtParser_MT565Parser::T__18)
| (1ULL << SwiftMtParser_MT565Parser::T__19)
| (1ULL << SwiftMtParser_MT565Parser::T__20)
| (1ULL << SwiftMtParser_MT565Parser::T__21)
| (1ULL << SwiftMtParser_MT565Parser::T__22)
| (1ULL << SwiftMtParser_MT565Parser::T__23)
| (1ULL << SwiftMtParser_MT565Parser::T__24)
| (1ULL << SwiftMtParser_MT565Parser::T__25)
| (1ULL << SwiftMtParser_MT565Parser::T__26)
| (1ULL << SwiftMtParser_MT565Parser::T__27)
| (1ULL << SwiftMtParser_MT565Parser::T__28)
| (1ULL << SwiftMtParser_MT565Parser::T__29)
| (1ULL << SwiftMtParser_MT565Parser::T__30)
| (1ULL << SwiftMtParser_MT565Parser::T__31)
| (1ULL << SwiftMtParser_MT565Parser::T__32)
| (1ULL << SwiftMtParser_MT565Parser::T__33)
| (1ULL << SwiftMtParser_MT565Parser::T__34)
| (1ULL << SwiftMtParser_MT565Parser::T__35)
| (1ULL << SwiftMtParser_MT565Parser::T__36)
| (1ULL << SwiftMtParser_MT565Parser::T__37)
| (1ULL << SwiftMtParser_MT565Parser::TAG_BH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_AH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_UH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_MT)
| (1ULL << SwiftMtParser_MT565Parser::TAG_TR)
| (1ULL << SwiftMtParser_MT565Parser::MT_END)
| (1ULL << SwiftMtParser_MT565Parser::LBRACE)
| (1ULL << SwiftMtParser_MT565Parser::RBRACE)
| (1ULL << SwiftMtParser_MT565Parser::COLON)
| (1ULL << SwiftMtParser_MT565Parser::ANY))) != 0));
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- Fld_94a_B2_BContext ------------------------------------------------------------------
SwiftMtParser_MT565Parser::Fld_94a_B2_BContext::Fld_94a_B2_BContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
std::vector<tree::TerminalNode *> SwiftMtParser_MT565Parser::Fld_94a_B2_BContext::START_OF_FIELD() {
return getTokens(SwiftMtParser_MT565Parser::START_OF_FIELD);
}
tree::TerminalNode* SwiftMtParser_MT565Parser::Fld_94a_B2_BContext::START_OF_FIELD(size_t i) {
return getToken(SwiftMtParser_MT565Parser::START_OF_FIELD, i);
}
size_t SwiftMtParser_MT565Parser::Fld_94a_B2_BContext::getRuleIndex() const {
return SwiftMtParser_MT565Parser::RuleFld_94a_B2_B;
}
void SwiftMtParser_MT565Parser::Fld_94a_B2_BContext::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->enterFld_94a_B2_B(this);
}
void SwiftMtParser_MT565Parser::Fld_94a_B2_BContext::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->exitFld_94a_B2_B(this);
}
SwiftMtParser_MT565Parser::Fld_94a_B2_BContext* SwiftMtParser_MT565Parser::fld_94a_B2_B() {
Fld_94a_B2_BContext *_localctx = _tracker.createInstance<Fld_94a_B2_BContext>(_ctx, getState());
enterRule(_localctx, 186, SwiftMtParser_MT565Parser::RuleFld_94a_B2_B);
_localctx->fld.set_tag("94B");
size_t _la = 0;
auto onExit = finally([=] {
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(1025);
match(SwiftMtParser_MT565Parser::START_OF_FIELD);
setState(1026);
match(SwiftMtParser_MT565Parser::T__10);
setState(1028);
_errHandler->sync(this);
_la = _input->LA(1);
do {
setState(1027);
_la = _input->LA(1);
if (_la == 0 || _la == Token::EOF || (_la == SwiftMtParser_MT565Parser::START_OF_FIELD)) {
_errHandler->recoverInline(this);
}
else {
_errHandler->reportMatch(this);
consume();
}
setState(1030);
_errHandler->sync(this);
_la = _input->LA(1);
} while ((((_la & ~ 0x3fULL) == 0) &&
((1ULL << _la) & ((1ULL << SwiftMtParser_MT565Parser::T__0)
| (1ULL << SwiftMtParser_MT565Parser::T__1)
| (1ULL << SwiftMtParser_MT565Parser::T__2)
| (1ULL << SwiftMtParser_MT565Parser::T__3)
| (1ULL << SwiftMtParser_MT565Parser::T__4)
| (1ULL << SwiftMtParser_MT565Parser::T__5)
| (1ULL << SwiftMtParser_MT565Parser::T__6)
| (1ULL << SwiftMtParser_MT565Parser::T__7)
| (1ULL << SwiftMtParser_MT565Parser::T__8)
| (1ULL << SwiftMtParser_MT565Parser::T__9)
| (1ULL << SwiftMtParser_MT565Parser::T__10)
| (1ULL << SwiftMtParser_MT565Parser::T__11)
| (1ULL << SwiftMtParser_MT565Parser::T__12)
| (1ULL << SwiftMtParser_MT565Parser::T__13)
| (1ULL << SwiftMtParser_MT565Parser::T__14)
| (1ULL << SwiftMtParser_MT565Parser::T__15)
| (1ULL << SwiftMtParser_MT565Parser::T__16)
| (1ULL << SwiftMtParser_MT565Parser::T__17)
| (1ULL << SwiftMtParser_MT565Parser::T__18)
| (1ULL << SwiftMtParser_MT565Parser::T__19)
| (1ULL << SwiftMtParser_MT565Parser::T__20)
| (1ULL << SwiftMtParser_MT565Parser::T__21)
| (1ULL << SwiftMtParser_MT565Parser::T__22)
| (1ULL << SwiftMtParser_MT565Parser::T__23)
| (1ULL << SwiftMtParser_MT565Parser::T__24)
| (1ULL << SwiftMtParser_MT565Parser::T__25)
| (1ULL << SwiftMtParser_MT565Parser::T__26)
| (1ULL << SwiftMtParser_MT565Parser::T__27)
| (1ULL << SwiftMtParser_MT565Parser::T__28)
| (1ULL << SwiftMtParser_MT565Parser::T__29)
| (1ULL << SwiftMtParser_MT565Parser::T__30)
| (1ULL << SwiftMtParser_MT565Parser::T__31)
| (1ULL << SwiftMtParser_MT565Parser::T__32)
| (1ULL << SwiftMtParser_MT565Parser::T__33)
| (1ULL << SwiftMtParser_MT565Parser::T__34)
| (1ULL << SwiftMtParser_MT565Parser::T__35)
| (1ULL << SwiftMtParser_MT565Parser::T__36)
| (1ULL << SwiftMtParser_MT565Parser::T__37)
| (1ULL << SwiftMtParser_MT565Parser::TAG_BH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_AH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_UH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_MT)
| (1ULL << SwiftMtParser_MT565Parser::TAG_TR)
| (1ULL << SwiftMtParser_MT565Parser::MT_END)
| (1ULL << SwiftMtParser_MT565Parser::LBRACE)
| (1ULL << SwiftMtParser_MT565Parser::RBRACE)
| (1ULL << SwiftMtParser_MT565Parser::COLON)
| (1ULL << SwiftMtParser_MT565Parser::ANY))) != 0));
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- Fld_94a_B2_CContext ------------------------------------------------------------------
SwiftMtParser_MT565Parser::Fld_94a_B2_CContext::Fld_94a_B2_CContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
std::vector<tree::TerminalNode *> SwiftMtParser_MT565Parser::Fld_94a_B2_CContext::START_OF_FIELD() {
return getTokens(SwiftMtParser_MT565Parser::START_OF_FIELD);
}
tree::TerminalNode* SwiftMtParser_MT565Parser::Fld_94a_B2_CContext::START_OF_FIELD(size_t i) {
return getToken(SwiftMtParser_MT565Parser::START_OF_FIELD, i);
}
size_t SwiftMtParser_MT565Parser::Fld_94a_B2_CContext::getRuleIndex() const {
return SwiftMtParser_MT565Parser::RuleFld_94a_B2_C;
}
void SwiftMtParser_MT565Parser::Fld_94a_B2_CContext::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->enterFld_94a_B2_C(this);
}
void SwiftMtParser_MT565Parser::Fld_94a_B2_CContext::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->exitFld_94a_B2_C(this);
}
SwiftMtParser_MT565Parser::Fld_94a_B2_CContext* SwiftMtParser_MT565Parser::fld_94a_B2_C() {
Fld_94a_B2_CContext *_localctx = _tracker.createInstance<Fld_94a_B2_CContext>(_ctx, getState());
enterRule(_localctx, 188, SwiftMtParser_MT565Parser::RuleFld_94a_B2_C);
_localctx->fld.set_tag("94C");
size_t _la = 0;
auto onExit = finally([=] {
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(1032);
match(SwiftMtParser_MT565Parser::START_OF_FIELD);
setState(1033);
match(SwiftMtParser_MT565Parser::T__19);
setState(1035);
_errHandler->sync(this);
_la = _input->LA(1);
do {
setState(1034);
_la = _input->LA(1);
if (_la == 0 || _la == Token::EOF || (_la == SwiftMtParser_MT565Parser::START_OF_FIELD)) {
_errHandler->recoverInline(this);
}
else {
_errHandler->reportMatch(this);
consume();
}
setState(1037);
_errHandler->sync(this);
_la = _input->LA(1);
} while ((((_la & ~ 0x3fULL) == 0) &&
((1ULL << _la) & ((1ULL << SwiftMtParser_MT565Parser::T__0)
| (1ULL << SwiftMtParser_MT565Parser::T__1)
| (1ULL << SwiftMtParser_MT565Parser::T__2)
| (1ULL << SwiftMtParser_MT565Parser::T__3)
| (1ULL << SwiftMtParser_MT565Parser::T__4)
| (1ULL << SwiftMtParser_MT565Parser::T__5)
| (1ULL << SwiftMtParser_MT565Parser::T__6)
| (1ULL << SwiftMtParser_MT565Parser::T__7)
| (1ULL << SwiftMtParser_MT565Parser::T__8)
| (1ULL << SwiftMtParser_MT565Parser::T__9)
| (1ULL << SwiftMtParser_MT565Parser::T__10)
| (1ULL << SwiftMtParser_MT565Parser::T__11)
| (1ULL << SwiftMtParser_MT565Parser::T__12)
| (1ULL << SwiftMtParser_MT565Parser::T__13)
| (1ULL << SwiftMtParser_MT565Parser::T__14)
| (1ULL << SwiftMtParser_MT565Parser::T__15)
| (1ULL << SwiftMtParser_MT565Parser::T__16)
| (1ULL << SwiftMtParser_MT565Parser::T__17)
| (1ULL << SwiftMtParser_MT565Parser::T__18)
| (1ULL << SwiftMtParser_MT565Parser::T__19)
| (1ULL << SwiftMtParser_MT565Parser::T__20)
| (1ULL << SwiftMtParser_MT565Parser::T__21)
| (1ULL << SwiftMtParser_MT565Parser::T__22)
| (1ULL << SwiftMtParser_MT565Parser::T__23)
| (1ULL << SwiftMtParser_MT565Parser::T__24)
| (1ULL << SwiftMtParser_MT565Parser::T__25)
| (1ULL << SwiftMtParser_MT565Parser::T__26)
| (1ULL << SwiftMtParser_MT565Parser::T__27)
| (1ULL << SwiftMtParser_MT565Parser::T__28)
| (1ULL << SwiftMtParser_MT565Parser::T__29)
| (1ULL << SwiftMtParser_MT565Parser::T__30)
| (1ULL << SwiftMtParser_MT565Parser::T__31)
| (1ULL << SwiftMtParser_MT565Parser::T__32)
| (1ULL << SwiftMtParser_MT565Parser::T__33)
| (1ULL << SwiftMtParser_MT565Parser::T__34)
| (1ULL << SwiftMtParser_MT565Parser::T__35)
| (1ULL << SwiftMtParser_MT565Parser::T__36)
| (1ULL << SwiftMtParser_MT565Parser::T__37)
| (1ULL << SwiftMtParser_MT565Parser::TAG_BH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_AH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_UH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_MT)
| (1ULL << SwiftMtParser_MT565Parser::TAG_TR)
| (1ULL << SwiftMtParser_MT565Parser::MT_END)
| (1ULL << SwiftMtParser_MT565Parser::LBRACE)
| (1ULL << SwiftMtParser_MT565Parser::RBRACE)
| (1ULL << SwiftMtParser_MT565Parser::COLON)
| (1ULL << SwiftMtParser_MT565Parser::ANY))) != 0));
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- Fld_94a_B2_FContext ------------------------------------------------------------------
SwiftMtParser_MT565Parser::Fld_94a_B2_FContext::Fld_94a_B2_FContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
std::vector<tree::TerminalNode *> SwiftMtParser_MT565Parser::Fld_94a_B2_FContext::START_OF_FIELD() {
return getTokens(SwiftMtParser_MT565Parser::START_OF_FIELD);
}
tree::TerminalNode* SwiftMtParser_MT565Parser::Fld_94a_B2_FContext::START_OF_FIELD(size_t i) {
return getToken(SwiftMtParser_MT565Parser::START_OF_FIELD, i);
}
size_t SwiftMtParser_MT565Parser::Fld_94a_B2_FContext::getRuleIndex() const {
return SwiftMtParser_MT565Parser::RuleFld_94a_B2_F;
}
void SwiftMtParser_MT565Parser::Fld_94a_B2_FContext::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->enterFld_94a_B2_F(this);
}
void SwiftMtParser_MT565Parser::Fld_94a_B2_FContext::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->exitFld_94a_B2_F(this);
}
SwiftMtParser_MT565Parser::Fld_94a_B2_FContext* SwiftMtParser_MT565Parser::fld_94a_B2_F() {
Fld_94a_B2_FContext *_localctx = _tracker.createInstance<Fld_94a_B2_FContext>(_ctx, getState());
enterRule(_localctx, 190, SwiftMtParser_MT565Parser::RuleFld_94a_B2_F);
_localctx->fld.set_tag("94F");
size_t _la = 0;
auto onExit = finally([=] {
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(1039);
match(SwiftMtParser_MT565Parser::START_OF_FIELD);
setState(1040);
match(SwiftMtParser_MT565Parser::T__20);
setState(1042);
_errHandler->sync(this);
_la = _input->LA(1);
do {
setState(1041);
_la = _input->LA(1);
if (_la == 0 || _la == Token::EOF || (_la == SwiftMtParser_MT565Parser::START_OF_FIELD)) {
_errHandler->recoverInline(this);
}
else {
_errHandler->reportMatch(this);
consume();
}
setState(1044);
_errHandler->sync(this);
_la = _input->LA(1);
} while ((((_la & ~ 0x3fULL) == 0) &&
((1ULL << _la) & ((1ULL << SwiftMtParser_MT565Parser::T__0)
| (1ULL << SwiftMtParser_MT565Parser::T__1)
| (1ULL << SwiftMtParser_MT565Parser::T__2)
| (1ULL << SwiftMtParser_MT565Parser::T__3)
| (1ULL << SwiftMtParser_MT565Parser::T__4)
| (1ULL << SwiftMtParser_MT565Parser::T__5)
| (1ULL << SwiftMtParser_MT565Parser::T__6)
| (1ULL << SwiftMtParser_MT565Parser::T__7)
| (1ULL << SwiftMtParser_MT565Parser::T__8)
| (1ULL << SwiftMtParser_MT565Parser::T__9)
| (1ULL << SwiftMtParser_MT565Parser::T__10)
| (1ULL << SwiftMtParser_MT565Parser::T__11)
| (1ULL << SwiftMtParser_MT565Parser::T__12)
| (1ULL << SwiftMtParser_MT565Parser::T__13)
| (1ULL << SwiftMtParser_MT565Parser::T__14)
| (1ULL << SwiftMtParser_MT565Parser::T__15)
| (1ULL << SwiftMtParser_MT565Parser::T__16)
| (1ULL << SwiftMtParser_MT565Parser::T__17)
| (1ULL << SwiftMtParser_MT565Parser::T__18)
| (1ULL << SwiftMtParser_MT565Parser::T__19)
| (1ULL << SwiftMtParser_MT565Parser::T__20)
| (1ULL << SwiftMtParser_MT565Parser::T__21)
| (1ULL << SwiftMtParser_MT565Parser::T__22)
| (1ULL << SwiftMtParser_MT565Parser::T__23)
| (1ULL << SwiftMtParser_MT565Parser::T__24)
| (1ULL << SwiftMtParser_MT565Parser::T__25)
| (1ULL << SwiftMtParser_MT565Parser::T__26)
| (1ULL << SwiftMtParser_MT565Parser::T__27)
| (1ULL << SwiftMtParser_MT565Parser::T__28)
| (1ULL << SwiftMtParser_MT565Parser::T__29)
| (1ULL << SwiftMtParser_MT565Parser::T__30)
| (1ULL << SwiftMtParser_MT565Parser::T__31)
| (1ULL << SwiftMtParser_MT565Parser::T__32)
| (1ULL << SwiftMtParser_MT565Parser::T__33)
| (1ULL << SwiftMtParser_MT565Parser::T__34)
| (1ULL << SwiftMtParser_MT565Parser::T__35)
| (1ULL << SwiftMtParser_MT565Parser::T__36)
| (1ULL << SwiftMtParser_MT565Parser::T__37)
| (1ULL << SwiftMtParser_MT565Parser::TAG_BH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_AH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_UH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_MT)
| (1ULL << SwiftMtParser_MT565Parser::TAG_TR)
| (1ULL << SwiftMtParser_MT565Parser::MT_END)
| (1ULL << SwiftMtParser_MT565Parser::LBRACE)
| (1ULL << SwiftMtParser_MT565Parser::RBRACE)
| (1ULL << SwiftMtParser_MT565Parser::COLON)
| (1ULL << SwiftMtParser_MT565Parser::ANY))) != 0));
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- Fld_93a_B2_BContext ------------------------------------------------------------------
SwiftMtParser_MT565Parser::Fld_93a_B2_BContext::Fld_93a_B2_BContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
std::vector<tree::TerminalNode *> SwiftMtParser_MT565Parser::Fld_93a_B2_BContext::START_OF_FIELD() {
return getTokens(SwiftMtParser_MT565Parser::START_OF_FIELD);
}
tree::TerminalNode* SwiftMtParser_MT565Parser::Fld_93a_B2_BContext::START_OF_FIELD(size_t i) {
return getToken(SwiftMtParser_MT565Parser::START_OF_FIELD, i);
}
size_t SwiftMtParser_MT565Parser::Fld_93a_B2_BContext::getRuleIndex() const {
return SwiftMtParser_MT565Parser::RuleFld_93a_B2_B;
}
void SwiftMtParser_MT565Parser::Fld_93a_B2_BContext::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->enterFld_93a_B2_B(this);
}
void SwiftMtParser_MT565Parser::Fld_93a_B2_BContext::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->exitFld_93a_B2_B(this);
}
SwiftMtParser_MT565Parser::Fld_93a_B2_BContext* SwiftMtParser_MT565Parser::fld_93a_B2_B() {
Fld_93a_B2_BContext *_localctx = _tracker.createInstance<Fld_93a_B2_BContext>(_ctx, getState());
enterRule(_localctx, 192, SwiftMtParser_MT565Parser::RuleFld_93a_B2_B);
_localctx->fld.set_tag("93B");
size_t _la = 0;
auto onExit = finally([=] {
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(1046);
match(SwiftMtParser_MT565Parser::START_OF_FIELD);
setState(1047);
match(SwiftMtParser_MT565Parser::T__21);
setState(1049);
_errHandler->sync(this);
_la = _input->LA(1);
do {
setState(1048);
_la = _input->LA(1);
if (_la == 0 || _la == Token::EOF || (_la == SwiftMtParser_MT565Parser::START_OF_FIELD)) {
_errHandler->recoverInline(this);
}
else {
_errHandler->reportMatch(this);
consume();
}
setState(1051);
_errHandler->sync(this);
_la = _input->LA(1);
} while ((((_la & ~ 0x3fULL) == 0) &&
((1ULL << _la) & ((1ULL << SwiftMtParser_MT565Parser::T__0)
| (1ULL << SwiftMtParser_MT565Parser::T__1)
| (1ULL << SwiftMtParser_MT565Parser::T__2)
| (1ULL << SwiftMtParser_MT565Parser::T__3)
| (1ULL << SwiftMtParser_MT565Parser::T__4)
| (1ULL << SwiftMtParser_MT565Parser::T__5)
| (1ULL << SwiftMtParser_MT565Parser::T__6)
| (1ULL << SwiftMtParser_MT565Parser::T__7)
| (1ULL << SwiftMtParser_MT565Parser::T__8)
| (1ULL << SwiftMtParser_MT565Parser::T__9)
| (1ULL << SwiftMtParser_MT565Parser::T__10)
| (1ULL << SwiftMtParser_MT565Parser::T__11)
| (1ULL << SwiftMtParser_MT565Parser::T__12)
| (1ULL << SwiftMtParser_MT565Parser::T__13)
| (1ULL << SwiftMtParser_MT565Parser::T__14)
| (1ULL << SwiftMtParser_MT565Parser::T__15)
| (1ULL << SwiftMtParser_MT565Parser::T__16)
| (1ULL << SwiftMtParser_MT565Parser::T__17)
| (1ULL << SwiftMtParser_MT565Parser::T__18)
| (1ULL << SwiftMtParser_MT565Parser::T__19)
| (1ULL << SwiftMtParser_MT565Parser::T__20)
| (1ULL << SwiftMtParser_MT565Parser::T__21)
| (1ULL << SwiftMtParser_MT565Parser::T__22)
| (1ULL << SwiftMtParser_MT565Parser::T__23)
| (1ULL << SwiftMtParser_MT565Parser::T__24)
| (1ULL << SwiftMtParser_MT565Parser::T__25)
| (1ULL << SwiftMtParser_MT565Parser::T__26)
| (1ULL << SwiftMtParser_MT565Parser::T__27)
| (1ULL << SwiftMtParser_MT565Parser::T__28)
| (1ULL << SwiftMtParser_MT565Parser::T__29)
| (1ULL << SwiftMtParser_MT565Parser::T__30)
| (1ULL << SwiftMtParser_MT565Parser::T__31)
| (1ULL << SwiftMtParser_MT565Parser::T__32)
| (1ULL << SwiftMtParser_MT565Parser::T__33)
| (1ULL << SwiftMtParser_MT565Parser::T__34)
| (1ULL << SwiftMtParser_MT565Parser::T__35)
| (1ULL << SwiftMtParser_MT565Parser::T__36)
| (1ULL << SwiftMtParser_MT565Parser::T__37)
| (1ULL << SwiftMtParser_MT565Parser::TAG_BH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_AH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_UH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_MT)
| (1ULL << SwiftMtParser_MT565Parser::TAG_TR)
| (1ULL << SwiftMtParser_MT565Parser::MT_END)
| (1ULL << SwiftMtParser_MT565Parser::LBRACE)
| (1ULL << SwiftMtParser_MT565Parser::RBRACE)
| (1ULL << SwiftMtParser_MT565Parser::COLON)
| (1ULL << SwiftMtParser_MT565Parser::ANY))) != 0));
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- Fld_93a_B2_CContext ------------------------------------------------------------------
SwiftMtParser_MT565Parser::Fld_93a_B2_CContext::Fld_93a_B2_CContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
std::vector<tree::TerminalNode *> SwiftMtParser_MT565Parser::Fld_93a_B2_CContext::START_OF_FIELD() {
return getTokens(SwiftMtParser_MT565Parser::START_OF_FIELD);
}
tree::TerminalNode* SwiftMtParser_MT565Parser::Fld_93a_B2_CContext::START_OF_FIELD(size_t i) {
return getToken(SwiftMtParser_MT565Parser::START_OF_FIELD, i);
}
size_t SwiftMtParser_MT565Parser::Fld_93a_B2_CContext::getRuleIndex() const {
return SwiftMtParser_MT565Parser::RuleFld_93a_B2_C;
}
void SwiftMtParser_MT565Parser::Fld_93a_B2_CContext::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->enterFld_93a_B2_C(this);
}
void SwiftMtParser_MT565Parser::Fld_93a_B2_CContext::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->exitFld_93a_B2_C(this);
}
SwiftMtParser_MT565Parser::Fld_93a_B2_CContext* SwiftMtParser_MT565Parser::fld_93a_B2_C() {
Fld_93a_B2_CContext *_localctx = _tracker.createInstance<Fld_93a_B2_CContext>(_ctx, getState());
enterRule(_localctx, 194, SwiftMtParser_MT565Parser::RuleFld_93a_B2_C);
_localctx->fld.set_tag("93C");
size_t _la = 0;
auto onExit = finally([=] {
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(1053);
match(SwiftMtParser_MT565Parser::START_OF_FIELD);
setState(1054);
match(SwiftMtParser_MT565Parser::T__22);
setState(1056);
_errHandler->sync(this);
_la = _input->LA(1);
do {
setState(1055);
_la = _input->LA(1);
if (_la == 0 || _la == Token::EOF || (_la == SwiftMtParser_MT565Parser::START_OF_FIELD)) {
_errHandler->recoverInline(this);
}
else {
_errHandler->reportMatch(this);
consume();
}
setState(1058);
_errHandler->sync(this);
_la = _input->LA(1);
} while ((((_la & ~ 0x3fULL) == 0) &&
((1ULL << _la) & ((1ULL << SwiftMtParser_MT565Parser::T__0)
| (1ULL << SwiftMtParser_MT565Parser::T__1)
| (1ULL << SwiftMtParser_MT565Parser::T__2)
| (1ULL << SwiftMtParser_MT565Parser::T__3)
| (1ULL << SwiftMtParser_MT565Parser::T__4)
| (1ULL << SwiftMtParser_MT565Parser::T__5)
| (1ULL << SwiftMtParser_MT565Parser::T__6)
| (1ULL << SwiftMtParser_MT565Parser::T__7)
| (1ULL << SwiftMtParser_MT565Parser::T__8)
| (1ULL << SwiftMtParser_MT565Parser::T__9)
| (1ULL << SwiftMtParser_MT565Parser::T__10)
| (1ULL << SwiftMtParser_MT565Parser::T__11)
| (1ULL << SwiftMtParser_MT565Parser::T__12)
| (1ULL << SwiftMtParser_MT565Parser::T__13)
| (1ULL << SwiftMtParser_MT565Parser::T__14)
| (1ULL << SwiftMtParser_MT565Parser::T__15)
| (1ULL << SwiftMtParser_MT565Parser::T__16)
| (1ULL << SwiftMtParser_MT565Parser::T__17)
| (1ULL << SwiftMtParser_MT565Parser::T__18)
| (1ULL << SwiftMtParser_MT565Parser::T__19)
| (1ULL << SwiftMtParser_MT565Parser::T__20)
| (1ULL << SwiftMtParser_MT565Parser::T__21)
| (1ULL << SwiftMtParser_MT565Parser::T__22)
| (1ULL << SwiftMtParser_MT565Parser::T__23)
| (1ULL << SwiftMtParser_MT565Parser::T__24)
| (1ULL << SwiftMtParser_MT565Parser::T__25)
| (1ULL << SwiftMtParser_MT565Parser::T__26)
| (1ULL << SwiftMtParser_MT565Parser::T__27)
| (1ULL << SwiftMtParser_MT565Parser::T__28)
| (1ULL << SwiftMtParser_MT565Parser::T__29)
| (1ULL << SwiftMtParser_MT565Parser::T__30)
| (1ULL << SwiftMtParser_MT565Parser::T__31)
| (1ULL << SwiftMtParser_MT565Parser::T__32)
| (1ULL << SwiftMtParser_MT565Parser::T__33)
| (1ULL << SwiftMtParser_MT565Parser::T__34)
| (1ULL << SwiftMtParser_MT565Parser::T__35)
| (1ULL << SwiftMtParser_MT565Parser::T__36)
| (1ULL << SwiftMtParser_MT565Parser::T__37)
| (1ULL << SwiftMtParser_MT565Parser::TAG_BH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_AH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_UH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_MT)
| (1ULL << SwiftMtParser_MT565Parser::TAG_TR)
| (1ULL << SwiftMtParser_MT565Parser::MT_END)
| (1ULL << SwiftMtParser_MT565Parser::LBRACE)
| (1ULL << SwiftMtParser_MT565Parser::RBRACE)
| (1ULL << SwiftMtParser_MT565Parser::COLON)
| (1ULL << SwiftMtParser_MT565Parser::ANY))) != 0));
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- Fld_95a_C_PContext ------------------------------------------------------------------
SwiftMtParser_MT565Parser::Fld_95a_C_PContext::Fld_95a_C_PContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
std::vector<tree::TerminalNode *> SwiftMtParser_MT565Parser::Fld_95a_C_PContext::START_OF_FIELD() {
return getTokens(SwiftMtParser_MT565Parser::START_OF_FIELD);
}
tree::TerminalNode* SwiftMtParser_MT565Parser::Fld_95a_C_PContext::START_OF_FIELD(size_t i) {
return getToken(SwiftMtParser_MT565Parser::START_OF_FIELD, i);
}
size_t SwiftMtParser_MT565Parser::Fld_95a_C_PContext::getRuleIndex() const {
return SwiftMtParser_MT565Parser::RuleFld_95a_C_P;
}
void SwiftMtParser_MT565Parser::Fld_95a_C_PContext::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->enterFld_95a_C_P(this);
}
void SwiftMtParser_MT565Parser::Fld_95a_C_PContext::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->exitFld_95a_C_P(this);
}
SwiftMtParser_MT565Parser::Fld_95a_C_PContext* SwiftMtParser_MT565Parser::fld_95a_C_P() {
Fld_95a_C_PContext *_localctx = _tracker.createInstance<Fld_95a_C_PContext>(_ctx, getState());
enterRule(_localctx, 196, SwiftMtParser_MT565Parser::RuleFld_95a_C_P);
_localctx->fld.set_tag("95P");
size_t _la = 0;
auto onExit = finally([=] {
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(1060);
match(SwiftMtParser_MT565Parser::START_OF_FIELD);
setState(1061);
match(SwiftMtParser_MT565Parser::T__16);
setState(1063);
_errHandler->sync(this);
_la = _input->LA(1);
do {
setState(1062);
_la = _input->LA(1);
if (_la == 0 || _la == Token::EOF || (_la == SwiftMtParser_MT565Parser::START_OF_FIELD)) {
_errHandler->recoverInline(this);
}
else {
_errHandler->reportMatch(this);
consume();
}
setState(1065);
_errHandler->sync(this);
_la = _input->LA(1);
} while ((((_la & ~ 0x3fULL) == 0) &&
((1ULL << _la) & ((1ULL << SwiftMtParser_MT565Parser::T__0)
| (1ULL << SwiftMtParser_MT565Parser::T__1)
| (1ULL << SwiftMtParser_MT565Parser::T__2)
| (1ULL << SwiftMtParser_MT565Parser::T__3)
| (1ULL << SwiftMtParser_MT565Parser::T__4)
| (1ULL << SwiftMtParser_MT565Parser::T__5)
| (1ULL << SwiftMtParser_MT565Parser::T__6)
| (1ULL << SwiftMtParser_MT565Parser::T__7)
| (1ULL << SwiftMtParser_MT565Parser::T__8)
| (1ULL << SwiftMtParser_MT565Parser::T__9)
| (1ULL << SwiftMtParser_MT565Parser::T__10)
| (1ULL << SwiftMtParser_MT565Parser::T__11)
| (1ULL << SwiftMtParser_MT565Parser::T__12)
| (1ULL << SwiftMtParser_MT565Parser::T__13)
| (1ULL << SwiftMtParser_MT565Parser::T__14)
| (1ULL << SwiftMtParser_MT565Parser::T__15)
| (1ULL << SwiftMtParser_MT565Parser::T__16)
| (1ULL << SwiftMtParser_MT565Parser::T__17)
| (1ULL << SwiftMtParser_MT565Parser::T__18)
| (1ULL << SwiftMtParser_MT565Parser::T__19)
| (1ULL << SwiftMtParser_MT565Parser::T__20)
| (1ULL << SwiftMtParser_MT565Parser::T__21)
| (1ULL << SwiftMtParser_MT565Parser::T__22)
| (1ULL << SwiftMtParser_MT565Parser::T__23)
| (1ULL << SwiftMtParser_MT565Parser::T__24)
| (1ULL << SwiftMtParser_MT565Parser::T__25)
| (1ULL << SwiftMtParser_MT565Parser::T__26)
| (1ULL << SwiftMtParser_MT565Parser::T__27)
| (1ULL << SwiftMtParser_MT565Parser::T__28)
| (1ULL << SwiftMtParser_MT565Parser::T__29)
| (1ULL << SwiftMtParser_MT565Parser::T__30)
| (1ULL << SwiftMtParser_MT565Parser::T__31)
| (1ULL << SwiftMtParser_MT565Parser::T__32)
| (1ULL << SwiftMtParser_MT565Parser::T__33)
| (1ULL << SwiftMtParser_MT565Parser::T__34)
| (1ULL << SwiftMtParser_MT565Parser::T__35)
| (1ULL << SwiftMtParser_MT565Parser::T__36)
| (1ULL << SwiftMtParser_MT565Parser::T__37)
| (1ULL << SwiftMtParser_MT565Parser::TAG_BH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_AH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_UH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_MT)
| (1ULL << SwiftMtParser_MT565Parser::TAG_TR)
| (1ULL << SwiftMtParser_MT565Parser::MT_END)
| (1ULL << SwiftMtParser_MT565Parser::LBRACE)
| (1ULL << SwiftMtParser_MT565Parser::RBRACE)
| (1ULL << SwiftMtParser_MT565Parser::COLON)
| (1ULL << SwiftMtParser_MT565Parser::ANY))) != 0));
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- Fld_95a_C_RContext ------------------------------------------------------------------
SwiftMtParser_MT565Parser::Fld_95a_C_RContext::Fld_95a_C_RContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
std::vector<tree::TerminalNode *> SwiftMtParser_MT565Parser::Fld_95a_C_RContext::START_OF_FIELD() {
return getTokens(SwiftMtParser_MT565Parser::START_OF_FIELD);
}
tree::TerminalNode* SwiftMtParser_MT565Parser::Fld_95a_C_RContext::START_OF_FIELD(size_t i) {
return getToken(SwiftMtParser_MT565Parser::START_OF_FIELD, i);
}
size_t SwiftMtParser_MT565Parser::Fld_95a_C_RContext::getRuleIndex() const {
return SwiftMtParser_MT565Parser::RuleFld_95a_C_R;
}
void SwiftMtParser_MT565Parser::Fld_95a_C_RContext::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->enterFld_95a_C_R(this);
}
void SwiftMtParser_MT565Parser::Fld_95a_C_RContext::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->exitFld_95a_C_R(this);
}
SwiftMtParser_MT565Parser::Fld_95a_C_RContext* SwiftMtParser_MT565Parser::fld_95a_C_R() {
Fld_95a_C_RContext *_localctx = _tracker.createInstance<Fld_95a_C_RContext>(_ctx, getState());
enterRule(_localctx, 198, SwiftMtParser_MT565Parser::RuleFld_95a_C_R);
_localctx->fld.set_tag("95R");
size_t _la = 0;
auto onExit = finally([=] {
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(1067);
match(SwiftMtParser_MT565Parser::START_OF_FIELD);
setState(1068);
match(SwiftMtParser_MT565Parser::T__17);
setState(1070);
_errHandler->sync(this);
_la = _input->LA(1);
do {
setState(1069);
_la = _input->LA(1);
if (_la == 0 || _la == Token::EOF || (_la == SwiftMtParser_MT565Parser::START_OF_FIELD)) {
_errHandler->recoverInline(this);
}
else {
_errHandler->reportMatch(this);
consume();
}
setState(1072);
_errHandler->sync(this);
_la = _input->LA(1);
} while ((((_la & ~ 0x3fULL) == 0) &&
((1ULL << _la) & ((1ULL << SwiftMtParser_MT565Parser::T__0)
| (1ULL << SwiftMtParser_MT565Parser::T__1)
| (1ULL << SwiftMtParser_MT565Parser::T__2)
| (1ULL << SwiftMtParser_MT565Parser::T__3)
| (1ULL << SwiftMtParser_MT565Parser::T__4)
| (1ULL << SwiftMtParser_MT565Parser::T__5)
| (1ULL << SwiftMtParser_MT565Parser::T__6)
| (1ULL << SwiftMtParser_MT565Parser::T__7)
| (1ULL << SwiftMtParser_MT565Parser::T__8)
| (1ULL << SwiftMtParser_MT565Parser::T__9)
| (1ULL << SwiftMtParser_MT565Parser::T__10)
| (1ULL << SwiftMtParser_MT565Parser::T__11)
| (1ULL << SwiftMtParser_MT565Parser::T__12)
| (1ULL << SwiftMtParser_MT565Parser::T__13)
| (1ULL << SwiftMtParser_MT565Parser::T__14)
| (1ULL << SwiftMtParser_MT565Parser::T__15)
| (1ULL << SwiftMtParser_MT565Parser::T__16)
| (1ULL << SwiftMtParser_MT565Parser::T__17)
| (1ULL << SwiftMtParser_MT565Parser::T__18)
| (1ULL << SwiftMtParser_MT565Parser::T__19)
| (1ULL << SwiftMtParser_MT565Parser::T__20)
| (1ULL << SwiftMtParser_MT565Parser::T__21)
| (1ULL << SwiftMtParser_MT565Parser::T__22)
| (1ULL << SwiftMtParser_MT565Parser::T__23)
| (1ULL << SwiftMtParser_MT565Parser::T__24)
| (1ULL << SwiftMtParser_MT565Parser::T__25)
| (1ULL << SwiftMtParser_MT565Parser::T__26)
| (1ULL << SwiftMtParser_MT565Parser::T__27)
| (1ULL << SwiftMtParser_MT565Parser::T__28)
| (1ULL << SwiftMtParser_MT565Parser::T__29)
| (1ULL << SwiftMtParser_MT565Parser::T__30)
| (1ULL << SwiftMtParser_MT565Parser::T__31)
| (1ULL << SwiftMtParser_MT565Parser::T__32)
| (1ULL << SwiftMtParser_MT565Parser::T__33)
| (1ULL << SwiftMtParser_MT565Parser::T__34)
| (1ULL << SwiftMtParser_MT565Parser::T__35)
| (1ULL << SwiftMtParser_MT565Parser::T__36)
| (1ULL << SwiftMtParser_MT565Parser::T__37)
| (1ULL << SwiftMtParser_MT565Parser::TAG_BH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_AH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_UH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_MT)
| (1ULL << SwiftMtParser_MT565Parser::TAG_TR)
| (1ULL << SwiftMtParser_MT565Parser::MT_END)
| (1ULL << SwiftMtParser_MT565Parser::LBRACE)
| (1ULL << SwiftMtParser_MT565Parser::RBRACE)
| (1ULL << SwiftMtParser_MT565Parser::COLON)
| (1ULL << SwiftMtParser_MT565Parser::ANY))) != 0));
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- Fld_95a_C_SContext ------------------------------------------------------------------
SwiftMtParser_MT565Parser::Fld_95a_C_SContext::Fld_95a_C_SContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
std::vector<tree::TerminalNode *> SwiftMtParser_MT565Parser::Fld_95a_C_SContext::START_OF_FIELD() {
return getTokens(SwiftMtParser_MT565Parser::START_OF_FIELD);
}
tree::TerminalNode* SwiftMtParser_MT565Parser::Fld_95a_C_SContext::START_OF_FIELD(size_t i) {
return getToken(SwiftMtParser_MT565Parser::START_OF_FIELD, i);
}
size_t SwiftMtParser_MT565Parser::Fld_95a_C_SContext::getRuleIndex() const {
return SwiftMtParser_MT565Parser::RuleFld_95a_C_S;
}
void SwiftMtParser_MT565Parser::Fld_95a_C_SContext::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->enterFld_95a_C_S(this);
}
void SwiftMtParser_MT565Parser::Fld_95a_C_SContext::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->exitFld_95a_C_S(this);
}
SwiftMtParser_MT565Parser::Fld_95a_C_SContext* SwiftMtParser_MT565Parser::fld_95a_C_S() {
Fld_95a_C_SContext *_localctx = _tracker.createInstance<Fld_95a_C_SContext>(_ctx, getState());
enterRule(_localctx, 200, SwiftMtParser_MT565Parser::RuleFld_95a_C_S);
_localctx->fld.set_tag("95S");
size_t _la = 0;
auto onExit = finally([=] {
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(1074);
match(SwiftMtParser_MT565Parser::START_OF_FIELD);
setState(1075);
match(SwiftMtParser_MT565Parser::T__23);
setState(1077);
_errHandler->sync(this);
_la = _input->LA(1);
do {
setState(1076);
_la = _input->LA(1);
if (_la == 0 || _la == Token::EOF || (_la == SwiftMtParser_MT565Parser::START_OF_FIELD)) {
_errHandler->recoverInline(this);
}
else {
_errHandler->reportMatch(this);
consume();
}
setState(1079);
_errHandler->sync(this);
_la = _input->LA(1);
} while ((((_la & ~ 0x3fULL) == 0) &&
((1ULL << _la) & ((1ULL << SwiftMtParser_MT565Parser::T__0)
| (1ULL << SwiftMtParser_MT565Parser::T__1)
| (1ULL << SwiftMtParser_MT565Parser::T__2)
| (1ULL << SwiftMtParser_MT565Parser::T__3)
| (1ULL << SwiftMtParser_MT565Parser::T__4)
| (1ULL << SwiftMtParser_MT565Parser::T__5)
| (1ULL << SwiftMtParser_MT565Parser::T__6)
| (1ULL << SwiftMtParser_MT565Parser::T__7)
| (1ULL << SwiftMtParser_MT565Parser::T__8)
| (1ULL << SwiftMtParser_MT565Parser::T__9)
| (1ULL << SwiftMtParser_MT565Parser::T__10)
| (1ULL << SwiftMtParser_MT565Parser::T__11)
| (1ULL << SwiftMtParser_MT565Parser::T__12)
| (1ULL << SwiftMtParser_MT565Parser::T__13)
| (1ULL << SwiftMtParser_MT565Parser::T__14)
| (1ULL << SwiftMtParser_MT565Parser::T__15)
| (1ULL << SwiftMtParser_MT565Parser::T__16)
| (1ULL << SwiftMtParser_MT565Parser::T__17)
| (1ULL << SwiftMtParser_MT565Parser::T__18)
| (1ULL << SwiftMtParser_MT565Parser::T__19)
| (1ULL << SwiftMtParser_MT565Parser::T__20)
| (1ULL << SwiftMtParser_MT565Parser::T__21)
| (1ULL << SwiftMtParser_MT565Parser::T__22)
| (1ULL << SwiftMtParser_MT565Parser::T__23)
| (1ULL << SwiftMtParser_MT565Parser::T__24)
| (1ULL << SwiftMtParser_MT565Parser::T__25)
| (1ULL << SwiftMtParser_MT565Parser::T__26)
| (1ULL << SwiftMtParser_MT565Parser::T__27)
| (1ULL << SwiftMtParser_MT565Parser::T__28)
| (1ULL << SwiftMtParser_MT565Parser::T__29)
| (1ULL << SwiftMtParser_MT565Parser::T__30)
| (1ULL << SwiftMtParser_MT565Parser::T__31)
| (1ULL << SwiftMtParser_MT565Parser::T__32)
| (1ULL << SwiftMtParser_MT565Parser::T__33)
| (1ULL << SwiftMtParser_MT565Parser::T__34)
| (1ULL << SwiftMtParser_MT565Parser::T__35)
| (1ULL << SwiftMtParser_MT565Parser::T__36)
| (1ULL << SwiftMtParser_MT565Parser::T__37)
| (1ULL << SwiftMtParser_MT565Parser::TAG_BH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_AH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_UH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_MT)
| (1ULL << SwiftMtParser_MT565Parser::TAG_TR)
| (1ULL << SwiftMtParser_MT565Parser::MT_END)
| (1ULL << SwiftMtParser_MT565Parser::LBRACE)
| (1ULL << SwiftMtParser_MT565Parser::RBRACE)
| (1ULL << SwiftMtParser_MT565Parser::COLON)
| (1ULL << SwiftMtParser_MT565Parser::ANY))) != 0));
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- Fld_95a_C_VContext ------------------------------------------------------------------
SwiftMtParser_MT565Parser::Fld_95a_C_VContext::Fld_95a_C_VContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
std::vector<tree::TerminalNode *> SwiftMtParser_MT565Parser::Fld_95a_C_VContext::START_OF_FIELD() {
return getTokens(SwiftMtParser_MT565Parser::START_OF_FIELD);
}
tree::TerminalNode* SwiftMtParser_MT565Parser::Fld_95a_C_VContext::START_OF_FIELD(size_t i) {
return getToken(SwiftMtParser_MT565Parser::START_OF_FIELD, i);
}
size_t SwiftMtParser_MT565Parser::Fld_95a_C_VContext::getRuleIndex() const {
return SwiftMtParser_MT565Parser::RuleFld_95a_C_V;
}
void SwiftMtParser_MT565Parser::Fld_95a_C_VContext::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->enterFld_95a_C_V(this);
}
void SwiftMtParser_MT565Parser::Fld_95a_C_VContext::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->exitFld_95a_C_V(this);
}
SwiftMtParser_MT565Parser::Fld_95a_C_VContext* SwiftMtParser_MT565Parser::fld_95a_C_V() {
Fld_95a_C_VContext *_localctx = _tracker.createInstance<Fld_95a_C_VContext>(_ctx, getState());
enterRule(_localctx, 202, SwiftMtParser_MT565Parser::RuleFld_95a_C_V);
_localctx->fld.set_tag("95V");
size_t _la = 0;
auto onExit = finally([=] {
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(1081);
match(SwiftMtParser_MT565Parser::START_OF_FIELD);
setState(1082);
match(SwiftMtParser_MT565Parser::T__24);
setState(1084);
_errHandler->sync(this);
_la = _input->LA(1);
do {
setState(1083);
_la = _input->LA(1);
if (_la == 0 || _la == Token::EOF || (_la == SwiftMtParser_MT565Parser::START_OF_FIELD)) {
_errHandler->recoverInline(this);
}
else {
_errHandler->reportMatch(this);
consume();
}
setState(1086);
_errHandler->sync(this);
_la = _input->LA(1);
} while ((((_la & ~ 0x3fULL) == 0) &&
((1ULL << _la) & ((1ULL << SwiftMtParser_MT565Parser::T__0)
| (1ULL << SwiftMtParser_MT565Parser::T__1)
| (1ULL << SwiftMtParser_MT565Parser::T__2)
| (1ULL << SwiftMtParser_MT565Parser::T__3)
| (1ULL << SwiftMtParser_MT565Parser::T__4)
| (1ULL << SwiftMtParser_MT565Parser::T__5)
| (1ULL << SwiftMtParser_MT565Parser::T__6)
| (1ULL << SwiftMtParser_MT565Parser::T__7)
| (1ULL << SwiftMtParser_MT565Parser::T__8)
| (1ULL << SwiftMtParser_MT565Parser::T__9)
| (1ULL << SwiftMtParser_MT565Parser::T__10)
| (1ULL << SwiftMtParser_MT565Parser::T__11)
| (1ULL << SwiftMtParser_MT565Parser::T__12)
| (1ULL << SwiftMtParser_MT565Parser::T__13)
| (1ULL << SwiftMtParser_MT565Parser::T__14)
| (1ULL << SwiftMtParser_MT565Parser::T__15)
| (1ULL << SwiftMtParser_MT565Parser::T__16)
| (1ULL << SwiftMtParser_MT565Parser::T__17)
| (1ULL << SwiftMtParser_MT565Parser::T__18)
| (1ULL << SwiftMtParser_MT565Parser::T__19)
| (1ULL << SwiftMtParser_MT565Parser::T__20)
| (1ULL << SwiftMtParser_MT565Parser::T__21)
| (1ULL << SwiftMtParser_MT565Parser::T__22)
| (1ULL << SwiftMtParser_MT565Parser::T__23)
| (1ULL << SwiftMtParser_MT565Parser::T__24)
| (1ULL << SwiftMtParser_MT565Parser::T__25)
| (1ULL << SwiftMtParser_MT565Parser::T__26)
| (1ULL << SwiftMtParser_MT565Parser::T__27)
| (1ULL << SwiftMtParser_MT565Parser::T__28)
| (1ULL << SwiftMtParser_MT565Parser::T__29)
| (1ULL << SwiftMtParser_MT565Parser::T__30)
| (1ULL << SwiftMtParser_MT565Parser::T__31)
| (1ULL << SwiftMtParser_MT565Parser::T__32)
| (1ULL << SwiftMtParser_MT565Parser::T__33)
| (1ULL << SwiftMtParser_MT565Parser::T__34)
| (1ULL << SwiftMtParser_MT565Parser::T__35)
| (1ULL << SwiftMtParser_MT565Parser::T__36)
| (1ULL << SwiftMtParser_MT565Parser::T__37)
| (1ULL << SwiftMtParser_MT565Parser::TAG_BH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_AH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_UH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_MT)
| (1ULL << SwiftMtParser_MT565Parser::TAG_TR)
| (1ULL << SwiftMtParser_MT565Parser::MT_END)
| (1ULL << SwiftMtParser_MT565Parser::LBRACE)
| (1ULL << SwiftMtParser_MT565Parser::RBRACE)
| (1ULL << SwiftMtParser_MT565Parser::COLON)
| (1ULL << SwiftMtParser_MT565Parser::ANY))) != 0));
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- Fld_94C_C_CContext ------------------------------------------------------------------
SwiftMtParser_MT565Parser::Fld_94C_C_CContext::Fld_94C_C_CContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
std::vector<tree::TerminalNode *> SwiftMtParser_MT565Parser::Fld_94C_C_CContext::START_OF_FIELD() {
return getTokens(SwiftMtParser_MT565Parser::START_OF_FIELD);
}
tree::TerminalNode* SwiftMtParser_MT565Parser::Fld_94C_C_CContext::START_OF_FIELD(size_t i) {
return getToken(SwiftMtParser_MT565Parser::START_OF_FIELD, i);
}
size_t SwiftMtParser_MT565Parser::Fld_94C_C_CContext::getRuleIndex() const {
return SwiftMtParser_MT565Parser::RuleFld_94C_C_C;
}
void SwiftMtParser_MT565Parser::Fld_94C_C_CContext::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->enterFld_94C_C_C(this);
}
void SwiftMtParser_MT565Parser::Fld_94C_C_CContext::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->exitFld_94C_C_C(this);
}
SwiftMtParser_MT565Parser::Fld_94C_C_CContext* SwiftMtParser_MT565Parser::fld_94C_C_C() {
Fld_94C_C_CContext *_localctx = _tracker.createInstance<Fld_94C_C_CContext>(_ctx, getState());
enterRule(_localctx, 204, SwiftMtParser_MT565Parser::RuleFld_94C_C_C);
_localctx->fld.set_tag("94C");
size_t _la = 0;
auto onExit = finally([=] {
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(1088);
match(SwiftMtParser_MT565Parser::START_OF_FIELD);
setState(1089);
match(SwiftMtParser_MT565Parser::T__19);
setState(1091);
_errHandler->sync(this);
_la = _input->LA(1);
do {
setState(1090);
_la = _input->LA(1);
if (_la == 0 || _la == Token::EOF || (_la == SwiftMtParser_MT565Parser::START_OF_FIELD)) {
_errHandler->recoverInline(this);
}
else {
_errHandler->reportMatch(this);
consume();
}
setState(1093);
_errHandler->sync(this);
_la = _input->LA(1);
} while ((((_la & ~ 0x3fULL) == 0) &&
((1ULL << _la) & ((1ULL << SwiftMtParser_MT565Parser::T__0)
| (1ULL << SwiftMtParser_MT565Parser::T__1)
| (1ULL << SwiftMtParser_MT565Parser::T__2)
| (1ULL << SwiftMtParser_MT565Parser::T__3)
| (1ULL << SwiftMtParser_MT565Parser::T__4)
| (1ULL << SwiftMtParser_MT565Parser::T__5)
| (1ULL << SwiftMtParser_MT565Parser::T__6)
| (1ULL << SwiftMtParser_MT565Parser::T__7)
| (1ULL << SwiftMtParser_MT565Parser::T__8)
| (1ULL << SwiftMtParser_MT565Parser::T__9)
| (1ULL << SwiftMtParser_MT565Parser::T__10)
| (1ULL << SwiftMtParser_MT565Parser::T__11)
| (1ULL << SwiftMtParser_MT565Parser::T__12)
| (1ULL << SwiftMtParser_MT565Parser::T__13)
| (1ULL << SwiftMtParser_MT565Parser::T__14)
| (1ULL << SwiftMtParser_MT565Parser::T__15)
| (1ULL << SwiftMtParser_MT565Parser::T__16)
| (1ULL << SwiftMtParser_MT565Parser::T__17)
| (1ULL << SwiftMtParser_MT565Parser::T__18)
| (1ULL << SwiftMtParser_MT565Parser::T__19)
| (1ULL << SwiftMtParser_MT565Parser::T__20)
| (1ULL << SwiftMtParser_MT565Parser::T__21)
| (1ULL << SwiftMtParser_MT565Parser::T__22)
| (1ULL << SwiftMtParser_MT565Parser::T__23)
| (1ULL << SwiftMtParser_MT565Parser::T__24)
| (1ULL << SwiftMtParser_MT565Parser::T__25)
| (1ULL << SwiftMtParser_MT565Parser::T__26)
| (1ULL << SwiftMtParser_MT565Parser::T__27)
| (1ULL << SwiftMtParser_MT565Parser::T__28)
| (1ULL << SwiftMtParser_MT565Parser::T__29)
| (1ULL << SwiftMtParser_MT565Parser::T__30)
| (1ULL << SwiftMtParser_MT565Parser::T__31)
| (1ULL << SwiftMtParser_MT565Parser::T__32)
| (1ULL << SwiftMtParser_MT565Parser::T__33)
| (1ULL << SwiftMtParser_MT565Parser::T__34)
| (1ULL << SwiftMtParser_MT565Parser::T__35)
| (1ULL << SwiftMtParser_MT565Parser::T__36)
| (1ULL << SwiftMtParser_MT565Parser::T__37)
| (1ULL << SwiftMtParser_MT565Parser::TAG_BH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_AH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_UH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_MT)
| (1ULL << SwiftMtParser_MT565Parser::TAG_TR)
| (1ULL << SwiftMtParser_MT565Parser::MT_END)
| (1ULL << SwiftMtParser_MT565Parser::LBRACE)
| (1ULL << SwiftMtParser_MT565Parser::RBRACE)
| (1ULL << SwiftMtParser_MT565Parser::COLON)
| (1ULL << SwiftMtParser_MT565Parser::ANY))) != 0));
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- Fld_36B_C_BContext ------------------------------------------------------------------
SwiftMtParser_MT565Parser::Fld_36B_C_BContext::Fld_36B_C_BContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
std::vector<tree::TerminalNode *> SwiftMtParser_MT565Parser::Fld_36B_C_BContext::START_OF_FIELD() {
return getTokens(SwiftMtParser_MT565Parser::START_OF_FIELD);
}
tree::TerminalNode* SwiftMtParser_MT565Parser::Fld_36B_C_BContext::START_OF_FIELD(size_t i) {
return getToken(SwiftMtParser_MT565Parser::START_OF_FIELD, i);
}
size_t SwiftMtParser_MT565Parser::Fld_36B_C_BContext::getRuleIndex() const {
return SwiftMtParser_MT565Parser::RuleFld_36B_C_B;
}
void SwiftMtParser_MT565Parser::Fld_36B_C_BContext::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->enterFld_36B_C_B(this);
}
void SwiftMtParser_MT565Parser::Fld_36B_C_BContext::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->exitFld_36B_C_B(this);
}
SwiftMtParser_MT565Parser::Fld_36B_C_BContext* SwiftMtParser_MT565Parser::fld_36B_C_B() {
Fld_36B_C_BContext *_localctx = _tracker.createInstance<Fld_36B_C_BContext>(_ctx, getState());
enterRule(_localctx, 206, SwiftMtParser_MT565Parser::RuleFld_36B_C_B);
_localctx->fld.set_tag("36B");
size_t _la = 0;
auto onExit = finally([=] {
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(1095);
match(SwiftMtParser_MT565Parser::START_OF_FIELD);
setState(1096);
match(SwiftMtParser_MT565Parser::T__15);
setState(1098);
_errHandler->sync(this);
_la = _input->LA(1);
do {
setState(1097);
_la = _input->LA(1);
if (_la == 0 || _la == Token::EOF || (_la == SwiftMtParser_MT565Parser::START_OF_FIELD)) {
_errHandler->recoverInline(this);
}
else {
_errHandler->reportMatch(this);
consume();
}
setState(1100);
_errHandler->sync(this);
_la = _input->LA(1);
} while ((((_la & ~ 0x3fULL) == 0) &&
((1ULL << _la) & ((1ULL << SwiftMtParser_MT565Parser::T__0)
| (1ULL << SwiftMtParser_MT565Parser::T__1)
| (1ULL << SwiftMtParser_MT565Parser::T__2)
| (1ULL << SwiftMtParser_MT565Parser::T__3)
| (1ULL << SwiftMtParser_MT565Parser::T__4)
| (1ULL << SwiftMtParser_MT565Parser::T__5)
| (1ULL << SwiftMtParser_MT565Parser::T__6)
| (1ULL << SwiftMtParser_MT565Parser::T__7)
| (1ULL << SwiftMtParser_MT565Parser::T__8)
| (1ULL << SwiftMtParser_MT565Parser::T__9)
| (1ULL << SwiftMtParser_MT565Parser::T__10)
| (1ULL << SwiftMtParser_MT565Parser::T__11)
| (1ULL << SwiftMtParser_MT565Parser::T__12)
| (1ULL << SwiftMtParser_MT565Parser::T__13)
| (1ULL << SwiftMtParser_MT565Parser::T__14)
| (1ULL << SwiftMtParser_MT565Parser::T__15)
| (1ULL << SwiftMtParser_MT565Parser::T__16)
| (1ULL << SwiftMtParser_MT565Parser::T__17)
| (1ULL << SwiftMtParser_MT565Parser::T__18)
| (1ULL << SwiftMtParser_MT565Parser::T__19)
| (1ULL << SwiftMtParser_MT565Parser::T__20)
| (1ULL << SwiftMtParser_MT565Parser::T__21)
| (1ULL << SwiftMtParser_MT565Parser::T__22)
| (1ULL << SwiftMtParser_MT565Parser::T__23)
| (1ULL << SwiftMtParser_MT565Parser::T__24)
| (1ULL << SwiftMtParser_MT565Parser::T__25)
| (1ULL << SwiftMtParser_MT565Parser::T__26)
| (1ULL << SwiftMtParser_MT565Parser::T__27)
| (1ULL << SwiftMtParser_MT565Parser::T__28)
| (1ULL << SwiftMtParser_MT565Parser::T__29)
| (1ULL << SwiftMtParser_MT565Parser::T__30)
| (1ULL << SwiftMtParser_MT565Parser::T__31)
| (1ULL << SwiftMtParser_MT565Parser::T__32)
| (1ULL << SwiftMtParser_MT565Parser::T__33)
| (1ULL << SwiftMtParser_MT565Parser::T__34)
| (1ULL << SwiftMtParser_MT565Parser::T__35)
| (1ULL << SwiftMtParser_MT565Parser::T__36)
| (1ULL << SwiftMtParser_MT565Parser::T__37)
| (1ULL << SwiftMtParser_MT565Parser::TAG_BH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_AH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_UH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_MT)
| (1ULL << SwiftMtParser_MT565Parser::TAG_TR)
| (1ULL << SwiftMtParser_MT565Parser::MT_END)
| (1ULL << SwiftMtParser_MT565Parser::LBRACE)
| (1ULL << SwiftMtParser_MT565Parser::RBRACE)
| (1ULL << SwiftMtParser_MT565Parser::COLON)
| (1ULL << SwiftMtParser_MT565Parser::ANY))) != 0));
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- Fld_22F_C_FContext ------------------------------------------------------------------
SwiftMtParser_MT565Parser::Fld_22F_C_FContext::Fld_22F_C_FContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
std::vector<tree::TerminalNode *> SwiftMtParser_MT565Parser::Fld_22F_C_FContext::START_OF_FIELD() {
return getTokens(SwiftMtParser_MT565Parser::START_OF_FIELD);
}
tree::TerminalNode* SwiftMtParser_MT565Parser::Fld_22F_C_FContext::START_OF_FIELD(size_t i) {
return getToken(SwiftMtParser_MT565Parser::START_OF_FIELD, i);
}
size_t SwiftMtParser_MT565Parser::Fld_22F_C_FContext::getRuleIndex() const {
return SwiftMtParser_MT565Parser::RuleFld_22F_C_F;
}
void SwiftMtParser_MT565Parser::Fld_22F_C_FContext::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->enterFld_22F_C_F(this);
}
void SwiftMtParser_MT565Parser::Fld_22F_C_FContext::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->exitFld_22F_C_F(this);
}
SwiftMtParser_MT565Parser::Fld_22F_C_FContext* SwiftMtParser_MT565Parser::fld_22F_C_F() {
Fld_22F_C_FContext *_localctx = _tracker.createInstance<Fld_22F_C_FContext>(_ctx, getState());
enterRule(_localctx, 208, SwiftMtParser_MT565Parser::RuleFld_22F_C_F);
_localctx->fld.set_tag("22F");
size_t _la = 0;
auto onExit = finally([=] {
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(1102);
match(SwiftMtParser_MT565Parser::START_OF_FIELD);
setState(1103);
match(SwiftMtParser_MT565Parser::T__4);
setState(1105);
_errHandler->sync(this);
_la = _input->LA(1);
do {
setState(1104);
_la = _input->LA(1);
if (_la == 0 || _la == Token::EOF || (_la == SwiftMtParser_MT565Parser::START_OF_FIELD)) {
_errHandler->recoverInline(this);
}
else {
_errHandler->reportMatch(this);
consume();
}
setState(1107);
_errHandler->sync(this);
_la = _input->LA(1);
} while ((((_la & ~ 0x3fULL) == 0) &&
((1ULL << _la) & ((1ULL << SwiftMtParser_MT565Parser::T__0)
| (1ULL << SwiftMtParser_MT565Parser::T__1)
| (1ULL << SwiftMtParser_MT565Parser::T__2)
| (1ULL << SwiftMtParser_MT565Parser::T__3)
| (1ULL << SwiftMtParser_MT565Parser::T__4)
| (1ULL << SwiftMtParser_MT565Parser::T__5)
| (1ULL << SwiftMtParser_MT565Parser::T__6)
| (1ULL << SwiftMtParser_MT565Parser::T__7)
| (1ULL << SwiftMtParser_MT565Parser::T__8)
| (1ULL << SwiftMtParser_MT565Parser::T__9)
| (1ULL << SwiftMtParser_MT565Parser::T__10)
| (1ULL << SwiftMtParser_MT565Parser::T__11)
| (1ULL << SwiftMtParser_MT565Parser::T__12)
| (1ULL << SwiftMtParser_MT565Parser::T__13)
| (1ULL << SwiftMtParser_MT565Parser::T__14)
| (1ULL << SwiftMtParser_MT565Parser::T__15)
| (1ULL << SwiftMtParser_MT565Parser::T__16)
| (1ULL << SwiftMtParser_MT565Parser::T__17)
| (1ULL << SwiftMtParser_MT565Parser::T__18)
| (1ULL << SwiftMtParser_MT565Parser::T__19)
| (1ULL << SwiftMtParser_MT565Parser::T__20)
| (1ULL << SwiftMtParser_MT565Parser::T__21)
| (1ULL << SwiftMtParser_MT565Parser::T__22)
| (1ULL << SwiftMtParser_MT565Parser::T__23)
| (1ULL << SwiftMtParser_MT565Parser::T__24)
| (1ULL << SwiftMtParser_MT565Parser::T__25)
| (1ULL << SwiftMtParser_MT565Parser::T__26)
| (1ULL << SwiftMtParser_MT565Parser::T__27)
| (1ULL << SwiftMtParser_MT565Parser::T__28)
| (1ULL << SwiftMtParser_MT565Parser::T__29)
| (1ULL << SwiftMtParser_MT565Parser::T__30)
| (1ULL << SwiftMtParser_MT565Parser::T__31)
| (1ULL << SwiftMtParser_MT565Parser::T__32)
| (1ULL << SwiftMtParser_MT565Parser::T__33)
| (1ULL << SwiftMtParser_MT565Parser::T__34)
| (1ULL << SwiftMtParser_MT565Parser::T__35)
| (1ULL << SwiftMtParser_MT565Parser::T__36)
| (1ULL << SwiftMtParser_MT565Parser::T__37)
| (1ULL << SwiftMtParser_MT565Parser::TAG_BH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_AH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_UH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_MT)
| (1ULL << SwiftMtParser_MT565Parser::TAG_TR)
| (1ULL << SwiftMtParser_MT565Parser::MT_END)
| (1ULL << SwiftMtParser_MT565Parser::LBRACE)
| (1ULL << SwiftMtParser_MT565Parser::RBRACE)
| (1ULL << SwiftMtParser_MT565Parser::COLON)
| (1ULL << SwiftMtParser_MT565Parser::ANY))) != 0));
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- Fld_70E_C_EContext ------------------------------------------------------------------
SwiftMtParser_MT565Parser::Fld_70E_C_EContext::Fld_70E_C_EContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
std::vector<tree::TerminalNode *> SwiftMtParser_MT565Parser::Fld_70E_C_EContext::START_OF_FIELD() {
return getTokens(SwiftMtParser_MT565Parser::START_OF_FIELD);
}
tree::TerminalNode* SwiftMtParser_MT565Parser::Fld_70E_C_EContext::START_OF_FIELD(size_t i) {
return getToken(SwiftMtParser_MT565Parser::START_OF_FIELD, i);
}
size_t SwiftMtParser_MT565Parser::Fld_70E_C_EContext::getRuleIndex() const {
return SwiftMtParser_MT565Parser::RuleFld_70E_C_E;
}
void SwiftMtParser_MT565Parser::Fld_70E_C_EContext::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->enterFld_70E_C_E(this);
}
void SwiftMtParser_MT565Parser::Fld_70E_C_EContext::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->exitFld_70E_C_E(this);
}
SwiftMtParser_MT565Parser::Fld_70E_C_EContext* SwiftMtParser_MT565Parser::fld_70E_C_E() {
Fld_70E_C_EContext *_localctx = _tracker.createInstance<Fld_70E_C_EContext>(_ctx, getState());
enterRule(_localctx, 210, SwiftMtParser_MT565Parser::RuleFld_70E_C_E);
_localctx->fld.set_tag("70E");
size_t _la = 0;
auto onExit = finally([=] {
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(1109);
match(SwiftMtParser_MT565Parser::START_OF_FIELD);
setState(1110);
match(SwiftMtParser_MT565Parser::T__25);
setState(1112);
_errHandler->sync(this);
_la = _input->LA(1);
do {
setState(1111);
_la = _input->LA(1);
if (_la == 0 || _la == Token::EOF || (_la == SwiftMtParser_MT565Parser::START_OF_FIELD)) {
_errHandler->recoverInline(this);
}
else {
_errHandler->reportMatch(this);
consume();
}
setState(1114);
_errHandler->sync(this);
_la = _input->LA(1);
} while ((((_la & ~ 0x3fULL) == 0) &&
((1ULL << _la) & ((1ULL << SwiftMtParser_MT565Parser::T__0)
| (1ULL << SwiftMtParser_MT565Parser::T__1)
| (1ULL << SwiftMtParser_MT565Parser::T__2)
| (1ULL << SwiftMtParser_MT565Parser::T__3)
| (1ULL << SwiftMtParser_MT565Parser::T__4)
| (1ULL << SwiftMtParser_MT565Parser::T__5)
| (1ULL << SwiftMtParser_MT565Parser::T__6)
| (1ULL << SwiftMtParser_MT565Parser::T__7)
| (1ULL << SwiftMtParser_MT565Parser::T__8)
| (1ULL << SwiftMtParser_MT565Parser::T__9)
| (1ULL << SwiftMtParser_MT565Parser::T__10)
| (1ULL << SwiftMtParser_MT565Parser::T__11)
| (1ULL << SwiftMtParser_MT565Parser::T__12)
| (1ULL << SwiftMtParser_MT565Parser::T__13)
| (1ULL << SwiftMtParser_MT565Parser::T__14)
| (1ULL << SwiftMtParser_MT565Parser::T__15)
| (1ULL << SwiftMtParser_MT565Parser::T__16)
| (1ULL << SwiftMtParser_MT565Parser::T__17)
| (1ULL << SwiftMtParser_MT565Parser::T__18)
| (1ULL << SwiftMtParser_MT565Parser::T__19)
| (1ULL << SwiftMtParser_MT565Parser::T__20)
| (1ULL << SwiftMtParser_MT565Parser::T__21)
| (1ULL << SwiftMtParser_MT565Parser::T__22)
| (1ULL << SwiftMtParser_MT565Parser::T__23)
| (1ULL << SwiftMtParser_MT565Parser::T__24)
| (1ULL << SwiftMtParser_MT565Parser::T__25)
| (1ULL << SwiftMtParser_MT565Parser::T__26)
| (1ULL << SwiftMtParser_MT565Parser::T__27)
| (1ULL << SwiftMtParser_MT565Parser::T__28)
| (1ULL << SwiftMtParser_MT565Parser::T__29)
| (1ULL << SwiftMtParser_MT565Parser::T__30)
| (1ULL << SwiftMtParser_MT565Parser::T__31)
| (1ULL << SwiftMtParser_MT565Parser::T__32)
| (1ULL << SwiftMtParser_MT565Parser::T__33)
| (1ULL << SwiftMtParser_MT565Parser::T__34)
| (1ULL << SwiftMtParser_MT565Parser::T__35)
| (1ULL << SwiftMtParser_MT565Parser::T__36)
| (1ULL << SwiftMtParser_MT565Parser::T__37)
| (1ULL << SwiftMtParser_MT565Parser::TAG_BH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_AH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_UH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_MT)
| (1ULL << SwiftMtParser_MT565Parser::TAG_TR)
| (1ULL << SwiftMtParser_MT565Parser::MT_END)
| (1ULL << SwiftMtParser_MT565Parser::LBRACE)
| (1ULL << SwiftMtParser_MT565Parser::RBRACE)
| (1ULL << SwiftMtParser_MT565Parser::COLON)
| (1ULL << SwiftMtParser_MT565Parser::ANY))) != 0));
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- Fld_13A_D_AContext ------------------------------------------------------------------
SwiftMtParser_MT565Parser::Fld_13A_D_AContext::Fld_13A_D_AContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
std::vector<tree::TerminalNode *> SwiftMtParser_MT565Parser::Fld_13A_D_AContext::START_OF_FIELD() {
return getTokens(SwiftMtParser_MT565Parser::START_OF_FIELD);
}
tree::TerminalNode* SwiftMtParser_MT565Parser::Fld_13A_D_AContext::START_OF_FIELD(size_t i) {
return getToken(SwiftMtParser_MT565Parser::START_OF_FIELD, i);
}
size_t SwiftMtParser_MT565Parser::Fld_13A_D_AContext::getRuleIndex() const {
return SwiftMtParser_MT565Parser::RuleFld_13A_D_A;
}
void SwiftMtParser_MT565Parser::Fld_13A_D_AContext::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->enterFld_13A_D_A(this);
}
void SwiftMtParser_MT565Parser::Fld_13A_D_AContext::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->exitFld_13A_D_A(this);
}
SwiftMtParser_MT565Parser::Fld_13A_D_AContext* SwiftMtParser_MT565Parser::fld_13A_D_A() {
Fld_13A_D_AContext *_localctx = _tracker.createInstance<Fld_13A_D_AContext>(_ctx, getState());
enterRule(_localctx, 212, SwiftMtParser_MT565Parser::RuleFld_13A_D_A);
_localctx->fld.set_tag("13A");
size_t _la = 0;
auto onExit = finally([=] {
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(1116);
match(SwiftMtParser_MT565Parser::START_OF_FIELD);
setState(1117);
match(SwiftMtParser_MT565Parser::T__7);
setState(1119);
_errHandler->sync(this);
_la = _input->LA(1);
do {
setState(1118);
_la = _input->LA(1);
if (_la == 0 || _la == Token::EOF || (_la == SwiftMtParser_MT565Parser::START_OF_FIELD)) {
_errHandler->recoverInline(this);
}
else {
_errHandler->reportMatch(this);
consume();
}
setState(1121);
_errHandler->sync(this);
_la = _input->LA(1);
} while ((((_la & ~ 0x3fULL) == 0) &&
((1ULL << _la) & ((1ULL << SwiftMtParser_MT565Parser::T__0)
| (1ULL << SwiftMtParser_MT565Parser::T__1)
| (1ULL << SwiftMtParser_MT565Parser::T__2)
| (1ULL << SwiftMtParser_MT565Parser::T__3)
| (1ULL << SwiftMtParser_MT565Parser::T__4)
| (1ULL << SwiftMtParser_MT565Parser::T__5)
| (1ULL << SwiftMtParser_MT565Parser::T__6)
| (1ULL << SwiftMtParser_MT565Parser::T__7)
| (1ULL << SwiftMtParser_MT565Parser::T__8)
| (1ULL << SwiftMtParser_MT565Parser::T__9)
| (1ULL << SwiftMtParser_MT565Parser::T__10)
| (1ULL << SwiftMtParser_MT565Parser::T__11)
| (1ULL << SwiftMtParser_MT565Parser::T__12)
| (1ULL << SwiftMtParser_MT565Parser::T__13)
| (1ULL << SwiftMtParser_MT565Parser::T__14)
| (1ULL << SwiftMtParser_MT565Parser::T__15)
| (1ULL << SwiftMtParser_MT565Parser::T__16)
| (1ULL << SwiftMtParser_MT565Parser::T__17)
| (1ULL << SwiftMtParser_MT565Parser::T__18)
| (1ULL << SwiftMtParser_MT565Parser::T__19)
| (1ULL << SwiftMtParser_MT565Parser::T__20)
| (1ULL << SwiftMtParser_MT565Parser::T__21)
| (1ULL << SwiftMtParser_MT565Parser::T__22)
| (1ULL << SwiftMtParser_MT565Parser::T__23)
| (1ULL << SwiftMtParser_MT565Parser::T__24)
| (1ULL << SwiftMtParser_MT565Parser::T__25)
| (1ULL << SwiftMtParser_MT565Parser::T__26)
| (1ULL << SwiftMtParser_MT565Parser::T__27)
| (1ULL << SwiftMtParser_MT565Parser::T__28)
| (1ULL << SwiftMtParser_MT565Parser::T__29)
| (1ULL << SwiftMtParser_MT565Parser::T__30)
| (1ULL << SwiftMtParser_MT565Parser::T__31)
| (1ULL << SwiftMtParser_MT565Parser::T__32)
| (1ULL << SwiftMtParser_MT565Parser::T__33)
| (1ULL << SwiftMtParser_MT565Parser::T__34)
| (1ULL << SwiftMtParser_MT565Parser::T__35)
| (1ULL << SwiftMtParser_MT565Parser::T__36)
| (1ULL << SwiftMtParser_MT565Parser::T__37)
| (1ULL << SwiftMtParser_MT565Parser::TAG_BH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_AH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_UH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_MT)
| (1ULL << SwiftMtParser_MT565Parser::TAG_TR)
| (1ULL << SwiftMtParser_MT565Parser::MT_END)
| (1ULL << SwiftMtParser_MT565Parser::LBRACE)
| (1ULL << SwiftMtParser_MT565Parser::RBRACE)
| (1ULL << SwiftMtParser_MT565Parser::COLON)
| (1ULL << SwiftMtParser_MT565Parser::ANY))) != 0));
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- Fld_22a_D_FContext ------------------------------------------------------------------
SwiftMtParser_MT565Parser::Fld_22a_D_FContext::Fld_22a_D_FContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
std::vector<tree::TerminalNode *> SwiftMtParser_MT565Parser::Fld_22a_D_FContext::START_OF_FIELD() {
return getTokens(SwiftMtParser_MT565Parser::START_OF_FIELD);
}
tree::TerminalNode* SwiftMtParser_MT565Parser::Fld_22a_D_FContext::START_OF_FIELD(size_t i) {
return getToken(SwiftMtParser_MT565Parser::START_OF_FIELD, i);
}
size_t SwiftMtParser_MT565Parser::Fld_22a_D_FContext::getRuleIndex() const {
return SwiftMtParser_MT565Parser::RuleFld_22a_D_F;
}
void SwiftMtParser_MT565Parser::Fld_22a_D_FContext::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->enterFld_22a_D_F(this);
}
void SwiftMtParser_MT565Parser::Fld_22a_D_FContext::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->exitFld_22a_D_F(this);
}
SwiftMtParser_MT565Parser::Fld_22a_D_FContext* SwiftMtParser_MT565Parser::fld_22a_D_F() {
Fld_22a_D_FContext *_localctx = _tracker.createInstance<Fld_22a_D_FContext>(_ctx, getState());
enterRule(_localctx, 214, SwiftMtParser_MT565Parser::RuleFld_22a_D_F);
_localctx->fld.set_tag("22F");
size_t _la = 0;
auto onExit = finally([=] {
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(1123);
match(SwiftMtParser_MT565Parser::START_OF_FIELD);
setState(1124);
match(SwiftMtParser_MT565Parser::T__4);
setState(1126);
_errHandler->sync(this);
_la = _input->LA(1);
do {
setState(1125);
_la = _input->LA(1);
if (_la == 0 || _la == Token::EOF || (_la == SwiftMtParser_MT565Parser::START_OF_FIELD)) {
_errHandler->recoverInline(this);
}
else {
_errHandler->reportMatch(this);
consume();
}
setState(1128);
_errHandler->sync(this);
_la = _input->LA(1);
} while ((((_la & ~ 0x3fULL) == 0) &&
((1ULL << _la) & ((1ULL << SwiftMtParser_MT565Parser::T__0)
| (1ULL << SwiftMtParser_MT565Parser::T__1)
| (1ULL << SwiftMtParser_MT565Parser::T__2)
| (1ULL << SwiftMtParser_MT565Parser::T__3)
| (1ULL << SwiftMtParser_MT565Parser::T__4)
| (1ULL << SwiftMtParser_MT565Parser::T__5)
| (1ULL << SwiftMtParser_MT565Parser::T__6)
| (1ULL << SwiftMtParser_MT565Parser::T__7)
| (1ULL << SwiftMtParser_MT565Parser::T__8)
| (1ULL << SwiftMtParser_MT565Parser::T__9)
| (1ULL << SwiftMtParser_MT565Parser::T__10)
| (1ULL << SwiftMtParser_MT565Parser::T__11)
| (1ULL << SwiftMtParser_MT565Parser::T__12)
| (1ULL << SwiftMtParser_MT565Parser::T__13)
| (1ULL << SwiftMtParser_MT565Parser::T__14)
| (1ULL << SwiftMtParser_MT565Parser::T__15)
| (1ULL << SwiftMtParser_MT565Parser::T__16)
| (1ULL << SwiftMtParser_MT565Parser::T__17)
| (1ULL << SwiftMtParser_MT565Parser::T__18)
| (1ULL << SwiftMtParser_MT565Parser::T__19)
| (1ULL << SwiftMtParser_MT565Parser::T__20)
| (1ULL << SwiftMtParser_MT565Parser::T__21)
| (1ULL << SwiftMtParser_MT565Parser::T__22)
| (1ULL << SwiftMtParser_MT565Parser::T__23)
| (1ULL << SwiftMtParser_MT565Parser::T__24)
| (1ULL << SwiftMtParser_MT565Parser::T__25)
| (1ULL << SwiftMtParser_MT565Parser::T__26)
| (1ULL << SwiftMtParser_MT565Parser::T__27)
| (1ULL << SwiftMtParser_MT565Parser::T__28)
| (1ULL << SwiftMtParser_MT565Parser::T__29)
| (1ULL << SwiftMtParser_MT565Parser::T__30)
| (1ULL << SwiftMtParser_MT565Parser::T__31)
| (1ULL << SwiftMtParser_MT565Parser::T__32)
| (1ULL << SwiftMtParser_MT565Parser::T__33)
| (1ULL << SwiftMtParser_MT565Parser::T__34)
| (1ULL << SwiftMtParser_MT565Parser::T__35)
| (1ULL << SwiftMtParser_MT565Parser::T__36)
| (1ULL << SwiftMtParser_MT565Parser::T__37)
| (1ULL << SwiftMtParser_MT565Parser::TAG_BH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_AH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_UH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_MT)
| (1ULL << SwiftMtParser_MT565Parser::TAG_TR)
| (1ULL << SwiftMtParser_MT565Parser::MT_END)
| (1ULL << SwiftMtParser_MT565Parser::LBRACE)
| (1ULL << SwiftMtParser_MT565Parser::RBRACE)
| (1ULL << SwiftMtParser_MT565Parser::COLON)
| (1ULL << SwiftMtParser_MT565Parser::ANY))) != 0));
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- Fld_22a_D_HContext ------------------------------------------------------------------
SwiftMtParser_MT565Parser::Fld_22a_D_HContext::Fld_22a_D_HContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
std::vector<tree::TerminalNode *> SwiftMtParser_MT565Parser::Fld_22a_D_HContext::START_OF_FIELD() {
return getTokens(SwiftMtParser_MT565Parser::START_OF_FIELD);
}
tree::TerminalNode* SwiftMtParser_MT565Parser::Fld_22a_D_HContext::START_OF_FIELD(size_t i) {
return getToken(SwiftMtParser_MT565Parser::START_OF_FIELD, i);
}
size_t SwiftMtParser_MT565Parser::Fld_22a_D_HContext::getRuleIndex() const {
return SwiftMtParser_MT565Parser::RuleFld_22a_D_H;
}
void SwiftMtParser_MT565Parser::Fld_22a_D_HContext::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->enterFld_22a_D_H(this);
}
void SwiftMtParser_MT565Parser::Fld_22a_D_HContext::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->exitFld_22a_D_H(this);
}
SwiftMtParser_MT565Parser::Fld_22a_D_HContext* SwiftMtParser_MT565Parser::fld_22a_D_H() {
Fld_22a_D_HContext *_localctx = _tracker.createInstance<Fld_22a_D_HContext>(_ctx, getState());
enterRule(_localctx, 216, SwiftMtParser_MT565Parser::RuleFld_22a_D_H);
_localctx->fld.set_tag("22H");
size_t _la = 0;
auto onExit = finally([=] {
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(1130);
match(SwiftMtParser_MT565Parser::START_OF_FIELD);
setState(1131);
match(SwiftMtParser_MT565Parser::T__26);
setState(1133);
_errHandler->sync(this);
_la = _input->LA(1);
do {
setState(1132);
_la = _input->LA(1);
if (_la == 0 || _la == Token::EOF || (_la == SwiftMtParser_MT565Parser::START_OF_FIELD)) {
_errHandler->recoverInline(this);
}
else {
_errHandler->reportMatch(this);
consume();
}
setState(1135);
_errHandler->sync(this);
_la = _input->LA(1);
} while ((((_la & ~ 0x3fULL) == 0) &&
((1ULL << _la) & ((1ULL << SwiftMtParser_MT565Parser::T__0)
| (1ULL << SwiftMtParser_MT565Parser::T__1)
| (1ULL << SwiftMtParser_MT565Parser::T__2)
| (1ULL << SwiftMtParser_MT565Parser::T__3)
| (1ULL << SwiftMtParser_MT565Parser::T__4)
| (1ULL << SwiftMtParser_MT565Parser::T__5)
| (1ULL << SwiftMtParser_MT565Parser::T__6)
| (1ULL << SwiftMtParser_MT565Parser::T__7)
| (1ULL << SwiftMtParser_MT565Parser::T__8)
| (1ULL << SwiftMtParser_MT565Parser::T__9)
| (1ULL << SwiftMtParser_MT565Parser::T__10)
| (1ULL << SwiftMtParser_MT565Parser::T__11)
| (1ULL << SwiftMtParser_MT565Parser::T__12)
| (1ULL << SwiftMtParser_MT565Parser::T__13)
| (1ULL << SwiftMtParser_MT565Parser::T__14)
| (1ULL << SwiftMtParser_MT565Parser::T__15)
| (1ULL << SwiftMtParser_MT565Parser::T__16)
| (1ULL << SwiftMtParser_MT565Parser::T__17)
| (1ULL << SwiftMtParser_MT565Parser::T__18)
| (1ULL << SwiftMtParser_MT565Parser::T__19)
| (1ULL << SwiftMtParser_MT565Parser::T__20)
| (1ULL << SwiftMtParser_MT565Parser::T__21)
| (1ULL << SwiftMtParser_MT565Parser::T__22)
| (1ULL << SwiftMtParser_MT565Parser::T__23)
| (1ULL << SwiftMtParser_MT565Parser::T__24)
| (1ULL << SwiftMtParser_MT565Parser::T__25)
| (1ULL << SwiftMtParser_MT565Parser::T__26)
| (1ULL << SwiftMtParser_MT565Parser::T__27)
| (1ULL << SwiftMtParser_MT565Parser::T__28)
| (1ULL << SwiftMtParser_MT565Parser::T__29)
| (1ULL << SwiftMtParser_MT565Parser::T__30)
| (1ULL << SwiftMtParser_MT565Parser::T__31)
| (1ULL << SwiftMtParser_MT565Parser::T__32)
| (1ULL << SwiftMtParser_MT565Parser::T__33)
| (1ULL << SwiftMtParser_MT565Parser::T__34)
| (1ULL << SwiftMtParser_MT565Parser::T__35)
| (1ULL << SwiftMtParser_MT565Parser::T__36)
| (1ULL << SwiftMtParser_MT565Parser::T__37)
| (1ULL << SwiftMtParser_MT565Parser::TAG_BH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_AH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_UH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_MT)
| (1ULL << SwiftMtParser_MT565Parser::TAG_TR)
| (1ULL << SwiftMtParser_MT565Parser::MT_END)
| (1ULL << SwiftMtParser_MT565Parser::LBRACE)
| (1ULL << SwiftMtParser_MT565Parser::RBRACE)
| (1ULL << SwiftMtParser_MT565Parser::COLON)
| (1ULL << SwiftMtParser_MT565Parser::ANY))) != 0));
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- Fld_11A_D_AContext ------------------------------------------------------------------
SwiftMtParser_MT565Parser::Fld_11A_D_AContext::Fld_11A_D_AContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
std::vector<tree::TerminalNode *> SwiftMtParser_MT565Parser::Fld_11A_D_AContext::START_OF_FIELD() {
return getTokens(SwiftMtParser_MT565Parser::START_OF_FIELD);
}
tree::TerminalNode* SwiftMtParser_MT565Parser::Fld_11A_D_AContext::START_OF_FIELD(size_t i) {
return getToken(SwiftMtParser_MT565Parser::START_OF_FIELD, i);
}
size_t SwiftMtParser_MT565Parser::Fld_11A_D_AContext::getRuleIndex() const {
return SwiftMtParser_MT565Parser::RuleFld_11A_D_A;
}
void SwiftMtParser_MT565Parser::Fld_11A_D_AContext::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->enterFld_11A_D_A(this);
}
void SwiftMtParser_MT565Parser::Fld_11A_D_AContext::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->exitFld_11A_D_A(this);
}
SwiftMtParser_MT565Parser::Fld_11A_D_AContext* SwiftMtParser_MT565Parser::fld_11A_D_A() {
Fld_11A_D_AContext *_localctx = _tracker.createInstance<Fld_11A_D_AContext>(_ctx, getState());
enterRule(_localctx, 218, SwiftMtParser_MT565Parser::RuleFld_11A_D_A);
_localctx->fld.set_tag("11A");
size_t _la = 0;
auto onExit = finally([=] {
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(1137);
match(SwiftMtParser_MT565Parser::START_OF_FIELD);
setState(1138);
match(SwiftMtParser_MT565Parser::T__13);
setState(1140);
_errHandler->sync(this);
_la = _input->LA(1);
do {
setState(1139);
_la = _input->LA(1);
if (_la == 0 || _la == Token::EOF || (_la == SwiftMtParser_MT565Parser::START_OF_FIELD)) {
_errHandler->recoverInline(this);
}
else {
_errHandler->reportMatch(this);
consume();
}
setState(1142);
_errHandler->sync(this);
_la = _input->LA(1);
} while ((((_la & ~ 0x3fULL) == 0) &&
((1ULL << _la) & ((1ULL << SwiftMtParser_MT565Parser::T__0)
| (1ULL << SwiftMtParser_MT565Parser::T__1)
| (1ULL << SwiftMtParser_MT565Parser::T__2)
| (1ULL << SwiftMtParser_MT565Parser::T__3)
| (1ULL << SwiftMtParser_MT565Parser::T__4)
| (1ULL << SwiftMtParser_MT565Parser::T__5)
| (1ULL << SwiftMtParser_MT565Parser::T__6)
| (1ULL << SwiftMtParser_MT565Parser::T__7)
| (1ULL << SwiftMtParser_MT565Parser::T__8)
| (1ULL << SwiftMtParser_MT565Parser::T__9)
| (1ULL << SwiftMtParser_MT565Parser::T__10)
| (1ULL << SwiftMtParser_MT565Parser::T__11)
| (1ULL << SwiftMtParser_MT565Parser::T__12)
| (1ULL << SwiftMtParser_MT565Parser::T__13)
| (1ULL << SwiftMtParser_MT565Parser::T__14)
| (1ULL << SwiftMtParser_MT565Parser::T__15)
| (1ULL << SwiftMtParser_MT565Parser::T__16)
| (1ULL << SwiftMtParser_MT565Parser::T__17)
| (1ULL << SwiftMtParser_MT565Parser::T__18)
| (1ULL << SwiftMtParser_MT565Parser::T__19)
| (1ULL << SwiftMtParser_MT565Parser::T__20)
| (1ULL << SwiftMtParser_MT565Parser::T__21)
| (1ULL << SwiftMtParser_MT565Parser::T__22)
| (1ULL << SwiftMtParser_MT565Parser::T__23)
| (1ULL << SwiftMtParser_MT565Parser::T__24)
| (1ULL << SwiftMtParser_MT565Parser::T__25)
| (1ULL << SwiftMtParser_MT565Parser::T__26)
| (1ULL << SwiftMtParser_MT565Parser::T__27)
| (1ULL << SwiftMtParser_MT565Parser::T__28)
| (1ULL << SwiftMtParser_MT565Parser::T__29)
| (1ULL << SwiftMtParser_MT565Parser::T__30)
| (1ULL << SwiftMtParser_MT565Parser::T__31)
| (1ULL << SwiftMtParser_MT565Parser::T__32)
| (1ULL << SwiftMtParser_MT565Parser::T__33)
| (1ULL << SwiftMtParser_MT565Parser::T__34)
| (1ULL << SwiftMtParser_MT565Parser::T__35)
| (1ULL << SwiftMtParser_MT565Parser::T__36)
| (1ULL << SwiftMtParser_MT565Parser::T__37)
| (1ULL << SwiftMtParser_MT565Parser::TAG_BH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_AH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_UH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_MT)
| (1ULL << SwiftMtParser_MT565Parser::TAG_TR)
| (1ULL << SwiftMtParser_MT565Parser::MT_END)
| (1ULL << SwiftMtParser_MT565Parser::LBRACE)
| (1ULL << SwiftMtParser_MT565Parser::RBRACE)
| (1ULL << SwiftMtParser_MT565Parser::COLON)
| (1ULL << SwiftMtParser_MT565Parser::ANY))) != 0));
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- Fld_35B_D_BContext ------------------------------------------------------------------
SwiftMtParser_MT565Parser::Fld_35B_D_BContext::Fld_35B_D_BContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
std::vector<tree::TerminalNode *> SwiftMtParser_MT565Parser::Fld_35B_D_BContext::START_OF_FIELD() {
return getTokens(SwiftMtParser_MT565Parser::START_OF_FIELD);
}
tree::TerminalNode* SwiftMtParser_MT565Parser::Fld_35B_D_BContext::START_OF_FIELD(size_t i) {
return getToken(SwiftMtParser_MT565Parser::START_OF_FIELD, i);
}
size_t SwiftMtParser_MT565Parser::Fld_35B_D_BContext::getRuleIndex() const {
return SwiftMtParser_MT565Parser::RuleFld_35B_D_B;
}
void SwiftMtParser_MT565Parser::Fld_35B_D_BContext::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->enterFld_35B_D_B(this);
}
void SwiftMtParser_MT565Parser::Fld_35B_D_BContext::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->exitFld_35B_D_B(this);
}
SwiftMtParser_MT565Parser::Fld_35B_D_BContext* SwiftMtParser_MT565Parser::fld_35B_D_B() {
Fld_35B_D_BContext *_localctx = _tracker.createInstance<Fld_35B_D_BContext>(_ctx, getState());
enterRule(_localctx, 220, SwiftMtParser_MT565Parser::RuleFld_35B_D_B);
_localctx->fld.set_tag("35B");
size_t _la = 0;
auto onExit = finally([=] {
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(1144);
match(SwiftMtParser_MT565Parser::START_OF_FIELD);
setState(1145);
match(SwiftMtParser_MT565Parser::T__9);
setState(1147);
_errHandler->sync(this);
_la = _input->LA(1);
do {
setState(1146);
_la = _input->LA(1);
if (_la == 0 || _la == Token::EOF || (_la == SwiftMtParser_MT565Parser::START_OF_FIELD)) {
_errHandler->recoverInline(this);
}
else {
_errHandler->reportMatch(this);
consume();
}
setState(1149);
_errHandler->sync(this);
_la = _input->LA(1);
} while ((((_la & ~ 0x3fULL) == 0) &&
((1ULL << _la) & ((1ULL << SwiftMtParser_MT565Parser::T__0)
| (1ULL << SwiftMtParser_MT565Parser::T__1)
| (1ULL << SwiftMtParser_MT565Parser::T__2)
| (1ULL << SwiftMtParser_MT565Parser::T__3)
| (1ULL << SwiftMtParser_MT565Parser::T__4)
| (1ULL << SwiftMtParser_MT565Parser::T__5)
| (1ULL << SwiftMtParser_MT565Parser::T__6)
| (1ULL << SwiftMtParser_MT565Parser::T__7)
| (1ULL << SwiftMtParser_MT565Parser::T__8)
| (1ULL << SwiftMtParser_MT565Parser::T__9)
| (1ULL << SwiftMtParser_MT565Parser::T__10)
| (1ULL << SwiftMtParser_MT565Parser::T__11)
| (1ULL << SwiftMtParser_MT565Parser::T__12)
| (1ULL << SwiftMtParser_MT565Parser::T__13)
| (1ULL << SwiftMtParser_MT565Parser::T__14)
| (1ULL << SwiftMtParser_MT565Parser::T__15)
| (1ULL << SwiftMtParser_MT565Parser::T__16)
| (1ULL << SwiftMtParser_MT565Parser::T__17)
| (1ULL << SwiftMtParser_MT565Parser::T__18)
| (1ULL << SwiftMtParser_MT565Parser::T__19)
| (1ULL << SwiftMtParser_MT565Parser::T__20)
| (1ULL << SwiftMtParser_MT565Parser::T__21)
| (1ULL << SwiftMtParser_MT565Parser::T__22)
| (1ULL << SwiftMtParser_MT565Parser::T__23)
| (1ULL << SwiftMtParser_MT565Parser::T__24)
| (1ULL << SwiftMtParser_MT565Parser::T__25)
| (1ULL << SwiftMtParser_MT565Parser::T__26)
| (1ULL << SwiftMtParser_MT565Parser::T__27)
| (1ULL << SwiftMtParser_MT565Parser::T__28)
| (1ULL << SwiftMtParser_MT565Parser::T__29)
| (1ULL << SwiftMtParser_MT565Parser::T__30)
| (1ULL << SwiftMtParser_MT565Parser::T__31)
| (1ULL << SwiftMtParser_MT565Parser::T__32)
| (1ULL << SwiftMtParser_MT565Parser::T__33)
| (1ULL << SwiftMtParser_MT565Parser::T__34)
| (1ULL << SwiftMtParser_MT565Parser::T__35)
| (1ULL << SwiftMtParser_MT565Parser::T__36)
| (1ULL << SwiftMtParser_MT565Parser::T__37)
| (1ULL << SwiftMtParser_MT565Parser::TAG_BH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_AH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_UH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_MT)
| (1ULL << SwiftMtParser_MT565Parser::TAG_TR)
| (1ULL << SwiftMtParser_MT565Parser::MT_END)
| (1ULL << SwiftMtParser_MT565Parser::LBRACE)
| (1ULL << SwiftMtParser_MT565Parser::RBRACE)
| (1ULL << SwiftMtParser_MT565Parser::COLON)
| (1ULL << SwiftMtParser_MT565Parser::ANY))) != 0));
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- Fld_36a_D_BContext ------------------------------------------------------------------
SwiftMtParser_MT565Parser::Fld_36a_D_BContext::Fld_36a_D_BContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
std::vector<tree::TerminalNode *> SwiftMtParser_MT565Parser::Fld_36a_D_BContext::START_OF_FIELD() {
return getTokens(SwiftMtParser_MT565Parser::START_OF_FIELD);
}
tree::TerminalNode* SwiftMtParser_MT565Parser::Fld_36a_D_BContext::START_OF_FIELD(size_t i) {
return getToken(SwiftMtParser_MT565Parser::START_OF_FIELD, i);
}
size_t SwiftMtParser_MT565Parser::Fld_36a_D_BContext::getRuleIndex() const {
return SwiftMtParser_MT565Parser::RuleFld_36a_D_B;
}
void SwiftMtParser_MT565Parser::Fld_36a_D_BContext::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->enterFld_36a_D_B(this);
}
void SwiftMtParser_MT565Parser::Fld_36a_D_BContext::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->exitFld_36a_D_B(this);
}
SwiftMtParser_MT565Parser::Fld_36a_D_BContext* SwiftMtParser_MT565Parser::fld_36a_D_B() {
Fld_36a_D_BContext *_localctx = _tracker.createInstance<Fld_36a_D_BContext>(_ctx, getState());
enterRule(_localctx, 222, SwiftMtParser_MT565Parser::RuleFld_36a_D_B);
_localctx->fld.set_tag("36B");
size_t _la = 0;
auto onExit = finally([=] {
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(1151);
match(SwiftMtParser_MT565Parser::START_OF_FIELD);
setState(1152);
match(SwiftMtParser_MT565Parser::T__15);
setState(1154);
_errHandler->sync(this);
_la = _input->LA(1);
do {
setState(1153);
_la = _input->LA(1);
if (_la == 0 || _la == Token::EOF || (_la == SwiftMtParser_MT565Parser::START_OF_FIELD)) {
_errHandler->recoverInline(this);
}
else {
_errHandler->reportMatch(this);
consume();
}
setState(1156);
_errHandler->sync(this);
_la = _input->LA(1);
} while ((((_la & ~ 0x3fULL) == 0) &&
((1ULL << _la) & ((1ULL << SwiftMtParser_MT565Parser::T__0)
| (1ULL << SwiftMtParser_MT565Parser::T__1)
| (1ULL << SwiftMtParser_MT565Parser::T__2)
| (1ULL << SwiftMtParser_MT565Parser::T__3)
| (1ULL << SwiftMtParser_MT565Parser::T__4)
| (1ULL << SwiftMtParser_MT565Parser::T__5)
| (1ULL << SwiftMtParser_MT565Parser::T__6)
| (1ULL << SwiftMtParser_MT565Parser::T__7)
| (1ULL << SwiftMtParser_MT565Parser::T__8)
| (1ULL << SwiftMtParser_MT565Parser::T__9)
| (1ULL << SwiftMtParser_MT565Parser::T__10)
| (1ULL << SwiftMtParser_MT565Parser::T__11)
| (1ULL << SwiftMtParser_MT565Parser::T__12)
| (1ULL << SwiftMtParser_MT565Parser::T__13)
| (1ULL << SwiftMtParser_MT565Parser::T__14)
| (1ULL << SwiftMtParser_MT565Parser::T__15)
| (1ULL << SwiftMtParser_MT565Parser::T__16)
| (1ULL << SwiftMtParser_MT565Parser::T__17)
| (1ULL << SwiftMtParser_MT565Parser::T__18)
| (1ULL << SwiftMtParser_MT565Parser::T__19)
| (1ULL << SwiftMtParser_MT565Parser::T__20)
| (1ULL << SwiftMtParser_MT565Parser::T__21)
| (1ULL << SwiftMtParser_MT565Parser::T__22)
| (1ULL << SwiftMtParser_MT565Parser::T__23)
| (1ULL << SwiftMtParser_MT565Parser::T__24)
| (1ULL << SwiftMtParser_MT565Parser::T__25)
| (1ULL << SwiftMtParser_MT565Parser::T__26)
| (1ULL << SwiftMtParser_MT565Parser::T__27)
| (1ULL << SwiftMtParser_MT565Parser::T__28)
| (1ULL << SwiftMtParser_MT565Parser::T__29)
| (1ULL << SwiftMtParser_MT565Parser::T__30)
| (1ULL << SwiftMtParser_MT565Parser::T__31)
| (1ULL << SwiftMtParser_MT565Parser::T__32)
| (1ULL << SwiftMtParser_MT565Parser::T__33)
| (1ULL << SwiftMtParser_MT565Parser::T__34)
| (1ULL << SwiftMtParser_MT565Parser::T__35)
| (1ULL << SwiftMtParser_MT565Parser::T__36)
| (1ULL << SwiftMtParser_MT565Parser::T__37)
| (1ULL << SwiftMtParser_MT565Parser::TAG_BH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_AH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_UH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_MT)
| (1ULL << SwiftMtParser_MT565Parser::TAG_TR)
| (1ULL << SwiftMtParser_MT565Parser::MT_END)
| (1ULL << SwiftMtParser_MT565Parser::LBRACE)
| (1ULL << SwiftMtParser_MT565Parser::RBRACE)
| (1ULL << SwiftMtParser_MT565Parser::COLON)
| (1ULL << SwiftMtParser_MT565Parser::ANY))) != 0));
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- Fld_36a_D_CContext ------------------------------------------------------------------
SwiftMtParser_MT565Parser::Fld_36a_D_CContext::Fld_36a_D_CContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
std::vector<tree::TerminalNode *> SwiftMtParser_MT565Parser::Fld_36a_D_CContext::START_OF_FIELD() {
return getTokens(SwiftMtParser_MT565Parser::START_OF_FIELD);
}
tree::TerminalNode* SwiftMtParser_MT565Parser::Fld_36a_D_CContext::START_OF_FIELD(size_t i) {
return getToken(SwiftMtParser_MT565Parser::START_OF_FIELD, i);
}
size_t SwiftMtParser_MT565Parser::Fld_36a_D_CContext::getRuleIndex() const {
return SwiftMtParser_MT565Parser::RuleFld_36a_D_C;
}
void SwiftMtParser_MT565Parser::Fld_36a_D_CContext::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->enterFld_36a_D_C(this);
}
void SwiftMtParser_MT565Parser::Fld_36a_D_CContext::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->exitFld_36a_D_C(this);
}
SwiftMtParser_MT565Parser::Fld_36a_D_CContext* SwiftMtParser_MT565Parser::fld_36a_D_C() {
Fld_36a_D_CContext *_localctx = _tracker.createInstance<Fld_36a_D_CContext>(_ctx, getState());
enterRule(_localctx, 224, SwiftMtParser_MT565Parser::RuleFld_36a_D_C);
_localctx->fld.set_tag("36C");
size_t _la = 0;
auto onExit = finally([=] {
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(1158);
match(SwiftMtParser_MT565Parser::START_OF_FIELD);
setState(1159);
match(SwiftMtParser_MT565Parser::T__27);
setState(1161);
_errHandler->sync(this);
_la = _input->LA(1);
do {
setState(1160);
_la = _input->LA(1);
if (_la == 0 || _la == Token::EOF || (_la == SwiftMtParser_MT565Parser::START_OF_FIELD)) {
_errHandler->recoverInline(this);
}
else {
_errHandler->reportMatch(this);
consume();
}
setState(1163);
_errHandler->sync(this);
_la = _input->LA(1);
} while ((((_la & ~ 0x3fULL) == 0) &&
((1ULL << _la) & ((1ULL << SwiftMtParser_MT565Parser::T__0)
| (1ULL << SwiftMtParser_MT565Parser::T__1)
| (1ULL << SwiftMtParser_MT565Parser::T__2)
| (1ULL << SwiftMtParser_MT565Parser::T__3)
| (1ULL << SwiftMtParser_MT565Parser::T__4)
| (1ULL << SwiftMtParser_MT565Parser::T__5)
| (1ULL << SwiftMtParser_MT565Parser::T__6)
| (1ULL << SwiftMtParser_MT565Parser::T__7)
| (1ULL << SwiftMtParser_MT565Parser::T__8)
| (1ULL << SwiftMtParser_MT565Parser::T__9)
| (1ULL << SwiftMtParser_MT565Parser::T__10)
| (1ULL << SwiftMtParser_MT565Parser::T__11)
| (1ULL << SwiftMtParser_MT565Parser::T__12)
| (1ULL << SwiftMtParser_MT565Parser::T__13)
| (1ULL << SwiftMtParser_MT565Parser::T__14)
| (1ULL << SwiftMtParser_MT565Parser::T__15)
| (1ULL << SwiftMtParser_MT565Parser::T__16)
| (1ULL << SwiftMtParser_MT565Parser::T__17)
| (1ULL << SwiftMtParser_MT565Parser::T__18)
| (1ULL << SwiftMtParser_MT565Parser::T__19)
| (1ULL << SwiftMtParser_MT565Parser::T__20)
| (1ULL << SwiftMtParser_MT565Parser::T__21)
| (1ULL << SwiftMtParser_MT565Parser::T__22)
| (1ULL << SwiftMtParser_MT565Parser::T__23)
| (1ULL << SwiftMtParser_MT565Parser::T__24)
| (1ULL << SwiftMtParser_MT565Parser::T__25)
| (1ULL << SwiftMtParser_MT565Parser::T__26)
| (1ULL << SwiftMtParser_MT565Parser::T__27)
| (1ULL << SwiftMtParser_MT565Parser::T__28)
| (1ULL << SwiftMtParser_MT565Parser::T__29)
| (1ULL << SwiftMtParser_MT565Parser::T__30)
| (1ULL << SwiftMtParser_MT565Parser::T__31)
| (1ULL << SwiftMtParser_MT565Parser::T__32)
| (1ULL << SwiftMtParser_MT565Parser::T__33)
| (1ULL << SwiftMtParser_MT565Parser::T__34)
| (1ULL << SwiftMtParser_MT565Parser::T__35)
| (1ULL << SwiftMtParser_MT565Parser::T__36)
| (1ULL << SwiftMtParser_MT565Parser::T__37)
| (1ULL << SwiftMtParser_MT565Parser::TAG_BH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_AH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_UH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_MT)
| (1ULL << SwiftMtParser_MT565Parser::TAG_TR)
| (1ULL << SwiftMtParser_MT565Parser::MT_END)
| (1ULL << SwiftMtParser_MT565Parser::LBRACE)
| (1ULL << SwiftMtParser_MT565Parser::RBRACE)
| (1ULL << SwiftMtParser_MT565Parser::COLON)
| (1ULL << SwiftMtParser_MT565Parser::ANY))) != 0));
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- Fld_19B_D_BContext ------------------------------------------------------------------
SwiftMtParser_MT565Parser::Fld_19B_D_BContext::Fld_19B_D_BContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
std::vector<tree::TerminalNode *> SwiftMtParser_MT565Parser::Fld_19B_D_BContext::START_OF_FIELD() {
return getTokens(SwiftMtParser_MT565Parser::START_OF_FIELD);
}
tree::TerminalNode* SwiftMtParser_MT565Parser::Fld_19B_D_BContext::START_OF_FIELD(size_t i) {
return getToken(SwiftMtParser_MT565Parser::START_OF_FIELD, i);
}
size_t SwiftMtParser_MT565Parser::Fld_19B_D_BContext::getRuleIndex() const {
return SwiftMtParser_MT565Parser::RuleFld_19B_D_B;
}
void SwiftMtParser_MT565Parser::Fld_19B_D_BContext::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->enterFld_19B_D_B(this);
}
void SwiftMtParser_MT565Parser::Fld_19B_D_BContext::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->exitFld_19B_D_B(this);
}
SwiftMtParser_MT565Parser::Fld_19B_D_BContext* SwiftMtParser_MT565Parser::fld_19B_D_B() {
Fld_19B_D_BContext *_localctx = _tracker.createInstance<Fld_19B_D_BContext>(_ctx, getState());
enterRule(_localctx, 226, SwiftMtParser_MT565Parser::RuleFld_19B_D_B);
_localctx->fld.set_tag("19B");
size_t _la = 0;
auto onExit = finally([=] {
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(1165);
match(SwiftMtParser_MT565Parser::START_OF_FIELD);
setState(1166);
match(SwiftMtParser_MT565Parser::T__28);
setState(1168);
_errHandler->sync(this);
_la = _input->LA(1);
do {
setState(1167);
_la = _input->LA(1);
if (_la == 0 || _la == Token::EOF || (_la == SwiftMtParser_MT565Parser::START_OF_FIELD)) {
_errHandler->recoverInline(this);
}
else {
_errHandler->reportMatch(this);
consume();
}
setState(1170);
_errHandler->sync(this);
_la = _input->LA(1);
} while ((((_la & ~ 0x3fULL) == 0) &&
((1ULL << _la) & ((1ULL << SwiftMtParser_MT565Parser::T__0)
| (1ULL << SwiftMtParser_MT565Parser::T__1)
| (1ULL << SwiftMtParser_MT565Parser::T__2)
| (1ULL << SwiftMtParser_MT565Parser::T__3)
| (1ULL << SwiftMtParser_MT565Parser::T__4)
| (1ULL << SwiftMtParser_MT565Parser::T__5)
| (1ULL << SwiftMtParser_MT565Parser::T__6)
| (1ULL << SwiftMtParser_MT565Parser::T__7)
| (1ULL << SwiftMtParser_MT565Parser::T__8)
| (1ULL << SwiftMtParser_MT565Parser::T__9)
| (1ULL << SwiftMtParser_MT565Parser::T__10)
| (1ULL << SwiftMtParser_MT565Parser::T__11)
| (1ULL << SwiftMtParser_MT565Parser::T__12)
| (1ULL << SwiftMtParser_MT565Parser::T__13)
| (1ULL << SwiftMtParser_MT565Parser::T__14)
| (1ULL << SwiftMtParser_MT565Parser::T__15)
| (1ULL << SwiftMtParser_MT565Parser::T__16)
| (1ULL << SwiftMtParser_MT565Parser::T__17)
| (1ULL << SwiftMtParser_MT565Parser::T__18)
| (1ULL << SwiftMtParser_MT565Parser::T__19)
| (1ULL << SwiftMtParser_MT565Parser::T__20)
| (1ULL << SwiftMtParser_MT565Parser::T__21)
| (1ULL << SwiftMtParser_MT565Parser::T__22)
| (1ULL << SwiftMtParser_MT565Parser::T__23)
| (1ULL << SwiftMtParser_MT565Parser::T__24)
| (1ULL << SwiftMtParser_MT565Parser::T__25)
| (1ULL << SwiftMtParser_MT565Parser::T__26)
| (1ULL << SwiftMtParser_MT565Parser::T__27)
| (1ULL << SwiftMtParser_MT565Parser::T__28)
| (1ULL << SwiftMtParser_MT565Parser::T__29)
| (1ULL << SwiftMtParser_MT565Parser::T__30)
| (1ULL << SwiftMtParser_MT565Parser::T__31)
| (1ULL << SwiftMtParser_MT565Parser::T__32)
| (1ULL << SwiftMtParser_MT565Parser::T__33)
| (1ULL << SwiftMtParser_MT565Parser::T__34)
| (1ULL << SwiftMtParser_MT565Parser::T__35)
| (1ULL << SwiftMtParser_MT565Parser::T__36)
| (1ULL << SwiftMtParser_MT565Parser::T__37)
| (1ULL << SwiftMtParser_MT565Parser::TAG_BH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_AH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_UH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_MT)
| (1ULL << SwiftMtParser_MT565Parser::TAG_TR)
| (1ULL << SwiftMtParser_MT565Parser::MT_END)
| (1ULL << SwiftMtParser_MT565Parser::LBRACE)
| (1ULL << SwiftMtParser_MT565Parser::RBRACE)
| (1ULL << SwiftMtParser_MT565Parser::COLON)
| (1ULL << SwiftMtParser_MT565Parser::ANY))) != 0));
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- Fld_98a_D_AContext ------------------------------------------------------------------
SwiftMtParser_MT565Parser::Fld_98a_D_AContext::Fld_98a_D_AContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
std::vector<tree::TerminalNode *> SwiftMtParser_MT565Parser::Fld_98a_D_AContext::START_OF_FIELD() {
return getTokens(SwiftMtParser_MT565Parser::START_OF_FIELD);
}
tree::TerminalNode* SwiftMtParser_MT565Parser::Fld_98a_D_AContext::START_OF_FIELD(size_t i) {
return getToken(SwiftMtParser_MT565Parser::START_OF_FIELD, i);
}
size_t SwiftMtParser_MT565Parser::Fld_98a_D_AContext::getRuleIndex() const {
return SwiftMtParser_MT565Parser::RuleFld_98a_D_A;
}
void SwiftMtParser_MT565Parser::Fld_98a_D_AContext::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->enterFld_98a_D_A(this);
}
void SwiftMtParser_MT565Parser::Fld_98a_D_AContext::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->exitFld_98a_D_A(this);
}
SwiftMtParser_MT565Parser::Fld_98a_D_AContext* SwiftMtParser_MT565Parser::fld_98a_D_A() {
Fld_98a_D_AContext *_localctx = _tracker.createInstance<Fld_98a_D_AContext>(_ctx, getState());
enterRule(_localctx, 228, SwiftMtParser_MT565Parser::RuleFld_98a_D_A);
_localctx->fld.set_tag("98A");
size_t _la = 0;
auto onExit = finally([=] {
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(1172);
match(SwiftMtParser_MT565Parser::START_OF_FIELD);
setState(1173);
match(SwiftMtParser_MT565Parser::T__5);
setState(1175);
_errHandler->sync(this);
_la = _input->LA(1);
do {
setState(1174);
_la = _input->LA(1);
if (_la == 0 || _la == Token::EOF || (_la == SwiftMtParser_MT565Parser::START_OF_FIELD)) {
_errHandler->recoverInline(this);
}
else {
_errHandler->reportMatch(this);
consume();
}
setState(1177);
_errHandler->sync(this);
_la = _input->LA(1);
} while ((((_la & ~ 0x3fULL) == 0) &&
((1ULL << _la) & ((1ULL << SwiftMtParser_MT565Parser::T__0)
| (1ULL << SwiftMtParser_MT565Parser::T__1)
| (1ULL << SwiftMtParser_MT565Parser::T__2)
| (1ULL << SwiftMtParser_MT565Parser::T__3)
| (1ULL << SwiftMtParser_MT565Parser::T__4)
| (1ULL << SwiftMtParser_MT565Parser::T__5)
| (1ULL << SwiftMtParser_MT565Parser::T__6)
| (1ULL << SwiftMtParser_MT565Parser::T__7)
| (1ULL << SwiftMtParser_MT565Parser::T__8)
| (1ULL << SwiftMtParser_MT565Parser::T__9)
| (1ULL << SwiftMtParser_MT565Parser::T__10)
| (1ULL << SwiftMtParser_MT565Parser::T__11)
| (1ULL << SwiftMtParser_MT565Parser::T__12)
| (1ULL << SwiftMtParser_MT565Parser::T__13)
| (1ULL << SwiftMtParser_MT565Parser::T__14)
| (1ULL << SwiftMtParser_MT565Parser::T__15)
| (1ULL << SwiftMtParser_MT565Parser::T__16)
| (1ULL << SwiftMtParser_MT565Parser::T__17)
| (1ULL << SwiftMtParser_MT565Parser::T__18)
| (1ULL << SwiftMtParser_MT565Parser::T__19)
| (1ULL << SwiftMtParser_MT565Parser::T__20)
| (1ULL << SwiftMtParser_MT565Parser::T__21)
| (1ULL << SwiftMtParser_MT565Parser::T__22)
| (1ULL << SwiftMtParser_MT565Parser::T__23)
| (1ULL << SwiftMtParser_MT565Parser::T__24)
| (1ULL << SwiftMtParser_MT565Parser::T__25)
| (1ULL << SwiftMtParser_MT565Parser::T__26)
| (1ULL << SwiftMtParser_MT565Parser::T__27)
| (1ULL << SwiftMtParser_MT565Parser::T__28)
| (1ULL << SwiftMtParser_MT565Parser::T__29)
| (1ULL << SwiftMtParser_MT565Parser::T__30)
| (1ULL << SwiftMtParser_MT565Parser::T__31)
| (1ULL << SwiftMtParser_MT565Parser::T__32)
| (1ULL << SwiftMtParser_MT565Parser::T__33)
| (1ULL << SwiftMtParser_MT565Parser::T__34)
| (1ULL << SwiftMtParser_MT565Parser::T__35)
| (1ULL << SwiftMtParser_MT565Parser::T__36)
| (1ULL << SwiftMtParser_MT565Parser::T__37)
| (1ULL << SwiftMtParser_MT565Parser::TAG_BH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_AH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_UH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_MT)
| (1ULL << SwiftMtParser_MT565Parser::TAG_TR)
| (1ULL << SwiftMtParser_MT565Parser::MT_END)
| (1ULL << SwiftMtParser_MT565Parser::LBRACE)
| (1ULL << SwiftMtParser_MT565Parser::RBRACE)
| (1ULL << SwiftMtParser_MT565Parser::COLON)
| (1ULL << SwiftMtParser_MT565Parser::ANY))) != 0));
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- Fld_98a_D_CContext ------------------------------------------------------------------
SwiftMtParser_MT565Parser::Fld_98a_D_CContext::Fld_98a_D_CContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
std::vector<tree::TerminalNode *> SwiftMtParser_MT565Parser::Fld_98a_D_CContext::START_OF_FIELD() {
return getTokens(SwiftMtParser_MT565Parser::START_OF_FIELD);
}
tree::TerminalNode* SwiftMtParser_MT565Parser::Fld_98a_D_CContext::START_OF_FIELD(size_t i) {
return getToken(SwiftMtParser_MT565Parser::START_OF_FIELD, i);
}
size_t SwiftMtParser_MT565Parser::Fld_98a_D_CContext::getRuleIndex() const {
return SwiftMtParser_MT565Parser::RuleFld_98a_D_C;
}
void SwiftMtParser_MT565Parser::Fld_98a_D_CContext::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->enterFld_98a_D_C(this);
}
void SwiftMtParser_MT565Parser::Fld_98a_D_CContext::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->exitFld_98a_D_C(this);
}
SwiftMtParser_MT565Parser::Fld_98a_D_CContext* SwiftMtParser_MT565Parser::fld_98a_D_C() {
Fld_98a_D_CContext *_localctx = _tracker.createInstance<Fld_98a_D_CContext>(_ctx, getState());
enterRule(_localctx, 230, SwiftMtParser_MT565Parser::RuleFld_98a_D_C);
_localctx->fld.set_tag("98C");
size_t _la = 0;
auto onExit = finally([=] {
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(1179);
match(SwiftMtParser_MT565Parser::START_OF_FIELD);
setState(1180);
match(SwiftMtParser_MT565Parser::T__6);
setState(1182);
_errHandler->sync(this);
_la = _input->LA(1);
do {
setState(1181);
_la = _input->LA(1);
if (_la == 0 || _la == Token::EOF || (_la == SwiftMtParser_MT565Parser::START_OF_FIELD)) {
_errHandler->recoverInline(this);
}
else {
_errHandler->reportMatch(this);
consume();
}
setState(1184);
_errHandler->sync(this);
_la = _input->LA(1);
} while ((((_la & ~ 0x3fULL) == 0) &&
((1ULL << _la) & ((1ULL << SwiftMtParser_MT565Parser::T__0)
| (1ULL << SwiftMtParser_MT565Parser::T__1)
| (1ULL << SwiftMtParser_MT565Parser::T__2)
| (1ULL << SwiftMtParser_MT565Parser::T__3)
| (1ULL << SwiftMtParser_MT565Parser::T__4)
| (1ULL << SwiftMtParser_MT565Parser::T__5)
| (1ULL << SwiftMtParser_MT565Parser::T__6)
| (1ULL << SwiftMtParser_MT565Parser::T__7)
| (1ULL << SwiftMtParser_MT565Parser::T__8)
| (1ULL << SwiftMtParser_MT565Parser::T__9)
| (1ULL << SwiftMtParser_MT565Parser::T__10)
| (1ULL << SwiftMtParser_MT565Parser::T__11)
| (1ULL << SwiftMtParser_MT565Parser::T__12)
| (1ULL << SwiftMtParser_MT565Parser::T__13)
| (1ULL << SwiftMtParser_MT565Parser::T__14)
| (1ULL << SwiftMtParser_MT565Parser::T__15)
| (1ULL << SwiftMtParser_MT565Parser::T__16)
| (1ULL << SwiftMtParser_MT565Parser::T__17)
| (1ULL << SwiftMtParser_MT565Parser::T__18)
| (1ULL << SwiftMtParser_MT565Parser::T__19)
| (1ULL << SwiftMtParser_MT565Parser::T__20)
| (1ULL << SwiftMtParser_MT565Parser::T__21)
| (1ULL << SwiftMtParser_MT565Parser::T__22)
| (1ULL << SwiftMtParser_MT565Parser::T__23)
| (1ULL << SwiftMtParser_MT565Parser::T__24)
| (1ULL << SwiftMtParser_MT565Parser::T__25)
| (1ULL << SwiftMtParser_MT565Parser::T__26)
| (1ULL << SwiftMtParser_MT565Parser::T__27)
| (1ULL << SwiftMtParser_MT565Parser::T__28)
| (1ULL << SwiftMtParser_MT565Parser::T__29)
| (1ULL << SwiftMtParser_MT565Parser::T__30)
| (1ULL << SwiftMtParser_MT565Parser::T__31)
| (1ULL << SwiftMtParser_MT565Parser::T__32)
| (1ULL << SwiftMtParser_MT565Parser::T__33)
| (1ULL << SwiftMtParser_MT565Parser::T__34)
| (1ULL << SwiftMtParser_MT565Parser::T__35)
| (1ULL << SwiftMtParser_MT565Parser::T__36)
| (1ULL << SwiftMtParser_MT565Parser::T__37)
| (1ULL << SwiftMtParser_MT565Parser::TAG_BH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_AH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_UH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_MT)
| (1ULL << SwiftMtParser_MT565Parser::TAG_TR)
| (1ULL << SwiftMtParser_MT565Parser::MT_END)
| (1ULL << SwiftMtParser_MT565Parser::LBRACE)
| (1ULL << SwiftMtParser_MT565Parser::RBRACE)
| (1ULL << SwiftMtParser_MT565Parser::COLON)
| (1ULL << SwiftMtParser_MT565Parser::ANY))) != 0));
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- Fld_92a_D_AContext ------------------------------------------------------------------
SwiftMtParser_MT565Parser::Fld_92a_D_AContext::Fld_92a_D_AContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
std::vector<tree::TerminalNode *> SwiftMtParser_MT565Parser::Fld_92a_D_AContext::START_OF_FIELD() {
return getTokens(SwiftMtParser_MT565Parser::START_OF_FIELD);
}
tree::TerminalNode* SwiftMtParser_MT565Parser::Fld_92a_D_AContext::START_OF_FIELD(size_t i) {
return getToken(SwiftMtParser_MT565Parser::START_OF_FIELD, i);
}
size_t SwiftMtParser_MT565Parser::Fld_92a_D_AContext::getRuleIndex() const {
return SwiftMtParser_MT565Parser::RuleFld_92a_D_A;
}
void SwiftMtParser_MT565Parser::Fld_92a_D_AContext::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->enterFld_92a_D_A(this);
}
void SwiftMtParser_MT565Parser::Fld_92a_D_AContext::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->exitFld_92a_D_A(this);
}
SwiftMtParser_MT565Parser::Fld_92a_D_AContext* SwiftMtParser_MT565Parser::fld_92a_D_A() {
Fld_92a_D_AContext *_localctx = _tracker.createInstance<Fld_92a_D_AContext>(_ctx, getState());
enterRule(_localctx, 232, SwiftMtParser_MT565Parser::RuleFld_92a_D_A);
_localctx->fld.set_tag("92A");
size_t _la = 0;
auto onExit = finally([=] {
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(1186);
match(SwiftMtParser_MT565Parser::START_OF_FIELD);
setState(1187);
match(SwiftMtParser_MT565Parser::T__14);
setState(1189);
_errHandler->sync(this);
_la = _input->LA(1);
do {
setState(1188);
_la = _input->LA(1);
if (_la == 0 || _la == Token::EOF || (_la == SwiftMtParser_MT565Parser::START_OF_FIELD)) {
_errHandler->recoverInline(this);
}
else {
_errHandler->reportMatch(this);
consume();
}
setState(1191);
_errHandler->sync(this);
_la = _input->LA(1);
} while ((((_la & ~ 0x3fULL) == 0) &&
((1ULL << _la) & ((1ULL << SwiftMtParser_MT565Parser::T__0)
| (1ULL << SwiftMtParser_MT565Parser::T__1)
| (1ULL << SwiftMtParser_MT565Parser::T__2)
| (1ULL << SwiftMtParser_MT565Parser::T__3)
| (1ULL << SwiftMtParser_MT565Parser::T__4)
| (1ULL << SwiftMtParser_MT565Parser::T__5)
| (1ULL << SwiftMtParser_MT565Parser::T__6)
| (1ULL << SwiftMtParser_MT565Parser::T__7)
| (1ULL << SwiftMtParser_MT565Parser::T__8)
| (1ULL << SwiftMtParser_MT565Parser::T__9)
| (1ULL << SwiftMtParser_MT565Parser::T__10)
| (1ULL << SwiftMtParser_MT565Parser::T__11)
| (1ULL << SwiftMtParser_MT565Parser::T__12)
| (1ULL << SwiftMtParser_MT565Parser::T__13)
| (1ULL << SwiftMtParser_MT565Parser::T__14)
| (1ULL << SwiftMtParser_MT565Parser::T__15)
| (1ULL << SwiftMtParser_MT565Parser::T__16)
| (1ULL << SwiftMtParser_MT565Parser::T__17)
| (1ULL << SwiftMtParser_MT565Parser::T__18)
| (1ULL << SwiftMtParser_MT565Parser::T__19)
| (1ULL << SwiftMtParser_MT565Parser::T__20)
| (1ULL << SwiftMtParser_MT565Parser::T__21)
| (1ULL << SwiftMtParser_MT565Parser::T__22)
| (1ULL << SwiftMtParser_MT565Parser::T__23)
| (1ULL << SwiftMtParser_MT565Parser::T__24)
| (1ULL << SwiftMtParser_MT565Parser::T__25)
| (1ULL << SwiftMtParser_MT565Parser::T__26)
| (1ULL << SwiftMtParser_MT565Parser::T__27)
| (1ULL << SwiftMtParser_MT565Parser::T__28)
| (1ULL << SwiftMtParser_MT565Parser::T__29)
| (1ULL << SwiftMtParser_MT565Parser::T__30)
| (1ULL << SwiftMtParser_MT565Parser::T__31)
| (1ULL << SwiftMtParser_MT565Parser::T__32)
| (1ULL << SwiftMtParser_MT565Parser::T__33)
| (1ULL << SwiftMtParser_MT565Parser::T__34)
| (1ULL << SwiftMtParser_MT565Parser::T__35)
| (1ULL << SwiftMtParser_MT565Parser::T__36)
| (1ULL << SwiftMtParser_MT565Parser::T__37)
| (1ULL << SwiftMtParser_MT565Parser::TAG_BH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_AH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_UH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_MT)
| (1ULL << SwiftMtParser_MT565Parser::TAG_TR)
| (1ULL << SwiftMtParser_MT565Parser::MT_END)
| (1ULL << SwiftMtParser_MT565Parser::LBRACE)
| (1ULL << SwiftMtParser_MT565Parser::RBRACE)
| (1ULL << SwiftMtParser_MT565Parser::COLON)
| (1ULL << SwiftMtParser_MT565Parser::ANY))) != 0));
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- Fld_92a_D_FContext ------------------------------------------------------------------
SwiftMtParser_MT565Parser::Fld_92a_D_FContext::Fld_92a_D_FContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
std::vector<tree::TerminalNode *> SwiftMtParser_MT565Parser::Fld_92a_D_FContext::START_OF_FIELD() {
return getTokens(SwiftMtParser_MT565Parser::START_OF_FIELD);
}
tree::TerminalNode* SwiftMtParser_MT565Parser::Fld_92a_D_FContext::START_OF_FIELD(size_t i) {
return getToken(SwiftMtParser_MT565Parser::START_OF_FIELD, i);
}
size_t SwiftMtParser_MT565Parser::Fld_92a_D_FContext::getRuleIndex() const {
return SwiftMtParser_MT565Parser::RuleFld_92a_D_F;
}
void SwiftMtParser_MT565Parser::Fld_92a_D_FContext::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->enterFld_92a_D_F(this);
}
void SwiftMtParser_MT565Parser::Fld_92a_D_FContext::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->exitFld_92a_D_F(this);
}
SwiftMtParser_MT565Parser::Fld_92a_D_FContext* SwiftMtParser_MT565Parser::fld_92a_D_F() {
Fld_92a_D_FContext *_localctx = _tracker.createInstance<Fld_92a_D_FContext>(_ctx, getState());
enterRule(_localctx, 234, SwiftMtParser_MT565Parser::RuleFld_92a_D_F);
_localctx->fld.set_tag("92F");
size_t _la = 0;
auto onExit = finally([=] {
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(1193);
match(SwiftMtParser_MT565Parser::START_OF_FIELD);
setState(1194);
match(SwiftMtParser_MT565Parser::T__29);
setState(1196);
_errHandler->sync(this);
_la = _input->LA(1);
do {
setState(1195);
_la = _input->LA(1);
if (_la == 0 || _la == Token::EOF || (_la == SwiftMtParser_MT565Parser::START_OF_FIELD)) {
_errHandler->recoverInline(this);
}
else {
_errHandler->reportMatch(this);
consume();
}
setState(1198);
_errHandler->sync(this);
_la = _input->LA(1);
} while ((((_la & ~ 0x3fULL) == 0) &&
((1ULL << _la) & ((1ULL << SwiftMtParser_MT565Parser::T__0)
| (1ULL << SwiftMtParser_MT565Parser::T__1)
| (1ULL << SwiftMtParser_MT565Parser::T__2)
| (1ULL << SwiftMtParser_MT565Parser::T__3)
| (1ULL << SwiftMtParser_MT565Parser::T__4)
| (1ULL << SwiftMtParser_MT565Parser::T__5)
| (1ULL << SwiftMtParser_MT565Parser::T__6)
| (1ULL << SwiftMtParser_MT565Parser::T__7)
| (1ULL << SwiftMtParser_MT565Parser::T__8)
| (1ULL << SwiftMtParser_MT565Parser::T__9)
| (1ULL << SwiftMtParser_MT565Parser::T__10)
| (1ULL << SwiftMtParser_MT565Parser::T__11)
| (1ULL << SwiftMtParser_MT565Parser::T__12)
| (1ULL << SwiftMtParser_MT565Parser::T__13)
| (1ULL << SwiftMtParser_MT565Parser::T__14)
| (1ULL << SwiftMtParser_MT565Parser::T__15)
| (1ULL << SwiftMtParser_MT565Parser::T__16)
| (1ULL << SwiftMtParser_MT565Parser::T__17)
| (1ULL << SwiftMtParser_MT565Parser::T__18)
| (1ULL << SwiftMtParser_MT565Parser::T__19)
| (1ULL << SwiftMtParser_MT565Parser::T__20)
| (1ULL << SwiftMtParser_MT565Parser::T__21)
| (1ULL << SwiftMtParser_MT565Parser::T__22)
| (1ULL << SwiftMtParser_MT565Parser::T__23)
| (1ULL << SwiftMtParser_MT565Parser::T__24)
| (1ULL << SwiftMtParser_MT565Parser::T__25)
| (1ULL << SwiftMtParser_MT565Parser::T__26)
| (1ULL << SwiftMtParser_MT565Parser::T__27)
| (1ULL << SwiftMtParser_MT565Parser::T__28)
| (1ULL << SwiftMtParser_MT565Parser::T__29)
| (1ULL << SwiftMtParser_MT565Parser::T__30)
| (1ULL << SwiftMtParser_MT565Parser::T__31)
| (1ULL << SwiftMtParser_MT565Parser::T__32)
| (1ULL << SwiftMtParser_MT565Parser::T__33)
| (1ULL << SwiftMtParser_MT565Parser::T__34)
| (1ULL << SwiftMtParser_MT565Parser::T__35)
| (1ULL << SwiftMtParser_MT565Parser::T__36)
| (1ULL << SwiftMtParser_MT565Parser::T__37)
| (1ULL << SwiftMtParser_MT565Parser::TAG_BH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_AH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_UH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_MT)
| (1ULL << SwiftMtParser_MT565Parser::TAG_TR)
| (1ULL << SwiftMtParser_MT565Parser::MT_END)
| (1ULL << SwiftMtParser_MT565Parser::LBRACE)
| (1ULL << SwiftMtParser_MT565Parser::RBRACE)
| (1ULL << SwiftMtParser_MT565Parser::COLON)
| (1ULL << SwiftMtParser_MT565Parser::ANY))) != 0));
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- Fld_92a_D_RContext ------------------------------------------------------------------
SwiftMtParser_MT565Parser::Fld_92a_D_RContext::Fld_92a_D_RContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
std::vector<tree::TerminalNode *> SwiftMtParser_MT565Parser::Fld_92a_D_RContext::START_OF_FIELD() {
return getTokens(SwiftMtParser_MT565Parser::START_OF_FIELD);
}
tree::TerminalNode* SwiftMtParser_MT565Parser::Fld_92a_D_RContext::START_OF_FIELD(size_t i) {
return getToken(SwiftMtParser_MT565Parser::START_OF_FIELD, i);
}
size_t SwiftMtParser_MT565Parser::Fld_92a_D_RContext::getRuleIndex() const {
return SwiftMtParser_MT565Parser::RuleFld_92a_D_R;
}
void SwiftMtParser_MT565Parser::Fld_92a_D_RContext::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->enterFld_92a_D_R(this);
}
void SwiftMtParser_MT565Parser::Fld_92a_D_RContext::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->exitFld_92a_D_R(this);
}
SwiftMtParser_MT565Parser::Fld_92a_D_RContext* SwiftMtParser_MT565Parser::fld_92a_D_R() {
Fld_92a_D_RContext *_localctx = _tracker.createInstance<Fld_92a_D_RContext>(_ctx, getState());
enterRule(_localctx, 236, SwiftMtParser_MT565Parser::RuleFld_92a_D_R);
_localctx->fld.set_tag("92R");
size_t _la = 0;
auto onExit = finally([=] {
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(1200);
match(SwiftMtParser_MT565Parser::START_OF_FIELD);
setState(1201);
match(SwiftMtParser_MT565Parser::T__30);
setState(1203);
_errHandler->sync(this);
_la = _input->LA(1);
do {
setState(1202);
_la = _input->LA(1);
if (_la == 0 || _la == Token::EOF || (_la == SwiftMtParser_MT565Parser::START_OF_FIELD)) {
_errHandler->recoverInline(this);
}
else {
_errHandler->reportMatch(this);
consume();
}
setState(1205);
_errHandler->sync(this);
_la = _input->LA(1);
} while ((((_la & ~ 0x3fULL) == 0) &&
((1ULL << _la) & ((1ULL << SwiftMtParser_MT565Parser::T__0)
| (1ULL << SwiftMtParser_MT565Parser::T__1)
| (1ULL << SwiftMtParser_MT565Parser::T__2)
| (1ULL << SwiftMtParser_MT565Parser::T__3)
| (1ULL << SwiftMtParser_MT565Parser::T__4)
| (1ULL << SwiftMtParser_MT565Parser::T__5)
| (1ULL << SwiftMtParser_MT565Parser::T__6)
| (1ULL << SwiftMtParser_MT565Parser::T__7)
| (1ULL << SwiftMtParser_MT565Parser::T__8)
| (1ULL << SwiftMtParser_MT565Parser::T__9)
| (1ULL << SwiftMtParser_MT565Parser::T__10)
| (1ULL << SwiftMtParser_MT565Parser::T__11)
| (1ULL << SwiftMtParser_MT565Parser::T__12)
| (1ULL << SwiftMtParser_MT565Parser::T__13)
| (1ULL << SwiftMtParser_MT565Parser::T__14)
| (1ULL << SwiftMtParser_MT565Parser::T__15)
| (1ULL << SwiftMtParser_MT565Parser::T__16)
| (1ULL << SwiftMtParser_MT565Parser::T__17)
| (1ULL << SwiftMtParser_MT565Parser::T__18)
| (1ULL << SwiftMtParser_MT565Parser::T__19)
| (1ULL << SwiftMtParser_MT565Parser::T__20)
| (1ULL << SwiftMtParser_MT565Parser::T__21)
| (1ULL << SwiftMtParser_MT565Parser::T__22)
| (1ULL << SwiftMtParser_MT565Parser::T__23)
| (1ULL << SwiftMtParser_MT565Parser::T__24)
| (1ULL << SwiftMtParser_MT565Parser::T__25)
| (1ULL << SwiftMtParser_MT565Parser::T__26)
| (1ULL << SwiftMtParser_MT565Parser::T__27)
| (1ULL << SwiftMtParser_MT565Parser::T__28)
| (1ULL << SwiftMtParser_MT565Parser::T__29)
| (1ULL << SwiftMtParser_MT565Parser::T__30)
| (1ULL << SwiftMtParser_MT565Parser::T__31)
| (1ULL << SwiftMtParser_MT565Parser::T__32)
| (1ULL << SwiftMtParser_MT565Parser::T__33)
| (1ULL << SwiftMtParser_MT565Parser::T__34)
| (1ULL << SwiftMtParser_MT565Parser::T__35)
| (1ULL << SwiftMtParser_MT565Parser::T__36)
| (1ULL << SwiftMtParser_MT565Parser::T__37)
| (1ULL << SwiftMtParser_MT565Parser::TAG_BH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_AH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_UH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_MT)
| (1ULL << SwiftMtParser_MT565Parser::TAG_TR)
| (1ULL << SwiftMtParser_MT565Parser::MT_END)
| (1ULL << SwiftMtParser_MT565Parser::LBRACE)
| (1ULL << SwiftMtParser_MT565Parser::RBRACE)
| (1ULL << SwiftMtParser_MT565Parser::COLON)
| (1ULL << SwiftMtParser_MT565Parser::ANY))) != 0));
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- Fld_90a_D_AContext ------------------------------------------------------------------
SwiftMtParser_MT565Parser::Fld_90a_D_AContext::Fld_90a_D_AContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
std::vector<tree::TerminalNode *> SwiftMtParser_MT565Parser::Fld_90a_D_AContext::START_OF_FIELD() {
return getTokens(SwiftMtParser_MT565Parser::START_OF_FIELD);
}
tree::TerminalNode* SwiftMtParser_MT565Parser::Fld_90a_D_AContext::START_OF_FIELD(size_t i) {
return getToken(SwiftMtParser_MT565Parser::START_OF_FIELD, i);
}
size_t SwiftMtParser_MT565Parser::Fld_90a_D_AContext::getRuleIndex() const {
return SwiftMtParser_MT565Parser::RuleFld_90a_D_A;
}
void SwiftMtParser_MT565Parser::Fld_90a_D_AContext::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->enterFld_90a_D_A(this);
}
void SwiftMtParser_MT565Parser::Fld_90a_D_AContext::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->exitFld_90a_D_A(this);
}
SwiftMtParser_MT565Parser::Fld_90a_D_AContext* SwiftMtParser_MT565Parser::fld_90a_D_A() {
Fld_90a_D_AContext *_localctx = _tracker.createInstance<Fld_90a_D_AContext>(_ctx, getState());
enterRule(_localctx, 238, SwiftMtParser_MT565Parser::RuleFld_90a_D_A);
_localctx->fld.set_tag("90A");
size_t _la = 0;
auto onExit = finally([=] {
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(1207);
match(SwiftMtParser_MT565Parser::START_OF_FIELD);
setState(1208);
match(SwiftMtParser_MT565Parser::T__31);
setState(1210);
_errHandler->sync(this);
_la = _input->LA(1);
do {
setState(1209);
_la = _input->LA(1);
if (_la == 0 || _la == Token::EOF || (_la == SwiftMtParser_MT565Parser::START_OF_FIELD)) {
_errHandler->recoverInline(this);
}
else {
_errHandler->reportMatch(this);
consume();
}
setState(1212);
_errHandler->sync(this);
_la = _input->LA(1);
} while ((((_la & ~ 0x3fULL) == 0) &&
((1ULL << _la) & ((1ULL << SwiftMtParser_MT565Parser::T__0)
| (1ULL << SwiftMtParser_MT565Parser::T__1)
| (1ULL << SwiftMtParser_MT565Parser::T__2)
| (1ULL << SwiftMtParser_MT565Parser::T__3)
| (1ULL << SwiftMtParser_MT565Parser::T__4)
| (1ULL << SwiftMtParser_MT565Parser::T__5)
| (1ULL << SwiftMtParser_MT565Parser::T__6)
| (1ULL << SwiftMtParser_MT565Parser::T__7)
| (1ULL << SwiftMtParser_MT565Parser::T__8)
| (1ULL << SwiftMtParser_MT565Parser::T__9)
| (1ULL << SwiftMtParser_MT565Parser::T__10)
| (1ULL << SwiftMtParser_MT565Parser::T__11)
| (1ULL << SwiftMtParser_MT565Parser::T__12)
| (1ULL << SwiftMtParser_MT565Parser::T__13)
| (1ULL << SwiftMtParser_MT565Parser::T__14)
| (1ULL << SwiftMtParser_MT565Parser::T__15)
| (1ULL << SwiftMtParser_MT565Parser::T__16)
| (1ULL << SwiftMtParser_MT565Parser::T__17)
| (1ULL << SwiftMtParser_MT565Parser::T__18)
| (1ULL << SwiftMtParser_MT565Parser::T__19)
| (1ULL << SwiftMtParser_MT565Parser::T__20)
| (1ULL << SwiftMtParser_MT565Parser::T__21)
| (1ULL << SwiftMtParser_MT565Parser::T__22)
| (1ULL << SwiftMtParser_MT565Parser::T__23)
| (1ULL << SwiftMtParser_MT565Parser::T__24)
| (1ULL << SwiftMtParser_MT565Parser::T__25)
| (1ULL << SwiftMtParser_MT565Parser::T__26)
| (1ULL << SwiftMtParser_MT565Parser::T__27)
| (1ULL << SwiftMtParser_MT565Parser::T__28)
| (1ULL << SwiftMtParser_MT565Parser::T__29)
| (1ULL << SwiftMtParser_MT565Parser::T__30)
| (1ULL << SwiftMtParser_MT565Parser::T__31)
| (1ULL << SwiftMtParser_MT565Parser::T__32)
| (1ULL << SwiftMtParser_MT565Parser::T__33)
| (1ULL << SwiftMtParser_MT565Parser::T__34)
| (1ULL << SwiftMtParser_MT565Parser::T__35)
| (1ULL << SwiftMtParser_MT565Parser::T__36)
| (1ULL << SwiftMtParser_MT565Parser::T__37)
| (1ULL << SwiftMtParser_MT565Parser::TAG_BH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_AH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_UH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_MT)
| (1ULL << SwiftMtParser_MT565Parser::TAG_TR)
| (1ULL << SwiftMtParser_MT565Parser::MT_END)
| (1ULL << SwiftMtParser_MT565Parser::LBRACE)
| (1ULL << SwiftMtParser_MT565Parser::RBRACE)
| (1ULL << SwiftMtParser_MT565Parser::COLON)
| (1ULL << SwiftMtParser_MT565Parser::ANY))) != 0));
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- Fld_90a_D_BContext ------------------------------------------------------------------
SwiftMtParser_MT565Parser::Fld_90a_D_BContext::Fld_90a_D_BContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
std::vector<tree::TerminalNode *> SwiftMtParser_MT565Parser::Fld_90a_D_BContext::START_OF_FIELD() {
return getTokens(SwiftMtParser_MT565Parser::START_OF_FIELD);
}
tree::TerminalNode* SwiftMtParser_MT565Parser::Fld_90a_D_BContext::START_OF_FIELD(size_t i) {
return getToken(SwiftMtParser_MT565Parser::START_OF_FIELD, i);
}
size_t SwiftMtParser_MT565Parser::Fld_90a_D_BContext::getRuleIndex() const {
return SwiftMtParser_MT565Parser::RuleFld_90a_D_B;
}
void SwiftMtParser_MT565Parser::Fld_90a_D_BContext::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->enterFld_90a_D_B(this);
}
void SwiftMtParser_MT565Parser::Fld_90a_D_BContext::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->exitFld_90a_D_B(this);
}
SwiftMtParser_MT565Parser::Fld_90a_D_BContext* SwiftMtParser_MT565Parser::fld_90a_D_B() {
Fld_90a_D_BContext *_localctx = _tracker.createInstance<Fld_90a_D_BContext>(_ctx, getState());
enterRule(_localctx, 240, SwiftMtParser_MT565Parser::RuleFld_90a_D_B);
_localctx->fld.set_tag("90B");
size_t _la = 0;
auto onExit = finally([=] {
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(1214);
match(SwiftMtParser_MT565Parser::START_OF_FIELD);
setState(1215);
match(SwiftMtParser_MT565Parser::T__32);
setState(1217);
_errHandler->sync(this);
_la = _input->LA(1);
do {
setState(1216);
_la = _input->LA(1);
if (_la == 0 || _la == Token::EOF || (_la == SwiftMtParser_MT565Parser::START_OF_FIELD)) {
_errHandler->recoverInline(this);
}
else {
_errHandler->reportMatch(this);
consume();
}
setState(1219);
_errHandler->sync(this);
_la = _input->LA(1);
} while ((((_la & ~ 0x3fULL) == 0) &&
((1ULL << _la) & ((1ULL << SwiftMtParser_MT565Parser::T__0)
| (1ULL << SwiftMtParser_MT565Parser::T__1)
| (1ULL << SwiftMtParser_MT565Parser::T__2)
| (1ULL << SwiftMtParser_MT565Parser::T__3)
| (1ULL << SwiftMtParser_MT565Parser::T__4)
| (1ULL << SwiftMtParser_MT565Parser::T__5)
| (1ULL << SwiftMtParser_MT565Parser::T__6)
| (1ULL << SwiftMtParser_MT565Parser::T__7)
| (1ULL << SwiftMtParser_MT565Parser::T__8)
| (1ULL << SwiftMtParser_MT565Parser::T__9)
| (1ULL << SwiftMtParser_MT565Parser::T__10)
| (1ULL << SwiftMtParser_MT565Parser::T__11)
| (1ULL << SwiftMtParser_MT565Parser::T__12)
| (1ULL << SwiftMtParser_MT565Parser::T__13)
| (1ULL << SwiftMtParser_MT565Parser::T__14)
| (1ULL << SwiftMtParser_MT565Parser::T__15)
| (1ULL << SwiftMtParser_MT565Parser::T__16)
| (1ULL << SwiftMtParser_MT565Parser::T__17)
| (1ULL << SwiftMtParser_MT565Parser::T__18)
| (1ULL << SwiftMtParser_MT565Parser::T__19)
| (1ULL << SwiftMtParser_MT565Parser::T__20)
| (1ULL << SwiftMtParser_MT565Parser::T__21)
| (1ULL << SwiftMtParser_MT565Parser::T__22)
| (1ULL << SwiftMtParser_MT565Parser::T__23)
| (1ULL << SwiftMtParser_MT565Parser::T__24)
| (1ULL << SwiftMtParser_MT565Parser::T__25)
| (1ULL << SwiftMtParser_MT565Parser::T__26)
| (1ULL << SwiftMtParser_MT565Parser::T__27)
| (1ULL << SwiftMtParser_MT565Parser::T__28)
| (1ULL << SwiftMtParser_MT565Parser::T__29)
| (1ULL << SwiftMtParser_MT565Parser::T__30)
| (1ULL << SwiftMtParser_MT565Parser::T__31)
| (1ULL << SwiftMtParser_MT565Parser::T__32)
| (1ULL << SwiftMtParser_MT565Parser::T__33)
| (1ULL << SwiftMtParser_MT565Parser::T__34)
| (1ULL << SwiftMtParser_MT565Parser::T__35)
| (1ULL << SwiftMtParser_MT565Parser::T__36)
| (1ULL << SwiftMtParser_MT565Parser::T__37)
| (1ULL << SwiftMtParser_MT565Parser::TAG_BH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_AH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_UH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_MT)
| (1ULL << SwiftMtParser_MT565Parser::TAG_TR)
| (1ULL << SwiftMtParser_MT565Parser::MT_END)
| (1ULL << SwiftMtParser_MT565Parser::LBRACE)
| (1ULL << SwiftMtParser_MT565Parser::RBRACE)
| (1ULL << SwiftMtParser_MT565Parser::COLON)
| (1ULL << SwiftMtParser_MT565Parser::ANY))) != 0));
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- Fld_90a_D_EContext ------------------------------------------------------------------
SwiftMtParser_MT565Parser::Fld_90a_D_EContext::Fld_90a_D_EContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
std::vector<tree::TerminalNode *> SwiftMtParser_MT565Parser::Fld_90a_D_EContext::START_OF_FIELD() {
return getTokens(SwiftMtParser_MT565Parser::START_OF_FIELD);
}
tree::TerminalNode* SwiftMtParser_MT565Parser::Fld_90a_D_EContext::START_OF_FIELD(size_t i) {
return getToken(SwiftMtParser_MT565Parser::START_OF_FIELD, i);
}
size_t SwiftMtParser_MT565Parser::Fld_90a_D_EContext::getRuleIndex() const {
return SwiftMtParser_MT565Parser::RuleFld_90a_D_E;
}
void SwiftMtParser_MT565Parser::Fld_90a_D_EContext::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->enterFld_90a_D_E(this);
}
void SwiftMtParser_MT565Parser::Fld_90a_D_EContext::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->exitFld_90a_D_E(this);
}
SwiftMtParser_MT565Parser::Fld_90a_D_EContext* SwiftMtParser_MT565Parser::fld_90a_D_E() {
Fld_90a_D_EContext *_localctx = _tracker.createInstance<Fld_90a_D_EContext>(_ctx, getState());
enterRule(_localctx, 242, SwiftMtParser_MT565Parser::RuleFld_90a_D_E);
_localctx->fld.set_tag("90E");
size_t _la = 0;
auto onExit = finally([=] {
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(1221);
match(SwiftMtParser_MT565Parser::START_OF_FIELD);
setState(1222);
match(SwiftMtParser_MT565Parser::T__33);
setState(1224);
_errHandler->sync(this);
_la = _input->LA(1);
do {
setState(1223);
_la = _input->LA(1);
if (_la == 0 || _la == Token::EOF || (_la == SwiftMtParser_MT565Parser::START_OF_FIELD)) {
_errHandler->recoverInline(this);
}
else {
_errHandler->reportMatch(this);
consume();
}
setState(1226);
_errHandler->sync(this);
_la = _input->LA(1);
} while ((((_la & ~ 0x3fULL) == 0) &&
((1ULL << _la) & ((1ULL << SwiftMtParser_MT565Parser::T__0)
| (1ULL << SwiftMtParser_MT565Parser::T__1)
| (1ULL << SwiftMtParser_MT565Parser::T__2)
| (1ULL << SwiftMtParser_MT565Parser::T__3)
| (1ULL << SwiftMtParser_MT565Parser::T__4)
| (1ULL << SwiftMtParser_MT565Parser::T__5)
| (1ULL << SwiftMtParser_MT565Parser::T__6)
| (1ULL << SwiftMtParser_MT565Parser::T__7)
| (1ULL << SwiftMtParser_MT565Parser::T__8)
| (1ULL << SwiftMtParser_MT565Parser::T__9)
| (1ULL << SwiftMtParser_MT565Parser::T__10)
| (1ULL << SwiftMtParser_MT565Parser::T__11)
| (1ULL << SwiftMtParser_MT565Parser::T__12)
| (1ULL << SwiftMtParser_MT565Parser::T__13)
| (1ULL << SwiftMtParser_MT565Parser::T__14)
| (1ULL << SwiftMtParser_MT565Parser::T__15)
| (1ULL << SwiftMtParser_MT565Parser::T__16)
| (1ULL << SwiftMtParser_MT565Parser::T__17)
| (1ULL << SwiftMtParser_MT565Parser::T__18)
| (1ULL << SwiftMtParser_MT565Parser::T__19)
| (1ULL << SwiftMtParser_MT565Parser::T__20)
| (1ULL << SwiftMtParser_MT565Parser::T__21)
| (1ULL << SwiftMtParser_MT565Parser::T__22)
| (1ULL << SwiftMtParser_MT565Parser::T__23)
| (1ULL << SwiftMtParser_MT565Parser::T__24)
| (1ULL << SwiftMtParser_MT565Parser::T__25)
| (1ULL << SwiftMtParser_MT565Parser::T__26)
| (1ULL << SwiftMtParser_MT565Parser::T__27)
| (1ULL << SwiftMtParser_MT565Parser::T__28)
| (1ULL << SwiftMtParser_MT565Parser::T__29)
| (1ULL << SwiftMtParser_MT565Parser::T__30)
| (1ULL << SwiftMtParser_MT565Parser::T__31)
| (1ULL << SwiftMtParser_MT565Parser::T__32)
| (1ULL << SwiftMtParser_MT565Parser::T__33)
| (1ULL << SwiftMtParser_MT565Parser::T__34)
| (1ULL << SwiftMtParser_MT565Parser::T__35)
| (1ULL << SwiftMtParser_MT565Parser::T__36)
| (1ULL << SwiftMtParser_MT565Parser::T__37)
| (1ULL << SwiftMtParser_MT565Parser::TAG_BH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_AH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_UH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_MT)
| (1ULL << SwiftMtParser_MT565Parser::TAG_TR)
| (1ULL << SwiftMtParser_MT565Parser::MT_END)
| (1ULL << SwiftMtParser_MT565Parser::LBRACE)
| (1ULL << SwiftMtParser_MT565Parser::RBRACE)
| (1ULL << SwiftMtParser_MT565Parser::COLON)
| (1ULL << SwiftMtParser_MT565Parser::ANY))) != 0));
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- Fld_90a_D_FContext ------------------------------------------------------------------
SwiftMtParser_MT565Parser::Fld_90a_D_FContext::Fld_90a_D_FContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
std::vector<tree::TerminalNode *> SwiftMtParser_MT565Parser::Fld_90a_D_FContext::START_OF_FIELD() {
return getTokens(SwiftMtParser_MT565Parser::START_OF_FIELD);
}
tree::TerminalNode* SwiftMtParser_MT565Parser::Fld_90a_D_FContext::START_OF_FIELD(size_t i) {
return getToken(SwiftMtParser_MT565Parser::START_OF_FIELD, i);
}
size_t SwiftMtParser_MT565Parser::Fld_90a_D_FContext::getRuleIndex() const {
return SwiftMtParser_MT565Parser::RuleFld_90a_D_F;
}
void SwiftMtParser_MT565Parser::Fld_90a_D_FContext::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->enterFld_90a_D_F(this);
}
void SwiftMtParser_MT565Parser::Fld_90a_D_FContext::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->exitFld_90a_D_F(this);
}
SwiftMtParser_MT565Parser::Fld_90a_D_FContext* SwiftMtParser_MT565Parser::fld_90a_D_F() {
Fld_90a_D_FContext *_localctx = _tracker.createInstance<Fld_90a_D_FContext>(_ctx, getState());
enterRule(_localctx, 244, SwiftMtParser_MT565Parser::RuleFld_90a_D_F);
_localctx->fld.set_tag("90F");
size_t _la = 0;
auto onExit = finally([=] {
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(1228);
match(SwiftMtParser_MT565Parser::START_OF_FIELD);
setState(1229);
match(SwiftMtParser_MT565Parser::T__34);
setState(1231);
_errHandler->sync(this);
_la = _input->LA(1);
do {
setState(1230);
_la = _input->LA(1);
if (_la == 0 || _la == Token::EOF || (_la == SwiftMtParser_MT565Parser::START_OF_FIELD)) {
_errHandler->recoverInline(this);
}
else {
_errHandler->reportMatch(this);
consume();
}
setState(1233);
_errHandler->sync(this);
_la = _input->LA(1);
} while ((((_la & ~ 0x3fULL) == 0) &&
((1ULL << _la) & ((1ULL << SwiftMtParser_MT565Parser::T__0)
| (1ULL << SwiftMtParser_MT565Parser::T__1)
| (1ULL << SwiftMtParser_MT565Parser::T__2)
| (1ULL << SwiftMtParser_MT565Parser::T__3)
| (1ULL << SwiftMtParser_MT565Parser::T__4)
| (1ULL << SwiftMtParser_MT565Parser::T__5)
| (1ULL << SwiftMtParser_MT565Parser::T__6)
| (1ULL << SwiftMtParser_MT565Parser::T__7)
| (1ULL << SwiftMtParser_MT565Parser::T__8)
| (1ULL << SwiftMtParser_MT565Parser::T__9)
| (1ULL << SwiftMtParser_MT565Parser::T__10)
| (1ULL << SwiftMtParser_MT565Parser::T__11)
| (1ULL << SwiftMtParser_MT565Parser::T__12)
| (1ULL << SwiftMtParser_MT565Parser::T__13)
| (1ULL << SwiftMtParser_MT565Parser::T__14)
| (1ULL << SwiftMtParser_MT565Parser::T__15)
| (1ULL << SwiftMtParser_MT565Parser::T__16)
| (1ULL << SwiftMtParser_MT565Parser::T__17)
| (1ULL << SwiftMtParser_MT565Parser::T__18)
| (1ULL << SwiftMtParser_MT565Parser::T__19)
| (1ULL << SwiftMtParser_MT565Parser::T__20)
| (1ULL << SwiftMtParser_MT565Parser::T__21)
| (1ULL << SwiftMtParser_MT565Parser::T__22)
| (1ULL << SwiftMtParser_MT565Parser::T__23)
| (1ULL << SwiftMtParser_MT565Parser::T__24)
| (1ULL << SwiftMtParser_MT565Parser::T__25)
| (1ULL << SwiftMtParser_MT565Parser::T__26)
| (1ULL << SwiftMtParser_MT565Parser::T__27)
| (1ULL << SwiftMtParser_MT565Parser::T__28)
| (1ULL << SwiftMtParser_MT565Parser::T__29)
| (1ULL << SwiftMtParser_MT565Parser::T__30)
| (1ULL << SwiftMtParser_MT565Parser::T__31)
| (1ULL << SwiftMtParser_MT565Parser::T__32)
| (1ULL << SwiftMtParser_MT565Parser::T__33)
| (1ULL << SwiftMtParser_MT565Parser::T__34)
| (1ULL << SwiftMtParser_MT565Parser::T__35)
| (1ULL << SwiftMtParser_MT565Parser::T__36)
| (1ULL << SwiftMtParser_MT565Parser::T__37)
| (1ULL << SwiftMtParser_MT565Parser::TAG_BH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_AH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_UH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_MT)
| (1ULL << SwiftMtParser_MT565Parser::TAG_TR)
| (1ULL << SwiftMtParser_MT565Parser::MT_END)
| (1ULL << SwiftMtParser_MT565Parser::LBRACE)
| (1ULL << SwiftMtParser_MT565Parser::RBRACE)
| (1ULL << SwiftMtParser_MT565Parser::COLON)
| (1ULL << SwiftMtParser_MT565Parser::ANY))) != 0));
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- Fld_90a_D_JContext ------------------------------------------------------------------
SwiftMtParser_MT565Parser::Fld_90a_D_JContext::Fld_90a_D_JContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
std::vector<tree::TerminalNode *> SwiftMtParser_MT565Parser::Fld_90a_D_JContext::START_OF_FIELD() {
return getTokens(SwiftMtParser_MT565Parser::START_OF_FIELD);
}
tree::TerminalNode* SwiftMtParser_MT565Parser::Fld_90a_D_JContext::START_OF_FIELD(size_t i) {
return getToken(SwiftMtParser_MT565Parser::START_OF_FIELD, i);
}
size_t SwiftMtParser_MT565Parser::Fld_90a_D_JContext::getRuleIndex() const {
return SwiftMtParser_MT565Parser::RuleFld_90a_D_J;
}
void SwiftMtParser_MT565Parser::Fld_90a_D_JContext::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->enterFld_90a_D_J(this);
}
void SwiftMtParser_MT565Parser::Fld_90a_D_JContext::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->exitFld_90a_D_J(this);
}
SwiftMtParser_MT565Parser::Fld_90a_D_JContext* SwiftMtParser_MT565Parser::fld_90a_D_J() {
Fld_90a_D_JContext *_localctx = _tracker.createInstance<Fld_90a_D_JContext>(_ctx, getState());
enterRule(_localctx, 246, SwiftMtParser_MT565Parser::RuleFld_90a_D_J);
_localctx->fld.set_tag("90J");
size_t _la = 0;
auto onExit = finally([=] {
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(1235);
match(SwiftMtParser_MT565Parser::START_OF_FIELD);
setState(1236);
match(SwiftMtParser_MT565Parser::T__35);
setState(1238);
_errHandler->sync(this);
_la = _input->LA(1);
do {
setState(1237);
_la = _input->LA(1);
if (_la == 0 || _la == Token::EOF || (_la == SwiftMtParser_MT565Parser::START_OF_FIELD)) {
_errHandler->recoverInline(this);
}
else {
_errHandler->reportMatch(this);
consume();
}
setState(1240);
_errHandler->sync(this);
_la = _input->LA(1);
} while ((((_la & ~ 0x3fULL) == 0) &&
((1ULL << _la) & ((1ULL << SwiftMtParser_MT565Parser::T__0)
| (1ULL << SwiftMtParser_MT565Parser::T__1)
| (1ULL << SwiftMtParser_MT565Parser::T__2)
| (1ULL << SwiftMtParser_MT565Parser::T__3)
| (1ULL << SwiftMtParser_MT565Parser::T__4)
| (1ULL << SwiftMtParser_MT565Parser::T__5)
| (1ULL << SwiftMtParser_MT565Parser::T__6)
| (1ULL << SwiftMtParser_MT565Parser::T__7)
| (1ULL << SwiftMtParser_MT565Parser::T__8)
| (1ULL << SwiftMtParser_MT565Parser::T__9)
| (1ULL << SwiftMtParser_MT565Parser::T__10)
| (1ULL << SwiftMtParser_MT565Parser::T__11)
| (1ULL << SwiftMtParser_MT565Parser::T__12)
| (1ULL << SwiftMtParser_MT565Parser::T__13)
| (1ULL << SwiftMtParser_MT565Parser::T__14)
| (1ULL << SwiftMtParser_MT565Parser::T__15)
| (1ULL << SwiftMtParser_MT565Parser::T__16)
| (1ULL << SwiftMtParser_MT565Parser::T__17)
| (1ULL << SwiftMtParser_MT565Parser::T__18)
| (1ULL << SwiftMtParser_MT565Parser::T__19)
| (1ULL << SwiftMtParser_MT565Parser::T__20)
| (1ULL << SwiftMtParser_MT565Parser::T__21)
| (1ULL << SwiftMtParser_MT565Parser::T__22)
| (1ULL << SwiftMtParser_MT565Parser::T__23)
| (1ULL << SwiftMtParser_MT565Parser::T__24)
| (1ULL << SwiftMtParser_MT565Parser::T__25)
| (1ULL << SwiftMtParser_MT565Parser::T__26)
| (1ULL << SwiftMtParser_MT565Parser::T__27)
| (1ULL << SwiftMtParser_MT565Parser::T__28)
| (1ULL << SwiftMtParser_MT565Parser::T__29)
| (1ULL << SwiftMtParser_MT565Parser::T__30)
| (1ULL << SwiftMtParser_MT565Parser::T__31)
| (1ULL << SwiftMtParser_MT565Parser::T__32)
| (1ULL << SwiftMtParser_MT565Parser::T__33)
| (1ULL << SwiftMtParser_MT565Parser::T__34)
| (1ULL << SwiftMtParser_MT565Parser::T__35)
| (1ULL << SwiftMtParser_MT565Parser::T__36)
| (1ULL << SwiftMtParser_MT565Parser::T__37)
| (1ULL << SwiftMtParser_MT565Parser::TAG_BH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_AH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_UH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_MT)
| (1ULL << SwiftMtParser_MT565Parser::TAG_TR)
| (1ULL << SwiftMtParser_MT565Parser::MT_END)
| (1ULL << SwiftMtParser_MT565Parser::LBRACE)
| (1ULL << SwiftMtParser_MT565Parser::RBRACE)
| (1ULL << SwiftMtParser_MT565Parser::COLON)
| (1ULL << SwiftMtParser_MT565Parser::ANY))) != 0));
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- Fld_90a_D_LContext ------------------------------------------------------------------
SwiftMtParser_MT565Parser::Fld_90a_D_LContext::Fld_90a_D_LContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
std::vector<tree::TerminalNode *> SwiftMtParser_MT565Parser::Fld_90a_D_LContext::START_OF_FIELD() {
return getTokens(SwiftMtParser_MT565Parser::START_OF_FIELD);
}
tree::TerminalNode* SwiftMtParser_MT565Parser::Fld_90a_D_LContext::START_OF_FIELD(size_t i) {
return getToken(SwiftMtParser_MT565Parser::START_OF_FIELD, i);
}
size_t SwiftMtParser_MT565Parser::Fld_90a_D_LContext::getRuleIndex() const {
return SwiftMtParser_MT565Parser::RuleFld_90a_D_L;
}
void SwiftMtParser_MT565Parser::Fld_90a_D_LContext::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->enterFld_90a_D_L(this);
}
void SwiftMtParser_MT565Parser::Fld_90a_D_LContext::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->exitFld_90a_D_L(this);
}
SwiftMtParser_MT565Parser::Fld_90a_D_LContext* SwiftMtParser_MT565Parser::fld_90a_D_L() {
Fld_90a_D_LContext *_localctx = _tracker.createInstance<Fld_90a_D_LContext>(_ctx, getState());
enterRule(_localctx, 248, SwiftMtParser_MT565Parser::RuleFld_90a_D_L);
_localctx->fld.set_tag("90L");
size_t _la = 0;
auto onExit = finally([=] {
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(1242);
match(SwiftMtParser_MT565Parser::START_OF_FIELD);
setState(1243);
match(SwiftMtParser_MT565Parser::T__36);
setState(1245);
_errHandler->sync(this);
_la = _input->LA(1);
do {
setState(1244);
_la = _input->LA(1);
if (_la == 0 || _la == Token::EOF || (_la == SwiftMtParser_MT565Parser::START_OF_FIELD)) {
_errHandler->recoverInline(this);
}
else {
_errHandler->reportMatch(this);
consume();
}
setState(1247);
_errHandler->sync(this);
_la = _input->LA(1);
} while ((((_la & ~ 0x3fULL) == 0) &&
((1ULL << _la) & ((1ULL << SwiftMtParser_MT565Parser::T__0)
| (1ULL << SwiftMtParser_MT565Parser::T__1)
| (1ULL << SwiftMtParser_MT565Parser::T__2)
| (1ULL << SwiftMtParser_MT565Parser::T__3)
| (1ULL << SwiftMtParser_MT565Parser::T__4)
| (1ULL << SwiftMtParser_MT565Parser::T__5)
| (1ULL << SwiftMtParser_MT565Parser::T__6)
| (1ULL << SwiftMtParser_MT565Parser::T__7)
| (1ULL << SwiftMtParser_MT565Parser::T__8)
| (1ULL << SwiftMtParser_MT565Parser::T__9)
| (1ULL << SwiftMtParser_MT565Parser::T__10)
| (1ULL << SwiftMtParser_MT565Parser::T__11)
| (1ULL << SwiftMtParser_MT565Parser::T__12)
| (1ULL << SwiftMtParser_MT565Parser::T__13)
| (1ULL << SwiftMtParser_MT565Parser::T__14)
| (1ULL << SwiftMtParser_MT565Parser::T__15)
| (1ULL << SwiftMtParser_MT565Parser::T__16)
| (1ULL << SwiftMtParser_MT565Parser::T__17)
| (1ULL << SwiftMtParser_MT565Parser::T__18)
| (1ULL << SwiftMtParser_MT565Parser::T__19)
| (1ULL << SwiftMtParser_MT565Parser::T__20)
| (1ULL << SwiftMtParser_MT565Parser::T__21)
| (1ULL << SwiftMtParser_MT565Parser::T__22)
| (1ULL << SwiftMtParser_MT565Parser::T__23)
| (1ULL << SwiftMtParser_MT565Parser::T__24)
| (1ULL << SwiftMtParser_MT565Parser::T__25)
| (1ULL << SwiftMtParser_MT565Parser::T__26)
| (1ULL << SwiftMtParser_MT565Parser::T__27)
| (1ULL << SwiftMtParser_MT565Parser::T__28)
| (1ULL << SwiftMtParser_MT565Parser::T__29)
| (1ULL << SwiftMtParser_MT565Parser::T__30)
| (1ULL << SwiftMtParser_MT565Parser::T__31)
| (1ULL << SwiftMtParser_MT565Parser::T__32)
| (1ULL << SwiftMtParser_MT565Parser::T__33)
| (1ULL << SwiftMtParser_MT565Parser::T__34)
| (1ULL << SwiftMtParser_MT565Parser::T__35)
| (1ULL << SwiftMtParser_MT565Parser::T__36)
| (1ULL << SwiftMtParser_MT565Parser::T__37)
| (1ULL << SwiftMtParser_MT565Parser::TAG_BH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_AH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_UH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_MT)
| (1ULL << SwiftMtParser_MT565Parser::TAG_TR)
| (1ULL << SwiftMtParser_MT565Parser::MT_END)
| (1ULL << SwiftMtParser_MT565Parser::LBRACE)
| (1ULL << SwiftMtParser_MT565Parser::RBRACE)
| (1ULL << SwiftMtParser_MT565Parser::COLON)
| (1ULL << SwiftMtParser_MT565Parser::ANY))) != 0));
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- Fld_70E_D_EContext ------------------------------------------------------------------
SwiftMtParser_MT565Parser::Fld_70E_D_EContext::Fld_70E_D_EContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
std::vector<tree::TerminalNode *> SwiftMtParser_MT565Parser::Fld_70E_D_EContext::START_OF_FIELD() {
return getTokens(SwiftMtParser_MT565Parser::START_OF_FIELD);
}
tree::TerminalNode* SwiftMtParser_MT565Parser::Fld_70E_D_EContext::START_OF_FIELD(size_t i) {
return getToken(SwiftMtParser_MT565Parser::START_OF_FIELD, i);
}
size_t SwiftMtParser_MT565Parser::Fld_70E_D_EContext::getRuleIndex() const {
return SwiftMtParser_MT565Parser::RuleFld_70E_D_E;
}
void SwiftMtParser_MT565Parser::Fld_70E_D_EContext::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->enterFld_70E_D_E(this);
}
void SwiftMtParser_MT565Parser::Fld_70E_D_EContext::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->exitFld_70E_D_E(this);
}
SwiftMtParser_MT565Parser::Fld_70E_D_EContext* SwiftMtParser_MT565Parser::fld_70E_D_E() {
Fld_70E_D_EContext *_localctx = _tracker.createInstance<Fld_70E_D_EContext>(_ctx, getState());
enterRule(_localctx, 250, SwiftMtParser_MT565Parser::RuleFld_70E_D_E);
_localctx->fld.set_tag("70E");
size_t _la = 0;
auto onExit = finally([=] {
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(1249);
match(SwiftMtParser_MT565Parser::START_OF_FIELD);
setState(1250);
match(SwiftMtParser_MT565Parser::T__25);
setState(1252);
_errHandler->sync(this);
_la = _input->LA(1);
do {
setState(1251);
_la = _input->LA(1);
if (_la == 0 || _la == Token::EOF || (_la == SwiftMtParser_MT565Parser::START_OF_FIELD)) {
_errHandler->recoverInline(this);
}
else {
_errHandler->reportMatch(this);
consume();
}
setState(1254);
_errHandler->sync(this);
_la = _input->LA(1);
} while ((((_la & ~ 0x3fULL) == 0) &&
((1ULL << _la) & ((1ULL << SwiftMtParser_MT565Parser::T__0)
| (1ULL << SwiftMtParser_MT565Parser::T__1)
| (1ULL << SwiftMtParser_MT565Parser::T__2)
| (1ULL << SwiftMtParser_MT565Parser::T__3)
| (1ULL << SwiftMtParser_MT565Parser::T__4)
| (1ULL << SwiftMtParser_MT565Parser::T__5)
| (1ULL << SwiftMtParser_MT565Parser::T__6)
| (1ULL << SwiftMtParser_MT565Parser::T__7)
| (1ULL << SwiftMtParser_MT565Parser::T__8)
| (1ULL << SwiftMtParser_MT565Parser::T__9)
| (1ULL << SwiftMtParser_MT565Parser::T__10)
| (1ULL << SwiftMtParser_MT565Parser::T__11)
| (1ULL << SwiftMtParser_MT565Parser::T__12)
| (1ULL << SwiftMtParser_MT565Parser::T__13)
| (1ULL << SwiftMtParser_MT565Parser::T__14)
| (1ULL << SwiftMtParser_MT565Parser::T__15)
| (1ULL << SwiftMtParser_MT565Parser::T__16)
| (1ULL << SwiftMtParser_MT565Parser::T__17)
| (1ULL << SwiftMtParser_MT565Parser::T__18)
| (1ULL << SwiftMtParser_MT565Parser::T__19)
| (1ULL << SwiftMtParser_MT565Parser::T__20)
| (1ULL << SwiftMtParser_MT565Parser::T__21)
| (1ULL << SwiftMtParser_MT565Parser::T__22)
| (1ULL << SwiftMtParser_MT565Parser::T__23)
| (1ULL << SwiftMtParser_MT565Parser::T__24)
| (1ULL << SwiftMtParser_MT565Parser::T__25)
| (1ULL << SwiftMtParser_MT565Parser::T__26)
| (1ULL << SwiftMtParser_MT565Parser::T__27)
| (1ULL << SwiftMtParser_MT565Parser::T__28)
| (1ULL << SwiftMtParser_MT565Parser::T__29)
| (1ULL << SwiftMtParser_MT565Parser::T__30)
| (1ULL << SwiftMtParser_MT565Parser::T__31)
| (1ULL << SwiftMtParser_MT565Parser::T__32)
| (1ULL << SwiftMtParser_MT565Parser::T__33)
| (1ULL << SwiftMtParser_MT565Parser::T__34)
| (1ULL << SwiftMtParser_MT565Parser::T__35)
| (1ULL << SwiftMtParser_MT565Parser::T__36)
| (1ULL << SwiftMtParser_MT565Parser::T__37)
| (1ULL << SwiftMtParser_MT565Parser::TAG_BH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_AH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_UH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_MT)
| (1ULL << SwiftMtParser_MT565Parser::TAG_TR)
| (1ULL << SwiftMtParser_MT565Parser::MT_END)
| (1ULL << SwiftMtParser_MT565Parser::LBRACE)
| (1ULL << SwiftMtParser_MT565Parser::RBRACE)
| (1ULL << SwiftMtParser_MT565Parser::COLON)
| (1ULL << SwiftMtParser_MT565Parser::ANY))) != 0));
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- Fld_70E_E_EContext ------------------------------------------------------------------
SwiftMtParser_MT565Parser::Fld_70E_E_EContext::Fld_70E_E_EContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
std::vector<tree::TerminalNode *> SwiftMtParser_MT565Parser::Fld_70E_E_EContext::START_OF_FIELD() {
return getTokens(SwiftMtParser_MT565Parser::START_OF_FIELD);
}
tree::TerminalNode* SwiftMtParser_MT565Parser::Fld_70E_E_EContext::START_OF_FIELD(size_t i) {
return getToken(SwiftMtParser_MT565Parser::START_OF_FIELD, i);
}
size_t SwiftMtParser_MT565Parser::Fld_70E_E_EContext::getRuleIndex() const {
return SwiftMtParser_MT565Parser::RuleFld_70E_E_E;
}
void SwiftMtParser_MT565Parser::Fld_70E_E_EContext::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->enterFld_70E_E_E(this);
}
void SwiftMtParser_MT565Parser::Fld_70E_E_EContext::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->exitFld_70E_E_E(this);
}
SwiftMtParser_MT565Parser::Fld_70E_E_EContext* SwiftMtParser_MT565Parser::fld_70E_E_E() {
Fld_70E_E_EContext *_localctx = _tracker.createInstance<Fld_70E_E_EContext>(_ctx, getState());
enterRule(_localctx, 252, SwiftMtParser_MT565Parser::RuleFld_70E_E_E);
_localctx->fld.set_tag("70E");
size_t _la = 0;
auto onExit = finally([=] {
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(1256);
match(SwiftMtParser_MT565Parser::START_OF_FIELD);
setState(1257);
match(SwiftMtParser_MT565Parser::T__25);
setState(1259);
_errHandler->sync(this);
_la = _input->LA(1);
do {
setState(1258);
_la = _input->LA(1);
if (_la == 0 || _la == Token::EOF || (_la == SwiftMtParser_MT565Parser::START_OF_FIELD)) {
_errHandler->recoverInline(this);
}
else {
_errHandler->reportMatch(this);
consume();
}
setState(1261);
_errHandler->sync(this);
_la = _input->LA(1);
} while ((((_la & ~ 0x3fULL) == 0) &&
((1ULL << _la) & ((1ULL << SwiftMtParser_MT565Parser::T__0)
| (1ULL << SwiftMtParser_MT565Parser::T__1)
| (1ULL << SwiftMtParser_MT565Parser::T__2)
| (1ULL << SwiftMtParser_MT565Parser::T__3)
| (1ULL << SwiftMtParser_MT565Parser::T__4)
| (1ULL << SwiftMtParser_MT565Parser::T__5)
| (1ULL << SwiftMtParser_MT565Parser::T__6)
| (1ULL << SwiftMtParser_MT565Parser::T__7)
| (1ULL << SwiftMtParser_MT565Parser::T__8)
| (1ULL << SwiftMtParser_MT565Parser::T__9)
| (1ULL << SwiftMtParser_MT565Parser::T__10)
| (1ULL << SwiftMtParser_MT565Parser::T__11)
| (1ULL << SwiftMtParser_MT565Parser::T__12)
| (1ULL << SwiftMtParser_MT565Parser::T__13)
| (1ULL << SwiftMtParser_MT565Parser::T__14)
| (1ULL << SwiftMtParser_MT565Parser::T__15)
| (1ULL << SwiftMtParser_MT565Parser::T__16)
| (1ULL << SwiftMtParser_MT565Parser::T__17)
| (1ULL << SwiftMtParser_MT565Parser::T__18)
| (1ULL << SwiftMtParser_MT565Parser::T__19)
| (1ULL << SwiftMtParser_MT565Parser::T__20)
| (1ULL << SwiftMtParser_MT565Parser::T__21)
| (1ULL << SwiftMtParser_MT565Parser::T__22)
| (1ULL << SwiftMtParser_MT565Parser::T__23)
| (1ULL << SwiftMtParser_MT565Parser::T__24)
| (1ULL << SwiftMtParser_MT565Parser::T__25)
| (1ULL << SwiftMtParser_MT565Parser::T__26)
| (1ULL << SwiftMtParser_MT565Parser::T__27)
| (1ULL << SwiftMtParser_MT565Parser::T__28)
| (1ULL << SwiftMtParser_MT565Parser::T__29)
| (1ULL << SwiftMtParser_MT565Parser::T__30)
| (1ULL << SwiftMtParser_MT565Parser::T__31)
| (1ULL << SwiftMtParser_MT565Parser::T__32)
| (1ULL << SwiftMtParser_MT565Parser::T__33)
| (1ULL << SwiftMtParser_MT565Parser::T__34)
| (1ULL << SwiftMtParser_MT565Parser::T__35)
| (1ULL << SwiftMtParser_MT565Parser::T__36)
| (1ULL << SwiftMtParser_MT565Parser::T__37)
| (1ULL << SwiftMtParser_MT565Parser::TAG_BH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_AH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_UH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_MT)
| (1ULL << SwiftMtParser_MT565Parser::TAG_TR)
| (1ULL << SwiftMtParser_MT565Parser::MT_END)
| (1ULL << SwiftMtParser_MT565Parser::LBRACE)
| (1ULL << SwiftMtParser_MT565Parser::RBRACE)
| (1ULL << SwiftMtParser_MT565Parser::COLON)
| (1ULL << SwiftMtParser_MT565Parser::ANY))) != 0));
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- Fld_95a_E_PContext ------------------------------------------------------------------
SwiftMtParser_MT565Parser::Fld_95a_E_PContext::Fld_95a_E_PContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
std::vector<tree::TerminalNode *> SwiftMtParser_MT565Parser::Fld_95a_E_PContext::START_OF_FIELD() {
return getTokens(SwiftMtParser_MT565Parser::START_OF_FIELD);
}
tree::TerminalNode* SwiftMtParser_MT565Parser::Fld_95a_E_PContext::START_OF_FIELD(size_t i) {
return getToken(SwiftMtParser_MT565Parser::START_OF_FIELD, i);
}
size_t SwiftMtParser_MT565Parser::Fld_95a_E_PContext::getRuleIndex() const {
return SwiftMtParser_MT565Parser::RuleFld_95a_E_P;
}
void SwiftMtParser_MT565Parser::Fld_95a_E_PContext::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->enterFld_95a_E_P(this);
}
void SwiftMtParser_MT565Parser::Fld_95a_E_PContext::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->exitFld_95a_E_P(this);
}
SwiftMtParser_MT565Parser::Fld_95a_E_PContext* SwiftMtParser_MT565Parser::fld_95a_E_P() {
Fld_95a_E_PContext *_localctx = _tracker.createInstance<Fld_95a_E_PContext>(_ctx, getState());
enterRule(_localctx, 254, SwiftMtParser_MT565Parser::RuleFld_95a_E_P);
_localctx->fld.set_tag("95P");
size_t _la = 0;
auto onExit = finally([=] {
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(1263);
match(SwiftMtParser_MT565Parser::START_OF_FIELD);
setState(1264);
match(SwiftMtParser_MT565Parser::T__16);
setState(1266);
_errHandler->sync(this);
_la = _input->LA(1);
do {
setState(1265);
_la = _input->LA(1);
if (_la == 0 || _la == Token::EOF || (_la == SwiftMtParser_MT565Parser::START_OF_FIELD)) {
_errHandler->recoverInline(this);
}
else {
_errHandler->reportMatch(this);
consume();
}
setState(1268);
_errHandler->sync(this);
_la = _input->LA(1);
} while ((((_la & ~ 0x3fULL) == 0) &&
((1ULL << _la) & ((1ULL << SwiftMtParser_MT565Parser::T__0)
| (1ULL << SwiftMtParser_MT565Parser::T__1)
| (1ULL << SwiftMtParser_MT565Parser::T__2)
| (1ULL << SwiftMtParser_MT565Parser::T__3)
| (1ULL << SwiftMtParser_MT565Parser::T__4)
| (1ULL << SwiftMtParser_MT565Parser::T__5)
| (1ULL << SwiftMtParser_MT565Parser::T__6)
| (1ULL << SwiftMtParser_MT565Parser::T__7)
| (1ULL << SwiftMtParser_MT565Parser::T__8)
| (1ULL << SwiftMtParser_MT565Parser::T__9)
| (1ULL << SwiftMtParser_MT565Parser::T__10)
| (1ULL << SwiftMtParser_MT565Parser::T__11)
| (1ULL << SwiftMtParser_MT565Parser::T__12)
| (1ULL << SwiftMtParser_MT565Parser::T__13)
| (1ULL << SwiftMtParser_MT565Parser::T__14)
| (1ULL << SwiftMtParser_MT565Parser::T__15)
| (1ULL << SwiftMtParser_MT565Parser::T__16)
| (1ULL << SwiftMtParser_MT565Parser::T__17)
| (1ULL << SwiftMtParser_MT565Parser::T__18)
| (1ULL << SwiftMtParser_MT565Parser::T__19)
| (1ULL << SwiftMtParser_MT565Parser::T__20)
| (1ULL << SwiftMtParser_MT565Parser::T__21)
| (1ULL << SwiftMtParser_MT565Parser::T__22)
| (1ULL << SwiftMtParser_MT565Parser::T__23)
| (1ULL << SwiftMtParser_MT565Parser::T__24)
| (1ULL << SwiftMtParser_MT565Parser::T__25)
| (1ULL << SwiftMtParser_MT565Parser::T__26)
| (1ULL << SwiftMtParser_MT565Parser::T__27)
| (1ULL << SwiftMtParser_MT565Parser::T__28)
| (1ULL << SwiftMtParser_MT565Parser::T__29)
| (1ULL << SwiftMtParser_MT565Parser::T__30)
| (1ULL << SwiftMtParser_MT565Parser::T__31)
| (1ULL << SwiftMtParser_MT565Parser::T__32)
| (1ULL << SwiftMtParser_MT565Parser::T__33)
| (1ULL << SwiftMtParser_MT565Parser::T__34)
| (1ULL << SwiftMtParser_MT565Parser::T__35)
| (1ULL << SwiftMtParser_MT565Parser::T__36)
| (1ULL << SwiftMtParser_MT565Parser::T__37)
| (1ULL << SwiftMtParser_MT565Parser::TAG_BH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_AH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_UH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_MT)
| (1ULL << SwiftMtParser_MT565Parser::TAG_TR)
| (1ULL << SwiftMtParser_MT565Parser::MT_END)
| (1ULL << SwiftMtParser_MT565Parser::LBRACE)
| (1ULL << SwiftMtParser_MT565Parser::RBRACE)
| (1ULL << SwiftMtParser_MT565Parser::COLON)
| (1ULL << SwiftMtParser_MT565Parser::ANY))) != 0));
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- Fld_95a_E_QContext ------------------------------------------------------------------
SwiftMtParser_MT565Parser::Fld_95a_E_QContext::Fld_95a_E_QContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
std::vector<tree::TerminalNode *> SwiftMtParser_MT565Parser::Fld_95a_E_QContext::START_OF_FIELD() {
return getTokens(SwiftMtParser_MT565Parser::START_OF_FIELD);
}
tree::TerminalNode* SwiftMtParser_MT565Parser::Fld_95a_E_QContext::START_OF_FIELD(size_t i) {
return getToken(SwiftMtParser_MT565Parser::START_OF_FIELD, i);
}
size_t SwiftMtParser_MT565Parser::Fld_95a_E_QContext::getRuleIndex() const {
return SwiftMtParser_MT565Parser::RuleFld_95a_E_Q;
}
void SwiftMtParser_MT565Parser::Fld_95a_E_QContext::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->enterFld_95a_E_Q(this);
}
void SwiftMtParser_MT565Parser::Fld_95a_E_QContext::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->exitFld_95a_E_Q(this);
}
SwiftMtParser_MT565Parser::Fld_95a_E_QContext* SwiftMtParser_MT565Parser::fld_95a_E_Q() {
Fld_95a_E_QContext *_localctx = _tracker.createInstance<Fld_95a_E_QContext>(_ctx, getState());
enterRule(_localctx, 256, SwiftMtParser_MT565Parser::RuleFld_95a_E_Q);
_localctx->fld.set_tag("95Q");
size_t _la = 0;
auto onExit = finally([=] {
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(1270);
match(SwiftMtParser_MT565Parser::START_OF_FIELD);
setState(1271);
match(SwiftMtParser_MT565Parser::T__37);
setState(1273);
_errHandler->sync(this);
_la = _input->LA(1);
do {
setState(1272);
_la = _input->LA(1);
if (_la == 0 || _la == Token::EOF || (_la == SwiftMtParser_MT565Parser::START_OF_FIELD)) {
_errHandler->recoverInline(this);
}
else {
_errHandler->reportMatch(this);
consume();
}
setState(1275);
_errHandler->sync(this);
_la = _input->LA(1);
} while ((((_la & ~ 0x3fULL) == 0) &&
((1ULL << _la) & ((1ULL << SwiftMtParser_MT565Parser::T__0)
| (1ULL << SwiftMtParser_MT565Parser::T__1)
| (1ULL << SwiftMtParser_MT565Parser::T__2)
| (1ULL << SwiftMtParser_MT565Parser::T__3)
| (1ULL << SwiftMtParser_MT565Parser::T__4)
| (1ULL << SwiftMtParser_MT565Parser::T__5)
| (1ULL << SwiftMtParser_MT565Parser::T__6)
| (1ULL << SwiftMtParser_MT565Parser::T__7)
| (1ULL << SwiftMtParser_MT565Parser::T__8)
| (1ULL << SwiftMtParser_MT565Parser::T__9)
| (1ULL << SwiftMtParser_MT565Parser::T__10)
| (1ULL << SwiftMtParser_MT565Parser::T__11)
| (1ULL << SwiftMtParser_MT565Parser::T__12)
| (1ULL << SwiftMtParser_MT565Parser::T__13)
| (1ULL << SwiftMtParser_MT565Parser::T__14)
| (1ULL << SwiftMtParser_MT565Parser::T__15)
| (1ULL << SwiftMtParser_MT565Parser::T__16)
| (1ULL << SwiftMtParser_MT565Parser::T__17)
| (1ULL << SwiftMtParser_MT565Parser::T__18)
| (1ULL << SwiftMtParser_MT565Parser::T__19)
| (1ULL << SwiftMtParser_MT565Parser::T__20)
| (1ULL << SwiftMtParser_MT565Parser::T__21)
| (1ULL << SwiftMtParser_MT565Parser::T__22)
| (1ULL << SwiftMtParser_MT565Parser::T__23)
| (1ULL << SwiftMtParser_MT565Parser::T__24)
| (1ULL << SwiftMtParser_MT565Parser::T__25)
| (1ULL << SwiftMtParser_MT565Parser::T__26)
| (1ULL << SwiftMtParser_MT565Parser::T__27)
| (1ULL << SwiftMtParser_MT565Parser::T__28)
| (1ULL << SwiftMtParser_MT565Parser::T__29)
| (1ULL << SwiftMtParser_MT565Parser::T__30)
| (1ULL << SwiftMtParser_MT565Parser::T__31)
| (1ULL << SwiftMtParser_MT565Parser::T__32)
| (1ULL << SwiftMtParser_MT565Parser::T__33)
| (1ULL << SwiftMtParser_MT565Parser::T__34)
| (1ULL << SwiftMtParser_MT565Parser::T__35)
| (1ULL << SwiftMtParser_MT565Parser::T__36)
| (1ULL << SwiftMtParser_MT565Parser::T__37)
| (1ULL << SwiftMtParser_MT565Parser::TAG_BH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_AH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_UH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_MT)
| (1ULL << SwiftMtParser_MT565Parser::TAG_TR)
| (1ULL << SwiftMtParser_MT565Parser::MT_END)
| (1ULL << SwiftMtParser_MT565Parser::LBRACE)
| (1ULL << SwiftMtParser_MT565Parser::RBRACE)
| (1ULL << SwiftMtParser_MT565Parser::COLON)
| (1ULL << SwiftMtParser_MT565Parser::ANY))) != 0));
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- Fld_95a_E_RContext ------------------------------------------------------------------
SwiftMtParser_MT565Parser::Fld_95a_E_RContext::Fld_95a_E_RContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
std::vector<tree::TerminalNode *> SwiftMtParser_MT565Parser::Fld_95a_E_RContext::START_OF_FIELD() {
return getTokens(SwiftMtParser_MT565Parser::START_OF_FIELD);
}
tree::TerminalNode* SwiftMtParser_MT565Parser::Fld_95a_E_RContext::START_OF_FIELD(size_t i) {
return getToken(SwiftMtParser_MT565Parser::START_OF_FIELD, i);
}
size_t SwiftMtParser_MT565Parser::Fld_95a_E_RContext::getRuleIndex() const {
return SwiftMtParser_MT565Parser::RuleFld_95a_E_R;
}
void SwiftMtParser_MT565Parser::Fld_95a_E_RContext::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->enterFld_95a_E_R(this);
}
void SwiftMtParser_MT565Parser::Fld_95a_E_RContext::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<SwiftMtParser_MT565Listener *>(listener);
if (parserListener != nullptr)
parserListener->exitFld_95a_E_R(this);
}
SwiftMtParser_MT565Parser::Fld_95a_E_RContext* SwiftMtParser_MT565Parser::fld_95a_E_R() {
Fld_95a_E_RContext *_localctx = _tracker.createInstance<Fld_95a_E_RContext>(_ctx, getState());
enterRule(_localctx, 258, SwiftMtParser_MT565Parser::RuleFld_95a_E_R);
_localctx->fld.set_tag("95R");
size_t _la = 0;
auto onExit = finally([=] {
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(1277);
match(SwiftMtParser_MT565Parser::START_OF_FIELD);
setState(1278);
match(SwiftMtParser_MT565Parser::T__17);
setState(1280);
_errHandler->sync(this);
_la = _input->LA(1);
do {
setState(1279);
_la = _input->LA(1);
if (_la == 0 || _la == Token::EOF || (_la == SwiftMtParser_MT565Parser::START_OF_FIELD)) {
_errHandler->recoverInline(this);
}
else {
_errHandler->reportMatch(this);
consume();
}
setState(1282);
_errHandler->sync(this);
_la = _input->LA(1);
} while ((((_la & ~ 0x3fULL) == 0) &&
((1ULL << _la) & ((1ULL << SwiftMtParser_MT565Parser::T__0)
| (1ULL << SwiftMtParser_MT565Parser::T__1)
| (1ULL << SwiftMtParser_MT565Parser::T__2)
| (1ULL << SwiftMtParser_MT565Parser::T__3)
| (1ULL << SwiftMtParser_MT565Parser::T__4)
| (1ULL << SwiftMtParser_MT565Parser::T__5)
| (1ULL << SwiftMtParser_MT565Parser::T__6)
| (1ULL << SwiftMtParser_MT565Parser::T__7)
| (1ULL << SwiftMtParser_MT565Parser::T__8)
| (1ULL << SwiftMtParser_MT565Parser::T__9)
| (1ULL << SwiftMtParser_MT565Parser::T__10)
| (1ULL << SwiftMtParser_MT565Parser::T__11)
| (1ULL << SwiftMtParser_MT565Parser::T__12)
| (1ULL << SwiftMtParser_MT565Parser::T__13)
| (1ULL << SwiftMtParser_MT565Parser::T__14)
| (1ULL << SwiftMtParser_MT565Parser::T__15)
| (1ULL << SwiftMtParser_MT565Parser::T__16)
| (1ULL << SwiftMtParser_MT565Parser::T__17)
| (1ULL << SwiftMtParser_MT565Parser::T__18)
| (1ULL << SwiftMtParser_MT565Parser::T__19)
| (1ULL << SwiftMtParser_MT565Parser::T__20)
| (1ULL << SwiftMtParser_MT565Parser::T__21)
| (1ULL << SwiftMtParser_MT565Parser::T__22)
| (1ULL << SwiftMtParser_MT565Parser::T__23)
| (1ULL << SwiftMtParser_MT565Parser::T__24)
| (1ULL << SwiftMtParser_MT565Parser::T__25)
| (1ULL << SwiftMtParser_MT565Parser::T__26)
| (1ULL << SwiftMtParser_MT565Parser::T__27)
| (1ULL << SwiftMtParser_MT565Parser::T__28)
| (1ULL << SwiftMtParser_MT565Parser::T__29)
| (1ULL << SwiftMtParser_MT565Parser::T__30)
| (1ULL << SwiftMtParser_MT565Parser::T__31)
| (1ULL << SwiftMtParser_MT565Parser::T__32)
| (1ULL << SwiftMtParser_MT565Parser::T__33)
| (1ULL << SwiftMtParser_MT565Parser::T__34)
| (1ULL << SwiftMtParser_MT565Parser::T__35)
| (1ULL << SwiftMtParser_MT565Parser::T__36)
| (1ULL << SwiftMtParser_MT565Parser::T__37)
| (1ULL << SwiftMtParser_MT565Parser::TAG_BH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_AH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_UH)
| (1ULL << SwiftMtParser_MT565Parser::TAG_MT)
| (1ULL << SwiftMtParser_MT565Parser::TAG_TR)
| (1ULL << SwiftMtParser_MT565Parser::MT_END)
| (1ULL << SwiftMtParser_MT565Parser::LBRACE)
| (1ULL << SwiftMtParser_MT565Parser::RBRACE)
| (1ULL << SwiftMtParser_MT565Parser::COLON)
| (1ULL << SwiftMtParser_MT565Parser::ANY))) != 0));
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
// Static vars and initialization.
std::vector<dfa::DFA> SwiftMtParser_MT565Parser::_decisionToDFA;
atn::PredictionContextCache SwiftMtParser_MT565Parser::_sharedContextCache;
// We own the ATN which in turn owns the ATN states.
atn::ATN SwiftMtParser_MT565Parser::_atn;
std::vector<uint16_t> SwiftMtParser_MT565Parser::_serializedATN;
std::vector<std::string> SwiftMtParser_MT565Parser::_ruleNames = {
"message", "bh", "bh_content", "ah", "ah_content", "uh", "tr", "sys_block",
"sys_element", "sys_element_key", "sys_element_content", "mt", "seq_A",
"seq_A1", "seq_B", "seq_B1", "seq_B2", "seq_C", "seq_D", "seq_E", "fld_16R_A",
"fld_20C_A", "fld_23G_A", "fld_22F_A", "fld_98a_A", "fld_16R_A1", "fld_22F_A1",
"fld_13a_A1", "fld_20C_A1", "fld_16S_A1", "fld_16S_A", "fld_16R_B", "fld_35B_B",
"fld_16R_B1", "fld_94B_B1", "fld_22F_B1", "fld_12a_B1", "fld_11A_B1",
"fld_98A_B1", "fld_92A_B1", "fld_36B_B1", "fld_16S_B1", "fld_16R_B2",
"fld_95a_B2", "fld_97A_B2", "fld_94a_B2", "fld_93a_B2", "fld_16S_B2",
"fld_16S_B", "fld_16R_C", "fld_95a_C", "fld_94C_C", "fld_36B_C", "fld_22F_C",
"fld_70E_C", "fld_16S_C", "fld_16R_D", "fld_13A_D", "fld_22a_D", "fld_11A_D",
"fld_35B_D", "fld_36a_D", "fld_19B_D", "fld_98a_D", "fld_92a_D", "fld_90a_D",
"fld_70E_D", "fld_16S_D", "fld_16R_E", "fld_70E_E", "fld_95a_E", "fld_16S_E",
"fld_20C_A_C", "fld_23G_A_G", "fld_22F_A_F", "fld_98a_A_A", "fld_98a_A_C",
"fld_22F_A1_F", "fld_13a_A1_A", "fld_13a_A1_B", "fld_20C_A1_C", "fld_35B_B_B",
"fld_94B_B1_B", "fld_22F_B1_F", "fld_12a_B1_A", "fld_12a_B1_C", "fld_11A_B1_A",
"fld_98A_B1_A", "fld_92A_B1_A", "fld_36B_B1_B", "fld_95a_B2_P", "fld_95a_B2_R",
"fld_97A_B2_A", "fld_94a_B2_B", "fld_94a_B2_C", "fld_94a_B2_F", "fld_93a_B2_B",
"fld_93a_B2_C", "fld_95a_C_P", "fld_95a_C_R", "fld_95a_C_S", "fld_95a_C_V",
"fld_94C_C_C", "fld_36B_C_B", "fld_22F_C_F", "fld_70E_C_E", "fld_13A_D_A",
"fld_22a_D_F", "fld_22a_D_H", "fld_11A_D_A", "fld_35B_D_B", "fld_36a_D_B",
"fld_36a_D_C", "fld_19B_D_B", "fld_98a_D_A", "fld_98a_D_C", "fld_92a_D_A",
"fld_92a_D_F", "fld_92a_D_R", "fld_90a_D_A", "fld_90a_D_B", "fld_90a_D_E",
"fld_90a_D_F", "fld_90a_D_J", "fld_90a_D_L", "fld_70E_D_E", "fld_70E_E_E",
"fld_95a_E_P", "fld_95a_E_Q", "fld_95a_E_R"
};
std::vector<std::string> SwiftMtParser_MT565Parser::_literalNames = {
"", "'16R:'", "'16S:'", "'20C:'", "'23G:'", "'22F:'", "'98A:'", "'98C:'",
"'13A:'", "'13B:'", "'35B:'", "'94B:'", "'12A:'", "'12C:'", "'11A:'",
"'92A:'", "'36B:'", "'95P:'", "'95R:'", "'97A:'", "'94C:'", "'94F:'",
"'93B:'", "'93C:'", "'95S:'", "'95V:'", "'70E:'", "'22H:'", "'36C:'",
"'19B:'", "'92F:'", "'92R:'", "'90A:'", "'90B:'", "'90E:'", "'90F:'",
"'90J:'", "'90L:'", "'95Q:'", "'{1:'", "'{2:'", "'{3:'", "'{4:'", "'{5:'",
"'-}'", "'{'", "'}'", "':'"
};
std::vector<std::string> SwiftMtParser_MT565Parser::_symbolicNames = {
"", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "",
"", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "",
"", "", "", "TAG_BH", "TAG_AH", "TAG_UH", "TAG_MT", "TAG_TR", "MT_END",
"LBRACE", "RBRACE", "COLON", "START_OF_FIELD", "ANY"
};
dfa::Vocabulary SwiftMtParser_MT565Parser::_vocabulary(_literalNames, _symbolicNames);
std::vector<std::string> SwiftMtParser_MT565Parser::_tokenNames;
SwiftMtParser_MT565Parser::Initializer::Initializer() {
for (size_t i = 0; i < _symbolicNames.size(); ++i) {
std::string name = _vocabulary.getLiteralName(i);
if (name.empty()) {
name = _vocabulary.getSymbolicName(i);
}
if (name.empty()) {
_tokenNames.push_back("<INVALID>");
} else {
_tokenNames.push_back(name);
}
}
_serializedATN = {
0x3, 0x608b, 0xa72a, 0x8133, 0xb9ed, 0x417c, 0x3be7, 0x7786, 0x5964,
0x3, 0x33, 0x507, 0x4, 0x2, 0x9, 0x2, 0x4, 0x3, 0x9, 0x3, 0x4, 0x4,
0x9, 0x4, 0x4, 0x5, 0x9, 0x5, 0x4, 0x6, 0x9, 0x6, 0x4, 0x7, 0x9, 0x7,
0x4, 0x8, 0x9, 0x8, 0x4, 0x9, 0x9, 0x9, 0x4, 0xa, 0x9, 0xa, 0x4, 0xb,
0x9, 0xb, 0x4, 0xc, 0x9, 0xc, 0x4, 0xd, 0x9, 0xd, 0x4, 0xe, 0x9, 0xe,
0x4, 0xf, 0x9, 0xf, 0x4, 0x10, 0x9, 0x10, 0x4, 0x11, 0x9, 0x11, 0x4,
0x12, 0x9, 0x12, 0x4, 0x13, 0x9, 0x13, 0x4, 0x14, 0x9, 0x14, 0x4, 0x15,
0x9, 0x15, 0x4, 0x16, 0x9, 0x16, 0x4, 0x17, 0x9, 0x17, 0x4, 0x18, 0x9,
0x18, 0x4, 0x19, 0x9, 0x19, 0x4, 0x1a, 0x9, 0x1a, 0x4, 0x1b, 0x9, 0x1b,
0x4, 0x1c, 0x9, 0x1c, 0x4, 0x1d, 0x9, 0x1d, 0x4, 0x1e, 0x9, 0x1e, 0x4,
0x1f, 0x9, 0x1f, 0x4, 0x20, 0x9, 0x20, 0x4, 0x21, 0x9, 0x21, 0x4, 0x22,
0x9, 0x22, 0x4, 0x23, 0x9, 0x23, 0x4, 0x24, 0x9, 0x24, 0x4, 0x25, 0x9,
0x25, 0x4, 0x26, 0x9, 0x26, 0x4, 0x27, 0x9, 0x27, 0x4, 0x28, 0x9, 0x28,
0x4, 0x29, 0x9, 0x29, 0x4, 0x2a, 0x9, 0x2a, 0x4, 0x2b, 0x9, 0x2b, 0x4,
0x2c, 0x9, 0x2c, 0x4, 0x2d, 0x9, 0x2d, 0x4, 0x2e, 0x9, 0x2e, 0x4, 0x2f,
0x9, 0x2f, 0x4, 0x30, 0x9, 0x30, 0x4, 0x31, 0x9, 0x31, 0x4, 0x32, 0x9,
0x32, 0x4, 0x33, 0x9, 0x33, 0x4, 0x34, 0x9, 0x34, 0x4, 0x35, 0x9, 0x35,
0x4, 0x36, 0x9, 0x36, 0x4, 0x37, 0x9, 0x37, 0x4, 0x38, 0x9, 0x38, 0x4,
0x39, 0x9, 0x39, 0x4, 0x3a, 0x9, 0x3a, 0x4, 0x3b, 0x9, 0x3b, 0x4, 0x3c,
0x9, 0x3c, 0x4, 0x3d, 0x9, 0x3d, 0x4, 0x3e, 0x9, 0x3e, 0x4, 0x3f, 0x9,
0x3f, 0x4, 0x40, 0x9, 0x40, 0x4, 0x41, 0x9, 0x41, 0x4, 0x42, 0x9, 0x42,
0x4, 0x43, 0x9, 0x43, 0x4, 0x44, 0x9, 0x44, 0x4, 0x45, 0x9, 0x45, 0x4,
0x46, 0x9, 0x46, 0x4, 0x47, 0x9, 0x47, 0x4, 0x48, 0x9, 0x48, 0x4, 0x49,
0x9, 0x49, 0x4, 0x4a, 0x9, 0x4a, 0x4, 0x4b, 0x9, 0x4b, 0x4, 0x4c, 0x9,
0x4c, 0x4, 0x4d, 0x9, 0x4d, 0x4, 0x4e, 0x9, 0x4e, 0x4, 0x4f, 0x9, 0x4f,
0x4, 0x50, 0x9, 0x50, 0x4, 0x51, 0x9, 0x51, 0x4, 0x52, 0x9, 0x52, 0x4,
0x53, 0x9, 0x53, 0x4, 0x54, 0x9, 0x54, 0x4, 0x55, 0x9, 0x55, 0x4, 0x56,
0x9, 0x56, 0x4, 0x57, 0x9, 0x57, 0x4, 0x58, 0x9, 0x58, 0x4, 0x59, 0x9,
0x59, 0x4, 0x5a, 0x9, 0x5a, 0x4, 0x5b, 0x9, 0x5b, 0x4, 0x5c, 0x9, 0x5c,
0x4, 0x5d, 0x9, 0x5d, 0x4, 0x5e, 0x9, 0x5e, 0x4, 0x5f, 0x9, 0x5f, 0x4,
0x60, 0x9, 0x60, 0x4, 0x61, 0x9, 0x61, 0x4, 0x62, 0x9, 0x62, 0x4, 0x63,
0x9, 0x63, 0x4, 0x64, 0x9, 0x64, 0x4, 0x65, 0x9, 0x65, 0x4, 0x66, 0x9,
0x66, 0x4, 0x67, 0x9, 0x67, 0x4, 0x68, 0x9, 0x68, 0x4, 0x69, 0x9, 0x69,
0x4, 0x6a, 0x9, 0x6a, 0x4, 0x6b, 0x9, 0x6b, 0x4, 0x6c, 0x9, 0x6c, 0x4,
0x6d, 0x9, 0x6d, 0x4, 0x6e, 0x9, 0x6e, 0x4, 0x6f, 0x9, 0x6f, 0x4, 0x70,
0x9, 0x70, 0x4, 0x71, 0x9, 0x71, 0x4, 0x72, 0x9, 0x72, 0x4, 0x73, 0x9,
0x73, 0x4, 0x74, 0x9, 0x74, 0x4, 0x75, 0x9, 0x75, 0x4, 0x76, 0x9, 0x76,
0x4, 0x77, 0x9, 0x77, 0x4, 0x78, 0x9, 0x78, 0x4, 0x79, 0x9, 0x79, 0x4,
0x7a, 0x9, 0x7a, 0x4, 0x7b, 0x9, 0x7b, 0x4, 0x7c, 0x9, 0x7c, 0x4, 0x7d,
0x9, 0x7d, 0x4, 0x7e, 0x9, 0x7e, 0x4, 0x7f, 0x9, 0x7f, 0x4, 0x80, 0x9,
0x80, 0x4, 0x81, 0x9, 0x81, 0x4, 0x82, 0x9, 0x82, 0x4, 0x83, 0x9, 0x83,
0x3, 0x2, 0x3, 0x2, 0x3, 0x2, 0x5, 0x2, 0x10a, 0xa, 0x2, 0x3, 0x2, 0x3,
0x2, 0x5, 0x2, 0x10e, 0xa, 0x2, 0x3, 0x2, 0x3, 0x2, 0x3, 0x3, 0x3, 0x3,
0x3, 0x3, 0x3, 0x3, 0x3, 0x4, 0x6, 0x4, 0x117, 0xa, 0x4, 0xd, 0x4, 0xe,
0x4, 0x118, 0x3, 0x5, 0x3, 0x5, 0x3, 0x5, 0x3, 0x5, 0x3, 0x6, 0x6, 0x6,
0x120, 0xa, 0x6, 0xd, 0x6, 0xe, 0x6, 0x121, 0x3, 0x7, 0x3, 0x7, 0x3,
0x7, 0x3, 0x7, 0x3, 0x8, 0x3, 0x8, 0x3, 0x8, 0x3, 0x8, 0x3, 0x9, 0x6,
0x9, 0x12d, 0xa, 0x9, 0xd, 0x9, 0xe, 0x9, 0x12e, 0x3, 0xa, 0x3, 0xa,
0x3, 0xa, 0x3, 0xa, 0x3, 0xa, 0x3, 0xa, 0x3, 0xb, 0x6, 0xb, 0x138, 0xa,
0xb, 0xd, 0xb, 0xe, 0xb, 0x139, 0x3, 0xc, 0x6, 0xc, 0x13d, 0xa, 0xc,
0xd, 0xc, 0xe, 0xc, 0x13e, 0x3, 0xd, 0x3, 0xd, 0x3, 0xd, 0x3, 0xd, 0x7,
0xd, 0x145, 0xa, 0xd, 0xc, 0xd, 0xe, 0xd, 0x148, 0xb, 0xd, 0x3, 0xd,
0x3, 0xd, 0x5, 0xd, 0x14c, 0xa, 0xd, 0x3, 0xd, 0x3, 0xd, 0x3, 0xe, 0x3,
0xe, 0x3, 0xe, 0x6, 0xe, 0x153, 0xa, 0xe, 0xd, 0xe, 0xe, 0xe, 0x154,
0x3, 0xe, 0x3, 0xe, 0x3, 0xe, 0x3, 0xe, 0x3, 0xe, 0x3, 0xe, 0x5, 0xe,
0x15d, 0xa, 0xe, 0x3, 0xe, 0x3, 0xe, 0x7, 0xe, 0x161, 0xa, 0xe, 0xc,
0xe, 0xe, 0xe, 0x164, 0xb, 0xe, 0x3, 0xe, 0x3, 0xe, 0x3, 0xe, 0x3, 0xe,
0x3, 0xf, 0x3, 0xf, 0x3, 0xf, 0x5, 0xf, 0x16d, 0xa, 0xf, 0x3, 0xf, 0x3,
0xf, 0x5, 0xf, 0x171, 0xa, 0xf, 0x3, 0xf, 0x3, 0xf, 0x3, 0xf, 0x3, 0xf,
0x3, 0xf, 0x3, 0xf, 0x3, 0x10, 0x3, 0x10, 0x3, 0x10, 0x5, 0x10, 0x17c,
0xa, 0x10, 0x3, 0x10, 0x3, 0x10, 0x5, 0x10, 0x180, 0xa, 0x10, 0x3, 0x10,
0x3, 0x10, 0x3, 0x10, 0x3, 0x10, 0x3, 0x10, 0x3, 0x10, 0x3, 0x11, 0x3,
0x11, 0x3, 0x11, 0x5, 0x11, 0x18b, 0xa, 0x11, 0x3, 0x11, 0x3, 0x11,
0x5, 0x11, 0x18f, 0xa, 0x11, 0x3, 0x11, 0x3, 0x11, 0x5, 0x11, 0x193,
0xa, 0x11, 0x3, 0x11, 0x3, 0x11, 0x5, 0x11, 0x197, 0xa, 0x11, 0x3, 0x11,
0x3, 0x11, 0x7, 0x11, 0x19b, 0xa, 0x11, 0xc, 0x11, 0xe, 0x11, 0x19e,
0xb, 0x11, 0x3, 0x11, 0x3, 0x11, 0x7, 0x11, 0x1a2, 0xa, 0x11, 0xc, 0x11,
0xe, 0x11, 0x1a5, 0xb, 0x11, 0x3, 0x11, 0x3, 0x11, 0x7, 0x11, 0x1a9,
0xa, 0x11, 0xc, 0x11, 0xe, 0x11, 0x1ac, 0xb, 0x11, 0x3, 0x11, 0x3, 0x11,
0x3, 0x11, 0x3, 0x11, 0x3, 0x12, 0x3, 0x12, 0x3, 0x12, 0x5, 0x12, 0x1b5,
0xa, 0x12, 0x3, 0x12, 0x3, 0x12, 0x3, 0x12, 0x3, 0x12, 0x5, 0x12, 0x1bb,
0xa, 0x12, 0x3, 0x12, 0x3, 0x12, 0x7, 0x12, 0x1bf, 0xa, 0x12, 0xc, 0x12,
0xe, 0x12, 0x1c2, 0xb, 0x12, 0x3, 0x12, 0x3, 0x12, 0x3, 0x12, 0x3, 0x12,
0x3, 0x13, 0x3, 0x13, 0x3, 0x13, 0x6, 0x13, 0x1cb, 0xa, 0x13, 0xd, 0x13,
0xe, 0x13, 0x1cc, 0x3, 0x13, 0x3, 0x13, 0x7, 0x13, 0x1d1, 0xa, 0x13,
0xc, 0x13, 0xe, 0x13, 0x1d4, 0xb, 0x13, 0x3, 0x13, 0x3, 0x13, 0x3, 0x13,
0x3, 0x13, 0x7, 0x13, 0x1da, 0xa, 0x13, 0xc, 0x13, 0xe, 0x13, 0x1dd,
0xb, 0x13, 0x3, 0x13, 0x3, 0x13, 0x7, 0x13, 0x1e1, 0xa, 0x13, 0xc, 0x13,
0xe, 0x13, 0x1e4, 0xb, 0x13, 0x3, 0x13, 0x3, 0x13, 0x3, 0x13, 0x3, 0x13,
0x3, 0x14, 0x3, 0x14, 0x3, 0x14, 0x3, 0x14, 0x3, 0x14, 0x6, 0x14, 0x1ef,
0xa, 0x14, 0xd, 0x14, 0xe, 0x14, 0x1f0, 0x3, 0x14, 0x3, 0x14, 0x7, 0x14,
0x1f5, 0xa, 0x14, 0xc, 0x14, 0xe, 0x14, 0x1f8, 0xb, 0x14, 0x3, 0x14,
0x3, 0x14, 0x5, 0x14, 0x1fc, 0xa, 0x14, 0x3, 0x14, 0x3, 0x14, 0x7, 0x14,
0x200, 0xa, 0x14, 0xc, 0x14, 0xe, 0x14, 0x203, 0xb, 0x14, 0x3, 0x14,
0x3, 0x14, 0x5, 0x14, 0x207, 0xa, 0x14, 0x3, 0x14, 0x3, 0x14, 0x5, 0x14,
0x20b, 0xa, 0x14, 0x3, 0x14, 0x3, 0x14, 0x7, 0x14, 0x20f, 0xa, 0x14,
0xc, 0x14, 0xe, 0x14, 0x212, 0xb, 0x14, 0x3, 0x14, 0x3, 0x14, 0x7, 0x14,
0x216, 0xa, 0x14, 0xc, 0x14, 0xe, 0x14, 0x219, 0xb, 0x14, 0x3, 0x14,
0x3, 0x14, 0x7, 0x14, 0x21d, 0xa, 0x14, 0xc, 0x14, 0xe, 0x14, 0x220,
0xb, 0x14, 0x3, 0x14, 0x3, 0x14, 0x3, 0x14, 0x3, 0x14, 0x3, 0x15, 0x3,
0x15, 0x3, 0x15, 0x7, 0x15, 0x229, 0xa, 0x15, 0xc, 0x15, 0xe, 0x15,
0x22c, 0xb, 0x15, 0x3, 0x15, 0x3, 0x15, 0x7, 0x15, 0x230, 0xa, 0x15,
0xc, 0x15, 0xe, 0x15, 0x233, 0xb, 0x15, 0x3, 0x15, 0x3, 0x15, 0x3, 0x15,
0x3, 0x15, 0x3, 0x16, 0x3, 0x16, 0x3, 0x16, 0x6, 0x16, 0x23c, 0xa, 0x16,
0xd, 0x16, 0xe, 0x16, 0x23d, 0x3, 0x17, 0x3, 0x17, 0x3, 0x17, 0x3, 0x18,
0x3, 0x18, 0x3, 0x18, 0x3, 0x19, 0x3, 0x19, 0x3, 0x19, 0x3, 0x1a, 0x3,
0x1a, 0x3, 0x1a, 0x3, 0x1a, 0x3, 0x1a, 0x3, 0x1a, 0x5, 0x1a, 0x24f,
0xa, 0x1a, 0x3, 0x1b, 0x3, 0x1b, 0x3, 0x1b, 0x6, 0x1b, 0x254, 0xa, 0x1b,
0xd, 0x1b, 0xe, 0x1b, 0x255, 0x3, 0x1c, 0x3, 0x1c, 0x3, 0x1c, 0x3, 0x1d,
0x3, 0x1d, 0x3, 0x1d, 0x3, 0x1d, 0x3, 0x1d, 0x3, 0x1d, 0x5, 0x1d, 0x261,
0xa, 0x1d, 0x3, 0x1e, 0x3, 0x1e, 0x3, 0x1e, 0x3, 0x1f, 0x3, 0x1f, 0x3,
0x1f, 0x6, 0x1f, 0x269, 0xa, 0x1f, 0xd, 0x1f, 0xe, 0x1f, 0x26a, 0x3,
0x20, 0x3, 0x20, 0x3, 0x20, 0x6, 0x20, 0x270, 0xa, 0x20, 0xd, 0x20,
0xe, 0x20, 0x271, 0x3, 0x21, 0x3, 0x21, 0x3, 0x21, 0x6, 0x21, 0x277,
0xa, 0x21, 0xd, 0x21, 0xe, 0x21, 0x278, 0x3, 0x22, 0x3, 0x22, 0x3, 0x22,
0x3, 0x23, 0x3, 0x23, 0x3, 0x23, 0x6, 0x23, 0x281, 0xa, 0x23, 0xd, 0x23,
0xe, 0x23, 0x282, 0x3, 0x24, 0x3, 0x24, 0x3, 0x24, 0x3, 0x25, 0x3, 0x25,
0x3, 0x25, 0x3, 0x26, 0x3, 0x26, 0x3, 0x26, 0x3, 0x26, 0x3, 0x26, 0x3,
0x26, 0x5, 0x26, 0x291, 0xa, 0x26, 0x3, 0x27, 0x3, 0x27, 0x3, 0x27,
0x3, 0x28, 0x3, 0x28, 0x3, 0x28, 0x3, 0x29, 0x3, 0x29, 0x3, 0x29, 0x3,
0x2a, 0x3, 0x2a, 0x3, 0x2a, 0x3, 0x2b, 0x3, 0x2b, 0x3, 0x2b, 0x6, 0x2b,
0x2a2, 0xa, 0x2b, 0xd, 0x2b, 0xe, 0x2b, 0x2a3, 0x3, 0x2c, 0x3, 0x2c,
0x3, 0x2c, 0x6, 0x2c, 0x2a9, 0xa, 0x2c, 0xd, 0x2c, 0xe, 0x2c, 0x2aa,
0x3, 0x2d, 0x3, 0x2d, 0x3, 0x2d, 0x3, 0x2d, 0x3, 0x2d, 0x3, 0x2d, 0x5,
0x2d, 0x2b3, 0xa, 0x2d, 0x3, 0x2e, 0x3, 0x2e, 0x3, 0x2e, 0x3, 0x2f,
0x3, 0x2f, 0x3, 0x2f, 0x3, 0x2f, 0x3, 0x2f, 0x3, 0x2f, 0x3, 0x2f, 0x3,
0x2f, 0x3, 0x2f, 0x5, 0x2f, 0x2c1, 0xa, 0x2f, 0x3, 0x30, 0x3, 0x30,
0x3, 0x30, 0x3, 0x30, 0x3, 0x30, 0x3, 0x30, 0x5, 0x30, 0x2c9, 0xa, 0x30,
0x3, 0x31, 0x3, 0x31, 0x3, 0x31, 0x6, 0x31, 0x2ce, 0xa, 0x31, 0xd, 0x31,
0xe, 0x31, 0x2cf, 0x3, 0x32, 0x3, 0x32, 0x3, 0x32, 0x6, 0x32, 0x2d5,
0xa, 0x32, 0xd, 0x32, 0xe, 0x32, 0x2d6, 0x3, 0x33, 0x3, 0x33, 0x3, 0x33,
0x6, 0x33, 0x2dc, 0xa, 0x33, 0xd, 0x33, 0xe, 0x33, 0x2dd, 0x3, 0x34,
0x3, 0x34, 0x3, 0x34, 0x3, 0x34, 0x3, 0x34, 0x3, 0x34, 0x3, 0x34, 0x3,
0x34, 0x3, 0x34, 0x3, 0x34, 0x3, 0x34, 0x3, 0x34, 0x5, 0x34, 0x2ec,
0xa, 0x34, 0x3, 0x35, 0x3, 0x35, 0x3, 0x35, 0x3, 0x36, 0x3, 0x36, 0x3,
0x36, 0x3, 0x37, 0x3, 0x37, 0x3, 0x37, 0x3, 0x38, 0x3, 0x38, 0x3, 0x38,
0x3, 0x39, 0x3, 0x39, 0x3, 0x39, 0x6, 0x39, 0x2fd, 0xa, 0x39, 0xd, 0x39,
0xe, 0x39, 0x2fe, 0x3, 0x3a, 0x3, 0x3a, 0x3, 0x3a, 0x6, 0x3a, 0x304,
0xa, 0x3a, 0xd, 0x3a, 0xe, 0x3a, 0x305, 0x3, 0x3b, 0x3, 0x3b, 0x3, 0x3b,
0x3, 0x3c, 0x3, 0x3c, 0x3, 0x3c, 0x3, 0x3c, 0x3, 0x3c, 0x3, 0x3c, 0x5,
0x3c, 0x311, 0xa, 0x3c, 0x3, 0x3d, 0x3, 0x3d, 0x3, 0x3d, 0x3, 0x3e,
0x3, 0x3e, 0x3, 0x3e, 0x3, 0x3f, 0x3, 0x3f, 0x3, 0x3f, 0x3, 0x3f, 0x3,
0x3f, 0x3, 0x3f, 0x5, 0x3f, 0x31f, 0xa, 0x3f, 0x3, 0x40, 0x3, 0x40,
0x3, 0x40, 0x3, 0x41, 0x3, 0x41, 0x3, 0x41, 0x3, 0x41, 0x3, 0x41, 0x3,
0x41, 0x5, 0x41, 0x32a, 0xa, 0x41, 0x3, 0x42, 0x3, 0x42, 0x3, 0x42,
0x3, 0x42, 0x3, 0x42, 0x3, 0x42, 0x3, 0x42, 0x3, 0x42, 0x3, 0x42, 0x5,
0x42, 0x335, 0xa, 0x42, 0x3, 0x43, 0x3, 0x43, 0x3, 0x43, 0x3, 0x43,
0x3, 0x43, 0x3, 0x43, 0x3, 0x43, 0x3, 0x43, 0x3, 0x43, 0x3, 0x43, 0x3,
0x43, 0x3, 0x43, 0x3, 0x43, 0x3, 0x43, 0x3, 0x43, 0x3, 0x43, 0x3, 0x43,
0x3, 0x43, 0x5, 0x43, 0x349, 0xa, 0x43, 0x3, 0x44, 0x3, 0x44, 0x3, 0x44,
0x3, 0x45, 0x3, 0x45, 0x3, 0x45, 0x6, 0x45, 0x351, 0xa, 0x45, 0xd, 0x45,
0xe, 0x45, 0x352, 0x3, 0x46, 0x3, 0x46, 0x3, 0x46, 0x6, 0x46, 0x358,
0xa, 0x46, 0xd, 0x46, 0xe, 0x46, 0x359, 0x3, 0x47, 0x3, 0x47, 0x3, 0x47,
0x3, 0x48, 0x3, 0x48, 0x3, 0x48, 0x3, 0x48, 0x3, 0x48, 0x3, 0x48, 0x3,
0x48, 0x3, 0x48, 0x3, 0x48, 0x5, 0x48, 0x368, 0xa, 0x48, 0x3, 0x49,
0x3, 0x49, 0x3, 0x49, 0x6, 0x49, 0x36d, 0xa, 0x49, 0xd, 0x49, 0xe, 0x49,
0x36e, 0x3, 0x4a, 0x3, 0x4a, 0x3, 0x4a, 0x6, 0x4a, 0x374, 0xa, 0x4a,
0xd, 0x4a, 0xe, 0x4a, 0x375, 0x3, 0x4b, 0x3, 0x4b, 0x3, 0x4b, 0x6, 0x4b,
0x37b, 0xa, 0x4b, 0xd, 0x4b, 0xe, 0x4b, 0x37c, 0x3, 0x4c, 0x3, 0x4c,
0x3, 0x4c, 0x6, 0x4c, 0x382, 0xa, 0x4c, 0xd, 0x4c, 0xe, 0x4c, 0x383,
0x3, 0x4d, 0x3, 0x4d, 0x3, 0x4d, 0x6, 0x4d, 0x389, 0xa, 0x4d, 0xd, 0x4d,
0xe, 0x4d, 0x38a, 0x3, 0x4e, 0x3, 0x4e, 0x3, 0x4e, 0x6, 0x4e, 0x390,
0xa, 0x4e, 0xd, 0x4e, 0xe, 0x4e, 0x391, 0x3, 0x4f, 0x3, 0x4f, 0x3, 0x4f,
0x6, 0x4f, 0x397, 0xa, 0x4f, 0xd, 0x4f, 0xe, 0x4f, 0x398, 0x3, 0x50,
0x3, 0x50, 0x3, 0x50, 0x6, 0x50, 0x39e, 0xa, 0x50, 0xd, 0x50, 0xe, 0x50,
0x39f, 0x3, 0x51, 0x3, 0x51, 0x3, 0x51, 0x6, 0x51, 0x3a5, 0xa, 0x51,
0xd, 0x51, 0xe, 0x51, 0x3a6, 0x3, 0x52, 0x3, 0x52, 0x3, 0x52, 0x6, 0x52,
0x3ac, 0xa, 0x52, 0xd, 0x52, 0xe, 0x52, 0x3ad, 0x3, 0x53, 0x3, 0x53,
0x3, 0x53, 0x6, 0x53, 0x3b3, 0xa, 0x53, 0xd, 0x53, 0xe, 0x53, 0x3b4,
0x3, 0x54, 0x3, 0x54, 0x3, 0x54, 0x6, 0x54, 0x3ba, 0xa, 0x54, 0xd, 0x54,
0xe, 0x54, 0x3bb, 0x3, 0x55, 0x3, 0x55, 0x3, 0x55, 0x6, 0x55, 0x3c1,
0xa, 0x55, 0xd, 0x55, 0xe, 0x55, 0x3c2, 0x3, 0x56, 0x3, 0x56, 0x3, 0x56,
0x6, 0x56, 0x3c8, 0xa, 0x56, 0xd, 0x56, 0xe, 0x56, 0x3c9, 0x3, 0x57,
0x3, 0x57, 0x3, 0x57, 0x6, 0x57, 0x3cf, 0xa, 0x57, 0xd, 0x57, 0xe, 0x57,
0x3d0, 0x3, 0x58, 0x3, 0x58, 0x3, 0x58, 0x6, 0x58, 0x3d6, 0xa, 0x58,
0xd, 0x58, 0xe, 0x58, 0x3d7, 0x3, 0x59, 0x3, 0x59, 0x3, 0x59, 0x6, 0x59,
0x3dd, 0xa, 0x59, 0xd, 0x59, 0xe, 0x59, 0x3de, 0x3, 0x5a, 0x3, 0x5a,
0x3, 0x5a, 0x6, 0x5a, 0x3e4, 0xa, 0x5a, 0xd, 0x5a, 0xe, 0x5a, 0x3e5,
0x3, 0x5b, 0x3, 0x5b, 0x3, 0x5b, 0x6, 0x5b, 0x3eb, 0xa, 0x5b, 0xd, 0x5b,
0xe, 0x5b, 0x3ec, 0x3, 0x5c, 0x3, 0x5c, 0x3, 0x5c, 0x6, 0x5c, 0x3f2,
0xa, 0x5c, 0xd, 0x5c, 0xe, 0x5c, 0x3f3, 0x3, 0x5d, 0x3, 0x5d, 0x3, 0x5d,
0x6, 0x5d, 0x3f9, 0xa, 0x5d, 0xd, 0x5d, 0xe, 0x5d, 0x3fa, 0x3, 0x5e,
0x3, 0x5e, 0x3, 0x5e, 0x6, 0x5e, 0x400, 0xa, 0x5e, 0xd, 0x5e, 0xe, 0x5e,
0x401, 0x3, 0x5f, 0x3, 0x5f, 0x3, 0x5f, 0x6, 0x5f, 0x407, 0xa, 0x5f,
0xd, 0x5f, 0xe, 0x5f, 0x408, 0x3, 0x60, 0x3, 0x60, 0x3, 0x60, 0x6, 0x60,
0x40e, 0xa, 0x60, 0xd, 0x60, 0xe, 0x60, 0x40f, 0x3, 0x61, 0x3, 0x61,
0x3, 0x61, 0x6, 0x61, 0x415, 0xa, 0x61, 0xd, 0x61, 0xe, 0x61, 0x416,
0x3, 0x62, 0x3, 0x62, 0x3, 0x62, 0x6, 0x62, 0x41c, 0xa, 0x62, 0xd, 0x62,
0xe, 0x62, 0x41d, 0x3, 0x63, 0x3, 0x63, 0x3, 0x63, 0x6, 0x63, 0x423,
0xa, 0x63, 0xd, 0x63, 0xe, 0x63, 0x424, 0x3, 0x64, 0x3, 0x64, 0x3, 0x64,
0x6, 0x64, 0x42a, 0xa, 0x64, 0xd, 0x64, 0xe, 0x64, 0x42b, 0x3, 0x65,
0x3, 0x65, 0x3, 0x65, 0x6, 0x65, 0x431, 0xa, 0x65, 0xd, 0x65, 0xe, 0x65,
0x432, 0x3, 0x66, 0x3, 0x66, 0x3, 0x66, 0x6, 0x66, 0x438, 0xa, 0x66,
0xd, 0x66, 0xe, 0x66, 0x439, 0x3, 0x67, 0x3, 0x67, 0x3, 0x67, 0x6, 0x67,
0x43f, 0xa, 0x67, 0xd, 0x67, 0xe, 0x67, 0x440, 0x3, 0x68, 0x3, 0x68,
0x3, 0x68, 0x6, 0x68, 0x446, 0xa, 0x68, 0xd, 0x68, 0xe, 0x68, 0x447,
0x3, 0x69, 0x3, 0x69, 0x3, 0x69, 0x6, 0x69, 0x44d, 0xa, 0x69, 0xd, 0x69,
0xe, 0x69, 0x44e, 0x3, 0x6a, 0x3, 0x6a, 0x3, 0x6a, 0x6, 0x6a, 0x454,
0xa, 0x6a, 0xd, 0x6a, 0xe, 0x6a, 0x455, 0x3, 0x6b, 0x3, 0x6b, 0x3, 0x6b,
0x6, 0x6b, 0x45b, 0xa, 0x6b, 0xd, 0x6b, 0xe, 0x6b, 0x45c, 0x3, 0x6c,
0x3, 0x6c, 0x3, 0x6c, 0x6, 0x6c, 0x462, 0xa, 0x6c, 0xd, 0x6c, 0xe, 0x6c,
0x463, 0x3, 0x6d, 0x3, 0x6d, 0x3, 0x6d, 0x6, 0x6d, 0x469, 0xa, 0x6d,
0xd, 0x6d, 0xe, 0x6d, 0x46a, 0x3, 0x6e, 0x3, 0x6e, 0x3, 0x6e, 0x6, 0x6e,
0x470, 0xa, 0x6e, 0xd, 0x6e, 0xe, 0x6e, 0x471, 0x3, 0x6f, 0x3, 0x6f,
0x3, 0x6f, 0x6, 0x6f, 0x477, 0xa, 0x6f, 0xd, 0x6f, 0xe, 0x6f, 0x478,
0x3, 0x70, 0x3, 0x70, 0x3, 0x70, 0x6, 0x70, 0x47e, 0xa, 0x70, 0xd, 0x70,
0xe, 0x70, 0x47f, 0x3, 0x71, 0x3, 0x71, 0x3, 0x71, 0x6, 0x71, 0x485,
0xa, 0x71, 0xd, 0x71, 0xe, 0x71, 0x486, 0x3, 0x72, 0x3, 0x72, 0x3, 0x72,
0x6, 0x72, 0x48c, 0xa, 0x72, 0xd, 0x72, 0xe, 0x72, 0x48d, 0x3, 0x73,
0x3, 0x73, 0x3, 0x73, 0x6, 0x73, 0x493, 0xa, 0x73, 0xd, 0x73, 0xe, 0x73,
0x494, 0x3, 0x74, 0x3, 0x74, 0x3, 0x74, 0x6, 0x74, 0x49a, 0xa, 0x74,
0xd, 0x74, 0xe, 0x74, 0x49b, 0x3, 0x75, 0x3, 0x75, 0x3, 0x75, 0x6, 0x75,
0x4a1, 0xa, 0x75, 0xd, 0x75, 0xe, 0x75, 0x4a2, 0x3, 0x76, 0x3, 0x76,
0x3, 0x76, 0x6, 0x76, 0x4a8, 0xa, 0x76, 0xd, 0x76, 0xe, 0x76, 0x4a9,
0x3, 0x77, 0x3, 0x77, 0x3, 0x77, 0x6, 0x77, 0x4af, 0xa, 0x77, 0xd, 0x77,
0xe, 0x77, 0x4b0, 0x3, 0x78, 0x3, 0x78, 0x3, 0x78, 0x6, 0x78, 0x4b6,
0xa, 0x78, 0xd, 0x78, 0xe, 0x78, 0x4b7, 0x3, 0x79, 0x3, 0x79, 0x3, 0x79,
0x6, 0x79, 0x4bd, 0xa, 0x79, 0xd, 0x79, 0xe, 0x79, 0x4be, 0x3, 0x7a,
0x3, 0x7a, 0x3, 0x7a, 0x6, 0x7a, 0x4c4, 0xa, 0x7a, 0xd, 0x7a, 0xe, 0x7a,
0x4c5, 0x3, 0x7b, 0x3, 0x7b, 0x3, 0x7b, 0x6, 0x7b, 0x4cb, 0xa, 0x7b,
0xd, 0x7b, 0xe, 0x7b, 0x4cc, 0x3, 0x7c, 0x3, 0x7c, 0x3, 0x7c, 0x6, 0x7c,
0x4d2, 0xa, 0x7c, 0xd, 0x7c, 0xe, 0x7c, 0x4d3, 0x3, 0x7d, 0x3, 0x7d,
0x3, 0x7d, 0x6, 0x7d, 0x4d9, 0xa, 0x7d, 0xd, 0x7d, 0xe, 0x7d, 0x4da,
0x3, 0x7e, 0x3, 0x7e, 0x3, 0x7e, 0x6, 0x7e, 0x4e0, 0xa, 0x7e, 0xd, 0x7e,
0xe, 0x7e, 0x4e1, 0x3, 0x7f, 0x3, 0x7f, 0x3, 0x7f, 0x6, 0x7f, 0x4e7,
0xa, 0x7f, 0xd, 0x7f, 0xe, 0x7f, 0x4e8, 0x3, 0x80, 0x3, 0x80, 0x3, 0x80,
0x6, 0x80, 0x4ee, 0xa, 0x80, 0xd, 0x80, 0xe, 0x80, 0x4ef, 0x3, 0x81,
0x3, 0x81, 0x3, 0x81, 0x6, 0x81, 0x4f5, 0xa, 0x81, 0xd, 0x81, 0xe, 0x81,
0x4f6, 0x3, 0x82, 0x3, 0x82, 0x3, 0x82, 0x6, 0x82, 0x4fc, 0xa, 0x82,
0xd, 0x82, 0xe, 0x82, 0x4fd, 0x3, 0x83, 0x3, 0x83, 0x3, 0x83, 0x6, 0x83,
0x503, 0xa, 0x83, 0xd, 0x83, 0xe, 0x83, 0x504, 0x3, 0x83, 0x2, 0x2,
0x84, 0x2, 0x4, 0x6, 0x8, 0xa, 0xc, 0xe, 0x10, 0x12, 0x14, 0x16, 0x18,
0x1a, 0x1c, 0x1e, 0x20, 0x22, 0x24, 0x26, 0x28, 0x2a, 0x2c, 0x2e, 0x30,
0x32, 0x34, 0x36, 0x38, 0x3a, 0x3c, 0x3e, 0x40, 0x42, 0x44, 0x46, 0x48,
0x4a, 0x4c, 0x4e, 0x50, 0x52, 0x54, 0x56, 0x58, 0x5a, 0x5c, 0x5e, 0x60,
0x62, 0x64, 0x66, 0x68, 0x6a, 0x6c, 0x6e, 0x70, 0x72, 0x74, 0x76, 0x78,
0x7a, 0x7c, 0x7e, 0x80, 0x82, 0x84, 0x86, 0x88, 0x8a, 0x8c, 0x8e, 0x90,
0x92, 0x94, 0x96, 0x98, 0x9a, 0x9c, 0x9e, 0xa0, 0xa2, 0xa4, 0xa6, 0xa8,
0xaa, 0xac, 0xae, 0xb0, 0xb2, 0xb4, 0xb6, 0xb8, 0xba, 0xbc, 0xbe, 0xc0,
0xc2, 0xc4, 0xc6, 0xc8, 0xca, 0xcc, 0xce, 0xd0, 0xd2, 0xd4, 0xd6, 0xd8,
0xda, 0xdc, 0xde, 0xe0, 0xe2, 0xe4, 0xe6, 0xe8, 0xea, 0xec, 0xee, 0xf0,
0xf2, 0xf4, 0xf6, 0xf8, 0xfa, 0xfc, 0xfe, 0x100, 0x102, 0x104, 0x2,
0x5, 0x3, 0x2, 0x30, 0x30, 0x3, 0x2, 0x30, 0x31, 0x3, 0x2, 0x32, 0x32,
0x2, 0x50d, 0x2, 0x106, 0x3, 0x2, 0x2, 0x2, 0x4, 0x111, 0x3, 0x2, 0x2,
0x2, 0x6, 0x116, 0x3, 0x2, 0x2, 0x2, 0x8, 0x11a, 0x3, 0x2, 0x2, 0x2,
0xa, 0x11f, 0x3, 0x2, 0x2, 0x2, 0xc, 0x123, 0x3, 0x2, 0x2, 0x2, 0xe,
0x127, 0x3, 0x2, 0x2, 0x2, 0x10, 0x12c, 0x3, 0x2, 0x2, 0x2, 0x12, 0x130,
0x3, 0x2, 0x2, 0x2, 0x14, 0x137, 0x3, 0x2, 0x2, 0x2, 0x16, 0x13c, 0x3,
0x2, 0x2, 0x2, 0x18, 0x140, 0x3, 0x2, 0x2, 0x2, 0x1a, 0x14f, 0x3, 0x2,
0x2, 0x2, 0x1c, 0x169, 0x3, 0x2, 0x2, 0x2, 0x1e, 0x178, 0x3, 0x2, 0x2,
0x2, 0x20, 0x187, 0x3, 0x2, 0x2, 0x2, 0x22, 0x1b1, 0x3, 0x2, 0x2, 0x2,
0x24, 0x1c7, 0x3, 0x2, 0x2, 0x2, 0x26, 0x1e9, 0x3, 0x2, 0x2, 0x2, 0x28,
0x225, 0x3, 0x2, 0x2, 0x2, 0x2a, 0x238, 0x3, 0x2, 0x2, 0x2, 0x2c, 0x23f,
0x3, 0x2, 0x2, 0x2, 0x2e, 0x242, 0x3, 0x2, 0x2, 0x2, 0x30, 0x245, 0x3,
0x2, 0x2, 0x2, 0x32, 0x24e, 0x3, 0x2, 0x2, 0x2, 0x34, 0x250, 0x3, 0x2,
0x2, 0x2, 0x36, 0x257, 0x3, 0x2, 0x2, 0x2, 0x38, 0x260, 0x3, 0x2, 0x2,
0x2, 0x3a, 0x262, 0x3, 0x2, 0x2, 0x2, 0x3c, 0x265, 0x3, 0x2, 0x2, 0x2,
0x3e, 0x26c, 0x3, 0x2, 0x2, 0x2, 0x40, 0x273, 0x3, 0x2, 0x2, 0x2, 0x42,
0x27a, 0x3, 0x2, 0x2, 0x2, 0x44, 0x27d, 0x3, 0x2, 0x2, 0x2, 0x46, 0x284,
0x3, 0x2, 0x2, 0x2, 0x48, 0x287, 0x3, 0x2, 0x2, 0x2, 0x4a, 0x290, 0x3,
0x2, 0x2, 0x2, 0x4c, 0x292, 0x3, 0x2, 0x2, 0x2, 0x4e, 0x295, 0x3, 0x2,
0x2, 0x2, 0x50, 0x298, 0x3, 0x2, 0x2, 0x2, 0x52, 0x29b, 0x3, 0x2, 0x2,
0x2, 0x54, 0x29e, 0x3, 0x2, 0x2, 0x2, 0x56, 0x2a5, 0x3, 0x2, 0x2, 0x2,
0x58, 0x2b2, 0x3, 0x2, 0x2, 0x2, 0x5a, 0x2b4, 0x3, 0x2, 0x2, 0x2, 0x5c,
0x2c0, 0x3, 0x2, 0x2, 0x2, 0x5e, 0x2c8, 0x3, 0x2, 0x2, 0x2, 0x60, 0x2ca,
0x3, 0x2, 0x2, 0x2, 0x62, 0x2d1, 0x3, 0x2, 0x2, 0x2, 0x64, 0x2d8, 0x3,
0x2, 0x2, 0x2, 0x66, 0x2eb, 0x3, 0x2, 0x2, 0x2, 0x68, 0x2ed, 0x3, 0x2,
0x2, 0x2, 0x6a, 0x2f0, 0x3, 0x2, 0x2, 0x2, 0x6c, 0x2f3, 0x3, 0x2, 0x2,
0x2, 0x6e, 0x2f6, 0x3, 0x2, 0x2, 0x2, 0x70, 0x2f9, 0x3, 0x2, 0x2, 0x2,
0x72, 0x300, 0x3, 0x2, 0x2, 0x2, 0x74, 0x307, 0x3, 0x2, 0x2, 0x2, 0x76,
0x310, 0x3, 0x2, 0x2, 0x2, 0x78, 0x312, 0x3, 0x2, 0x2, 0x2, 0x7a, 0x315,
0x3, 0x2, 0x2, 0x2, 0x7c, 0x31e, 0x3, 0x2, 0x2, 0x2, 0x7e, 0x320, 0x3,
0x2, 0x2, 0x2, 0x80, 0x329, 0x3, 0x2, 0x2, 0x2, 0x82, 0x334, 0x3, 0x2,
0x2, 0x2, 0x84, 0x348, 0x3, 0x2, 0x2, 0x2, 0x86, 0x34a, 0x3, 0x2, 0x2,
0x2, 0x88, 0x34d, 0x3, 0x2, 0x2, 0x2, 0x8a, 0x354, 0x3, 0x2, 0x2, 0x2,
0x8c, 0x35b, 0x3, 0x2, 0x2, 0x2, 0x8e, 0x367, 0x3, 0x2, 0x2, 0x2, 0x90,
0x369, 0x3, 0x2, 0x2, 0x2, 0x92, 0x370, 0x3, 0x2, 0x2, 0x2, 0x94, 0x377,
0x3, 0x2, 0x2, 0x2, 0x96, 0x37e, 0x3, 0x2, 0x2, 0x2, 0x98, 0x385, 0x3,
0x2, 0x2, 0x2, 0x9a, 0x38c, 0x3, 0x2, 0x2, 0x2, 0x9c, 0x393, 0x3, 0x2,
0x2, 0x2, 0x9e, 0x39a, 0x3, 0x2, 0x2, 0x2, 0xa0, 0x3a1, 0x3, 0x2, 0x2,
0x2, 0xa2, 0x3a8, 0x3, 0x2, 0x2, 0x2, 0xa4, 0x3af, 0x3, 0x2, 0x2, 0x2,
0xa6, 0x3b6, 0x3, 0x2, 0x2, 0x2, 0xa8, 0x3bd, 0x3, 0x2, 0x2, 0x2, 0xaa,
0x3c4, 0x3, 0x2, 0x2, 0x2, 0xac, 0x3cb, 0x3, 0x2, 0x2, 0x2, 0xae, 0x3d2,
0x3, 0x2, 0x2, 0x2, 0xb0, 0x3d9, 0x3, 0x2, 0x2, 0x2, 0xb2, 0x3e0, 0x3,
0x2, 0x2, 0x2, 0xb4, 0x3e7, 0x3, 0x2, 0x2, 0x2, 0xb6, 0x3ee, 0x3, 0x2,
0x2, 0x2, 0xb8, 0x3f5, 0x3, 0x2, 0x2, 0x2, 0xba, 0x3fc, 0x3, 0x2, 0x2,
0x2, 0xbc, 0x403, 0x3, 0x2, 0x2, 0x2, 0xbe, 0x40a, 0x3, 0x2, 0x2, 0x2,
0xc0, 0x411, 0x3, 0x2, 0x2, 0x2, 0xc2, 0x418, 0x3, 0x2, 0x2, 0x2, 0xc4,
0x41f, 0x3, 0x2, 0x2, 0x2, 0xc6, 0x426, 0x3, 0x2, 0x2, 0x2, 0xc8, 0x42d,
0x3, 0x2, 0x2, 0x2, 0xca, 0x434, 0x3, 0x2, 0x2, 0x2, 0xcc, 0x43b, 0x3,
0x2, 0x2, 0x2, 0xce, 0x442, 0x3, 0x2, 0x2, 0x2, 0xd0, 0x449, 0x3, 0x2,
0x2, 0x2, 0xd2, 0x450, 0x3, 0x2, 0x2, 0x2, 0xd4, 0x457, 0x3, 0x2, 0x2,
0x2, 0xd6, 0x45e, 0x3, 0x2, 0x2, 0x2, 0xd8, 0x465, 0x3, 0x2, 0x2, 0x2,
0xda, 0x46c, 0x3, 0x2, 0x2, 0x2, 0xdc, 0x473, 0x3, 0x2, 0x2, 0x2, 0xde,
0x47a, 0x3, 0x2, 0x2, 0x2, 0xe0, 0x481, 0x3, 0x2, 0x2, 0x2, 0xe2, 0x488,
0x3, 0x2, 0x2, 0x2, 0xe4, 0x48f, 0x3, 0x2, 0x2, 0x2, 0xe6, 0x496, 0x3,
0x2, 0x2, 0x2, 0xe8, 0x49d, 0x3, 0x2, 0x2, 0x2, 0xea, 0x4a4, 0x3, 0x2,
0x2, 0x2, 0xec, 0x4ab, 0x3, 0x2, 0x2, 0x2, 0xee, 0x4b2, 0x3, 0x2, 0x2,
0x2, 0xf0, 0x4b9, 0x3, 0x2, 0x2, 0x2, 0xf2, 0x4c0, 0x3, 0x2, 0x2, 0x2,
0xf4, 0x4c7, 0x3, 0x2, 0x2, 0x2, 0xf6, 0x4ce, 0x3, 0x2, 0x2, 0x2, 0xf8,
0x4d5, 0x3, 0x2, 0x2, 0x2, 0xfa, 0x4dc, 0x3, 0x2, 0x2, 0x2, 0xfc, 0x4e3,
0x3, 0x2, 0x2, 0x2, 0xfe, 0x4ea, 0x3, 0x2, 0x2, 0x2, 0x100, 0x4f1, 0x3,
0x2, 0x2, 0x2, 0x102, 0x4f8, 0x3, 0x2, 0x2, 0x2, 0x104, 0x4ff, 0x3,
0x2, 0x2, 0x2, 0x106, 0x107, 0x5, 0x4, 0x3, 0x2, 0x107, 0x109, 0x5,
0x8, 0x5, 0x2, 0x108, 0x10a, 0x5, 0xc, 0x7, 0x2, 0x109, 0x108, 0x3,
0x2, 0x2, 0x2, 0x109, 0x10a, 0x3, 0x2, 0x2, 0x2, 0x10a, 0x10b, 0x3,
0x2, 0x2, 0x2, 0x10b, 0x10d, 0x5, 0x18, 0xd, 0x2, 0x10c, 0x10e, 0x5,
0xe, 0x8, 0x2, 0x10d, 0x10c, 0x3, 0x2, 0x2, 0x2, 0x10d, 0x10e, 0x3,
0x2, 0x2, 0x2, 0x10e, 0x10f, 0x3, 0x2, 0x2, 0x2, 0x10f, 0x110, 0x7,
0x2, 0x2, 0x3, 0x110, 0x3, 0x3, 0x2, 0x2, 0x2, 0x111, 0x112, 0x7, 0x29,
0x2, 0x2, 0x112, 0x113, 0x5, 0x6, 0x4, 0x2, 0x113, 0x114, 0x7, 0x30,
0x2, 0x2, 0x114, 0x5, 0x3, 0x2, 0x2, 0x2, 0x115, 0x117, 0xa, 0x2, 0x2,
0x2, 0x116, 0x115, 0x3, 0x2, 0x2, 0x2, 0x117, 0x118, 0x3, 0x2, 0x2,
0x2, 0x118, 0x116, 0x3, 0x2, 0x2, 0x2, 0x118, 0x119, 0x3, 0x2, 0x2,
0x2, 0x119, 0x7, 0x3, 0x2, 0x2, 0x2, 0x11a, 0x11b, 0x7, 0x2a, 0x2, 0x2,
0x11b, 0x11c, 0x5, 0xa, 0x6, 0x2, 0x11c, 0x11d, 0x7, 0x30, 0x2, 0x2,
0x11d, 0x9, 0x3, 0x2, 0x2, 0x2, 0x11e, 0x120, 0xa, 0x2, 0x2, 0x2, 0x11f,
0x11e, 0x3, 0x2, 0x2, 0x2, 0x120, 0x121, 0x3, 0x2, 0x2, 0x2, 0x121,
0x11f, 0x3, 0x2, 0x2, 0x2, 0x121, 0x122, 0x3, 0x2, 0x2, 0x2, 0x122,
0xb, 0x3, 0x2, 0x2, 0x2, 0x123, 0x124, 0x7, 0x2b, 0x2, 0x2, 0x124, 0x125,
0x5, 0x10, 0x9, 0x2, 0x125, 0x126, 0x7, 0x30, 0x2, 0x2, 0x126, 0xd,
0x3, 0x2, 0x2, 0x2, 0x127, 0x128, 0x7, 0x2d, 0x2, 0x2, 0x128, 0x129,
0x5, 0x10, 0x9, 0x2, 0x129, 0x12a, 0x7, 0x30, 0x2, 0x2, 0x12a, 0xf,
0x3, 0x2, 0x2, 0x2, 0x12b, 0x12d, 0x5, 0x12, 0xa, 0x2, 0x12c, 0x12b,
0x3, 0x2, 0x2, 0x2, 0x12d, 0x12e, 0x3, 0x2, 0x2, 0x2, 0x12e, 0x12c,
0x3, 0x2, 0x2, 0x2, 0x12e, 0x12f, 0x3, 0x2, 0x2, 0x2, 0x12f, 0x11, 0x3,
0x2, 0x2, 0x2, 0x130, 0x131, 0x7, 0x2f, 0x2, 0x2, 0x131, 0x132, 0x5,
0x14, 0xb, 0x2, 0x132, 0x133, 0x7, 0x31, 0x2, 0x2, 0x133, 0x134, 0x5,
0x16, 0xc, 0x2, 0x134, 0x135, 0x7, 0x30, 0x2, 0x2, 0x135, 0x13, 0x3,
0x2, 0x2, 0x2, 0x136, 0x138, 0xa, 0x3, 0x2, 0x2, 0x137, 0x136, 0x3,
0x2, 0x2, 0x2, 0x138, 0x139, 0x3, 0x2, 0x2, 0x2, 0x139, 0x137, 0x3,
0x2, 0x2, 0x2, 0x139, 0x13a, 0x3, 0x2, 0x2, 0x2, 0x13a, 0x15, 0x3, 0x2,
0x2, 0x2, 0x13b, 0x13d, 0xa, 0x2, 0x2, 0x2, 0x13c, 0x13b, 0x3, 0x2,
0x2, 0x2, 0x13d, 0x13e, 0x3, 0x2, 0x2, 0x2, 0x13e, 0x13c, 0x3, 0x2,
0x2, 0x2, 0x13e, 0x13f, 0x3, 0x2, 0x2, 0x2, 0x13f, 0x17, 0x3, 0x2, 0x2,
0x2, 0x140, 0x141, 0x7, 0x2c, 0x2, 0x2, 0x141, 0x142, 0x5, 0x1a, 0xe,
0x2, 0x142, 0x146, 0x5, 0x1e, 0x10, 0x2, 0x143, 0x145, 0x5, 0x24, 0x13,
0x2, 0x144, 0x143, 0x3, 0x2, 0x2, 0x2, 0x145, 0x148, 0x3, 0x2, 0x2,
0x2, 0x146, 0x144, 0x3, 0x2, 0x2, 0x2, 0x146, 0x147, 0x3, 0x2, 0x2,
0x2, 0x147, 0x149, 0x3, 0x2, 0x2, 0x2, 0x148, 0x146, 0x3, 0x2, 0x2,
0x2, 0x149, 0x14b, 0x5, 0x26, 0x14, 0x2, 0x14a, 0x14c, 0x5, 0x28, 0x15,
0x2, 0x14b, 0x14a, 0x3, 0x2, 0x2, 0x2, 0x14b, 0x14c, 0x3, 0x2, 0x2,
0x2, 0x14c, 0x14d, 0x3, 0x2, 0x2, 0x2, 0x14d, 0x14e, 0x7, 0x2e, 0x2,
0x2, 0x14e, 0x19, 0x3, 0x2, 0x2, 0x2, 0x14f, 0x150, 0x5, 0x2a, 0x16,
0x2, 0x150, 0x152, 0x8, 0xe, 0x1, 0x2, 0x151, 0x153, 0x5, 0x2c, 0x17,
0x2, 0x152, 0x151, 0x3, 0x2, 0x2, 0x2, 0x153, 0x154, 0x3, 0x2, 0x2,
0x2, 0x154, 0x152, 0x3, 0x2, 0x2, 0x2, 0x154, 0x155, 0x3, 0x2, 0x2,
0x2, 0x155, 0x156, 0x3, 0x2, 0x2, 0x2, 0x156, 0x157, 0x8, 0xe, 0x1,
0x2, 0x157, 0x158, 0x5, 0x2e, 0x18, 0x2, 0x158, 0x159, 0x8, 0xe, 0x1,
0x2, 0x159, 0x15a, 0x5, 0x30, 0x19, 0x2, 0x15a, 0x15c, 0x8, 0xe, 0x1,
0x2, 0x15b, 0x15d, 0x5, 0x32, 0x1a, 0x2, 0x15c, 0x15b, 0x3, 0x2, 0x2,
0x2, 0x15c, 0x15d, 0x3, 0x2, 0x2, 0x2, 0x15d, 0x15e, 0x3, 0x2, 0x2,
0x2, 0x15e, 0x162, 0x8, 0xe, 0x1, 0x2, 0x15f, 0x161, 0x5, 0x1c, 0xf,
0x2, 0x160, 0x15f, 0x3, 0x2, 0x2, 0x2, 0x161, 0x164, 0x3, 0x2, 0x2,
0x2, 0x162, 0x160, 0x3, 0x2, 0x2, 0x2, 0x162, 0x163, 0x3, 0x2, 0x2,
0x2, 0x163, 0x165, 0x3, 0x2, 0x2, 0x2, 0x164, 0x162, 0x3, 0x2, 0x2,
0x2, 0x165, 0x166, 0x8, 0xe, 0x1, 0x2, 0x166, 0x167, 0x5, 0x3e, 0x20,
0x2, 0x167, 0x168, 0x8, 0xe, 0x1, 0x2, 0x168, 0x1b, 0x3, 0x2, 0x2, 0x2,
0x169, 0x16a, 0x5, 0x34, 0x1b, 0x2, 0x16a, 0x16c, 0x8, 0xf, 0x1, 0x2,
0x16b, 0x16d, 0x5, 0x36, 0x1c, 0x2, 0x16c, 0x16b, 0x3, 0x2, 0x2, 0x2,
0x16c, 0x16d, 0x3, 0x2, 0x2, 0x2, 0x16d, 0x16e, 0x3, 0x2, 0x2, 0x2,
0x16e, 0x170, 0x8, 0xf, 0x1, 0x2, 0x16f, 0x171, 0x5, 0x38, 0x1d, 0x2,
0x170, 0x16f, 0x3, 0x2, 0x2, 0x2, 0x170, 0x171, 0x3, 0x2, 0x2, 0x2,
0x171, 0x172, 0x3, 0x2, 0x2, 0x2, 0x172, 0x173, 0x8, 0xf, 0x1, 0x2,
0x173, 0x174, 0x5, 0x3a, 0x1e, 0x2, 0x174, 0x175, 0x8, 0xf, 0x1, 0x2,
0x175, 0x176, 0x5, 0x3c, 0x1f, 0x2, 0x176, 0x177, 0x8, 0xf, 0x1, 0x2,
0x177, 0x1d, 0x3, 0x2, 0x2, 0x2, 0x178, 0x179, 0x5, 0x40, 0x21, 0x2,
0x179, 0x17b, 0x8, 0x10, 0x1, 0x2, 0x17a, 0x17c, 0x5, 0x42, 0x22, 0x2,
0x17b, 0x17a, 0x3, 0x2, 0x2, 0x2, 0x17b, 0x17c, 0x3, 0x2, 0x2, 0x2,
0x17c, 0x17d, 0x3, 0x2, 0x2, 0x2, 0x17d, 0x17f, 0x8, 0x10, 0x1, 0x2,
0x17e, 0x180, 0x5, 0x20, 0x11, 0x2, 0x17f, 0x17e, 0x3, 0x2, 0x2, 0x2,
0x17f, 0x180, 0x3, 0x2, 0x2, 0x2, 0x180, 0x181, 0x3, 0x2, 0x2, 0x2,
0x181, 0x182, 0x8, 0x10, 0x1, 0x2, 0x182, 0x183, 0x5, 0x22, 0x12, 0x2,
0x183, 0x184, 0x8, 0x10, 0x1, 0x2, 0x184, 0x185, 0x5, 0x62, 0x32, 0x2,
0x185, 0x186, 0x8, 0x10, 0x1, 0x2, 0x186, 0x1f, 0x3, 0x2, 0x2, 0x2,
0x187, 0x188, 0x5, 0x44, 0x23, 0x2, 0x188, 0x18a, 0x8, 0x11, 0x1, 0x2,
0x189, 0x18b, 0x5, 0x46, 0x24, 0x2, 0x18a, 0x189, 0x3, 0x2, 0x2, 0x2,
0x18a, 0x18b, 0x3, 0x2, 0x2, 0x2, 0x18b, 0x18c, 0x3, 0x2, 0x2, 0x2,
0x18c, 0x18e, 0x8, 0x11, 0x1, 0x2, 0x18d, 0x18f, 0x5, 0x48, 0x25, 0x2,
0x18e, 0x18d, 0x3, 0x2, 0x2, 0x2, 0x18e, 0x18f, 0x3, 0x2, 0x2, 0x2,
0x18f, 0x190, 0x3, 0x2, 0x2, 0x2, 0x190, 0x192, 0x8, 0x11, 0x1, 0x2,
0x191, 0x193, 0x5, 0x4a, 0x26, 0x2, 0x192, 0x191, 0x3, 0x2, 0x2, 0x2,
0x192, 0x193, 0x3, 0x2, 0x2, 0x2, 0x193, 0x194, 0x3, 0x2, 0x2, 0x2,
0x194, 0x196, 0x8, 0x11, 0x1, 0x2, 0x195, 0x197, 0x5, 0x4c, 0x27, 0x2,
0x196, 0x195, 0x3, 0x2, 0x2, 0x2, 0x196, 0x197, 0x3, 0x2, 0x2, 0x2,
0x197, 0x198, 0x3, 0x2, 0x2, 0x2, 0x198, 0x19c, 0x8, 0x11, 0x1, 0x2,
0x199, 0x19b, 0x5, 0x4e, 0x28, 0x2, 0x19a, 0x199, 0x3, 0x2, 0x2, 0x2,
0x19b, 0x19e, 0x3, 0x2, 0x2, 0x2, 0x19c, 0x19a, 0x3, 0x2, 0x2, 0x2,
0x19c, 0x19d, 0x3, 0x2, 0x2, 0x2, 0x19d, 0x19f, 0x3, 0x2, 0x2, 0x2,
0x19e, 0x19c, 0x3, 0x2, 0x2, 0x2, 0x19f, 0x1a3, 0x8, 0x11, 0x1, 0x2,
0x1a0, 0x1a2, 0x5, 0x50, 0x29, 0x2, 0x1a1, 0x1a0, 0x3, 0x2, 0x2, 0x2,
0x1a2, 0x1a5, 0x3, 0x2, 0x2, 0x2, 0x1a3, 0x1a1, 0x3, 0x2, 0x2, 0x2,
0x1a3, 0x1a4, 0x3, 0x2, 0x2, 0x2, 0x1a4, 0x1a6, 0x3, 0x2, 0x2, 0x2,
0x1a5, 0x1a3, 0x3, 0x2, 0x2, 0x2, 0x1a6, 0x1aa, 0x8, 0x11, 0x1, 0x2,
0x1a7, 0x1a9, 0x5, 0x52, 0x2a, 0x2, 0x1a8, 0x1a7, 0x3, 0x2, 0x2, 0x2,
0x1a9, 0x1ac, 0x3, 0x2, 0x2, 0x2, 0x1aa, 0x1a8, 0x3, 0x2, 0x2, 0x2,
0x1aa, 0x1ab, 0x3, 0x2, 0x2, 0x2, 0x1ab, 0x1ad, 0x3, 0x2, 0x2, 0x2,
0x1ac, 0x1aa, 0x3, 0x2, 0x2, 0x2, 0x1ad, 0x1ae, 0x8, 0x11, 0x1, 0x2,
0x1ae, 0x1af, 0x5, 0x54, 0x2b, 0x2, 0x1af, 0x1b0, 0x8, 0x11, 0x1, 0x2,
0x1b0, 0x21, 0x3, 0x2, 0x2, 0x2, 0x1b1, 0x1b2, 0x5, 0x56, 0x2c, 0x2,
0x1b2, 0x1b4, 0x8, 0x12, 0x1, 0x2, 0x1b3, 0x1b5, 0x5, 0x58, 0x2d, 0x2,
0x1b4, 0x1b3, 0x3, 0x2, 0x2, 0x2, 0x1b4, 0x1b5, 0x3, 0x2, 0x2, 0x2,
0x1b5, 0x1b6, 0x3, 0x2, 0x2, 0x2, 0x1b6, 0x1b7, 0x8, 0x12, 0x1, 0x2,
0x1b7, 0x1b8, 0x5, 0x5a, 0x2e, 0x2, 0x1b8, 0x1ba, 0x8, 0x12, 0x1, 0x2,
0x1b9, 0x1bb, 0x5, 0x5c, 0x2f, 0x2, 0x1ba, 0x1b9, 0x3, 0x2, 0x2, 0x2,
0x1ba, 0x1bb, 0x3, 0x2, 0x2, 0x2, 0x1bb, 0x1bc, 0x3, 0x2, 0x2, 0x2,
0x1bc, 0x1c0, 0x8, 0x12, 0x1, 0x2, 0x1bd, 0x1bf, 0x5, 0x5e, 0x30, 0x2,
0x1be, 0x1bd, 0x3, 0x2, 0x2, 0x2, 0x1bf, 0x1c2, 0x3, 0x2, 0x2, 0x2,
0x1c0, 0x1be, 0x3, 0x2, 0x2, 0x2, 0x1c0, 0x1c1, 0x3, 0x2, 0x2, 0x2,
0x1c1, 0x1c3, 0x3, 0x2, 0x2, 0x2, 0x1c2, 0x1c0, 0x3, 0x2, 0x2, 0x2,
0x1c3, 0x1c4, 0x8, 0x12, 0x1, 0x2, 0x1c4, 0x1c5, 0x5, 0x60, 0x31, 0x2,
0x1c5, 0x1c6, 0x8, 0x12, 0x1, 0x2, 0x1c6, 0x23, 0x3, 0x2, 0x2, 0x2,
0x1c7, 0x1c8, 0x5, 0x64, 0x33, 0x2, 0x1c8, 0x1ca, 0x8, 0x13, 0x1, 0x2,
0x1c9, 0x1cb, 0x5, 0x66, 0x34, 0x2, 0x1ca, 0x1c9, 0x3, 0x2, 0x2, 0x2,
0x1cb, 0x1cc, 0x3, 0x2, 0x2, 0x2, 0x1cc, 0x1ca, 0x3, 0x2, 0x2, 0x2,
0x1cc, 0x1cd, 0x3, 0x2, 0x2, 0x2, 0x1cd, 0x1ce, 0x3, 0x2, 0x2, 0x2,
0x1ce, 0x1d2, 0x8, 0x13, 0x1, 0x2, 0x1cf, 0x1d1, 0x5, 0x68, 0x35, 0x2,
0x1d0, 0x1cf, 0x3, 0x2, 0x2, 0x2, 0x1d1, 0x1d4, 0x3, 0x2, 0x2, 0x2,
0x1d2, 0x1d0, 0x3, 0x2, 0x2, 0x2, 0x1d2, 0x1d3, 0x3, 0x2, 0x2, 0x2,
0x1d3, 0x1d5, 0x3, 0x2, 0x2, 0x2, 0x1d4, 0x1d2, 0x3, 0x2, 0x2, 0x2,
0x1d5, 0x1d6, 0x8, 0x13, 0x1, 0x2, 0x1d6, 0x1d7, 0x5, 0x6a, 0x36, 0x2,
0x1d7, 0x1db, 0x8, 0x13, 0x1, 0x2, 0x1d8, 0x1da, 0x5, 0x6c, 0x37, 0x2,
0x1d9, 0x1d8, 0x3, 0x2, 0x2, 0x2, 0x1da, 0x1dd, 0x3, 0x2, 0x2, 0x2,
0x1db, 0x1d9, 0x3, 0x2, 0x2, 0x2, 0x1db, 0x1dc, 0x3, 0x2, 0x2, 0x2,
0x1dc, 0x1de, 0x3, 0x2, 0x2, 0x2, 0x1dd, 0x1db, 0x3, 0x2, 0x2, 0x2,
0x1de, 0x1e2, 0x8, 0x13, 0x1, 0x2, 0x1df, 0x1e1, 0x5, 0x6e, 0x38, 0x2,
0x1e0, 0x1df, 0x3, 0x2, 0x2, 0x2, 0x1e1, 0x1e4, 0x3, 0x2, 0x2, 0x2,
0x1e2, 0x1e0, 0x3, 0x2, 0x2, 0x2, 0x1e2, 0x1e3, 0x3, 0x2, 0x2, 0x2,
0x1e3, 0x1e5, 0x3, 0x2, 0x2, 0x2, 0x1e4, 0x1e2, 0x3, 0x2, 0x2, 0x2,
0x1e5, 0x1e6, 0x8, 0x13, 0x1, 0x2, 0x1e6, 0x1e7, 0x5, 0x70, 0x39, 0x2,
0x1e7, 0x1e8, 0x8, 0x13, 0x1, 0x2, 0x1e8, 0x25, 0x3, 0x2, 0x2, 0x2,
0x1e9, 0x1ea, 0x5, 0x72, 0x3a, 0x2, 0x1ea, 0x1eb, 0x8, 0x14, 0x1, 0x2,
0x1eb, 0x1ec, 0x5, 0x74, 0x3b, 0x2, 0x1ec, 0x1ee, 0x8, 0x14, 0x1, 0x2,
0x1ed, 0x1ef, 0x5, 0x76, 0x3c, 0x2, 0x1ee, 0x1ed, 0x3, 0x2, 0x2, 0x2,
0x1ef, 0x1f0, 0x3, 0x2, 0x2, 0x2, 0x1f0, 0x1ee, 0x3, 0x2, 0x2, 0x2,
0x1f0, 0x1f1, 0x3, 0x2, 0x2, 0x2, 0x1f1, 0x1f2, 0x3, 0x2, 0x2, 0x2,
0x1f2, 0x1f6, 0x8, 0x14, 0x1, 0x2, 0x1f3, 0x1f5, 0x5, 0x78, 0x3d, 0x2,
0x1f4, 0x1f3, 0x3, 0x2, 0x2, 0x2, 0x1f5, 0x1f8, 0x3, 0x2, 0x2, 0x2,
0x1f6, 0x1f4, 0x3, 0x2, 0x2, 0x2, 0x1f6, 0x1f7, 0x3, 0x2, 0x2, 0x2,
0x1f7, 0x1f9, 0x3, 0x2, 0x2, 0x2, 0x1f8, 0x1f6, 0x3, 0x2, 0x2, 0x2,
0x1f9, 0x1fb, 0x8, 0x14, 0x1, 0x2, 0x1fa, 0x1fc, 0x5, 0x7a, 0x3e, 0x2,
0x1fb, 0x1fa, 0x3, 0x2, 0x2, 0x2, 0x1fb, 0x1fc, 0x3, 0x2, 0x2, 0x2,
0x1fc, 0x1fd, 0x3, 0x2, 0x2, 0x2, 0x1fd, 0x201, 0x8, 0x14, 0x1, 0x2,
0x1fe, 0x200, 0x5, 0x7c, 0x3f, 0x2, 0x1ff, 0x1fe, 0x3, 0x2, 0x2, 0x2,
0x200, 0x203, 0x3, 0x2, 0x2, 0x2, 0x201, 0x1ff, 0x3, 0x2, 0x2, 0x2,
0x201, 0x202, 0x3, 0x2, 0x2, 0x2, 0x202, 0x204, 0x3, 0x2, 0x2, 0x2,
0x203, 0x201, 0x3, 0x2, 0x2, 0x2, 0x204, 0x206, 0x8, 0x14, 0x1, 0x2,
0x205, 0x207, 0x5, 0x7e, 0x40, 0x2, 0x206, 0x205, 0x3, 0x2, 0x2, 0x2,
0x206, 0x207, 0x3, 0x2, 0x2, 0x2, 0x207, 0x208, 0x3, 0x2, 0x2, 0x2,
0x208, 0x20a, 0x8, 0x14, 0x1, 0x2, 0x209, 0x20b, 0x5, 0x80, 0x41, 0x2,
0x20a, 0x209, 0x3, 0x2, 0x2, 0x2, 0x20a, 0x20b, 0x3, 0x2, 0x2, 0x2,
0x20b, 0x20c, 0x3, 0x2, 0x2, 0x2, 0x20c, 0x210, 0x8, 0x14, 0x1, 0x2,
0x20d, 0x20f, 0x5, 0x82, 0x42, 0x2, 0x20e, 0x20d, 0x3, 0x2, 0x2, 0x2,
0x20f, 0x212, 0x3, 0x2, 0x2, 0x2, 0x210, 0x20e, 0x3, 0x2, 0x2, 0x2,
0x210, 0x211, 0x3, 0x2, 0x2, 0x2, 0x211, 0x213, 0x3, 0x2, 0x2, 0x2,
0x212, 0x210, 0x3, 0x2, 0x2, 0x2, 0x213, 0x217, 0x8, 0x14, 0x1, 0x2,
0x214, 0x216, 0x5, 0x84, 0x43, 0x2, 0x215, 0x214, 0x3, 0x2, 0x2, 0x2,
0x216, 0x219, 0x3, 0x2, 0x2, 0x2, 0x217, 0x215, 0x3, 0x2, 0x2, 0x2,
0x217, 0x218, 0x3, 0x2, 0x2, 0x2, 0x218, 0x21a, 0x3, 0x2, 0x2, 0x2,
0x219, 0x217, 0x3, 0x2, 0x2, 0x2, 0x21a, 0x21e, 0x8, 0x14, 0x1, 0x2,
0x21b, 0x21d, 0x5, 0x86, 0x44, 0x2, 0x21c, 0x21b, 0x3, 0x2, 0x2, 0x2,
0x21d, 0x220, 0x3, 0x2, 0x2, 0x2, 0x21e, 0x21c, 0x3, 0x2, 0x2, 0x2,
0x21e, 0x21f, 0x3, 0x2, 0x2, 0x2, 0x21f, 0x221, 0x3, 0x2, 0x2, 0x2,
0x220, 0x21e, 0x3, 0x2, 0x2, 0x2, 0x221, 0x222, 0x8, 0x14, 0x1, 0x2,
0x222, 0x223, 0x5, 0x88, 0x45, 0x2, 0x223, 0x224, 0x8, 0x14, 0x1, 0x2,
0x224, 0x27, 0x3, 0x2, 0x2, 0x2, 0x225, 0x226, 0x5, 0x8a, 0x46, 0x2,
0x226, 0x22a, 0x8, 0x15, 0x1, 0x2, 0x227, 0x229, 0x5, 0x8c, 0x47, 0x2,
0x228, 0x227, 0x3, 0x2, 0x2, 0x2, 0x229, 0x22c, 0x3, 0x2, 0x2, 0x2,
0x22a, 0x228, 0x3, 0x2, 0x2, 0x2, 0x22a, 0x22b, 0x3, 0x2, 0x2, 0x2,
0x22b, 0x22d, 0x3, 0x2, 0x2, 0x2, 0x22c, 0x22a, 0x3, 0x2, 0x2, 0x2,
0x22d, 0x231, 0x8, 0x15, 0x1, 0x2, 0x22e, 0x230, 0x5, 0x8e, 0x48, 0x2,
0x22f, 0x22e, 0x3, 0x2, 0x2, 0x2, 0x230, 0x233, 0x3, 0x2, 0x2, 0x2,
0x231, 0x22f, 0x3, 0x2, 0x2, 0x2, 0x231, 0x232, 0x3, 0x2, 0x2, 0x2,
0x232, 0x234, 0x3, 0x2, 0x2, 0x2, 0x233, 0x231, 0x3, 0x2, 0x2, 0x2,
0x234, 0x235, 0x8, 0x15, 0x1, 0x2, 0x235, 0x236, 0x5, 0x90, 0x49, 0x2,
0x236, 0x237, 0x8, 0x15, 0x1, 0x2, 0x237, 0x29, 0x3, 0x2, 0x2, 0x2,
0x238, 0x239, 0x7, 0x32, 0x2, 0x2, 0x239, 0x23b, 0x7, 0x3, 0x2, 0x2,
0x23a, 0x23c, 0xa, 0x4, 0x2, 0x2, 0x23b, 0x23a, 0x3, 0x2, 0x2, 0x2,
0x23c, 0x23d, 0x3, 0x2, 0x2, 0x2, 0x23d, 0x23b, 0x3, 0x2, 0x2, 0x2,
0x23d, 0x23e, 0x3, 0x2, 0x2, 0x2, 0x23e, 0x2b, 0x3, 0x2, 0x2, 0x2, 0x23f,
0x240, 0x5, 0x92, 0x4a, 0x2, 0x240, 0x241, 0x8, 0x17, 0x1, 0x2, 0x241,
0x2d, 0x3, 0x2, 0x2, 0x2, 0x242, 0x243, 0x5, 0x94, 0x4b, 0x2, 0x243,
0x244, 0x8, 0x18, 0x1, 0x2, 0x244, 0x2f, 0x3, 0x2, 0x2, 0x2, 0x245,
0x246, 0x5, 0x96, 0x4c, 0x2, 0x246, 0x247, 0x8, 0x19, 0x1, 0x2, 0x247,
0x31, 0x3, 0x2, 0x2, 0x2, 0x248, 0x249, 0x5, 0x98, 0x4d, 0x2, 0x249,
0x24a, 0x8, 0x1a, 0x1, 0x2, 0x24a, 0x24f, 0x3, 0x2, 0x2, 0x2, 0x24b,
0x24c, 0x5, 0x9a, 0x4e, 0x2, 0x24c, 0x24d, 0x8, 0x1a, 0x1, 0x2, 0x24d,
0x24f, 0x3, 0x2, 0x2, 0x2, 0x24e, 0x248, 0x3, 0x2, 0x2, 0x2, 0x24e,
0x24b, 0x3, 0x2, 0x2, 0x2, 0x24f, 0x33, 0x3, 0x2, 0x2, 0x2, 0x250, 0x251,
0x7, 0x32, 0x2, 0x2, 0x251, 0x253, 0x7, 0x3, 0x2, 0x2, 0x252, 0x254,
0xa, 0x4, 0x2, 0x2, 0x253, 0x252, 0x3, 0x2, 0x2, 0x2, 0x254, 0x255,
0x3, 0x2, 0x2, 0x2, 0x255, 0x253, 0x3, 0x2, 0x2, 0x2, 0x255, 0x256,
0x3, 0x2, 0x2, 0x2, 0x256, 0x35, 0x3, 0x2, 0x2, 0x2, 0x257, 0x258, 0x5,
0x9c, 0x4f, 0x2, 0x258, 0x259, 0x8, 0x1c, 0x1, 0x2, 0x259, 0x37, 0x3,
0x2, 0x2, 0x2, 0x25a, 0x25b, 0x5, 0x9e, 0x50, 0x2, 0x25b, 0x25c, 0x8,
0x1d, 0x1, 0x2, 0x25c, 0x261, 0x3, 0x2, 0x2, 0x2, 0x25d, 0x25e, 0x5,
0xa0, 0x51, 0x2, 0x25e, 0x25f, 0x8, 0x1d, 0x1, 0x2, 0x25f, 0x261, 0x3,
0x2, 0x2, 0x2, 0x260, 0x25a, 0x3, 0x2, 0x2, 0x2, 0x260, 0x25d, 0x3,
0x2, 0x2, 0x2, 0x261, 0x39, 0x3, 0x2, 0x2, 0x2, 0x262, 0x263, 0x5, 0xa2,
0x52, 0x2, 0x263, 0x264, 0x8, 0x1e, 0x1, 0x2, 0x264, 0x3b, 0x3, 0x2,
0x2, 0x2, 0x265, 0x266, 0x7, 0x32, 0x2, 0x2, 0x266, 0x268, 0x7, 0x4,
0x2, 0x2, 0x267, 0x269, 0xa, 0x4, 0x2, 0x2, 0x268, 0x267, 0x3, 0x2,
0x2, 0x2, 0x269, 0x26a, 0x3, 0x2, 0x2, 0x2, 0x26a, 0x268, 0x3, 0x2,
0x2, 0x2, 0x26a, 0x26b, 0x3, 0x2, 0x2, 0x2, 0x26b, 0x3d, 0x3, 0x2, 0x2,
0x2, 0x26c, 0x26d, 0x7, 0x32, 0x2, 0x2, 0x26d, 0x26f, 0x7, 0x4, 0x2,
0x2, 0x26e, 0x270, 0xa, 0x4, 0x2, 0x2, 0x26f, 0x26e, 0x3, 0x2, 0x2,
0x2, 0x270, 0x271, 0x3, 0x2, 0x2, 0x2, 0x271, 0x26f, 0x3, 0x2, 0x2,
0x2, 0x271, 0x272, 0x3, 0x2, 0x2, 0x2, 0x272, 0x3f, 0x3, 0x2, 0x2, 0x2,
0x273, 0x274, 0x7, 0x32, 0x2, 0x2, 0x274, 0x276, 0x7, 0x3, 0x2, 0x2,
0x275, 0x277, 0xa, 0x4, 0x2, 0x2, 0x276, 0x275, 0x3, 0x2, 0x2, 0x2,
0x277, 0x278, 0x3, 0x2, 0x2, 0x2, 0x278, 0x276, 0x3, 0x2, 0x2, 0x2,
0x278, 0x279, 0x3, 0x2, 0x2, 0x2, 0x279, 0x41, 0x3, 0x2, 0x2, 0x2, 0x27a,
0x27b, 0x5, 0xa4, 0x53, 0x2, 0x27b, 0x27c, 0x8, 0x22, 0x1, 0x2, 0x27c,
0x43, 0x3, 0x2, 0x2, 0x2, 0x27d, 0x27e, 0x7, 0x32, 0x2, 0x2, 0x27e,
0x280, 0x7, 0x3, 0x2, 0x2, 0x27f, 0x281, 0xa, 0x4, 0x2, 0x2, 0x280,
0x27f, 0x3, 0x2, 0x2, 0x2, 0x281, 0x282, 0x3, 0x2, 0x2, 0x2, 0x282,
0x280, 0x3, 0x2, 0x2, 0x2, 0x282, 0x283, 0x3, 0x2, 0x2, 0x2, 0x283,
0x45, 0x3, 0x2, 0x2, 0x2, 0x284, 0x285, 0x5, 0xa6, 0x54, 0x2, 0x285,
0x286, 0x8, 0x24, 0x1, 0x2, 0x286, 0x47, 0x3, 0x2, 0x2, 0x2, 0x287,
0x288, 0x5, 0xa8, 0x55, 0x2, 0x288, 0x289, 0x8, 0x25, 0x1, 0x2, 0x289,
0x49, 0x3, 0x2, 0x2, 0x2, 0x28a, 0x28b, 0x5, 0xaa, 0x56, 0x2, 0x28b,
0x28c, 0x8, 0x26, 0x1, 0x2, 0x28c, 0x291, 0x3, 0x2, 0x2, 0x2, 0x28d,
0x28e, 0x5, 0xac, 0x57, 0x2, 0x28e, 0x28f, 0x8, 0x26, 0x1, 0x2, 0x28f,
0x291, 0x3, 0x2, 0x2, 0x2, 0x290, 0x28a, 0x3, 0x2, 0x2, 0x2, 0x290,
0x28d, 0x3, 0x2, 0x2, 0x2, 0x291, 0x4b, 0x3, 0x2, 0x2, 0x2, 0x292, 0x293,
0x5, 0xae, 0x58, 0x2, 0x293, 0x294, 0x8, 0x27, 0x1, 0x2, 0x294, 0x4d,
0x3, 0x2, 0x2, 0x2, 0x295, 0x296, 0x5, 0xb0, 0x59, 0x2, 0x296, 0x297,
0x8, 0x28, 0x1, 0x2, 0x297, 0x4f, 0x3, 0x2, 0x2, 0x2, 0x298, 0x299,
0x5, 0xb2, 0x5a, 0x2, 0x299, 0x29a, 0x8, 0x29, 0x1, 0x2, 0x29a, 0x51,
0x3, 0x2, 0x2, 0x2, 0x29b, 0x29c, 0x5, 0xb4, 0x5b, 0x2, 0x29c, 0x29d,
0x8, 0x2a, 0x1, 0x2, 0x29d, 0x53, 0x3, 0x2, 0x2, 0x2, 0x29e, 0x29f,
0x7, 0x32, 0x2, 0x2, 0x29f, 0x2a1, 0x7, 0x4, 0x2, 0x2, 0x2a0, 0x2a2,
0xa, 0x4, 0x2, 0x2, 0x2a1, 0x2a0, 0x3, 0x2, 0x2, 0x2, 0x2a2, 0x2a3,
0x3, 0x2, 0x2, 0x2, 0x2a3, 0x2a1, 0x3, 0x2, 0x2, 0x2, 0x2a3, 0x2a4,
0x3, 0x2, 0x2, 0x2, 0x2a4, 0x55, 0x3, 0x2, 0x2, 0x2, 0x2a5, 0x2a6, 0x7,
0x32, 0x2, 0x2, 0x2a6, 0x2a8, 0x7, 0x3, 0x2, 0x2, 0x2a7, 0x2a9, 0xa,
0x4, 0x2, 0x2, 0x2a8, 0x2a7, 0x3, 0x2, 0x2, 0x2, 0x2a9, 0x2aa, 0x3,
0x2, 0x2, 0x2, 0x2aa, 0x2a8, 0x3, 0x2, 0x2, 0x2, 0x2aa, 0x2ab, 0x3,
0x2, 0x2, 0x2, 0x2ab, 0x57, 0x3, 0x2, 0x2, 0x2, 0x2ac, 0x2ad, 0x5, 0xb6,
0x5c, 0x2, 0x2ad, 0x2ae, 0x8, 0x2d, 0x1, 0x2, 0x2ae, 0x2b3, 0x3, 0x2,
0x2, 0x2, 0x2af, 0x2b0, 0x5, 0xb8, 0x5d, 0x2, 0x2b0, 0x2b1, 0x8, 0x2d,
0x1, 0x2, 0x2b1, 0x2b3, 0x3, 0x2, 0x2, 0x2, 0x2b2, 0x2ac, 0x3, 0x2,
0x2, 0x2, 0x2b2, 0x2af, 0x3, 0x2, 0x2, 0x2, 0x2b3, 0x59, 0x3, 0x2, 0x2,
0x2, 0x2b4, 0x2b5, 0x5, 0xba, 0x5e, 0x2, 0x2b5, 0x2b6, 0x8, 0x2e, 0x1,
0x2, 0x2b6, 0x5b, 0x3, 0x2, 0x2, 0x2, 0x2b7, 0x2b8, 0x5, 0xbc, 0x5f,
0x2, 0x2b8, 0x2b9, 0x8, 0x2f, 0x1, 0x2, 0x2b9, 0x2c1, 0x3, 0x2, 0x2,
0x2, 0x2ba, 0x2bb, 0x5, 0xbe, 0x60, 0x2, 0x2bb, 0x2bc, 0x8, 0x2f, 0x1,
0x2, 0x2bc, 0x2c1, 0x3, 0x2, 0x2, 0x2, 0x2bd, 0x2be, 0x5, 0xc0, 0x61,
0x2, 0x2be, 0x2bf, 0x8, 0x2f, 0x1, 0x2, 0x2bf, 0x2c1, 0x3, 0x2, 0x2,
0x2, 0x2c0, 0x2b7, 0x3, 0x2, 0x2, 0x2, 0x2c0, 0x2ba, 0x3, 0x2, 0x2,
0x2, 0x2c0, 0x2bd, 0x3, 0x2, 0x2, 0x2, 0x2c1, 0x5d, 0x3, 0x2, 0x2, 0x2,
0x2c2, 0x2c3, 0x5, 0xc2, 0x62, 0x2, 0x2c3, 0x2c4, 0x8, 0x30, 0x1, 0x2,
0x2c4, 0x2c9, 0x3, 0x2, 0x2, 0x2, 0x2c5, 0x2c6, 0x5, 0xc4, 0x63, 0x2,
0x2c6, 0x2c7, 0x8, 0x30, 0x1, 0x2, 0x2c7, 0x2c9, 0x3, 0x2, 0x2, 0x2,
0x2c8, 0x2c2, 0x3, 0x2, 0x2, 0x2, 0x2c8, 0x2c5, 0x3, 0x2, 0x2, 0x2,
0x2c9, 0x5f, 0x3, 0x2, 0x2, 0x2, 0x2ca, 0x2cb, 0x7, 0x32, 0x2, 0x2,
0x2cb, 0x2cd, 0x7, 0x4, 0x2, 0x2, 0x2cc, 0x2ce, 0xa, 0x4, 0x2, 0x2,
0x2cd, 0x2cc, 0x3, 0x2, 0x2, 0x2, 0x2ce, 0x2cf, 0x3, 0x2, 0x2, 0x2,
0x2cf, 0x2cd, 0x3, 0x2, 0x2, 0x2, 0x2cf, 0x2d0, 0x3, 0x2, 0x2, 0x2,
0x2d0, 0x61, 0x3, 0x2, 0x2, 0x2, 0x2d1, 0x2d2, 0x7, 0x32, 0x2, 0x2,
0x2d2, 0x2d4, 0x7, 0x4, 0x2, 0x2, 0x2d3, 0x2d5, 0xa, 0x4, 0x2, 0x2,
0x2d4, 0x2d3, 0x3, 0x2, 0x2, 0x2, 0x2d5, 0x2d6, 0x3, 0x2, 0x2, 0x2,
0x2d6, 0x2d4, 0x3, 0x2, 0x2, 0x2, 0x2d6, 0x2d7, 0x3, 0x2, 0x2, 0x2,
0x2d7, 0x63, 0x3, 0x2, 0x2, 0x2, 0x2d8, 0x2d9, 0x7, 0x32, 0x2, 0x2,
0x2d9, 0x2db, 0x7, 0x3, 0x2, 0x2, 0x2da, 0x2dc, 0xa, 0x4, 0x2, 0x2,
0x2db, 0x2da, 0x3, 0x2, 0x2, 0x2, 0x2dc, 0x2dd, 0x3, 0x2, 0x2, 0x2,
0x2dd, 0x2db, 0x3, 0x2, 0x2, 0x2, 0x2dd, 0x2de, 0x3, 0x2, 0x2, 0x2,
0x2de, 0x65, 0x3, 0x2, 0x2, 0x2, 0x2df, 0x2e0, 0x5, 0xc6, 0x64, 0x2,
0x2e0, 0x2e1, 0x8, 0x34, 0x1, 0x2, 0x2e1, 0x2ec, 0x3, 0x2, 0x2, 0x2,
0x2e2, 0x2e3, 0x5, 0xc8, 0x65, 0x2, 0x2e3, 0x2e4, 0x8, 0x34, 0x1, 0x2,
0x2e4, 0x2ec, 0x3, 0x2, 0x2, 0x2, 0x2e5, 0x2e6, 0x5, 0xca, 0x66, 0x2,
0x2e6, 0x2e7, 0x8, 0x34, 0x1, 0x2, 0x2e7, 0x2ec, 0x3, 0x2, 0x2, 0x2,
0x2e8, 0x2e9, 0x5, 0xcc, 0x67, 0x2, 0x2e9, 0x2ea, 0x8, 0x34, 0x1, 0x2,
0x2ea, 0x2ec, 0x3, 0x2, 0x2, 0x2, 0x2eb, 0x2df, 0x3, 0x2, 0x2, 0x2,
0x2eb, 0x2e2, 0x3, 0x2, 0x2, 0x2, 0x2eb, 0x2e5, 0x3, 0x2, 0x2, 0x2,
0x2eb, 0x2e8, 0x3, 0x2, 0x2, 0x2, 0x2ec, 0x67, 0x3, 0x2, 0x2, 0x2, 0x2ed,
0x2ee, 0x5, 0xce, 0x68, 0x2, 0x2ee, 0x2ef, 0x8, 0x35, 0x1, 0x2, 0x2ef,
0x69, 0x3, 0x2, 0x2, 0x2, 0x2f0, 0x2f1, 0x5, 0xd0, 0x69, 0x2, 0x2f1,
0x2f2, 0x8, 0x36, 0x1, 0x2, 0x2f2, 0x6b, 0x3, 0x2, 0x2, 0x2, 0x2f3,
0x2f4, 0x5, 0xd2, 0x6a, 0x2, 0x2f4, 0x2f5, 0x8, 0x37, 0x1, 0x2, 0x2f5,
0x6d, 0x3, 0x2, 0x2, 0x2, 0x2f6, 0x2f7, 0x5, 0xd4, 0x6b, 0x2, 0x2f7,
0x2f8, 0x8, 0x38, 0x1, 0x2, 0x2f8, 0x6f, 0x3, 0x2, 0x2, 0x2, 0x2f9,
0x2fa, 0x7, 0x32, 0x2, 0x2, 0x2fa, 0x2fc, 0x7, 0x4, 0x2, 0x2, 0x2fb,
0x2fd, 0xa, 0x4, 0x2, 0x2, 0x2fc, 0x2fb, 0x3, 0x2, 0x2, 0x2, 0x2fd,
0x2fe, 0x3, 0x2, 0x2, 0x2, 0x2fe, 0x2fc, 0x3, 0x2, 0x2, 0x2, 0x2fe,
0x2ff, 0x3, 0x2, 0x2, 0x2, 0x2ff, 0x71, 0x3, 0x2, 0x2, 0x2, 0x300, 0x301,
0x7, 0x32, 0x2, 0x2, 0x301, 0x303, 0x7, 0x3, 0x2, 0x2, 0x302, 0x304,
0xa, 0x4, 0x2, 0x2, 0x303, 0x302, 0x3, 0x2, 0x2, 0x2, 0x304, 0x305,
0x3, 0x2, 0x2, 0x2, 0x305, 0x303, 0x3, 0x2, 0x2, 0x2, 0x305, 0x306,
0x3, 0x2, 0x2, 0x2, 0x306, 0x73, 0x3, 0x2, 0x2, 0x2, 0x307, 0x308, 0x5,
0xd6, 0x6c, 0x2, 0x308, 0x309, 0x8, 0x3b, 0x1, 0x2, 0x309, 0x75, 0x3,
0x2, 0x2, 0x2, 0x30a, 0x30b, 0x5, 0xd8, 0x6d, 0x2, 0x30b, 0x30c, 0x8,
0x3c, 0x1, 0x2, 0x30c, 0x311, 0x3, 0x2, 0x2, 0x2, 0x30d, 0x30e, 0x5,
0xda, 0x6e, 0x2, 0x30e, 0x30f, 0x8, 0x3c, 0x1, 0x2, 0x30f, 0x311, 0x3,
0x2, 0x2, 0x2, 0x310, 0x30a, 0x3, 0x2, 0x2, 0x2, 0x310, 0x30d, 0x3,
0x2, 0x2, 0x2, 0x311, 0x77, 0x3, 0x2, 0x2, 0x2, 0x312, 0x313, 0x5, 0xdc,
0x6f, 0x2, 0x313, 0x314, 0x8, 0x3d, 0x1, 0x2, 0x314, 0x79, 0x3, 0x2,
0x2, 0x2, 0x315, 0x316, 0x5, 0xde, 0x70, 0x2, 0x316, 0x317, 0x8, 0x3e,
0x1, 0x2, 0x317, 0x7b, 0x3, 0x2, 0x2, 0x2, 0x318, 0x319, 0x5, 0xe0,
0x71, 0x2, 0x319, 0x31a, 0x8, 0x3f, 0x1, 0x2, 0x31a, 0x31f, 0x3, 0x2,
0x2, 0x2, 0x31b, 0x31c, 0x5, 0xe2, 0x72, 0x2, 0x31c, 0x31d, 0x8, 0x3f,
0x1, 0x2, 0x31d, 0x31f, 0x3, 0x2, 0x2, 0x2, 0x31e, 0x318, 0x3, 0x2,
0x2, 0x2, 0x31e, 0x31b, 0x3, 0x2, 0x2, 0x2, 0x31f, 0x7d, 0x3, 0x2, 0x2,
0x2, 0x320, 0x321, 0x5, 0xe4, 0x73, 0x2, 0x321, 0x322, 0x8, 0x40, 0x1,
0x2, 0x322, 0x7f, 0x3, 0x2, 0x2, 0x2, 0x323, 0x324, 0x5, 0xe6, 0x74,
0x2, 0x324, 0x325, 0x8, 0x41, 0x1, 0x2, 0x325, 0x32a, 0x3, 0x2, 0x2,
0x2, 0x326, 0x327, 0x5, 0xe8, 0x75, 0x2, 0x327, 0x328, 0x8, 0x41, 0x1,
0x2, 0x328, 0x32a, 0x3, 0x2, 0x2, 0x2, 0x329, 0x323, 0x3, 0x2, 0x2,
0x2, 0x329, 0x326, 0x3, 0x2, 0x2, 0x2, 0x32a, 0x81, 0x3, 0x2, 0x2, 0x2,
0x32b, 0x32c, 0x5, 0xea, 0x76, 0x2, 0x32c, 0x32d, 0x8, 0x42, 0x1, 0x2,
0x32d, 0x335, 0x3, 0x2, 0x2, 0x2, 0x32e, 0x32f, 0x5, 0xec, 0x77, 0x2,
0x32f, 0x330, 0x8, 0x42, 0x1, 0x2, 0x330, 0x335, 0x3, 0x2, 0x2, 0x2,
0x331, 0x332, 0x5, 0xee, 0x78, 0x2, 0x332, 0x333, 0x8, 0x42, 0x1, 0x2,
0x333, 0x335, 0x3, 0x2, 0x2, 0x2, 0x334, 0x32b, 0x3, 0x2, 0x2, 0x2,
0x334, 0x32e, 0x3, 0x2, 0x2, 0x2, 0x334, 0x331, 0x3, 0x2, 0x2, 0x2,
0x335, 0x83, 0x3, 0x2, 0x2, 0x2, 0x336, 0x337, 0x5, 0xf0, 0x79, 0x2,
0x337, 0x338, 0x8, 0x43, 0x1, 0x2, 0x338, 0x349, 0x3, 0x2, 0x2, 0x2,
0x339, 0x33a, 0x5, 0xf2, 0x7a, 0x2, 0x33a, 0x33b, 0x8, 0x43, 0x1, 0x2,
0x33b, 0x349, 0x3, 0x2, 0x2, 0x2, 0x33c, 0x33d, 0x5, 0xf4, 0x7b, 0x2,
0x33d, 0x33e, 0x8, 0x43, 0x1, 0x2, 0x33e, 0x349, 0x3, 0x2, 0x2, 0x2,
0x33f, 0x340, 0x5, 0xf6, 0x7c, 0x2, 0x340, 0x341, 0x8, 0x43, 0x1, 0x2,
0x341, 0x349, 0x3, 0x2, 0x2, 0x2, 0x342, 0x343, 0x5, 0xf8, 0x7d, 0x2,
0x343, 0x344, 0x8, 0x43, 0x1, 0x2, 0x344, 0x349, 0x3, 0x2, 0x2, 0x2,
0x345, 0x346, 0x5, 0xfa, 0x7e, 0x2, 0x346, 0x347, 0x8, 0x43, 0x1, 0x2,
0x347, 0x349, 0x3, 0x2, 0x2, 0x2, 0x348, 0x336, 0x3, 0x2, 0x2, 0x2,
0x348, 0x339, 0x3, 0x2, 0x2, 0x2, 0x348, 0x33c, 0x3, 0x2, 0x2, 0x2,
0x348, 0x33f, 0x3, 0x2, 0x2, 0x2, 0x348, 0x342, 0x3, 0x2, 0x2, 0x2,
0x348, 0x345, 0x3, 0x2, 0x2, 0x2, 0x349, 0x85, 0x3, 0x2, 0x2, 0x2, 0x34a,
0x34b, 0x5, 0xfc, 0x7f, 0x2, 0x34b, 0x34c, 0x8, 0x44, 0x1, 0x2, 0x34c,
0x87, 0x3, 0x2, 0x2, 0x2, 0x34d, 0x34e, 0x7, 0x32, 0x2, 0x2, 0x34e,
0x350, 0x7, 0x4, 0x2, 0x2, 0x34f, 0x351, 0xa, 0x4, 0x2, 0x2, 0x350,
0x34f, 0x3, 0x2, 0x2, 0x2, 0x351, 0x352, 0x3, 0x2, 0x2, 0x2, 0x352,
0x350, 0x3, 0x2, 0x2, 0x2, 0x352, 0x353, 0x3, 0x2, 0x2, 0x2, 0x353,
0x89, 0x3, 0x2, 0x2, 0x2, 0x354, 0x355, 0x7, 0x32, 0x2, 0x2, 0x355,
0x357, 0x7, 0x3, 0x2, 0x2, 0x356, 0x358, 0xa, 0x4, 0x2, 0x2, 0x357,
0x356, 0x3, 0x2, 0x2, 0x2, 0x358, 0x359, 0x3, 0x2, 0x2, 0x2, 0x359,
0x357, 0x3, 0x2, 0x2, 0x2, 0x359, 0x35a, 0x3, 0x2, 0x2, 0x2, 0x35a,
0x8b, 0x3, 0x2, 0x2, 0x2, 0x35b, 0x35c, 0x5, 0xfe, 0x80, 0x2, 0x35c,
0x35d, 0x8, 0x47, 0x1, 0x2, 0x35d, 0x8d, 0x3, 0x2, 0x2, 0x2, 0x35e,
0x35f, 0x5, 0x100, 0x81, 0x2, 0x35f, 0x360, 0x8, 0x48, 0x1, 0x2, 0x360,
0x368, 0x3, 0x2, 0x2, 0x2, 0x361, 0x362, 0x5, 0x102, 0x82, 0x2, 0x362,
0x363, 0x8, 0x48, 0x1, 0x2, 0x363, 0x368, 0x3, 0x2, 0x2, 0x2, 0x364,
0x365, 0x5, 0x104, 0x83, 0x2, 0x365, 0x366, 0x8, 0x48, 0x1, 0x2, 0x366,
0x368, 0x3, 0x2, 0x2, 0x2, 0x367, 0x35e, 0x3, 0x2, 0x2, 0x2, 0x367,
0x361, 0x3, 0x2, 0x2, 0x2, 0x367, 0x364, 0x3, 0x2, 0x2, 0x2, 0x368,
0x8f, 0x3, 0x2, 0x2, 0x2, 0x369, 0x36a, 0x7, 0x32, 0x2, 0x2, 0x36a,
0x36c, 0x7, 0x4, 0x2, 0x2, 0x36b, 0x36d, 0xa, 0x4, 0x2, 0x2, 0x36c,
0x36b, 0x3, 0x2, 0x2, 0x2, 0x36d, 0x36e, 0x3, 0x2, 0x2, 0x2, 0x36e,
0x36c, 0x3, 0x2, 0x2, 0x2, 0x36e, 0x36f, 0x3, 0x2, 0x2, 0x2, 0x36f,
0x91, 0x3, 0x2, 0x2, 0x2, 0x370, 0x371, 0x7, 0x32, 0x2, 0x2, 0x371,
0x373, 0x7, 0x5, 0x2, 0x2, 0x372, 0x374, 0xa, 0x4, 0x2, 0x2, 0x373,
0x372, 0x3, 0x2, 0x2, 0x2, 0x374, 0x375, 0x3, 0x2, 0x2, 0x2, 0x375,
0x373, 0x3, 0x2, 0x2, 0x2, 0x375, 0x376, 0x3, 0x2, 0x2, 0x2, 0x376,
0x93, 0x3, 0x2, 0x2, 0x2, 0x377, 0x378, 0x7, 0x32, 0x2, 0x2, 0x378,
0x37a, 0x7, 0x6, 0x2, 0x2, 0x379, 0x37b, 0xa, 0x4, 0x2, 0x2, 0x37a,
0x379, 0x3, 0x2, 0x2, 0x2, 0x37b, 0x37c, 0x3, 0x2, 0x2, 0x2, 0x37c,
0x37a, 0x3, 0x2, 0x2, 0x2, 0x37c, 0x37d, 0x3, 0x2, 0x2, 0x2, 0x37d,
0x95, 0x3, 0x2, 0x2, 0x2, 0x37e, 0x37f, 0x7, 0x32, 0x2, 0x2, 0x37f,
0x381, 0x7, 0x7, 0x2, 0x2, 0x380, 0x382, 0xa, 0x4, 0x2, 0x2, 0x381,
0x380, 0x3, 0x2, 0x2, 0x2, 0x382, 0x383, 0x3, 0x2, 0x2, 0x2, 0x383,
0x381, 0x3, 0x2, 0x2, 0x2, 0x383, 0x384, 0x3, 0x2, 0x2, 0x2, 0x384,
0x97, 0x3, 0x2, 0x2, 0x2, 0x385, 0x386, 0x7, 0x32, 0x2, 0x2, 0x386,
0x388, 0x7, 0x8, 0x2, 0x2, 0x387, 0x389, 0xa, 0x4, 0x2, 0x2, 0x388,
0x387, 0x3, 0x2, 0x2, 0x2, 0x389, 0x38a, 0x3, 0x2, 0x2, 0x2, 0x38a,
0x388, 0x3, 0x2, 0x2, 0x2, 0x38a, 0x38b, 0x3, 0x2, 0x2, 0x2, 0x38b,
0x99, 0x3, 0x2, 0x2, 0x2, 0x38c, 0x38d, 0x7, 0x32, 0x2, 0x2, 0x38d,
0x38f, 0x7, 0x9, 0x2, 0x2, 0x38e, 0x390, 0xa, 0x4, 0x2, 0x2, 0x38f,
0x38e, 0x3, 0x2, 0x2, 0x2, 0x390, 0x391, 0x3, 0x2, 0x2, 0x2, 0x391,
0x38f, 0x3, 0x2, 0x2, 0x2, 0x391, 0x392, 0x3, 0x2, 0x2, 0x2, 0x392,
0x9b, 0x3, 0x2, 0x2, 0x2, 0x393, 0x394, 0x7, 0x32, 0x2, 0x2, 0x394,
0x396, 0x7, 0x7, 0x2, 0x2, 0x395, 0x397, 0xa, 0x4, 0x2, 0x2, 0x396,
0x395, 0x3, 0x2, 0x2, 0x2, 0x397, 0x398, 0x3, 0x2, 0x2, 0x2, 0x398,
0x396, 0x3, 0x2, 0x2, 0x2, 0x398, 0x399, 0x3, 0x2, 0x2, 0x2, 0x399,
0x9d, 0x3, 0x2, 0x2, 0x2, 0x39a, 0x39b, 0x7, 0x32, 0x2, 0x2, 0x39b,
0x39d, 0x7, 0xa, 0x2, 0x2, 0x39c, 0x39e, 0xa, 0x4, 0x2, 0x2, 0x39d,
0x39c, 0x3, 0x2, 0x2, 0x2, 0x39e, 0x39f, 0x3, 0x2, 0x2, 0x2, 0x39f,
0x39d, 0x3, 0x2, 0x2, 0x2, 0x39f, 0x3a0, 0x3, 0x2, 0x2, 0x2, 0x3a0,
0x9f, 0x3, 0x2, 0x2, 0x2, 0x3a1, 0x3a2, 0x7, 0x32, 0x2, 0x2, 0x3a2,
0x3a4, 0x7, 0xb, 0x2, 0x2, 0x3a3, 0x3a5, 0xa, 0x4, 0x2, 0x2, 0x3a4,
0x3a3, 0x3, 0x2, 0x2, 0x2, 0x3a5, 0x3a6, 0x3, 0x2, 0x2, 0x2, 0x3a6,
0x3a4, 0x3, 0x2, 0x2, 0x2, 0x3a6, 0x3a7, 0x3, 0x2, 0x2, 0x2, 0x3a7,
0xa1, 0x3, 0x2, 0x2, 0x2, 0x3a8, 0x3a9, 0x7, 0x32, 0x2, 0x2, 0x3a9,
0x3ab, 0x7, 0x5, 0x2, 0x2, 0x3aa, 0x3ac, 0xa, 0x4, 0x2, 0x2, 0x3ab,
0x3aa, 0x3, 0x2, 0x2, 0x2, 0x3ac, 0x3ad, 0x3, 0x2, 0x2, 0x2, 0x3ad,
0x3ab, 0x3, 0x2, 0x2, 0x2, 0x3ad, 0x3ae, 0x3, 0x2, 0x2, 0x2, 0x3ae,
0xa3, 0x3, 0x2, 0x2, 0x2, 0x3af, 0x3b0, 0x7, 0x32, 0x2, 0x2, 0x3b0,
0x3b2, 0x7, 0xc, 0x2, 0x2, 0x3b1, 0x3b3, 0xa, 0x4, 0x2, 0x2, 0x3b2,
0x3b1, 0x3, 0x2, 0x2, 0x2, 0x3b3, 0x3b4, 0x3, 0x2, 0x2, 0x2, 0x3b4,
0x3b2, 0x3, 0x2, 0x2, 0x2, 0x3b4, 0x3b5, 0x3, 0x2, 0x2, 0x2, 0x3b5,
0xa5, 0x3, 0x2, 0x2, 0x2, 0x3b6, 0x3b7, 0x7, 0x32, 0x2, 0x2, 0x3b7,
0x3b9, 0x7, 0xd, 0x2, 0x2, 0x3b8, 0x3ba, 0xa, 0x4, 0x2, 0x2, 0x3b9,
0x3b8, 0x3, 0x2, 0x2, 0x2, 0x3ba, 0x3bb, 0x3, 0x2, 0x2, 0x2, 0x3bb,
0x3b9, 0x3, 0x2, 0x2, 0x2, 0x3bb, 0x3bc, 0x3, 0x2, 0x2, 0x2, 0x3bc,
0xa7, 0x3, 0x2, 0x2, 0x2, 0x3bd, 0x3be, 0x7, 0x32, 0x2, 0x2, 0x3be,
0x3c0, 0x7, 0x7, 0x2, 0x2, 0x3bf, 0x3c1, 0xa, 0x4, 0x2, 0x2, 0x3c0,
0x3bf, 0x3, 0x2, 0x2, 0x2, 0x3c1, 0x3c2, 0x3, 0x2, 0x2, 0x2, 0x3c2,
0x3c0, 0x3, 0x2, 0x2, 0x2, 0x3c2, 0x3c3, 0x3, 0x2, 0x2, 0x2, 0x3c3,
0xa9, 0x3, 0x2, 0x2, 0x2, 0x3c4, 0x3c5, 0x7, 0x32, 0x2, 0x2, 0x3c5,
0x3c7, 0x7, 0xe, 0x2, 0x2, 0x3c6, 0x3c8, 0xa, 0x4, 0x2, 0x2, 0x3c7,
0x3c6, 0x3, 0x2, 0x2, 0x2, 0x3c8, 0x3c9, 0x3, 0x2, 0x2, 0x2, 0x3c9,
0x3c7, 0x3, 0x2, 0x2, 0x2, 0x3c9, 0x3ca, 0x3, 0x2, 0x2, 0x2, 0x3ca,
0xab, 0x3, 0x2, 0x2, 0x2, 0x3cb, 0x3cc, 0x7, 0x32, 0x2, 0x2, 0x3cc,
0x3ce, 0x7, 0xf, 0x2, 0x2, 0x3cd, 0x3cf, 0xa, 0x4, 0x2, 0x2, 0x3ce,
0x3cd, 0x3, 0x2, 0x2, 0x2, 0x3cf, 0x3d0, 0x3, 0x2, 0x2, 0x2, 0x3d0,
0x3ce, 0x3, 0x2, 0x2, 0x2, 0x3d0, 0x3d1, 0x3, 0x2, 0x2, 0x2, 0x3d1,
0xad, 0x3, 0x2, 0x2, 0x2, 0x3d2, 0x3d3, 0x7, 0x32, 0x2, 0x2, 0x3d3,
0x3d5, 0x7, 0x10, 0x2, 0x2, 0x3d4, 0x3d6, 0xa, 0x4, 0x2, 0x2, 0x3d5,
0x3d4, 0x3, 0x2, 0x2, 0x2, 0x3d6, 0x3d7, 0x3, 0x2, 0x2, 0x2, 0x3d7,
0x3d5, 0x3, 0x2, 0x2, 0x2, 0x3d7, 0x3d8, 0x3, 0x2, 0x2, 0x2, 0x3d8,
0xaf, 0x3, 0x2, 0x2, 0x2, 0x3d9, 0x3da, 0x7, 0x32, 0x2, 0x2, 0x3da,
0x3dc, 0x7, 0x8, 0x2, 0x2, 0x3db, 0x3dd, 0xa, 0x4, 0x2, 0x2, 0x3dc,
0x3db, 0x3, 0x2, 0x2, 0x2, 0x3dd, 0x3de, 0x3, 0x2, 0x2, 0x2, 0x3de,
0x3dc, 0x3, 0x2, 0x2, 0x2, 0x3de, 0x3df, 0x3, 0x2, 0x2, 0x2, 0x3df,
0xb1, 0x3, 0x2, 0x2, 0x2, 0x3e0, 0x3e1, 0x7, 0x32, 0x2, 0x2, 0x3e1,
0x3e3, 0x7, 0x11, 0x2, 0x2, 0x3e2, 0x3e4, 0xa, 0x4, 0x2, 0x2, 0x3e3,
0x3e2, 0x3, 0x2, 0x2, 0x2, 0x3e4, 0x3e5, 0x3, 0x2, 0x2, 0x2, 0x3e5,
0x3e3, 0x3, 0x2, 0x2, 0x2, 0x3e5, 0x3e6, 0x3, 0x2, 0x2, 0x2, 0x3e6,
0xb3, 0x3, 0x2, 0x2, 0x2, 0x3e7, 0x3e8, 0x7, 0x32, 0x2, 0x2, 0x3e8,
0x3ea, 0x7, 0x12, 0x2, 0x2, 0x3e9, 0x3eb, 0xa, 0x4, 0x2, 0x2, 0x3ea,
0x3e9, 0x3, 0x2, 0x2, 0x2, 0x3eb, 0x3ec, 0x3, 0x2, 0x2, 0x2, 0x3ec,
0x3ea, 0x3, 0x2, 0x2, 0x2, 0x3ec, 0x3ed, 0x3, 0x2, 0x2, 0x2, 0x3ed,
0xb5, 0x3, 0x2, 0x2, 0x2, 0x3ee, 0x3ef, 0x7, 0x32, 0x2, 0x2, 0x3ef,
0x3f1, 0x7, 0x13, 0x2, 0x2, 0x3f0, 0x3f2, 0xa, 0x4, 0x2, 0x2, 0x3f1,
0x3f0, 0x3, 0x2, 0x2, 0x2, 0x3f2, 0x3f3, 0x3, 0x2, 0x2, 0x2, 0x3f3,
0x3f1, 0x3, 0x2, 0x2, 0x2, 0x3f3, 0x3f4, 0x3, 0x2, 0x2, 0x2, 0x3f4,
0xb7, 0x3, 0x2, 0x2, 0x2, 0x3f5, 0x3f6, 0x7, 0x32, 0x2, 0x2, 0x3f6,
0x3f8, 0x7, 0x14, 0x2, 0x2, 0x3f7, 0x3f9, 0xa, 0x4, 0x2, 0x2, 0x3f8,
0x3f7, 0x3, 0x2, 0x2, 0x2, 0x3f9, 0x3fa, 0x3, 0x2, 0x2, 0x2, 0x3fa,
0x3f8, 0x3, 0x2, 0x2, 0x2, 0x3fa, 0x3fb, 0x3, 0x2, 0x2, 0x2, 0x3fb,
0xb9, 0x3, 0x2, 0x2, 0x2, 0x3fc, 0x3fd, 0x7, 0x32, 0x2, 0x2, 0x3fd,
0x3ff, 0x7, 0x15, 0x2, 0x2, 0x3fe, 0x400, 0xa, 0x4, 0x2, 0x2, 0x3ff,
0x3fe, 0x3, 0x2, 0x2, 0x2, 0x400, 0x401, 0x3, 0x2, 0x2, 0x2, 0x401,
0x3ff, 0x3, 0x2, 0x2, 0x2, 0x401, 0x402, 0x3, 0x2, 0x2, 0x2, 0x402,
0xbb, 0x3, 0x2, 0x2, 0x2, 0x403, 0x404, 0x7, 0x32, 0x2, 0x2, 0x404,
0x406, 0x7, 0xd, 0x2, 0x2, 0x405, 0x407, 0xa, 0x4, 0x2, 0x2, 0x406,
0x405, 0x3, 0x2, 0x2, 0x2, 0x407, 0x408, 0x3, 0x2, 0x2, 0x2, 0x408,
0x406, 0x3, 0x2, 0x2, 0x2, 0x408, 0x409, 0x3, 0x2, 0x2, 0x2, 0x409,
0xbd, 0x3, 0x2, 0x2, 0x2, 0x40a, 0x40b, 0x7, 0x32, 0x2, 0x2, 0x40b,
0x40d, 0x7, 0x16, 0x2, 0x2, 0x40c, 0x40e, 0xa, 0x4, 0x2, 0x2, 0x40d,
0x40c, 0x3, 0x2, 0x2, 0x2, 0x40e, 0x40f, 0x3, 0x2, 0x2, 0x2, 0x40f,
0x40d, 0x3, 0x2, 0x2, 0x2, 0x40f, 0x410, 0x3, 0x2, 0x2, 0x2, 0x410,
0xbf, 0x3, 0x2, 0x2, 0x2, 0x411, 0x412, 0x7, 0x32, 0x2, 0x2, 0x412,
0x414, 0x7, 0x17, 0x2, 0x2, 0x413, 0x415, 0xa, 0x4, 0x2, 0x2, 0x414,
0x413, 0x3, 0x2, 0x2, 0x2, 0x415, 0x416, 0x3, 0x2, 0x2, 0x2, 0x416,
0x414, 0x3, 0x2, 0x2, 0x2, 0x416, 0x417, 0x3, 0x2, 0x2, 0x2, 0x417,
0xc1, 0x3, 0x2, 0x2, 0x2, 0x418, 0x419, 0x7, 0x32, 0x2, 0x2, 0x419,
0x41b, 0x7, 0x18, 0x2, 0x2, 0x41a, 0x41c, 0xa, 0x4, 0x2, 0x2, 0x41b,
0x41a, 0x3, 0x2, 0x2, 0x2, 0x41c, 0x41d, 0x3, 0x2, 0x2, 0x2, 0x41d,
0x41b, 0x3, 0x2, 0x2, 0x2, 0x41d, 0x41e, 0x3, 0x2, 0x2, 0x2, 0x41e,
0xc3, 0x3, 0x2, 0x2, 0x2, 0x41f, 0x420, 0x7, 0x32, 0x2, 0x2, 0x420,
0x422, 0x7, 0x19, 0x2, 0x2, 0x421, 0x423, 0xa, 0x4, 0x2, 0x2, 0x422,
0x421, 0x3, 0x2, 0x2, 0x2, 0x423, 0x424, 0x3, 0x2, 0x2, 0x2, 0x424,
0x422, 0x3, 0x2, 0x2, 0x2, 0x424, 0x425, 0x3, 0x2, 0x2, 0x2, 0x425,
0xc5, 0x3, 0x2, 0x2, 0x2, 0x426, 0x427, 0x7, 0x32, 0x2, 0x2, 0x427,
0x429, 0x7, 0x13, 0x2, 0x2, 0x428, 0x42a, 0xa, 0x4, 0x2, 0x2, 0x429,
0x428, 0x3, 0x2, 0x2, 0x2, 0x42a, 0x42b, 0x3, 0x2, 0x2, 0x2, 0x42b,
0x429, 0x3, 0x2, 0x2, 0x2, 0x42b, 0x42c, 0x3, 0x2, 0x2, 0x2, 0x42c,
0xc7, 0x3, 0x2, 0x2, 0x2, 0x42d, 0x42e, 0x7, 0x32, 0x2, 0x2, 0x42e,
0x430, 0x7, 0x14, 0x2, 0x2, 0x42f, 0x431, 0xa, 0x4, 0x2, 0x2, 0x430,
0x42f, 0x3, 0x2, 0x2, 0x2, 0x431, 0x432, 0x3, 0x2, 0x2, 0x2, 0x432,
0x430, 0x3, 0x2, 0x2, 0x2, 0x432, 0x433, 0x3, 0x2, 0x2, 0x2, 0x433,
0xc9, 0x3, 0x2, 0x2, 0x2, 0x434, 0x435, 0x7, 0x32, 0x2, 0x2, 0x435,
0x437, 0x7, 0x1a, 0x2, 0x2, 0x436, 0x438, 0xa, 0x4, 0x2, 0x2, 0x437,
0x436, 0x3, 0x2, 0x2, 0x2, 0x438, 0x439, 0x3, 0x2, 0x2, 0x2, 0x439,
0x437, 0x3, 0x2, 0x2, 0x2, 0x439, 0x43a, 0x3, 0x2, 0x2, 0x2, 0x43a,
0xcb, 0x3, 0x2, 0x2, 0x2, 0x43b, 0x43c, 0x7, 0x32, 0x2, 0x2, 0x43c,
0x43e, 0x7, 0x1b, 0x2, 0x2, 0x43d, 0x43f, 0xa, 0x4, 0x2, 0x2, 0x43e,
0x43d, 0x3, 0x2, 0x2, 0x2, 0x43f, 0x440, 0x3, 0x2, 0x2, 0x2, 0x440,
0x43e, 0x3, 0x2, 0x2, 0x2, 0x440, 0x441, 0x3, 0x2, 0x2, 0x2, 0x441,
0xcd, 0x3, 0x2, 0x2, 0x2, 0x442, 0x443, 0x7, 0x32, 0x2, 0x2, 0x443,
0x445, 0x7, 0x16, 0x2, 0x2, 0x444, 0x446, 0xa, 0x4, 0x2, 0x2, 0x445,
0x444, 0x3, 0x2, 0x2, 0x2, 0x446, 0x447, 0x3, 0x2, 0x2, 0x2, 0x447,
0x445, 0x3, 0x2, 0x2, 0x2, 0x447, 0x448, 0x3, 0x2, 0x2, 0x2, 0x448,
0xcf, 0x3, 0x2, 0x2, 0x2, 0x449, 0x44a, 0x7, 0x32, 0x2, 0x2, 0x44a,
0x44c, 0x7, 0x12, 0x2, 0x2, 0x44b, 0x44d, 0xa, 0x4, 0x2, 0x2, 0x44c,
0x44b, 0x3, 0x2, 0x2, 0x2, 0x44d, 0x44e, 0x3, 0x2, 0x2, 0x2, 0x44e,
0x44c, 0x3, 0x2, 0x2, 0x2, 0x44e, 0x44f, 0x3, 0x2, 0x2, 0x2, 0x44f,
0xd1, 0x3, 0x2, 0x2, 0x2, 0x450, 0x451, 0x7, 0x32, 0x2, 0x2, 0x451,
0x453, 0x7, 0x7, 0x2, 0x2, 0x452, 0x454, 0xa, 0x4, 0x2, 0x2, 0x453,
0x452, 0x3, 0x2, 0x2, 0x2, 0x454, 0x455, 0x3, 0x2, 0x2, 0x2, 0x455,
0x453, 0x3, 0x2, 0x2, 0x2, 0x455, 0x456, 0x3, 0x2, 0x2, 0x2, 0x456,
0xd3, 0x3, 0x2, 0x2, 0x2, 0x457, 0x458, 0x7, 0x32, 0x2, 0x2, 0x458,
0x45a, 0x7, 0x1c, 0x2, 0x2, 0x459, 0x45b, 0xa, 0x4, 0x2, 0x2, 0x45a,
0x459, 0x3, 0x2, 0x2, 0x2, 0x45b, 0x45c, 0x3, 0x2, 0x2, 0x2, 0x45c,
0x45a, 0x3, 0x2, 0x2, 0x2, 0x45c, 0x45d, 0x3, 0x2, 0x2, 0x2, 0x45d,
0xd5, 0x3, 0x2, 0x2, 0x2, 0x45e, 0x45f, 0x7, 0x32, 0x2, 0x2, 0x45f,
0x461, 0x7, 0xa, 0x2, 0x2, 0x460, 0x462, 0xa, 0x4, 0x2, 0x2, 0x461,
0x460, 0x3, 0x2, 0x2, 0x2, 0x462, 0x463, 0x3, 0x2, 0x2, 0x2, 0x463,
0x461, 0x3, 0x2, 0x2, 0x2, 0x463, 0x464, 0x3, 0x2, 0x2, 0x2, 0x464,
0xd7, 0x3, 0x2, 0x2, 0x2, 0x465, 0x466, 0x7, 0x32, 0x2, 0x2, 0x466,
0x468, 0x7, 0x7, 0x2, 0x2, 0x467, 0x469, 0xa, 0x4, 0x2, 0x2, 0x468,
0x467, 0x3, 0x2, 0x2, 0x2, 0x469, 0x46a, 0x3, 0x2, 0x2, 0x2, 0x46a,
0x468, 0x3, 0x2, 0x2, 0x2, 0x46a, 0x46b, 0x3, 0x2, 0x2, 0x2, 0x46b,
0xd9, 0x3, 0x2, 0x2, 0x2, 0x46c, 0x46d, 0x7, 0x32, 0x2, 0x2, 0x46d,
0x46f, 0x7, 0x1d, 0x2, 0x2, 0x46e, 0x470, 0xa, 0x4, 0x2, 0x2, 0x46f,
0x46e, 0x3, 0x2, 0x2, 0x2, 0x470, 0x471, 0x3, 0x2, 0x2, 0x2, 0x471,
0x46f, 0x3, 0x2, 0x2, 0x2, 0x471, 0x472, 0x3, 0x2, 0x2, 0x2, 0x472,
0xdb, 0x3, 0x2, 0x2, 0x2, 0x473, 0x474, 0x7, 0x32, 0x2, 0x2, 0x474,
0x476, 0x7, 0x10, 0x2, 0x2, 0x475, 0x477, 0xa, 0x4, 0x2, 0x2, 0x476,
0x475, 0x3, 0x2, 0x2, 0x2, 0x477, 0x478, 0x3, 0x2, 0x2, 0x2, 0x478,
0x476, 0x3, 0x2, 0x2, 0x2, 0x478, 0x479, 0x3, 0x2, 0x2, 0x2, 0x479,
0xdd, 0x3, 0x2, 0x2, 0x2, 0x47a, 0x47b, 0x7, 0x32, 0x2, 0x2, 0x47b,
0x47d, 0x7, 0xc, 0x2, 0x2, 0x47c, 0x47e, 0xa, 0x4, 0x2, 0x2, 0x47d,
0x47c, 0x3, 0x2, 0x2, 0x2, 0x47e, 0x47f, 0x3, 0x2, 0x2, 0x2, 0x47f,
0x47d, 0x3, 0x2, 0x2, 0x2, 0x47f, 0x480, 0x3, 0x2, 0x2, 0x2, 0x480,
0xdf, 0x3, 0x2, 0x2, 0x2, 0x481, 0x482, 0x7, 0x32, 0x2, 0x2, 0x482,
0x484, 0x7, 0x12, 0x2, 0x2, 0x483, 0x485, 0xa, 0x4, 0x2, 0x2, 0x484,
0x483, 0x3, 0x2, 0x2, 0x2, 0x485, 0x486, 0x3, 0x2, 0x2, 0x2, 0x486,
0x484, 0x3, 0x2, 0x2, 0x2, 0x486, 0x487, 0x3, 0x2, 0x2, 0x2, 0x487,
0xe1, 0x3, 0x2, 0x2, 0x2, 0x488, 0x489, 0x7, 0x32, 0x2, 0x2, 0x489,
0x48b, 0x7, 0x1e, 0x2, 0x2, 0x48a, 0x48c, 0xa, 0x4, 0x2, 0x2, 0x48b,
0x48a, 0x3, 0x2, 0x2, 0x2, 0x48c, 0x48d, 0x3, 0x2, 0x2, 0x2, 0x48d,
0x48b, 0x3, 0x2, 0x2, 0x2, 0x48d, 0x48e, 0x3, 0x2, 0x2, 0x2, 0x48e,
0xe3, 0x3, 0x2, 0x2, 0x2, 0x48f, 0x490, 0x7, 0x32, 0x2, 0x2, 0x490,
0x492, 0x7, 0x1f, 0x2, 0x2, 0x491, 0x493, 0xa, 0x4, 0x2, 0x2, 0x492,
0x491, 0x3, 0x2, 0x2, 0x2, 0x493, 0x494, 0x3, 0x2, 0x2, 0x2, 0x494,
0x492, 0x3, 0x2, 0x2, 0x2, 0x494, 0x495, 0x3, 0x2, 0x2, 0x2, 0x495,
0xe5, 0x3, 0x2, 0x2, 0x2, 0x496, 0x497, 0x7, 0x32, 0x2, 0x2, 0x497,
0x499, 0x7, 0x8, 0x2, 0x2, 0x498, 0x49a, 0xa, 0x4, 0x2, 0x2, 0x499,
0x498, 0x3, 0x2, 0x2, 0x2, 0x49a, 0x49b, 0x3, 0x2, 0x2, 0x2, 0x49b,
0x499, 0x3, 0x2, 0x2, 0x2, 0x49b, 0x49c, 0x3, 0x2, 0x2, 0x2, 0x49c,
0xe7, 0x3, 0x2, 0x2, 0x2, 0x49d, 0x49e, 0x7, 0x32, 0x2, 0x2, 0x49e,
0x4a0, 0x7, 0x9, 0x2, 0x2, 0x49f, 0x4a1, 0xa, 0x4, 0x2, 0x2, 0x4a0,
0x49f, 0x3, 0x2, 0x2, 0x2, 0x4a1, 0x4a2, 0x3, 0x2, 0x2, 0x2, 0x4a2,
0x4a0, 0x3, 0x2, 0x2, 0x2, 0x4a2, 0x4a3, 0x3, 0x2, 0x2, 0x2, 0x4a3,
0xe9, 0x3, 0x2, 0x2, 0x2, 0x4a4, 0x4a5, 0x7, 0x32, 0x2, 0x2, 0x4a5,
0x4a7, 0x7, 0x11, 0x2, 0x2, 0x4a6, 0x4a8, 0xa, 0x4, 0x2, 0x2, 0x4a7,
0x4a6, 0x3, 0x2, 0x2, 0x2, 0x4a8, 0x4a9, 0x3, 0x2, 0x2, 0x2, 0x4a9,
0x4a7, 0x3, 0x2, 0x2, 0x2, 0x4a9, 0x4aa, 0x3, 0x2, 0x2, 0x2, 0x4aa,
0xeb, 0x3, 0x2, 0x2, 0x2, 0x4ab, 0x4ac, 0x7, 0x32, 0x2, 0x2, 0x4ac,
0x4ae, 0x7, 0x20, 0x2, 0x2, 0x4ad, 0x4af, 0xa, 0x4, 0x2, 0x2, 0x4ae,
0x4ad, 0x3, 0x2, 0x2, 0x2, 0x4af, 0x4b0, 0x3, 0x2, 0x2, 0x2, 0x4b0,
0x4ae, 0x3, 0x2, 0x2, 0x2, 0x4b0, 0x4b1, 0x3, 0x2, 0x2, 0x2, 0x4b1,
0xed, 0x3, 0x2, 0x2, 0x2, 0x4b2, 0x4b3, 0x7, 0x32, 0x2, 0x2, 0x4b3,
0x4b5, 0x7, 0x21, 0x2, 0x2, 0x4b4, 0x4b6, 0xa, 0x4, 0x2, 0x2, 0x4b5,
0x4b4, 0x3, 0x2, 0x2, 0x2, 0x4b6, 0x4b7, 0x3, 0x2, 0x2, 0x2, 0x4b7,
0x4b5, 0x3, 0x2, 0x2, 0x2, 0x4b7, 0x4b8, 0x3, 0x2, 0x2, 0x2, 0x4b8,
0xef, 0x3, 0x2, 0x2, 0x2, 0x4b9, 0x4ba, 0x7, 0x32, 0x2, 0x2, 0x4ba,
0x4bc, 0x7, 0x22, 0x2, 0x2, 0x4bb, 0x4bd, 0xa, 0x4, 0x2, 0x2, 0x4bc,
0x4bb, 0x3, 0x2, 0x2, 0x2, 0x4bd, 0x4be, 0x3, 0x2, 0x2, 0x2, 0x4be,
0x4bc, 0x3, 0x2, 0x2, 0x2, 0x4be, 0x4bf, 0x3, 0x2, 0x2, 0x2, 0x4bf,
0xf1, 0x3, 0x2, 0x2, 0x2, 0x4c0, 0x4c1, 0x7, 0x32, 0x2, 0x2, 0x4c1,
0x4c3, 0x7, 0x23, 0x2, 0x2, 0x4c2, 0x4c4, 0xa, 0x4, 0x2, 0x2, 0x4c3,
0x4c2, 0x3, 0x2, 0x2, 0x2, 0x4c4, 0x4c5, 0x3, 0x2, 0x2, 0x2, 0x4c5,
0x4c3, 0x3, 0x2, 0x2, 0x2, 0x4c5, 0x4c6, 0x3, 0x2, 0x2, 0x2, 0x4c6,
0xf3, 0x3, 0x2, 0x2, 0x2, 0x4c7, 0x4c8, 0x7, 0x32, 0x2, 0x2, 0x4c8,
0x4ca, 0x7, 0x24, 0x2, 0x2, 0x4c9, 0x4cb, 0xa, 0x4, 0x2, 0x2, 0x4ca,
0x4c9, 0x3, 0x2, 0x2, 0x2, 0x4cb, 0x4cc, 0x3, 0x2, 0x2, 0x2, 0x4cc,
0x4ca, 0x3, 0x2, 0x2, 0x2, 0x4cc, 0x4cd, 0x3, 0x2, 0x2, 0x2, 0x4cd,
0xf5, 0x3, 0x2, 0x2, 0x2, 0x4ce, 0x4cf, 0x7, 0x32, 0x2, 0x2, 0x4cf,
0x4d1, 0x7, 0x25, 0x2, 0x2, 0x4d0, 0x4d2, 0xa, 0x4, 0x2, 0x2, 0x4d1,
0x4d0, 0x3, 0x2, 0x2, 0x2, 0x4d2, 0x4d3, 0x3, 0x2, 0x2, 0x2, 0x4d3,
0x4d1, 0x3, 0x2, 0x2, 0x2, 0x4d3, 0x4d4, 0x3, 0x2, 0x2, 0x2, 0x4d4,
0xf7, 0x3, 0x2, 0x2, 0x2, 0x4d5, 0x4d6, 0x7, 0x32, 0x2, 0x2, 0x4d6,
0x4d8, 0x7, 0x26, 0x2, 0x2, 0x4d7, 0x4d9, 0xa, 0x4, 0x2, 0x2, 0x4d8,
0x4d7, 0x3, 0x2, 0x2, 0x2, 0x4d9, 0x4da, 0x3, 0x2, 0x2, 0x2, 0x4da,
0x4d8, 0x3, 0x2, 0x2, 0x2, 0x4da, 0x4db, 0x3, 0x2, 0x2, 0x2, 0x4db,
0xf9, 0x3, 0x2, 0x2, 0x2, 0x4dc, 0x4dd, 0x7, 0x32, 0x2, 0x2, 0x4dd,
0x4df, 0x7, 0x27, 0x2, 0x2, 0x4de, 0x4e0, 0xa, 0x4, 0x2, 0x2, 0x4df,
0x4de, 0x3, 0x2, 0x2, 0x2, 0x4e0, 0x4e1, 0x3, 0x2, 0x2, 0x2, 0x4e1,
0x4df, 0x3, 0x2, 0x2, 0x2, 0x4e1, 0x4e2, 0x3, 0x2, 0x2, 0x2, 0x4e2,
0xfb, 0x3, 0x2, 0x2, 0x2, 0x4e3, 0x4e4, 0x7, 0x32, 0x2, 0x2, 0x4e4,
0x4e6, 0x7, 0x1c, 0x2, 0x2, 0x4e5, 0x4e7, 0xa, 0x4, 0x2, 0x2, 0x4e6,
0x4e5, 0x3, 0x2, 0x2, 0x2, 0x4e7, 0x4e8, 0x3, 0x2, 0x2, 0x2, 0x4e8,
0x4e6, 0x3, 0x2, 0x2, 0x2, 0x4e8, 0x4e9, 0x3, 0x2, 0x2, 0x2, 0x4e9,
0xfd, 0x3, 0x2, 0x2, 0x2, 0x4ea, 0x4eb, 0x7, 0x32, 0x2, 0x2, 0x4eb,
0x4ed, 0x7, 0x1c, 0x2, 0x2, 0x4ec, 0x4ee, 0xa, 0x4, 0x2, 0x2, 0x4ed,
0x4ec, 0x3, 0x2, 0x2, 0x2, 0x4ee, 0x4ef, 0x3, 0x2, 0x2, 0x2, 0x4ef,
0x4ed, 0x3, 0x2, 0x2, 0x2, 0x4ef, 0x4f0, 0x3, 0x2, 0x2, 0x2, 0x4f0,
0xff, 0x3, 0x2, 0x2, 0x2, 0x4f1, 0x4f2, 0x7, 0x32, 0x2, 0x2, 0x4f2,
0x4f4, 0x7, 0x13, 0x2, 0x2, 0x4f3, 0x4f5, 0xa, 0x4, 0x2, 0x2, 0x4f4,
0x4f3, 0x3, 0x2, 0x2, 0x2, 0x4f5, 0x4f6, 0x3, 0x2, 0x2, 0x2, 0x4f6,
0x4f4, 0x3, 0x2, 0x2, 0x2, 0x4f6, 0x4f7, 0x3, 0x2, 0x2, 0x2, 0x4f7,
0x101, 0x3, 0x2, 0x2, 0x2, 0x4f8, 0x4f9, 0x7, 0x32, 0x2, 0x2, 0x4f9,
0x4fb, 0x7, 0x28, 0x2, 0x2, 0x4fa, 0x4fc, 0xa, 0x4, 0x2, 0x2, 0x4fb,
0x4fa, 0x3, 0x2, 0x2, 0x2, 0x4fc, 0x4fd, 0x3, 0x2, 0x2, 0x2, 0x4fd,
0x4fb, 0x3, 0x2, 0x2, 0x2, 0x4fd, 0x4fe, 0x3, 0x2, 0x2, 0x2, 0x4fe,
0x103, 0x3, 0x2, 0x2, 0x2, 0x4ff, 0x500, 0x7, 0x32, 0x2, 0x2, 0x500,
0x502, 0x7, 0x14, 0x2, 0x2, 0x501, 0x503, 0xa, 0x4, 0x2, 0x2, 0x502,
0x501, 0x3, 0x2, 0x2, 0x2, 0x503, 0x504, 0x3, 0x2, 0x2, 0x2, 0x504,
0x502, 0x3, 0x2, 0x2, 0x2, 0x504, 0x505, 0x3, 0x2, 0x2, 0x2, 0x505,
0x105, 0x3, 0x2, 0x2, 0x2, 0x82, 0x109, 0x10d, 0x118, 0x121, 0x12e,
0x139, 0x13e, 0x146, 0x14b, 0x154, 0x15c, 0x162, 0x16c, 0x170, 0x17b,
0x17f, 0x18a, 0x18e, 0x192, 0x196, 0x19c, 0x1a3, 0x1aa, 0x1b4, 0x1ba,
0x1c0, 0x1cc, 0x1d2, 0x1db, 0x1e2, 0x1f0, 0x1f6, 0x1fb, 0x201, 0x206,
0x20a, 0x210, 0x217, 0x21e, 0x22a, 0x231, 0x23d, 0x24e, 0x255, 0x260,
0x26a, 0x271, 0x278, 0x282, 0x290, 0x2a3, 0x2aa, 0x2b2, 0x2c0, 0x2c8,
0x2cf, 0x2d6, 0x2dd, 0x2eb, 0x2fe, 0x305, 0x310, 0x31e, 0x329, 0x334,
0x348, 0x352, 0x359, 0x367, 0x36e, 0x375, 0x37c, 0x383, 0x38a, 0x391,
0x398, 0x39f, 0x3a6, 0x3ad, 0x3b4, 0x3bb, 0x3c2, 0x3c9, 0x3d0, 0x3d7,
0x3de, 0x3e5, 0x3ec, 0x3f3, 0x3fa, 0x401, 0x408, 0x40f, 0x416, 0x41d,
0x424, 0x42b, 0x432, 0x439, 0x440, 0x447, 0x44e, 0x455, 0x45c, 0x463,
0x46a, 0x471, 0x478, 0x47f, 0x486, 0x48d, 0x494, 0x49b, 0x4a2, 0x4a9,
0x4b0, 0x4b7, 0x4be, 0x4c5, 0x4cc, 0x4d3, 0x4da, 0x4e1, 0x4e8, 0x4ef,
0x4f6, 0x4fd, 0x504,
};
atn::ATNDeserializer deserializer;
_atn = deserializer.deserialize(_serializedATN);
size_t count = _atn.getNumberOfDecisions();
_decisionToDFA.reserve(count);
for (size_t i = 0; i < count; i++) {
_decisionToDFA.emplace_back(_atn.getDecisionState(i), i);
}
}
SwiftMtParser_MT565Parser::Initializer SwiftMtParser_MT565Parser::_init;
| 41.872182 | 156 | 0.687249 | Yanick-Salzmann |
0b5802c893bbbfe10573041bfe26a1141ed6e8a4 | 3,853 | cpp | C++ | SOFTWARE/A64-TERES/linux-a64/tools/gator/daemon/CapturedXML.cpp | xloem/DIY-LAPTOP | f2a410706f7a919ac644de073c570629d5601203 | [
"Apache-2.0"
] | null | null | null | SOFTWARE/A64-TERES/linux-a64/tools/gator/daemon/CapturedXML.cpp | xloem/DIY-LAPTOP | f2a410706f7a919ac644de073c570629d5601203 | [
"Apache-2.0"
] | null | null | null | SOFTWARE/A64-TERES/linux-a64/tools/gator/daemon/CapturedXML.cpp | xloem/DIY-LAPTOP | f2a410706f7a919ac644de073c570629d5601203 | [
"Apache-2.0"
] | 1 | 2021-10-31T18:37:47.000Z | 2021-10-31T18:37:47.000Z | /**
* Copyright (C) ARM Limited 2010-2014. All rights reserved.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 as
* published by the Free Software Foundation.
*/
#include "CapturedXML.h"
#include <stdlib.h>
#include <string.h>
#include <dirent.h>
#include "SessionData.h"
#include "Logging.h"
#include "OlyUtility.h"
CapturedXML::CapturedXML() {
}
CapturedXML::~CapturedXML() {
}
mxml_node_t* CapturedXML::getTree(bool includeTime) {
mxml_node_t *xml;
mxml_node_t *captured;
mxml_node_t *target;
int x;
xml = mxmlNewXML("1.0");
captured = mxmlNewElement(xml, "captured");
mxmlElementSetAttr(captured, "version", "1");
if (gSessionData->perf.isSetup()) {
mxmlElementSetAttr(captured, "type", "Perf");
mxmlElementSetAttr(captured, "perf_beta", "yes");
}
mxmlElementSetAttrf(captured, "protocol", "%d", PROTOCOL_VERSION);
if (includeTime) { // Send the following only after the capture is complete
if (time(NULL) > 1267000000) { // If the time is reasonable (after Feb 23, 2010)
mxmlElementSetAttrf(captured, "created", "%lu", time(NULL)); // Valid until the year 2038
}
}
target = mxmlNewElement(captured, "target");
mxmlElementSetAttr(target, "name", gSessionData->mCoreName);
mxmlElementSetAttrf(target, "sample_rate", "%d", gSessionData->mSampleRate);
mxmlElementSetAttrf(target, "cores", "%d", gSessionData->mCores);
mxmlElementSetAttrf(target, "cpuid", "0x%x", gSessionData->mMaxCpuId);
if (!gSessionData->mOneShot && (gSessionData->mSampleRate > 0)) {
mxmlElementSetAttr(target, "supports_live", "yes");
}
if (gSessionData->mLocalCapture) {
mxmlElementSetAttr(target, "local_capture", "yes");
}
mxml_node_t *counters = NULL;
for (x = 0; x < MAX_PERFORMANCE_COUNTERS; x++) {
const Counter & counter = gSessionData->mCounters[x];
if (counter.isEnabled()) {
if (counters == NULL) {
counters = mxmlNewElement(captured, "counters");
}
mxml_node_t *const node = mxmlNewElement(counters, "counter");
mxmlElementSetAttrf(node, "key", "0x%x", counter.getKey());
mxmlElementSetAttr(node, "type", counter.getType());
if (counter.getEvent() != -1) {
mxmlElementSetAttrf(node, "event", "0x%x", counter.getEvent());
}
if (counter.getCount() > 0) {
mxmlElementSetAttrf(node, "count", "%d", counter.getCount());
}
if (counter.getCores() > 0) {
mxmlElementSetAttrf(node, "cores", "%d", counter.getCores());
}
}
}
return xml;
}
char* CapturedXML::getXML(bool includeTime) {
char* xml_string;
mxml_node_t *xml = getTree(includeTime);
xml_string = mxmlSaveAllocString(xml, mxmlWhitespaceCB);
mxmlDelete(xml);
return xml_string;
}
void CapturedXML::write(char* path) {
char file[PATH_MAX];
// Set full path
snprintf(file, PATH_MAX, "%s/captured.xml", path);
char* xml = getXML(true);
if (util->writeToDisk(file, xml) < 0) {
logg->logError(__FILE__, __LINE__, "Error writing %s\nPlease verify the path.", file);
handleException();
}
free(xml);
}
// whitespace callback utility function used with mini-xml
const char * mxmlWhitespaceCB(mxml_node_t *node, int loc) {
const char *name;
name = mxmlGetElement(node);
if (loc == MXML_WS_BEFORE_OPEN) {
// Single indentation
if (!strcmp(name, "target") || !strcmp(name, "counters"))
return "\n ";
// Double indentation
if (!strcmp(name, "counter"))
return "\n ";
// Avoid a carriage return on the first line of the xml file
if (!strncmp(name, "?xml", 4))
return NULL;
// Default - no indentation
return "\n";
}
if (loc == MXML_WS_BEFORE_CLOSE) {
// No indentation
if (!strcmp(name, "captured"))
return "\n";
// Single indentation
if (!strcmp(name, "counters"))
return "\n ";
// Default - no carriage return
return NULL;
}
return NULL;
}
| 26.390411 | 92 | 0.683364 | xloem |
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 |
0b649ed96545aa7ecfc7370693c36b8a455d19be | 1,083 | hpp | C++ | 3rdParty/boost/1.71.0/libs/contract/test/check/audit.hpp | rajeev02101987/arangodb | 817e6c04cb82777d266f3b444494140676da98e2 | [
"Apache-2.0"
] | 12,278 | 2015-01-29T17:11:33.000Z | 2022-03-31T21:12:00.000Z | 3rdParty/boost/1.71.0/libs/contract/test/check/audit.hpp | rajeev02101987/arangodb | 817e6c04cb82777d266f3b444494140676da98e2 | [
"Apache-2.0"
] | 9,469 | 2015-01-30T05:33:07.000Z | 2022-03-31T16:17:21.000Z | 3rdParty/boost/1.71.0/libs/contract/test/check/audit.hpp | rajeev02101987/arangodb | 817e6c04cb82777d266f3b444494140676da98e2 | [
"Apache-2.0"
] | 892 | 2015-01-29T16:26:19.000Z | 2022-03-20T07:44:30.000Z |
// no #include guard
// Copyright (C) 2008-2018 Lorenzo Caminiti
// Distributed under the Boost Software License, Version 1.0 (see accompanying
// file LICENSE_1_0.txt or a copy at http://www.boost.org/LICENSE_1_0.txt).
// See: http://www.boost.org/doc/libs/release/libs/contract/doc/html/index.html
#include <boost/contract/check.hpp>
#include <boost/contract/core/exception.hpp>
#include <boost/detail/lightweight_test.hpp>
struct err {}; // Global decl so visible in MSVC10 lambdas.
int main() {
boost::contract::set_check_failure([] { throw err(); });
bool threw = false;
try {
#ifdef BOOST_CONTRACT_TEST_ERROR
BOOST_CONTRACT_CHECK_AUDIT(
BOOST_CONTRACT_TEST_ERROR_expected_undeclared_identifier);
#else
BOOST_CONTRACT_CHECK_AUDIT(false);
#endif
} catch(err const&) { threw = true; }
#if defined(BOOST_CONTRACT_AUDITS) && !defined(BOOST_CONTRACT_NO_CHECKS)
BOOST_TEST(threw);
#else
BOOST_TEST(!threw);
#endif
return boost::report_errors();
}
| 29.27027 | 79 | 0.674054 | rajeev02101987 |
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 |
0b66cec2a46ec93602a5e3e8a0af0b9eb21e402a | 2,041 | cpp | C++ | src/Entity/Player.cpp | zmeadows/aerocore | 15d68c6eebf42e9280c9b172c8fce970af7a30e8 | [
"MIT"
] | 2 | 2019-01-11T16:17:15.000Z | 2019-08-03T04:00:02.000Z | src/Entity/Player.cpp | zmeadows/aerocore | 15d68c6eebf42e9280c9b172c8fce970af7a30e8 | [
"MIT"
] | null | null | null | src/Entity/Player.cpp | zmeadows/aerocore | 15d68c6eebf42e9280c9b172c8fce970af7a30e8 | [
"MIT"
] | null | null | null | #include "Bullet/Bullet.hpp"
#include "Component/Common.hpp"
#include "Component/OffscreenBehavior.hpp"
#include "Engine/UUID.hpp"
#include "Engine/ComponentManager.hpp"
#include "Entity/Player.hpp"
#include "Geometry.hpp"
#include "SpriteCache.hpp"
#include "InputManager.hpp"
const UUID playerUUID(void) {
static UUID id;
return id;
}
void generate_player(ComponentManager* CM, SpriteCache* SC) {
Entity& player = CM->book<Entity>(playerUUID());
player.angle = PI/2.0;
CM->book<EulerTranslation>(playerUUID());
CM->book<EulerRotation>(playerUUID());
CM->book<FriendlyTag>(playerUUID());
CM->book<Health>(playerUUID());
SC->attach_sprite_to_uuid(CM, playerUUID(), "player_idle");
auto& osb = CM->book<OffscreenBehavior>(playerUUID());
osb.type = OffscreenBehavior::Type::Wraps;
}
void generate_player_bullet(ComponentManager* CM, AudioContext* AC, SpriteCache* SC, v2 bullet_direction) {
bullet_direction = bullet_direction.normalized();
const auto& entity = CM->get<Entity>(playerUUID());
const v2 bullet_pos = entity.pos + 4.0 * bullet_direction;
const v2 bullet_vel = 200.f * bullet_direction;
generate_bullet(CM, AC, SC, PLAYER_BULLET, bullet_pos, bullet_vel, true);
}
void tick_player(ComponentManager* CM,
AudioContext* AC,
SpriteCache* SC,
PlayerInput* input,
PlayerState* state,
f32 dt) {
if (state->shot_countdown > 0.f)
state->shot_countdown -= dt;
const bool player_wants_to_shoot = input->joystick_active[RIGHT_JOYSTICK];
if (player_wants_to_shoot && state->shot_countdown <= 0.f) {
generate_player_bullet(CM, AC, SC, input->joystick_state[RIGHT_JOYSTICK]);
state->shot_countdown += state->shot_delay;
}
auto& kin = CM->get<EulerTranslation>(playerUUID());
if (input->joystick_active[LEFT_JOYSTICK]) {
kin.vel = 90.f * input->joystick_state[LEFT_JOYSTICK];
} else {
kin.vel = { 0.f, 0.f };
}
}
| 31.4 | 107 | 0.66977 | zmeadows |
0b6757e591c969625f7db3e0b2b8b4bf0b842e60 | 410 | cpp | C++ | POJ/2773.cpp | claviering/code | 7019d50ff2e390696bc60358d1e39d9112f332e0 | [
"WTFPL"
] | 1 | 2017-12-16T13:55:04.000Z | 2017-12-16T13:55:04.000Z | POJ/2773.cpp | claviering/code | 7019d50ff2e390696bc60358d1e39d9112f332e0 | [
"WTFPL"
] | 1 | 2021-09-03T03:00:17.000Z | 2021-09-03T03:00:17.000Z | POJ/2773.cpp | claviering/code | 7019d50ff2e390696bc60358d1e39d9112f332e0 | [
"WTFPL"
] | 1 | 2016-12-19T16:35:13.000Z | 2016-12-19T16:35:13.000Z | #include <iostream>
using namespace std;
int main()
{
int t;
cin >> t;
int time = 1;
while (t--)
{
int n;
cin >> n;
int sum = 0;
for (int k = 1; k <= n; k++)
{
int tmp = (1 + k + 1) * (k + 1) / 2;
sum += k * tmp;
}
cout << time << " " << n << " " << sum << endl;
time++;
}
return 0;
}
| 17.083333 | 59 | 0.32439 | claviering |
0b69fc7528e3d8e46ff7f2fe4e6bfcadb1e6840c | 1,738 | hh | C++ | core/include/milan/core/Function.hh | matt-komm/milan-alpha | b6affa5541ca6b01384ab57256983a9fe7e1689c | [
"MIT"
] | null | null | null | core/include/milan/core/Function.hh | matt-komm/milan-alpha | b6affa5541ca6b01384ab57256983a9fe7e1689c | [
"MIT"
] | null | null | null | core/include/milan/core/Function.hh | matt-komm/milan-alpha | b6affa5541ca6b01384ab57256983a9fe7e1689c | [
"MIT"
] | null | null | null | #ifndef __MILAN_CORE_FUNCTION_H__
#define __MILAN_CORE_FUNCTION_H__
#include "milan/core/Types.hh"
#include "milan/core/Ptr.hh"
#include "milan/core/Parameter.hh"
#include <string>
namespace milan
{
class Function:
public FunctionInterface
{
protected:
Ptr<const FunctionInterface> _fctPtr;
public:
Function(const Function& function):
_fctPtr(function._fctPtr)
{
}
Function(Function&& function):
_fctPtr(std::move(function._fctPtr))
{
}
Function& operator=(const Function& function)
{
_fctPtr = function._fctPtr;
return *this;
}
Function& operator=(Function&& function)
{
_fctPtr = std::move(function._fctPtr);
return *this;
}
Function(const Ptr<const FunctionInterface>& fctPtr):
_fctPtr(fctPtr)
{
}
Function& operator=(const Ptr<const FunctionInterface>& fctPtr)
{
_fctPtr = fctPtr;
return *this;
}
const inline Ptr<const FunctionInterface>& getPtr() const
{
return _fctPtr;
}
virtual double getValue() const
{
return _fctPtr->getValue();
}
virtual double getDerivative(const Ptr<Parameter>& parameter) const
{
return _fctPtr->getDerivative(parameter);
}
virtual std::vector<double> getValueAndDerivatives(const std::vector<Ptr<Parameter>>& parameters) const
{
return _fctPtr->getValueAndDerivatives(parameters);
}
};
}
#endif
| 22 | 111 | 0.548331 | matt-komm |
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 |
0b6d4b4a35199edc44768ac8739ce58567b00f92 | 2,464 | hpp | C++ | src/reflection/type/ptr/duplicator.hpp | dmilos/reflection | 0d190d4c625f80dab2d0fde10914365695d2bcc7 | [
"Apache-2.0"
] | 2 | 2020-09-04T13:11:04.000Z | 2021-01-28T02:39:38.000Z | src/reflection/type/ptr/duplicator.hpp | dmilos/reflection | 0d190d4c625f80dab2d0fde10914365695d2bcc7 | [
"Apache-2.0"
] | 1 | 2018-12-31T10:01:19.000Z | 2018-12-31T10:01:19.000Z | src/reflection/type/ptr/duplicator.hpp | dmilos/reflection | 0d190d4c625f80dab2d0fde10914365695d2bcc7 | [
"Apache-2.0"
] | 1 | 2020-09-04T11:00:15.000Z | 2020-09-04T11:00:15.000Z | #ifndef Dh_DDMRM_memory_functor_duplicate_basic_HPP_
#define Dh_DDMRM_memory_functor_duplicate_basic_HPP_
#ifndef TEMPLATE
#ifdef __GNUC__
#define TEMPLATE template
#else
#define TEMPLATE
#endif
#endif
namespace memory
{
namespace pointer
{
template
<
typename base_name
>
class duplicator
{
public:
typedef base_name base_type;
typedef bool (*raw_type)( base_name **, base_name const * );
duplicator():m_raw(NULL){ }
template< typename derive_type, typename allocator_type >
duplicator( derive_type , allocator_type )
{
this->template operator()<derive_type, allocator_type>( );
}
~duplicator(){ ; }
template< typename derive_type, typename allocator_type >
void operator()( void )const
{
// TODO m_raw = &GF_general< base_type, derive_type, allocator_type, bool >;
}
template< typename derive_type >
bool operator()( base_type ** P_base, derive_type const* P_model )const
{
//std::cout << "duplicate::basic::operator()<"<<typeid( derive_type ).name() <<">" << std::endl;
this->TEMPLATE operator()<derive_type, std::allocator< derive_type > >( );
return Fvc_process( P_base, P_model );
}
public:
bool operator() ( base_type **P_copy, base_type const* P_model )const
{
if( NULL != raw() )
{
return (*raw())( P_copy, P_model );
}
if( ( NULL == P_model ) && ( NULL != P_copy ) )
{
//! by definition: (ptr=NULL;) <=> ( delete ptr; )
delete *P_copy; //!< weak point;
*P_copy = NULL;
return bool( true );
}
//this->TEMPLATE operator()< base_type, std::allocator<base_type > >( ); zbog cisto virtuelnih klasa
return bool( false );
}
public:
raw_type const& raw( void ) const{ return m_raw; }
bool raw( raw_type const& P_raw ) { m_raw = P_raw; return bool( true ); }
protected:
raw_type & F1_raw( void ) { return m_raw; }
private:
mutable raw_type m_raw;
};
}
}
#endif
| 27.377778 | 112 | 0.513393 | dmilos |
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 (vdv_b@tgui.eu)
//
// 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 |
0b74a396bf0ffe49395feb5f649f84039cf75c1d | 1,005 | hpp | C++ | TextHelper/U8g2.hpp | Finomnis/ArduinoUtilities | 4d617486398a186b9bfeaa0c2f088f995a021672 | [
"MIT"
] | null | null | null | TextHelper/U8g2.hpp | Finomnis/ArduinoUtilities | 4d617486398a186b9bfeaa0c2f088f995a021672 | [
"MIT"
] | null | null | null | TextHelper/U8g2.hpp | Finomnis/ArduinoUtilities | 4d617486398a186b9bfeaa0c2f088f995a021672 | [
"MIT"
] | null | null | null | #pragma once
#include "common.hpp"
#include <U8g2lib.h>
namespace TextHelper
{
namespace impl
{
template <>
class TextWritingDisplayImpl<U8G2> : public TextWritingDisplay
{
public:
constexpr TextWritingDisplayImpl(U8G2 &display) : display{display} {}
inline void setCursor(int16_t x, int16_t y) override
{
display.setCursor(x, y);
}
inline void print(const char *text) override
{
display.print(text);
}
inline void getTextBounds(const char *text, int16_t *x, int16_t *y, uint16_t *width, uint16_t *height) override
{
*width = display.getStrWidth(text);
*height = uint16_t(int16_t(display.getAscent()) - int16_t(display.getDescent()));
*x = 0;
*y = -int16_t(display.getAscent());
}
private:
U8G2 &display;
};
}
}
| 26.447368 | 123 | 0.527363 | Finomnis |
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 |
0b7a100456536af92e05f44121b290c6e607a821 | 2,720 | cpp | C++ | code_reading/oceanbase-master/src/storage/transaction/ob_trans_ctx_lock.cpp | wangcy6/weekly_read | 3a8837ee9cd957787ee1785e4066dd623e02e13a | [
"Apache-2.0"
] | null | null | null | code_reading/oceanbase-master/src/storage/transaction/ob_trans_ctx_lock.cpp | wangcy6/weekly_read | 3a8837ee9cd957787ee1785e4066dd623e02e13a | [
"Apache-2.0"
] | null | null | null | code_reading/oceanbase-master/src/storage/transaction/ob_trans_ctx_lock.cpp | wangcy6/weekly_read | 3a8837ee9cd957787ee1785e4066dd623e02e13a | [
"Apache-2.0"
] | 1 | 2020-10-18T12:59:31.000Z | 2020-10-18T12:59:31.000Z | /**
* Copyright (c) 2021 OceanBase
* OceanBase CE is licensed under Mulan PubL v2.
* You can use this software according to the terms and conditions of the Mulan PubL v2.
* You may obtain a copy of Mulan PubL v2 at:
* http://license.coscl.org.cn/MulanPubL-2.0
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PubL v2 for more details.
*/
#include "ob_trans_ctx_lock.h"
#include "ob_trans_ctx.h"
#include "ob_trans_service.h"
namespace oceanbase {
using namespace common;
using namespace storage;
using namespace obrpc;
namespace transaction {
int CtxLock::init(ObTransCtx* ctx)
{
int ret = OB_SUCCESS;
if (OB_ISNULL(ctx)) {
TRANS_LOG(WARN, "invalid argument", KP(ctx));
ret = OB_INVALID_ARGUMENT;
} else {
ctx_ = ctx;
}
return ret;
}
void CtxLock::reset()
{
ctx_ = NULL;
}
void CtxLock::before_unlock(CtxLockArg& arg)
{
if (NULL != ctx_) {
ctx_->before_unlock(arg);
}
}
void CtxLock::after_unlock(CtxLockArg& arg)
{
if (NULL != ctx_) {
ctx_->after_unlock(arg);
}
}
int CtxLock::lock()
{
return lock_.wrlock(common::ObLatchIds::TRANS_CTX_LOCK);
}
int CtxLock::lock(const int64_t timeout_us)
{
return lock_.wrlock(common::ObLatchIds::TRANS_CTX_LOCK, ObTimeUtility::current_time() + timeout_us);
}
int CtxLock::try_lock()
{
return lock_.try_wrlock(common::ObLatchIds::TRANS_CTX_LOCK);
}
void CtxLock::unlock()
{
CtxLockArg arg;
before_unlock(arg);
lock_.unlock();
after_unlock(arg);
}
CtxLockGuard::~CtxLockGuard()
{
reset();
}
void CtxLockGuard::set(CtxLock& lock)
{
reset();
lock_ = &lock;
lock_->lock();
}
void CtxLockGuard::reset()
{
if (NULL != lock_) {
lock_->unlock();
lock_ = NULL;
}
}
void TransTableSeqLock::write_lock()
{
seq_++;
MEM_BARRIER();
}
void TransTableSeqLock::write_unlock()
{
MEM_BARRIER();
if (seq_ & 1L) {
seq_++;
}
}
uint64_t TransTableSeqLock::read_begin()
{
uint64_t seq = ATOMIC_LOAD(&seq_);
MEM_BARRIER();
return seq;
}
bool TransTableSeqLock::read_retry(const uint64_t seq)
{
MEM_BARRIER();
if (ATOMIC_LOAD(&seq_) != seq) {
return true;
}
return seq & 1L;
}
CtxTransTableLockGuard::~CtxTransTableLockGuard()
{
reset();
}
void CtxTransTableLockGuard::set(CtxLock& lock, TransTableSeqLock& seqlock)
{
reset();
CtxLockGuard::set(lock);
lock_ = &seqlock;
lock_->write_lock();
}
void CtxTransTableLockGuard::reset()
{
if (lock_) {
lock_->write_unlock();
lock_ = NULL;
}
CtxLockGuard::reset();
}
} // namespace transaction
} // namespace oceanbase
| 17.662338 | 102 | 0.684191 | wangcy6 |
0b7a7319836f9aa3d2ee9a882cd08869752e3bd5 | 30,794 | cpp | C++ | sumo/src/microsim/cfmodels/MSCFModel.cpp | iltempe/osmosi | c0f54ecdbb7c7b5602d587768617d0dc50f1d75d | [
"MIT"
] | null | null | null | sumo/src/microsim/cfmodels/MSCFModel.cpp | iltempe/osmosi | c0f54ecdbb7c7b5602d587768617d0dc50f1d75d | [
"MIT"
] | null | null | null | sumo/src/microsim/cfmodels/MSCFModel.cpp | iltempe/osmosi | c0f54ecdbb7c7b5602d587768617d0dc50f1d75d | [
"MIT"
] | 2 | 2017-12-14T16:41:59.000Z | 2020-10-16T17:51:27.000Z | /****************************************************************************/
/// @file MSCFModel.cpp
/// @author Tobias Mayer
/// @author Daniel Krajzewicz
/// @author Jakob Erdmann
/// @author Michael Behrisch
/// @author Laura Bieker
/// @author Leonhard Lücken
/// @date Mon, 27 Jul 2009
/// @version $Id$
///
// The car-following model abstraction
/****************************************************************************/
// SUMO, Simulation of Urban MObility; see http://sumo.dlr.de/
// Copyright (C) 2001-2017 DLR (http://www.dlr.de/) and contributors
/****************************************************************************/
//
// This file is part of SUMO.
// SUMO is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
/****************************************************************************/
// ===========================================================================
// included modules
// ===========================================================================
#ifdef _MSC_VER
#include <windows_config.h>
#else
#include <config.h>
#endif
#include <cmath>
#include <microsim/MSGlobals.h>
#include <microsim/MSVehicleType.h>
#include <microsim/MSVehicle.h>
#include <microsim/MSLane.h>
#include <microsim/lcmodels/MSAbstractLaneChangeModel.h>
#include "MSCFModel.h"
// ===========================================================================
// method definitions
// ===========================================================================
MSCFModel::MSCFModel(const MSVehicleType* vtype, double accel,
double decel, double emergencyDecel, double apparentDecel, double headwayTime) :
myType(vtype),
myAccel(accel),
myDecel(decel),
myEmergencyDecel(emergencyDecel),
myApparentDecel(apparentDecel),
myHeadwayTime(headwayTime) {
}
MSCFModel::~MSCFModel() {}
MSCFModel::VehicleVariables::~VehicleVariables() {}
double
MSCFModel::brakeGap(const double speed, const double decel, const double headwayTime) {
if (MSGlobals::gSemiImplicitEulerUpdate) {
return brakeGapEuler(speed, decel, headwayTime);
} else {
// ballistic
if (speed <= 0) {
return 0.;
} else {
return speed * (headwayTime + 0.5 * speed / decel);
}
}
}
double
MSCFModel::brakeGapEuler(const double speed, const double decel, const double headwayTime) {
/* one possibility to speed this up is to calculate speedReduction * steps * (steps+1) / 2
for small values of steps (up to 10 maybe) and store them in an array */
const double speedReduction = ACCEL2SPEED(decel);
const int steps = int(speed / speedReduction);
return SPEED2DIST(steps * speed - speedReduction * steps * (steps + 1) / 2) + speed * headwayTime;
}
double
MSCFModel::freeSpeed(const double currentSpeed, const double decel, const double dist, const double targetSpeed, const bool onInsertion) {
// XXX: (Leo) This seems to be exclusively called with decel = myDecel (max deceleration) and is not overridden
// by any specific CFModel. That may cause undesirable hard braking (at junctions where the vehicle
// changes to a road with a lower speed limit).
if (MSGlobals::gSemiImplicitEulerUpdate) {
// adapt speed to succeeding lane, no reaction time is involved
// when breaking for y steps the following distance g is covered
// (drive with v in the final step)
// g = (y^2 + y) * 0.5 * b + y * v
// y = ((((sqrt((b + 2.0*v)*(b + 2.0*v) + 8.0*b*g)) - b)*0.5 - v)/b)
const double v = SPEED2DIST(targetSpeed);
if (dist < v) {
return targetSpeed;
}
const double b = ACCEL2DIST(decel);
const double y = MAX2(0.0, ((sqrt((b + 2.0 * v) * (b + 2.0 * v) + 8.0 * b * dist) - b) * 0.5 - v) / b);
const double yFull = floor(y);
const double exactGap = (yFull * yFull + yFull) * 0.5 * b + yFull * v + (y > yFull ? v : 0.0);
const double fullSpeedGain = (yFull + (onInsertion ? 1. : 0.)) * ACCEL2SPEED(decel);
return DIST2SPEED(MAX2(0.0, dist - exactGap) / (yFull + 1)) + fullSpeedGain + targetSpeed;
} else {
// ballistic update (Leo)
// calculate maximum next speed vN that is adjustable to vT=targetSpeed after a distance d=dist
// and given a maximal deceleration b=decel, denote the current speed by v0.
// the distance covered by a trajectory that attains vN in the next timestep and decelerates afterwards
// with b is given as
// d = 0.5*dt*(v0+vN) + (t-dt)*vN - 0.5*b*(t-dt)^2, (1)
// where time t of arrival at d with speed vT is
// t = dt + (vN-vT)/b. (2)
// We insert (2) into (1) to obtain
// d = 0.5*dt*(v0+vN) + vN*(vN-vT)/b - 0.5*b*((vN-vT)/b)^2
// 0 = (dt*b*v0 - vT*vT - 2*b*d) + dt*b*vN + vN*vN
// and solve for vN
assert(currentSpeed >= 0);
assert(targetSpeed >= 0);
const double dt = onInsertion ? 0 : TS; // handles case that vehicle is inserted just now (at the end of move)
const double v0 = currentSpeed;
const double vT = targetSpeed;
const double b = decel;
const double d = dist - NUMERICAL_EPS; // prevent returning a value > targetSpeed due to rounding errors
// Solvability for positive vN (if d is small relative to v0):
// 1) If 0.5*(v0+vT)*dt > d, we set vN=vT.
// (In case vT<v0, this implies that on the interpolated trajectory there are points beyond d where
// the interpolated velocity is larger than vT, but at least on the temporal discretization grid, vT is not exceeded)
// 2) We ignore the (possible) constraint vN >= v0 - b*dt, which could lead to a problem if v0 - t*b > vT.
// (moveHelper() is responsible for assuring that the next velocity is chosen in accordance with maximal decelerations)
if (0.5 * (v0 + vT)*dt >= d) {
return vT; // (#)
}
const double q = ((dt * v0 - 2 * d) * b - vT * vT); // (q < 0 is fulfilled because of (#))
const double p = 0.5 * b * dt;
return -p + sqrt(p * p - q);
}
}
double
MSCFModel::moveHelper(MSVehicle* const veh, double vPos) const {
const double oldV = veh->getSpeed(); // save old v for optional acceleration computation
const double vSafe = MIN2(vPos, veh->processNextStop(vPos)); // process stops
// we need the acceleration for emission computation;
// in this case, we neglect dawdling, nonetheless, using
// vSafe does not incorporate speed reduction due to interaction
// on lane changing
double vMin, vNext;
const double vMax = MIN3(veh->getMaxSpeedOnLane(), maxNextSpeed(oldV, veh), vSafe);
if (MSGlobals::gSemiImplicitEulerUpdate) {
// we cannot rely on never braking harder than maxDecel because TraCI or strange cf models may decide to do so
// vMin = MIN2(getSpeedAfterMaxDecel(oldV), vMax);
vMin = MIN2(minNextSpeed(oldV, veh), vMax);
vNext = veh->getLaneChangeModel().patchSpeed(vMin, vMax, vMax, *this);
} else {
// for ballistic update, negative vnext must be allowed to
// indicate a stop within the coming timestep (i.e., to attain negative values)
vMin = MIN2(minNextSpeed(oldV, veh), vMax);
vNext = veh->getLaneChangeModel().patchSpeed(vMin, vMax, vMax, *this);
// (Leo) moveHelper() is responsible for assuring that the next
// velocity is chosen in accordance with maximal decelerations.
// At this point vNext may also be negative indicating a stop within next step.
// Moreover, because maximumSafeStopSpeed() does not consider deceleration bounds
// vNext can be a large negative value at this point. We cap vNext here.
vNext = MAX2(vNext, vMin);
}
return vNext;
}
double
MSCFModel::interactionGap(const MSVehicle* const veh, double vL) const {
// Resolve the vsafe equation to gap. Assume predecessor has
// speed != 0 and that vsafe will be the current speed plus acceleration,
// i.e that with this gap there will be no interaction.
const double vNext = MIN2(maxNextSpeed(veh->getSpeed(), veh), veh->getLane()->getVehicleMaxSpeed(veh));
const double gap = (vNext - vL) *
((veh->getSpeed() + vL) / (2.*myDecel) + myHeadwayTime) +
vL * myHeadwayTime;
// Don't allow timeHeadWay < deltaT situations.
return MAX2(gap, SPEED2DIST(vNext));
}
double
MSCFModel::maxNextSpeed(double speed, const MSVehicle* const /*veh*/) const {
return MIN2(speed + (double) ACCEL2SPEED(getMaxAccel()), myType->getMaxSpeed());
}
double
MSCFModel::minNextSpeed(double speed, const MSVehicle* const /*veh*/) const {
if (MSGlobals::gSemiImplicitEulerUpdate) {
// return MAX2(speed - ACCEL2SPEED(getMaxDecel()), 0.);
return MAX2(speed - ACCEL2SPEED(myEmergencyDecel), 0.);
} else {
// NOTE: ballistic update allows for negative speeds to indicate a stop within the next timestep
// return speed - ACCEL2SPEED(getMaxDecel());
return speed - ACCEL2SPEED(myEmergencyDecel);
}
}
double
MSCFModel::freeSpeed(const MSVehicle* const /* veh */, double speed, double seen, double maxSpeed, const bool onInsertion) const {
double vSafe = freeSpeed(speed, myDecel, seen, maxSpeed, onInsertion);
return vSafe;
}
double
MSCFModel::insertionFollowSpeed(const MSVehicle* const /* v */, double speed, double gap2pred, double predSpeed, double predMaxDecel) const {
if (MSGlobals::gSemiImplicitEulerUpdate) {
return maximumSafeFollowSpeed(gap2pred, speed, predSpeed, predMaxDecel);
} else {
// NOTE: Even for ballistic update, the current speed is irrelevant at insertion, therefore passing 0. (Leo)
return maximumSafeFollowSpeed(gap2pred, 0., predSpeed, predMaxDecel, true);
}
}
double
MSCFModel::insertionStopSpeed(const MSVehicle* const veh, double speed, double gap) const {
if (MSGlobals::gSemiImplicitEulerUpdate) {
return stopSpeed(veh, speed, gap);
} else {
return MIN2(maximumSafeStopSpeed(gap, 0., true, 0.), myType->getMaxSpeed());
}
}
double
MSCFModel::followSpeedTransient(double duration, const MSVehicle* const /*veh*/, double /*speed*/, double gap2pred, double predSpeed, double predMaxDecel) const {
// minimium distance covered by the leader if braking
double leaderMinDist = gap2pred + distAfterTime(duration, predSpeed, predMaxDecel);
// if ego would not brake it could drive with speed leaderMinDist / duration
// due to potentential ego braking it can safely drive faster
if (MSGlobals::gSemiImplicitEulerUpdate) {
// number of potential braking steps
int a = (int)ceil(duration / TS - TS);
// can we brake for the whole time?
const double bg = brakeGap(a * myDecel, myDecel, 0);
if (bg <= leaderMinDist) {
// braking continuously for duration
// distance reduction due to braking
double b = TS * getMaxDecel() * 0.5 * (a * a - a);
if (gDebugFlag2) std::cout << " followSpeedTransient"
<< " duration=" << duration
<< " gap=" << gap2pred
<< " leaderMinDist=" << leaderMinDist
<< " decel=" << getMaxDecel()
<< " a=" << a
<< " bg=" << bg
<< " b=" << b
<< " x=" << (b + leaderMinDist) / duration
<< "\n";
return (b + leaderMinDist) / duration;
} else {
// @todo improve efficiency
double bg = 0;
double speed = 0;
while (bg < leaderMinDist) {
speed += ACCEL2SPEED(myDecel);
bg += SPEED2DIST(speed);
}
speed -= DIST2SPEED(bg - leaderMinDist);
return speed;
}
} else {
// can we brake for the whole time?
const double fullBrakingSeconds = sqrt(leaderMinDist * 2 / myDecel);
if (fullBrakingSeconds >= duration) {
// braking continuously for duration
// average speed after braking for duration is x2 = x - 0.5 * duration * myDecel
// x2 * duration <= leaderMinDist must hold
return leaderMinDist / duration + duration * getMaxDecel() / 2;
} else {
return fullBrakingSeconds * myDecel;
}
}
}
double
MSCFModel::distAfterTime(double t, double speed, double decel) {
assert(decel > 0);
if (speed <= decel * t) {
// braking to a full stop
return brakeGap(speed, decel, 0);
}
if (MSGlobals::gSemiImplicitEulerUpdate) {
// @todo improve efficiency
double result = 0;
while (t > 0) {
speed -= ACCEL2SPEED(decel);
result += MAX2(0.0, SPEED2DIST(speed));
t -= TS;
}
return result;
} else {
const double speed2 = speed - t * decel;
return 0.5 * (speed + speed2) * t;
}
}
SUMOTime
MSCFModel::getMinimalArrivalTime(double dist, double currentSpeed, double arrivalSpeed) const {
const double accel = (arrivalSpeed >= currentSpeed) ? getMaxAccel() : -getMaxDecel();
const double accelTime = (arrivalSpeed - currentSpeed) / accel;
const double accelWay = accelTime * (arrivalSpeed + currentSpeed) * 0.5;
const double nonAccelWay = MAX2(0., dist - accelWay);
// will either drive as fast as possible and decelerate as late as possible
// or accelerate as fast as possible and then hold that speed
const double nonAccelSpeed = MAX3(currentSpeed, arrivalSpeed, SUMO_const_haltingSpeed);
return TIME2STEPS(accelTime + nonAccelWay / nonAccelSpeed);
}
double
MSCFModel::estimateArrivalTime(double dist, double speed, double maxSpeed, double accel) const {
assert(speed >= 0.);
assert(dist >= 0.);
if (dist == 0.) {
return 0.;
}
if ((accel < 0. && -0.5 * speed * speed / accel < dist) || (accel <= 0. && speed == 0.)) {
// distance will never be covered with these values
return INVALID_DOUBLE;
}
if (accel == 0.) {
return dist / speed;
}
double p = speed / accel;
if (accel < 0.) {
// we already know, that the distance will be covered despite breaking
return (-p - sqrt(p * p + 2 * dist / accel));
}
// Here, accel > 0
// t1 is the time to use the given acceleration
double t1 = (maxSpeed - speed) / accel;
// distance covered until t1
double d1 = speed * t1 + 0.5 * accel * t1 * t1;
if (d1 >= dist) {
// dist is covered before changing the speed
return (-p + sqrt(p * p + 2 * dist / accel));
} else {
return (-p + sqrt(p * p + 2 * d1 / accel)) + (dist - d1) / maxSpeed;
}
}
double
MSCFModel::getMinimalArrivalSpeed(double dist, double currentSpeed) const {
// ballistic update
return estimateSpeedAfterDistance(dist - currentSpeed * getHeadwayTime(), currentSpeed, -getMaxDecel());
}
double
MSCFModel::getMinimalArrivalSpeedEuler(double dist, double currentSpeed) const {
double arrivalSpeedBraking;
// Because we use a continuous formula for computing the possible slow-down
// we need to handle the mismatch with the discrete dynamics
if (dist < currentSpeed) {
arrivalSpeedBraking = INVALID_SPEED; // no time left for braking after this step
// (inserted max() to get rid of arrivalSpeed dependency within method) (Leo)
} else if (2 * (dist - currentSpeed * getHeadwayTime()) * -getMaxDecel() + currentSpeed * currentSpeed >= 0) {
arrivalSpeedBraking = estimateSpeedAfterDistance(dist - currentSpeed * getHeadwayTime(), currentSpeed, -getMaxDecel());
} else {
arrivalSpeedBraking = getMaxDecel();
}
return arrivalSpeedBraking;
}
double
MSCFModel::gapExtrapolation(const double duration, const double currentGap, double v1, double v2, double a1, double a2, const double maxV1, const double maxV2) {
double newGap = currentGap;
if (MSGlobals::gSemiImplicitEulerUpdate) {
for (unsigned int steps = 1; steps * TS <= duration; ++steps) {
v1 = MIN2(MAX2(v1 + a1, 0.), maxV1);
v2 = MIN2(MAX2(v2 + a2, 0.), maxV2);
newGap += TS * (v1 - v2);
}
} else {
// determine times t1, t2 for which vehicles can break until stop (within duration)
// and t3, t4 for which they reach their maximal speed on their current lanes.
double t1 = 0, t2 = 0, t3 = 0, t4 = 0;
// t1: ego veh stops
if (a1 < 0 && v1 > 0) {
const double leaderStopTime = - v1 / a1;
t1 = MIN2(leaderStopTime, duration);
} else if (a1 >= 0) {
t1 = duration;
}
// t2: veh2 stops
if (a2 < 0 && v2 > 0) {
const double followerStopTime = -v2 / a2;
t2 = MIN2(followerStopTime, duration);
} else if (a2 >= 0) {
t2 = duration;
}
// t3: ego veh reaches vMax
if (a1 > 0 && v1 < maxV1) {
const double leaderMaxSpeedTime = (maxV1 - v1) / a1;
t3 = MIN2(leaderMaxSpeedTime, duration);
} else if (a1 <= 0) {
t3 = duration;
}
// t4: veh2 reaches vMax
if (a2 > 0 && v2 < maxV2) {
const double followerMaxSpeedTime = (maxV2 - v2) / a2;
t4 = MIN2(followerMaxSpeedTime, duration);
} else if (a2 <= 0) {
t4 = duration;
}
// NOTE: this assumes that the accelerations a1 and a2 are constant over the next
// followerBreakTime seconds (if no vehicle stops before or reaches vMax)
std::list<double> l;
l.push_back(t1);
l.push_back(t2);
l.push_back(t3);
l.push_back(t4);
l.sort();
std::list<double>::const_iterator i;
double tLast = 0.;
for (i = l.begin(); i != l.end(); ++i) {
if (*i != tLast) {
double dt = MIN2(*i, duration) - tLast; // time between *i and tLast
double dv = v1 - v2; // current velocity difference
double da = a1 - a2; // current acceleration difference
newGap += dv * dt + da * dt * dt / 2.; // update gap
v1 += dt * a1;
v2 += dt * a2;
}
if (*i == t1 || *i == t3) {
// ego veh reached velocity bound
a1 = 0.;
}
if (*i == t2 || *i == t4) {
// veh2 reached velocity bound
a2 = 0.;
}
tLast = MIN2(*i, duration);
if (tLast == duration) {
break;
}
}
if (duration != tLast) {
// (both vehicles have zero acceleration)
assert(a1 == 0. && a2 == 0.);
double dt = duration - tLast; // remaining time until duration
double dv = v1 - v2; // current velocity difference
newGap += dv * dt; // update gap
}
}
return newGap;
}
double
MSCFModel::passingTime(const double lastPos, const double passedPos, const double currentPos, const double lastSpeed, const double currentSpeed) {
assert(passedPos <= currentPos && passedPos >= lastPos && currentPos > lastPos);
assert(currentSpeed >= 0);
if (passedPos > currentPos || passedPos < lastPos) {
std::stringstream ss;
// Debug (Leo)
if (!MSGlobals::gSemiImplicitEulerUpdate) {
// NOTE: error is guarded to maintain original test output for euler update (Leo).
ss << "passingTime(): given argument passedPos = " << passedPos << " doesn't lie within [lastPos, currentPos] = [" << lastPos << ", " << currentPos << "]\nExtrapolating...";
std::cout << ss.str() << "\n";
WRITE_ERROR(ss.str());
}
const double lastCoveredDist = currentPos - lastPos;
const double extrapolated = passedPos > currentPos ? TS * (passedPos - lastPos) / lastCoveredDist : TS * (currentPos - passedPos) / lastCoveredDist;
return extrapolated;
} else if (currentSpeed < 0) {
WRITE_ERROR("passingTime(): given argument 'currentSpeed' is negative. This case is not handled yet.");
return -1;
}
const double distanceOldToPassed = passedPos - lastPos; // assert: >=0
if (MSGlobals::gSemiImplicitEulerUpdate) {
// euler update (constantly moving with currentSpeed during [0,TS])
const double t = distanceOldToPassed / currentSpeed;
return MIN2(TS, MAX2(0., t)); //rounding errors could give results out of the admissible result range
} else {
// ballistic update (constant acceleration a during [0,TS], except in case of a stop)
// determine acceleration
double a;
if (currentSpeed > 0) {
// the acceleration was constant within the last time step
a = SPEED2ACCEL(currentSpeed - lastSpeed);
} else {
// the currentSpeed is zero (the last was not because lastPos<currentPos).
assert(currentSpeed == 0 && lastSpeed != 0);
// In general the stop has taken place within the last time step.
// The acceleration (a<0) is obtained from
// deltaPos = - lastSpeed^2/(2*a)
a = lastSpeed * lastSpeed / (2 * (lastPos - currentPos));
assert(a < 0);
}
// determine passing time t
// we solve distanceOldToPassed = lastSpeed*t + a*t^2/2
if (fabs(a) < NUMERICAL_EPS) {
// treat as constant speed within [0, TS]
const double t = 2 * distanceOldToPassed / (lastSpeed + currentSpeed);
return MIN2(TS, MAX2(0., t)); //rounding errors could give results out of the admissible result range
} else if (a > 0) {
// positive acceleration => only one positive solution
const double va = lastSpeed / a;
const double t = -va + sqrt(va * va + 2 * distanceOldToPassed / a);
assert(t < 1 && t >= 0);
return t;
} else {
// negative acceleration => two positive solutions (pick the smaller one.)
const double va = lastSpeed / a;
const double t = -va - sqrt(va * va + 2 * distanceOldToPassed / a);
assert(t < 1 && t >= 0);
return t;
}
}
}
double
MSCFModel::speedAfterTime(const double t, const double v0, const double dist) {
assert(dist >= 0);
assert(t >= 0 && t <= TS);
if (MSGlobals::gSemiImplicitEulerUpdate) {
// euler: constant speed within [0,TS]
return DIST2SPEED(dist);
} else {
// ballistic: piecewise constant acceleration in [0,TS] (may become 0 for a stop within TS)
// We reconstruct acceleration at time t=0. Note that the covered distance in case
// of a stop exactly at t=TS is TS*v0/2.
if (dist < TS * v0 / 2) {
// stop must have occured within [0,TS], use dist = -v0^2/(2a) (stopping dist),
// i.e., a = -v0^2/(2*dist)
const double accel = - v0 * v0 / (2 * dist);
// The speed at time t is then
return v0 + accel * t;
} else {
// no stop occured within [0,TS], thus (from dist = v0*TS + accel*TS^2/2)
const double accel = 2 * (dist / TS - v0) / TS;
// The speed at time t is then
return v0 + accel * t;
}
}
}
double
MSCFModel::estimateSpeedAfterDistance(const double dist, const double v, const double accel) const {
// dist=v*t + 0.5*accel*t^2, solve for t and use v1 = v + accel*t
return MAX2(0., MIN2(myType->getMaxSpeed(),
(double)sqrt(2 * dist * accel + v * v)));
}
double
MSCFModel::maximumSafeStopSpeed(double g /*gap*/, double v /*currentSpeed*/, bool onInsertion, double headway) const {
if (MSGlobals::gSemiImplicitEulerUpdate) {
return maximumSafeStopSpeedEuler(g);
} else {
return maximumSafeStopSpeedBallistic(g, v, onInsertion, headway);
}
}
double
MSCFModel::maximumSafeStopSpeedEuler(double gap) const {
gap -= NUMERICAL_EPS; // lots of code relies on some slack XXX: it shouldn't...
if (gap <= 0) {
return 0;
} else if (gap <= ACCEL2SPEED(myDecel)) {
// workaround for #2310
return MIN2(ACCEL2SPEED(myDecel), DIST2SPEED(gap));
}
const double g = gap;
const double b = ACCEL2SPEED(myDecel);
const double t = myHeadwayTime;
const double s = TS;
// h = the distance that would be covered if it were possible to stop
// exactly after gap and decelerate with b every simulation step
// h = 0.5 * n * (n-1) * b * s + n * b * t (solve for n)
//n = ((1.0/2.0) - ((t + (pow(((s*s) + (4.0*((s*((2.0*h/b) - t)) + (t*t)))), (1.0/2.0))*sign/2.0))/s));
const double n = floor(.5 - ((t + (sqrt(((s * s) + (4.0 * ((s * (2.0 * g / b - t)) + (t * t))))) * -0.5)) / s));
const double h = 0.5 * n * (n - 1) * b * s + n * b * t;
assert(h <= g + NUMERICAL_EPS);
// compute the additional speed that must be used during deceleration to fix
// the discrepancy between g and h
const double r = (g - h) / (n * s + t);
const double x = n * b + r;
assert(x >= 0);
return x;
}
double
MSCFModel::maximumSafeStopSpeedBallistic(double g /*gap*/, double v /*currentSpeed*/, bool onInsertion, double headway) const {
// decrease gap slightly (to avoid passing end of lane by values of magnitude ~1e-12, when exact stop is required)
g = MAX2(0., g - NUMERICAL_EPS);
headway = headway >= 0 ? headway : myHeadwayTime;
// (Leo) Note that in contrast to the Euler update, for the ballistic update
// the distance covered in the coming step depends on the current velocity, in general.
// one exception is the situation when the vehicle is just being inserted.
// In that case, it will not cover any distance until the next timestep by convention.
// We treat the latter case first:
if (onInsertion) {
// The distance covered with constant insertion speed v0 until time tau is given as
// G1 = tau*v0
// The distance covered between time tau and the stopping moment at time tau+v0/b is
// G2 = v0^2/(2b),
// where b is an assumed constant deceleration (= myDecel)
// We solve g = G1 + G2 for v0:
const double btau = myDecel * headway;
const double v0 = -btau + sqrt(btau * btau + 2 * myDecel * g);
return v0;
}
// In the usual case during the driving task, the vehicle goes by
// a current speed v0=v, and we seek to determine a safe acceleration a (possibly <0)
// such that starting to break after accelerating with a for the time tau
// still allows us to stop in time.
const double tau = headway;
const double v0 = MAX2(0., v);
// We first consider the case that a stop has to take place within time tau
if (v0 * tau >= 2 * g) {
if (g == 0.) {
if (v0 > 0.) {
// indicate to brake as hard as possible
return -INVALID_SPEED;
} else {
// stay stopped
return 0.;
}
}
// In general we solve g = v0^2/(-2a), where the the rhs is the distance
// covered until stop when breaking with a<0
const double a = -v0 * v0 / (2 * g);
return v0 + a * TS;
}
// The last case corresponds to a situation, where the vehicle may go with a positive
// speed v1 = v0 + tau*a after time tau.
// The distance covered until time tau is given as
// G1 = tau*(v0+v1)/2
// The distance covered between time tau and the stopping moment at time tau+v1/b is
// G2 = v1^2/(2b),
// where b is an assumed constant deceleration (= myDecel)
// We solve g = G1 + G2 for v1>0:
// <=> 0 = v1^2 + b*tau*v1 + b*tau*v0 - 2bg
// => v1 = -b*tau/2 + sqrt( (b*tau)^2/4 + b(2g - tau*v0) )
const double btau2 = myDecel * tau / 2;
const double v1 = -btau2 + sqrt(btau2 * btau2 + myDecel * (2 * g - tau * v0));
const double a = (v1 - v0) / tau;
return v0 + a * TS;
}
/** Returns the SK-vsafe. */
double
MSCFModel::maximumSafeFollowSpeed(double gap, double egoSpeed, double predSpeed, double predMaxDecel, bool onInsertion) const {
// the speed is safe if allows the ego vehicle to come to a stop behind the leader even if
// the leaders starts braking hard until stopped
// unfortunately it is not sufficient to compare stopping distances if the follower can brake harder than the leader
// (the trajectories might intersect before both vehicles are stopped even if the follower has a shorter stopping distance than the leader)
// To make things safe, we ensure that the leaders brake distance is computed with an deceleration that is at least as high as the follower's.
// @todo: this is a conservative estimate for safe speed which could be increased
// // For negative gaps, we return the lowest meaningful value by convention
// // XXX: check whether this is desireable (changes test results, therefore I exclude it for now (Leo), refs. #2575)
// if(gap<0){
// if(MSGlobals::gSemiImplicitEulerUpdate){
// return 0.;
// } else {
// return -INVALID_SPEED;
// }
// }
// The following commented code is a variant to assure brief stopping behind a stopped leading vehicle:
// if leader is stopped, calculate stopSpeed without time-headway to prevent creeping stop
// NOTE: this can lead to the strange phenomenon (for the Krauss-model at least) that if the leader comes to a stop,
// the follower accelerates for a short period of time. Refs #2310 (Leo)
// const double headway = predSpeed > 0. ? myHeadwayTime : 0.;
const double headway = myHeadwayTime;
const double x = maximumSafeStopSpeed(gap + brakeGap(predSpeed, MAX2(myDecel, predMaxDecel), 0), egoSpeed, onInsertion, headway);
assert(x >= 0 || !MSGlobals::gSemiImplicitEulerUpdate);
assert(!ISNAN(x));
return x;
}
/****************************************************************************/
| 41.334228 | 185 | 0.588199 | iltempe |
0b7c7920c1bec5b954e8c45920ea402617c90252 | 275 | cpp | C++ | Algorithms/char.cpp | zengboming/Algorithms-Date-Structures-Design-Patterns | 2755f7b1f03c3bd4ac53c70c8c11a5ec593ee0ea | [
"Apache-2.0"
] | null | null | null | Algorithms/char.cpp | zengboming/Algorithms-Date-Structures-Design-Patterns | 2755f7b1f03c3bd4ac53c70c8c11a5ec593ee0ea | [
"Apache-2.0"
] | null | null | null | Algorithms/char.cpp | zengboming/Algorithms-Date-Structures-Design-Patterns | 2755f7b1f03c3bd4ac53c70c8c11a5ec593ee0ea | [
"Apache-2.0"
] | null | null | null | #include<iostream>
#include<cstdlib>
using namespace std;
int main()
{
const char* p="hello";
int cnt=0;
//while(*p){cnt++;p++;cout<<cnt;}
//cnt=0;
while(p){
cnt++;
p++;
cout<<p;
system("pause");
}
return 0;
}
| 14.473684 | 37 | 0.469091 | zengboming |
0b826146ce44efd10cae8056973886fa81794f83 | 3,478 | cc | C++ | third-party/webscalesqlclient/mysql-5.6/sql/hyperloglog.cc | hkirsman/hhvm_centos7_builds | 2a1fd6de0d2d289c1575f43f10018f3bec23bb13 | [
"PHP-3.01",
"Zend-2.0"
] | null | null | null | third-party/webscalesqlclient/mysql-5.6/sql/hyperloglog.cc | hkirsman/hhvm_centos7_builds | 2a1fd6de0d2d289c1575f43f10018f3bec23bb13 | [
"PHP-3.01",
"Zend-2.0"
] | null | null | null | third-party/webscalesqlclient/mysql-5.6/sql/hyperloglog.cc | hkirsman/hhvm_centos7_builds | 2a1fd6de0d2d289c1575f43f10018f3bec23bb13 | [
"PHP-3.01",
"Zend-2.0"
] | null | null | null | #include "hyperloglog.h"
#include "my_sys.h"
#include <stdlib.h>
#include <math.h>
#include <string.h>
#include <stdio.h>
const uchar bit_parts[] = {16,8,4,2,1};
const uchar default_data_size_log2 = 10;
const double long_range_adjustment_constant32 = 4.294967296e9;
uchar find_first_set_bit_after_index(uint hash, uchar start_bit) {
uint num = hash >> start_bit;
uchar pos = 0;
int i;
if (num == 0) {
return (uchar)(32 - start_bit);
}
for(i = 0; i < 5; i++) {
uchar part = bit_parts[i];
if((num & ((1 << part) - 1)) == 0) {
num >>= part;
pos += part;
}
}
return pos;
}
// alpha_m in the hyperloglog paper. Refer to the comment in hyperloglog.h
double get_harmonic_mean_constant(uint data_size) {
if (data_size >= 128) {
return 0.7213 / (1.079 / data_size + 1.0);
} else if (data_size == 16) {
return 0.673;
} else if (data_size == 32) {
return 0.697;
} else if (data_size == 64) {
return 0.709;
}
//Should never reach here.
return 0;
}
void hyperloglog_init(struct hyperloglog* hll) {
hll->data_size_log2 = default_data_size_log2;
hll->data_size = 1 << hll->data_size_log2;
hll->max_bit_position = 32 - hll->data_size_log2 + 1;
hll->data = (uint*)my_malloc(
hll->data_size * hll->max_bit_position * sizeof(uint),
MYF(MY_WME));
memset(hll->data, 0, hll->data_size * hll->max_bit_position * sizeof(uint));
}
void hyperloglog_reset(struct hyperloglog* hll) {
memset(hll->data, 0, hll->data_size * hll->max_bit_position * sizeof(uint));
}
ulonglong hyperloglog_query(struct hyperloglog* hll, uint since_time) {
double harmonic_mean_constant = get_harmonic_mean_constant(hll->data_size);
double query_sum = 0.0;
uint count_zero_elements = 0;
uint i,j;
double cardinality_estimate = 0.0;
for (i = 0; i < hll->data_size; i++) {
uchar max_valid_index = 32;
// We need the maximum index seen since since_time.
// As data[i][j] stores the last time when an index of j was seen,
// We just need to find the largest j, for which data[i][j] is
// larger than since_time.
for (j = hll->max_bit_position; j >= 1; j--) {
if (hll->data[i * hll->max_bit_position + j - 1] > since_time) {
max_valid_index = j;
break;
}
}
if (max_valid_index == 32) {
count_zero_elements++;
query_sum += 1.0;
} else {
query_sum += 1.0 / ((uint) 1 << max_valid_index);
}
}
cardinality_estimate =
harmonic_mean_constant * hll->data_size * hll->data_size / query_sum;
if (cardinality_estimate <= 2.5 * hll->data_size) {
// small range correction
if (count_zero_elements != 0)
cardinality_estimate = log((double)hll->data_size / count_zero_elements)
* hll->data_size;
} else if (cardinality_estimate > long_range_adjustment_constant32 / 30.0) {
// Adjust for hash collisions that occur when nearing 2^32 uniques
cardinality_estimate = -long_range_adjustment_constant32 *
log(1.0 - cardinality_estimate / long_range_adjustment_constant32);
}
return (ulonglong)(cardinality_estimate + 0.5);
}
void hyperloglog_insert(
struct hyperloglog* hll,
uint hash,
uint current_time) {
uint index = hash & (hll->data_size-1);
uint first_set_bit =
find_first_set_bit_after_index(hash, hll->data_size_log2);
hll->data[index * hll->max_bit_position + first_set_bit] = current_time;
}
void hyperloglog_destroy(struct hyperloglog* hll) {
my_free((char*)(hll->data));
}
| 30.243478 | 78 | 0.668775 | hkirsman |
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 |
0b8cc5285bebd41c07ac4c3d7d1fda16e0ffbf61 | 7,411 | cpp | C++ | Source/web/FullscreenController.cpp | quanganh2627/bytm-x64-L-w05-2015_external_chromium_org_third_party_WebKit | 20e637e67a0c272870ae4d78466a68bcb77af041 | [
"BSD-3-Clause"
] | null | null | null | Source/web/FullscreenController.cpp | quanganh2627/bytm-x64-L-w05-2015_external_chromium_org_third_party_WebKit | 20e637e67a0c272870ae4d78466a68bcb77af041 | [
"BSD-3-Clause"
] | null | null | null | Source/web/FullscreenController.cpp | quanganh2627/bytm-x64-L-w05-2015_external_chromium_org_third_party_WebKit | 20e637e67a0c272870ae4d78466a68bcb77af041 | [
"BSD-3-Clause"
] | null | null | null | /*
* Copyright (C) 2013 Google Inc. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following disclaimer
* in the documentation and/or other materials provided with the
* distribution.
* * Neither the name of Google Inc. nor the names of its
* contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include "config.h"
#include "web/FullscreenController.h"
#include "core/dom/Document.h"
#include "core/dom/FullscreenElementStack.h"
#include "core/frame/LocalFrame.h"
#include "core/html/HTMLMediaElement.h"
#include "platform/LayoutTestSupport.h"
#include "platform/RuntimeEnabledFeatures.h"
#include "public/web/WebFrame.h"
#include "public/web/WebViewClient.h"
#include "web/WebSettingsImpl.h"
#include "web/WebViewImpl.h"
using namespace WebCore;
namespace blink {
PassOwnPtr<FullscreenController> FullscreenController::create(WebViewImpl* webViewImpl)
{
return adoptPtr(new FullscreenController(webViewImpl));
}
FullscreenController::FullscreenController(WebViewImpl* webViewImpl)
: m_webViewImpl(webViewImpl)
, m_exitFullscreenPageScaleFactor(0)
, m_isCancelingFullScreen(false)
{
}
void FullscreenController::willEnterFullScreen()
{
if (!m_provisionalFullScreenElement)
return;
// Ensure that this element's document is still attached.
Document& doc = m_provisionalFullScreenElement->document();
if (doc.frame()) {
FullscreenElementStack::from(doc).webkitWillEnterFullScreenForElement(m_provisionalFullScreenElement.get());
m_fullScreenFrame = doc.frame();
}
m_provisionalFullScreenElement.clear();
}
void FullscreenController::didEnterFullScreen()
{
if (!m_fullScreenFrame)
return;
if (Document* doc = m_fullScreenFrame->document()) {
if (FullscreenElementStack::isFullScreen(*doc)) {
if (!m_exitFullscreenPageScaleFactor) {
m_exitFullscreenPageScaleFactor = m_webViewImpl->pageScaleFactor();
m_exitFullscreenScrollOffset = m_webViewImpl->mainFrame()->scrollOffset();
m_exitFullscreenPinchViewportOffset = m_webViewImpl->pinchViewportOffset();
m_webViewImpl->setPageScaleFactor(1.0f);
m_webViewImpl->setMainFrameScrollOffset(IntPoint());
m_webViewImpl->setPinchViewportOffset(FloatPoint());
}
FullscreenElementStack::from(*doc).webkitDidEnterFullScreenForElement(0);
if (RuntimeEnabledFeatures::overlayFullscreenVideoEnabled()) {
Element* element = FullscreenElementStack::currentFullScreenElementFrom(*doc);
ASSERT(element);
if (isHTMLMediaElement(*element)) {
HTMLMediaElement* mediaElement = toHTMLMediaElement(element);
if (mediaElement->webMediaPlayer() && mediaElement->webMediaPlayer()->canEnterFullscreen()
// FIXME: There is no embedder-side handling in layout test mode.
&& !isRunningLayoutTest()) {
mediaElement->webMediaPlayer()->enterFullscreen();
}
if (m_webViewImpl->layerTreeView())
m_webViewImpl->layerTreeView()->setHasTransparentBackground(true);
}
}
}
}
}
void FullscreenController::willExitFullScreen()
{
if (!m_fullScreenFrame)
return;
if (Document* doc = m_fullScreenFrame->document()) {
FullscreenElementStack* fullscreen = FullscreenElementStack::fromIfExists(*doc);
if (!fullscreen)
return;
if (fullscreen->isFullScreen(*doc)) {
// When the client exits from full screen we have to call webkitCancelFullScreen to
// notify the document. While doing that, suppress notifications back to the client.
m_isCancelingFullScreen = true;
fullscreen->webkitCancelFullScreen();
m_isCancelingFullScreen = false;
fullscreen->webkitWillExitFullScreenForElement(0);
if (RuntimeEnabledFeatures::overlayFullscreenVideoEnabled() && m_webViewImpl->layerTreeView())
m_webViewImpl->layerTreeView()->setHasTransparentBackground(m_webViewImpl->isTransparent());
}
}
}
void FullscreenController::didExitFullScreen()
{
if (!m_fullScreenFrame)
return;
if (Document* doc = m_fullScreenFrame->document()) {
if (FullscreenElementStack* fullscreen = FullscreenElementStack::fromIfExists(*doc)) {
if (fullscreen->webkitIsFullScreen()) {
if (m_exitFullscreenPageScaleFactor) {
m_webViewImpl->setPageScaleFactor(m_exitFullscreenPageScaleFactor);
m_webViewImpl->setMainFrameScrollOffset(IntPoint(m_exitFullscreenScrollOffset));
m_webViewImpl->setPinchViewportOffset(m_exitFullscreenPinchViewportOffset);
m_exitFullscreenPageScaleFactor = 0;
m_exitFullscreenScrollOffset = IntSize();
}
fullscreen->webkitDidExitFullScreenForElement(0);
}
}
}
m_fullScreenFrame.clear();
}
void FullscreenController::enterFullScreenForElement(WebCore::Element* element)
{
// We are already transitioning to fullscreen for a different element.
if (m_provisionalFullScreenElement) {
m_provisionalFullScreenElement = element;
return;
}
// We are already in fullscreen mode.
if (m_fullScreenFrame) {
m_provisionalFullScreenElement = element;
willEnterFullScreen();
didEnterFullScreen();
return;
}
// We need to transition to fullscreen mode.
if (WebViewClient* client = m_webViewImpl->client()) {
if (client->enterFullScreen())
m_provisionalFullScreenElement = element;
}
}
void FullscreenController::exitFullScreenForElement(WebCore::Element* element)
{
// The client is exiting full screen, so don't send a notification.
if (m_isCancelingFullScreen)
return;
if (WebViewClient* client = m_webViewImpl->client())
client->exitFullScreen();
}
}
| 39.005263 | 116 | 0.689651 | quanganh2627 |
0b8d253421eb1ebe102508ffea5efab04122f536 | 1,586 | cpp | C++ | Release/tests/functional/websockets/client/proxy_tests.cpp | LewisCheng-MSFT/cpprestsdk | 219daed12e45618aeffc94b73b83af55c3dca7aa | [
"Apache-2.0"
] | 11 | 2015-01-18T21:46:19.000Z | 2022-02-09T02:10:45.000Z | Release/tests/functional/websockets/client/proxy_tests.cpp | LewisCheng-MSFT/cpprestsdk | 219daed12e45618aeffc94b73b83af55c3dca7aa | [
"Apache-2.0"
] | null | null | null | Release/tests/functional/websockets/client/proxy_tests.cpp | LewisCheng-MSFT/cpprestsdk | 219daed12e45618aeffc94b73b83af55c3dca7aa | [
"Apache-2.0"
] | 6 | 2015-01-18T21:47:04.000Z | 2021-05-20T03:14:40.000Z | /***
* ==++==
*
* Copyright (c) Microsoft Corporation. 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.
*
* ==--==
* =+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+
*
* proxy_tests.cpp
*
* Tests cases for covering proxies using websocket_client
*
* =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
****/
#include "stdafx.h"
#if defined(__cplusplus_winrt) || !defined(_M_ARM)
using namespace web::websockets;
using namespace web::websockets::client;
using namespace tests::functional::websocket::utilities;
namespace tests { namespace functional { namespace websocket { namespace client {
SUITE(proxy_tests)
{
#ifdef __cplusplus_winrt
TEST_FIXTURE(uri_address, no_proxy_options_on_winrt)
{
websocket_client_config config;
config.set_proxy(web::web_proxy::use_auto_discovery);
websocket_client client(config);
VERIFY_THROWS(client.connect(m_uri).wait(), websocket_exception);
}
#endif
} // SUITE(proxy_tests)
}}}}
#endif
| 28.836364 | 114 | 0.643127 | LewisCheng-MSFT |
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 |
0b93a61618557df314ef01706bddef6cf7edaa2f | 95 | cpp | C++ | tutorial1/ex5 - extra files/main.cpp | hoppfull/Legacy-Cpp | 0785e70230bd2fd4a732e5852ca5a8ab320eaa67 | [
"MIT"
] | null | null | null | tutorial1/ex5 - extra files/main.cpp | hoppfull/Legacy-Cpp | 0785e70230bd2fd4a732e5852ca5a8ab320eaa67 | [
"MIT"
] | null | null | null | tutorial1/ex5 - extra files/main.cpp | hoppfull/Legacy-Cpp | 0785e70230bd2fd4a732e5852ca5a8ab320eaa67 | [
"MIT"
] | null | null | null | #include <iostream>
#include "test.h"
int main(){
std::cout << five();
return 0;
}
| 8.636364 | 24 | 0.547368 | hoppfull |
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 |