void ActionListSwitch::GenerateCaseMap()
{
Datum& cases = Actions();
Datum::DatumType switchType = Datum::DatumType::UNKNOWN;
if (cases.Size() > 0)
{
delete mCaseMap;
mCaseMap = new Hashmap<Datum, ActionListSwitchCase*>(cases.Size());
Datum* conditionDatum = Search((*this)[ATTRIBUTE_SWITCH_VALUE].Get<std::string>());
if (conditionDatum == nullptr)
{
std::stringstream str;
str << "Undefined variable: " << (*this)[ATTRIBUTE_SWITCH_VALUE].Get<std::string>();
throw std::exception(str.str().c_str());
}
switchType = conditionDatum->Type();
}
for (uint32_t i = 0; i < cases.Size(); i++)
{
ActionListSwitchCase* switchCase = cases.Get<Scope>(i).As<ActionListSwitchCase>();
if (switchCase == nullptr)
continue;
if (switchCase->DefaultCase)
{
Adopt(ActionListSwitchCase::ATTRIBUTE_DEFAULT, *switchCase);
}
else
{
Datum d;
d.SetType(switchType);
d.SetFromString(switchCase->operator[](ActionListSwitchCase::ATTRIBUTE_CASE_VALUE).Get<std::string>());
mCaseMap->Insert(d, switchCase);
}
}
}
ForStmt::ForStmt(Stmt *init, Expr *c, Stmt *iterate, Stmt *body) :
fInit(init), ///< Optional; can be NULL
fCondition(c), ///< Optional; can be NULL
fIterate(iterate), ///< Optional; can be NULL
fBody(body)
{
// we need to keep child statements in a list
fChildren.InsertHead(fBody);
if (fIterate)
fChildren.InsertHead(fIterate);
if (fInit)
fChildren.InsertHead(fInit);
Adopt(init);
Adopt(iterate);
Adopt(body);
}
void Attributed::AddNestedScope(const std::string& name, Scope& initialValue, std::uint32_t size)
{
AddEmptyInternalSignature(name, Datum::DatumType::TABLE, 0);
for (std::uint32_t j = 0; j < size; j++)
{
Scope* scope = new Scope(initialValue);
Adopt(name, *scope);
}
}
Field::Field(int n) : d_impl_p(0) {
if(!s_currentRep_p) {
if(s_inInitialize) {
s_currentRep_p = CreateNumber(n,1);
} else {
cerr << "Error with field setting\n";
};
};
RECORDHERE(d_impl_p = new FieldImplementation(s_currentRep_p->make(n),Adopt());)
};
//---------------------------------------------------------------------------
// ELSEIF
//
// This routine recognizes and compiles the ELSEIF statement. The pcode
// generated is as follows:
//
// STATEMENT: ELSEIF <intexp> THEN
//
// PCODE: JMP CSF_ENDBLOCK
// CSF_ELSEBLOCK:
// <intexp>
// POPA
// JE 0, CSF_ELSEBLOCK ; (new ELSE block)
//
// RETURNS: Root node of ELSEIF compilation tree
//---------------------------------------------------------------------------
INT ELSEIF (INT op)
{
INT curCS, n, n2, v;
// Ensure that the current CS is an IF...
//-----------------------------------------------------------------------
curCS = AssertCSType (CS_IF);
if (curCS == -1)
return (-1);
// The IF control struct was found. First thing to do is check to see if
// the ENDBLOCK label is the same as the ELSEBLOCK label. This indicates
// that no ELSEx block has been encountered. If so, we set a new
// ENDBLOCK label for the next jump.
//-----------------------------------------------------------------------
ADVANCE;
v = GetCSField (curCS, CSF_ELSEBLOCK);
if (GetCSField(curCS, CSF_ENDBLOCK) == v)
SetCSField (curCS, CSF_ENDBLOCK, TempLabel());
// Generate the code trees that jump to the ENDIF (ENDBLOCK), and make a
// new ELSEBLOCK label
//-----------------------------------------------------------------------
n = Siblingize (MakeNode (opJMP, GetCSField (curCS, CSF_ENDBLOCK)),
MakeNode (opFIXUP, v), -1);
SetCSField (curCS, CSF_ELSEBLOCK, v = TempLabel());
// Generate another IF tree
//-----------------------------------------------------------------------
n2 = MakeParentNode (IntExpression(), opPOPA);
n2 = MakeParentNode (n2, opJE, 0L, v);
n = Adopt (MakeNode (opNOP), n, n2, -1);
// Insist on the THEN keyword, and we're done!
//-----------------------------------------------------------------------
ReadKT (ST_THEN, PRS_SYNTAX);
return (n);
(op);
}
void Attributed::CopyAuxiliaryAttributesFromAnotherAttributed(const Attributed& anotherAttributed)
{
std::uint32_t i;
for (i = anotherAttributed.AuxiliaryBegin(); i < anotherAttributed.Size(); i++)
{
const SymbolPair& pair = anotherAttributed.GetPair(i);
Remove(pair.first);
if (pair.second.Type() == Datum::DatumType::TABLE)
{
const Datum& nestedScopeDatum = pair.second;
std::uint32_t j;
for (j = 0; j < nestedScopeDatum.Size(); j++)
{
Scope* nestedScopeAttribute = new Scope(nestedScopeDatum.Get<Scope>(j));
Adopt(pair.first, *nestedScopeAttribute);
}
}
else
{
AppendAuxiliaryAttribute(pair.first) = pair.second;
}
}
}
void BidirectionalIBFS::IBFS() {
auto start = Clock::now();
m_forward_search = false;
m_source_tree_d = 1;
m_sink_tree_d = 0;
IBFSInit();
// Set up initial current_q and search nodes to make it look like
// we just finished scanning the sink node
NodeQueue* current_q = &(m_sink_layers[0]);
m_search_node_iter = current_q->end();
m_search_node_end = current_q->end();
while (!current_q->empty()) {
if (m_search_node_iter == m_search_node_end) {
// Swap queues and continue
if (m_forward_search) {
m_source_tree_d++;
current_q = &(m_sink_layers[m_sink_tree_d]);
} else {
m_sink_tree_d++;
current_q = &(m_source_layers[m_source_tree_d]);
}
m_search_node_iter = current_q->begin();
m_search_node_end = current_q->end();
m_forward_search = !m_forward_search;
if (!current_q->empty()) {
Node& n = *m_search_node_iter;
NodeId nodeIdx = n.id;
if (m_forward_search) {
ASSERT(n.state == NodeState::S || n.state == NodeState::S_orphan);
m_search_arc = m_graph->ArcsBegin(nodeIdx);
m_search_arc_end = m_graph->ArcsEnd(nodeIdx);
} else {
ASSERT(n.state == NodeState::T || n.state == NodeState::T_orphan);
m_search_arc = m_graph->ArcsBegin(nodeIdx);
m_search_arc_end = m_graph->ArcsEnd(nodeIdx);
}
}
continue;
}
Node& n = *m_search_node_iter;
NodeId search_node = n.id;
int distance;
if (m_forward_search) {
distance = m_source_tree_d;
} else {
distance = m_sink_tree_d;
}
ASSERT(n.dis == distance);
// Advance m_search_arc until we find a residual arc
while (m_search_arc != m_search_arc_end && !m_graph->NonzeroCap(m_search_arc, m_forward_search))
++m_search_arc;
if (m_search_arc != m_search_arc_end) {
NodeId neighbor = m_search_arc.Target();
NodeState neighbor_state = m_graph->node(neighbor).state;
if (neighbor_state == n.state) {
ASSERT(m_graph->node(neighbor).dis <= n.dis + 1);
if (m_graph->node(neighbor).dis == n.dis+1) {
auto reverseArc = m_search_arc.Reverse();
if (reverseArc < m_graph->node(neighbor).parent_arc) {
m_graph->node(neighbor).parent_arc = reverseArc;
m_graph->node(neighbor).parent = search_node;
}
}
++m_search_arc;
} else if (neighbor_state == NodeState::N) {
// Then we found an unlabeled node, add it to the tree
m_graph->node(neighbor).state = n.state;
m_graph->node(neighbor).dis = n.dis + 1;
AddToLayer(neighbor);
auto reverseArc = m_search_arc.Reverse();
m_graph->node(neighbor).parent_arc = reverseArc;
ASSERT(m_graph->NonzeroCap(m_graph->node(neighbor).parent_arc, !m_forward_search));
m_graph->node(neighbor).parent = search_node;
++m_search_arc;
} else {
// Then we found an arc to the other tree
ASSERT(neighbor_state != NodeState::S_orphan && neighbor_state != NodeState::T_orphan);
ASSERT(m_graph->NonzeroCap(m_search_arc, m_forward_search));
Augment(m_search_arc);
Adopt();
}
} else {
// No more arcs to scan from this node, so remove from queue
AdvanceSearchNode();
}
} // End while
m_totalTime += Duration{ Clock::now() - start }.count();
//std::cout << "Total time: " << m_totalTime << "\n";
//std::cout << "Init time: " << m_initTime << "\n";
//std::cout << "Augment time: " << m_augmentTime << "\n";
//std::cout << "Adopt time: " << m_adoptTime << "\n";
}
BString&
BString::AdoptChars(BString& string, int32 charCount)
{
return Adopt(string, UTF8CountBytes(string.String(), charCount));
}
Field::Field() : d_impl_p(0) {
RECORDHERE(d_impl_p = new FieldImplementation(s_currentRep_p->make(0),Adopt());)
};
