void C_DirectedGraph::getNodesWithNoSuccessor (TC_UniqueArray <uint32_t> & outNodes) const { outNodes.setCountToZero () ; for (uint32_t i=0 ; i<(uint32_t) mEdges.count () ; i++) { if (isNodeDefined (i) && mEdges ((int32_t) i COMMA_HERE).isEmpty ()) { outNodes.appendObject (i) ; } } }
GALGAS__32_stringlist GALGAS_application::constructor_boolOptionNameList (LOCATION_ARGS) { GALGAS__32_stringlist result = GALGAS__32_stringlist::constructor_emptyList (THERE) ; TC_UniqueArray <C_String> array ; C_BoolCommandLineOption::getBoolOptionNameList (array) ; for (int32_t i=0 ; i<array.count () ; i+=2) { result.addAssign_operation (GALGAS_string (array (i COMMA_THERE)), GALGAS_string (array (i+1 COMMA_THERE)) COMMA_THERE) ; } return result ; }
void C_DirectedGraph::getEdges (TC_UniqueArray <cEdge> & outEdges) const { outEdges.setCountToZero () ; for (int32_t i=0 ; i<mEdges.count () ; i++) { TC_UniqueArray <uint32_t> targetList ; mEdges (i COMMA_HERE).getValueArray (targetList) ; for (int32_t j=0 ; j<targetList.count () ; j++) { const cEdge edge = {(uint32_t) i, targetList (j COMMA_HERE)} ; outEdges.appendObject (edge) ; } } }
void C_DirectedGraph::print (void) const { for (int32_t i=0 ; i<mEdges.count () ; i++) { if (isNodeDefined ((uint32_t) i)) { printf ("Node %d:\n", i) ; TC_UniqueArray <uint32_t> s ; mEdges (i COMMA_HERE).getValueArray (s) ; for (int32_t j=0 ; j<s.count () ; j++) { printf (" %d --> %d\n", i, s (j COMMA_HERE)) ; } } } }
C_DirectedGraph C_DirectedGraph::subGraphFromNodes (const C_UIntSet & inStartNodes, #ifdef USE_NODE_NAMES_WITH_SUBGRAPH_COMPUTATION const TC_UniqueArray <C_String> & inNodeNames, #endif const C_UIntSet & inNodesToExclude) const { TC_UniqueArray <bool> nodeBoolArray ; mNodes.getBoolValueArray (nodeBoolArray) ; C_DirectedGraph result ; { C_UIntSet nodeSet = inStartNodes ; nodeSet -= inNodesToExclude ; result.addNodes (nodeSet) ; } #ifdef USE_NODE_NAMES_WITH_SUBGRAPH_COMPUTATION { TC_UniqueArray <uint32_t> sourceNodeArray ; result.getNodeValueArray (sourceNodeArray) ; printf ("START NODES (%d):\n", sourceNodeArray.count ()) ; for (int32_t i=0 ; i<sourceNodeArray.count () ; i++) { printf (" - %d (%s)\n", sourceNodeArray (i COMMA_HERE), inNodeNames ((int32_t) sourceNodeArray (i COMMA_HERE) COMMA_HERE).cString (HERE)) ; } } #endif bool loop = true ; while (loop) { loop = false ; TC_UniqueArray <uint32_t> sourceNodeArray ; result.getNodeValueArray (sourceNodeArray) ; #ifdef USE_NODE_NAMES_WITH_SUBGRAPH_COMPUTATION printf ("********************* NODE COUNT %d\n", sourceNodeArray.count ()) ; #endif for (int32_t i=0 ; i<sourceNodeArray.count () ; i++) { const uint32_t sourceNodeIndex = sourceNodeArray (i COMMA_HERE) ; if (nodeBoolArray ((int32_t) sourceNodeIndex COMMA_HERE)) { #ifdef USE_NODE_NAMES_WITH_SUBGRAPH_COMPUTATION printf ("NEW NODE %d (%s):\n", sourceNodeIndex, inNodeNames ((int32_t) sourceNodeIndex COMMA_HERE).cString (HERE)) ; #endif loop = true ; nodeBoolArray.setObjectAtIndex (false, (int32_t) sourceNodeIndex COMMA_HERE) ; C_UIntSet s = mEdges ((int32_t) sourceNodeIndex COMMA_HERE) ; s -= inNodesToExclude ; TC_UniqueArray <uint32_t> targetNodeArray ; s.getValueArray (targetNodeArray) ; for (int32_t j=0 ; j<targetNodeArray.count () ; j++) { result.addEdge (sourceNodeIndex, targetNodeArray (j COMMA_HERE)) ; #ifdef USE_NODE_NAMES_WITH_SUBGRAPH_COMPUTATION printf (" edge %d (%s)\n", targetNodeArray (j COMMA_HERE), inNodeNames ((int32_t) targetNodeArray (j COMMA_HERE) COMMA_HERE).cString (HERE)) ; #endif } } } } return result ; }
C_String C_DirectedGraph::graphvizString (const TC_UniqueArray <C_String> & inNodeNameArray) const { C_String s = "digraph G {\n" ; for (int32_t i=0 ; i<mEdges.count () ; i++) { if (isNodeDefined ((uint32_t) i)) { s << " \"" << inNodeNameArray (i COMMA_HERE) << "\" [shape=rectangle] ;\n" ; const C_UIntSet targetSet = mEdges (i COMMA_HERE) ; TC_UniqueArray <uint32_t> targetList ; targetSet.getValueArray (targetList) ; for (int32_t j=0 ; j<targetList.count () ; j++) { const uint32_t targetIndex = targetList (j COMMA_HERE) ; s << " \"" << inNodeNameArray (i COMMA_HERE) << "\" -> \"" << inNodeNameArray ((int32_t) targetIndex COMMA_HERE) << "\" ;\n" ; } } } s << "}\n" ; return s ; }
void C_StringListCommandLineOption::getStringOptionNameList (TC_UniqueArray <C_String> & outArray) { C_StringListCommandLineOption * p = gFirstStringListOption ; while (p != NULL) { outArray.addObject (p->mDomainName) ; outArray.addObject (p->mIdentifier) ; p = p->mNext ; } }
void cLexiqueIntrospection::getKeywordListNames (TC_UniqueArray <C_String> & outList) { outList.setCountToZero () ; cLexiqueIntrospection * p = gLexiqueIntrospectionRoot ; while (NULL != p) { p->mAppendKeywordListNames (outList) ; p = p->mNext ; } }
void C_DirectedGraph::removeEdgesToNode (const uint32_t inNodeIndex COMMA_LOCATION_ARGS) { //--- get nodes that have edges to this node const C_UIntSet nodeSet = mReverseEdges ((int32_t) inNodeIndex COMMA_THERE) ; //--- Remove edges in reverse egde array mReverseEdges.setObjectAtIndex (C_UIntSet (), (int32_t) inNodeIndex COMMA_THERE) ; //--- Remove edge in direct edge array TC_UniqueArray <uint32_t> sourceNodeArray ; nodeSet.getValueArray (sourceNodeArray) ; for (int32_t i=0 ; i<sourceNodeArray.count () ; i++) { const uint32_t sourceNodeIndex = sourceNodeArray (i COMMA_HERE) ; mEdges ((int32_t) sourceNodeIndex COMMA_HERE).remove (inNodeIndex) ; } //--- Check #ifndef DO_NOT_GENERATE_CHECKINGS checkGraph (HERE) ; #endif }
void C_galgas_type_descriptor::recursiveGetSortedTypeList (C_galgas_type_descriptor * inRoot, TC_UniqueArray <C_galgas_type_descriptor *> & ioTypeList) { if (NULL != inRoot) { recursiveGetSortedTypeList (inRoot->mPreviousType, ioTypeList) ; ioTypeList.addObject (inRoot) ; recursiveGetSortedTypeList (inRoot->mNextType, ioTypeList) ; } }
void C_DirectedGraph::removeNode (const uint32_t inNodeIndex) { if (inNodeIndex < (uint32_t) mEdges.count ()) { mNodes.remove (inNodeIndex) ; const C_UIntSet targetSet = mEdges ((int32_t) inNodeIndex COMMA_HERE) ; TC_UniqueArray <uint32_t> targetList ; targetSet.getValueArray (targetList) ; for (int32_t i=0 ; i<targetList.count () ; i++) { const uint32_t targetIndex = targetList (i COMMA_HERE) ; mReverseEdges ((int32_t) targetIndex COMMA_HERE).remove (inNodeIndex) ; } mEdges.setObjectAtIndex (C_UIntSet (), (int32_t) inNodeIndex COMMA_HERE) ; } const uint32_t f = mNodes.firstValueNotIsSet () ; while (f < (uint32_t) mEdges.count ()) { mEdges.removeLastObject (HERE) ; mReverseEdges.removeLastObject (HERE) ; } #ifndef DO_NOT_GENERATE_CHECKINGS checkGraph (HERE) ; #endif }
void C_DirectedGraph::checkGraph (LOCATION_ARGS) const { MF_AssertThere (mEdges.count () == mReverseEdges.count (), "mEdges.count () %lld != mReverseEdges.count () %lld", mEdges.count (), mReverseEdges.count ()) ; MF_AssertThere (mNodes.firstValueNotIsSet () == (uint32_t) (mEdges.count ()), "mNodes.firstValueNotIsSet () %lld != mEdges.count () %lld", mNodes.firstValueNotIsSet (), mEdges.count ()) ; //--- for (uint32_t i=0 ; i<(uint32_t) mEdges.count () ; i++) { TC_UniqueArray <uint32_t> targetList ; mEdges ((int32_t) i COMMA_HERE).getValueArray (targetList) ; for (int32_t j=0 ; j<targetList.count () ; j++) { const uint32_t target = targetList (j COMMA_HERE) ; MF_AssertThere (mReverseEdges ((int32_t) target COMMA_HERE).contains (i), "! mReverseEdges (%lld COMMA_HERE).contains (%lld)", target, i) ; } } //--- for (uint32_t i=0 ; i<(uint32_t) mReverseEdges.count () ; i++) { TC_UniqueArray <uint32_t> sourceList ; mReverseEdges ((int32_t) i COMMA_HERE).getValueArray (sourceList) ; for (int32_t j=0 ; j<sourceList.count () ; j++) { const uint32_t source = sourceList (j COMMA_HERE) ; MF_AssertThere (mEdges ((int32_t) source COMMA_HERE).contains (i), "! mEdges (%lld COMMA_HERE).contains (%lld)", source, i) ; } } }
void cLexiqueIntrospection::getKeywordListForIdentifier (const C_String & inIdentifier, bool & outFound, TC_UniqueArray <C_String> & outList) { outFound = false ; outList.setCountToZero () ; cLexiqueIntrospection * p = gLexiqueIntrospectionRoot ; while ((NULL != p) && !outFound) { p->mGetKeywordsForIdentifier (inIdentifier, outFound, outList) ; p = p->mNext ; } }
void cLexiqueIntrospection::handleGetKeywordListOption (C_Compiler * inCompiler) { const C_String option = gOption_galgas_5F_builtin_5F_options_outputKeywordList.getter_value () ; if (option != "") { const C_String optionFormat = "lexique_name:list_name:columns:prefix:postfix:path" ; co << "Option \"--" << gOption_galgas_5F_builtin_5F_options_outputKeywordList.mCommandString << "=" << option << "\":\n" ; TC_UniqueArray <C_String> components ; option.componentsSeparatedByString (":", components) ; if (components.count () != 6) { C_String message = "invalid option ; should be \"--" ; message << gOption_galgas_5F_builtin_5F_options_outputKeywordList.mCommandString << "=" << optionFormat + "\"" ; inCompiler->onTheFlyRunTimeError (message COMMA_HERE) ; }else if (!components (2 COMMA_HERE).isUnsignedInteger ()) { C_String message = "invalid option ; in \"--" ; message << gOption_galgas_5F_builtin_5F_options_outputKeywordList.mCommandString << "=" << optionFormat + "\", " << "\"columns\" should be an decimal unsigned number" ; inCompiler->onTheFlyRunTimeError (message COMMA_HERE) ; }else{ const uint32_t columns = components (2 COMMA_HERE).unsignedIntegerValue () ; const C_String prefix = components (3 COMMA_HERE) ; const C_String postfix = components (4 COMMA_HERE) ; const C_String identifier = components (0 COMMA_HERE) + ":" + components (1 COMMA_HERE) ; TC_UniqueArray <C_String> nameList ; bool found = false ; getKeywordListForIdentifier (identifier, found, nameList) ; if (!found) { C_String message = "invalid option ; in \"--" ; message << gOption_galgas_5F_builtin_5F_options_outputKeywordList.mCommandString << "=" << optionFormat + "\", " << "available values for \"lexique_name:list_name\" are:" ; TC_UniqueArray <C_String> keywordListNames ; getKeywordListNames (keywordListNames) ; for (int32_t i=0 ; i<keywordListNames.count () ; i++) { message << " - " << keywordListNames (i COMMA_HERE) << "\n" ; } inCompiler->onTheFlyRunTimeError (message COMMA_HERE) ; }else{ uint32_t idx = 0 ; C_String s ; for (int32_t i=0 ; i<nameList.count() ; i++) { s << " " << prefix << nameList (i COMMA_HERE) << postfix << " " ; idx ++ ; if (idx < columns) { s << "&" ; }else{ s << " \\\\\n" ; idx = 0 ; } } if (idx > 0) { for (uint32_t i = idx+1 ; i<columns ; i++) { s << " & " ; } s << " \\\\\n" ; } const C_String path = components (5 COMMA_HERE) ; C_FileManager::writeStringToFile (s, path) ; } } } }
void C_DirectedGraph::depthFirstTopologicalSort (TC_UniqueArray <uint32_t> & outSortedNodes, TC_UniqueArray <uint32_t> & outUnsortedNodes) const { outSortedNodes.setCountToZero () ; outUnsortedNodes.setCountToZero () ; //--- Get working copies TC_UniqueArray <bool> nodes ; getNodeBoolArray (nodes) ; TC_UniqueArray <uint32_t> dependencyCount (mReverseEdges.count (), 0 COMMA_HERE) ; for (int32_t i=0 ; i<mReverseEdges.count () ; i++) { TC_UniqueArray <uint32_t> s ; mReverseEdges (i COMMA_HERE).getValueArray (s) ; for (int32_t j=0 ; j<s.count () ; j++) { dependencyCount.incrementAtIndex ((int32_t) s (j COMMA_HERE) COMMA_HERE) ; } } //--- Loop TC_UniqueArray <uint32_t> workingArray ; TC_UniqueArray <uint32_t> s ; bool loop = true ; while (loop) { //--- Find a node without any dependence for (int32_t i=0 ; (i<dependencyCount.count ()) && (workingArray.count () == 0) ; i++) { if (nodes (i COMMA_HERE) && (dependencyCount (i COMMA_HERE) == 0)) { nodes.setObjectAtIndex (false, i COMMA_HERE) ; workingArray.appendObject ((uint32_t) i) ; } } loop = workingArray.count () > 0 ; if (loop) { const uint32_t node = workingArray.lastObject (HERE) ; workingArray.removeLastObject (HERE) ; outSortedNodes.appendObject (node) ; mReverseEdges ((int32_t) node COMMA_HERE).getValueArray (s) ; for (int32_t j=0 ; j<s.count () ; j++) { const uint32_t candidate = s (j COMMA_HERE) ; dependencyCount.decrementAtIndex ((int32_t) candidate COMMA_HERE) ; if (dependencyCount ((int32_t) candidate COMMA_HERE) == 0) { workingArray.appendObject (candidate) ; nodes.setObjectAtIndex (false, (int32_t) candidate COMMA_HERE) ; } } } } //--- Add unusorted nodes for (int32_t i=0 ; i<nodes.count () ; i++) { if (nodes (i COMMA_HERE)) { outUnsortedNodes.appendObject ((uint32_t) i) ; } } }
void C_DirectedGraph::topologicalSort (TC_UniqueArray <uint32_t> & outSortedNodes, TC_UniqueArray <uint32_t> & outUnsortedNodes) const { outSortedNodes.setCountToZero () ; outUnsortedNodes.setCountToZero () ; //--- Get working copies TC_UniqueArray <bool> nodes ; getNodeBoolArray (nodes) ; TC_UniqueArray <uint32_t> dependencyCount (mReverseEdges.count (), 0 COMMA_HERE) ; for (int32_t i=0 ; i<mReverseEdges.count () ; i++) { TC_UniqueArray <uint32_t> s ; mReverseEdges (i COMMA_HERE).getValueArray (s) ; for (int32_t j=0 ; j<s.count () ; j++) { dependencyCount.incrementAtIndex ((int32_t) s (j COMMA_HERE) COMMA_HERE) ; } } //--- Loop bool loop = true ; TC_UniqueArray <uint32_t> s ; while (loop) { loop = false ; for (int32_t i=0 ; i<nodes.count () ; i++) { if (nodes (i COMMA_HERE) && (dependencyCount (i COMMA_HERE) == 0)) { loop = true ; outSortedNodes.appendObject ((uint32_t) i) ; nodes.setObjectAtIndex (false, i COMMA_HERE) ; mReverseEdges (i COMMA_HERE).getValueArray (s) ; for (int32_t j=0 ; j<s.count () ; j++) { dependencyCount.decrementAtIndex ((int32_t) s (j COMMA_HERE) COMMA_HERE) ; } } } } //--- Add unusorted nodes for (int32_t i=0 ; i<nodes.count () ; i++) { if (nodes (i COMMA_HERE)) { outUnsortedNodes.appendObject ((uint32_t) i) ; } } }
void C_DirectedGraph::getNodesInvolvedInCircularities (TC_UniqueArray <uint32_t> & outNodes) const { outNodes.setCountToZero () ; //--- Get working copies TC_UniqueArray <bool> nodes ; getNodeBoolArray (nodes) ; TC_UniqueArray <uint32_t> successorCount ; TC_UniqueArray <uint32_t> predecessorCount ; for (int32_t i=0 ; i<mEdges.count () ; i++) { successorCount.appendObject (mEdges (i COMMA_HERE).count ()) ; } for (int32_t i=0 ; i<mReverseEdges.count () ; i++) { predecessorCount.appendObject (mReverseEdges (i COMMA_HERE).count ()) ; } //--- Eliminate nodes that have no successor or no predecessor bool loop = true ; while (loop) { loop = false ; for (int32_t i=0 ; i<nodes.count () ; i++) { if (nodes (i COMMA_HERE) && ((successorCount (i COMMA_HERE) == 0) || (predecessorCount (i COMMA_HERE) == 0))) { loop = true ; nodes.setObjectAtIndex (false, i COMMA_HERE) ; TC_UniqueArray <uint32_t> s ; mEdges (i COMMA_HERE).getValueArray (s) ; for (int32_t j=0 ; j<s.count () ; j++) { predecessorCount.decrementAtIndex ((int32_t) s (j COMMA_HERE) COMMA_HERE) ; } mReverseEdges (i COMMA_HERE).getValueArray (s) ; for (int32_t j=0 ; j<s.count () ; j++) { successorCount.decrementAtIndex ((int32_t) s (j COMMA_HERE) COMMA_HERE) ; } } } } //--- Add circular nodes for (int32_t i=0 ; i<nodes.count () ; i++) { if (nodes (i COMMA_HERE)) { outNodes.appendObject ((uint32_t) i) ; } } }