idep_LinkDep_i Struct Reference

List of all members.

Public Member Functions

 idep_LinkDep_i ()
 ~idep_LinkDep_i ()
int entry (const char *name, int suffixFlag)
void loadDependencies (std::istream &in, int suffixFlag)
void createCycleArray ()
int calculate (std::ostream &orr, int canonicalFlag, int suffixFlag)

Public Attributes

idep_NameIndexMap d_unaliases
idep_AliasTable d_aliases
idep_NameArray d_dependencyFiles
idep_NameIndexMapd_componentNames_p
idep_BinReld_dependencies_p
int * d_map_p
int * d_levels_p
int * d_levelNumbers_p
int * d_cycles_p
int * d_weights_p
int * d_cycleIndices_p
int d_numComponents
int d_numLevels
int d_numCycles
int d_numMembers
int d_ccd

Detailed Description

Definition at line 113 of file idep_ldep.cxx.


Constructor & Destructor Documentation

idep_LinkDep_i::idep_LinkDep_i (  ) 

Definition at line 141 of file idep_ldep.cxx.

00142 : d_componentNames_p(0)
00143 , d_dependencies_p(0)
00144 , d_map_p(0)
00145 , d_levels_p(0)
00146 , d_levelNumbers_p(0)
00147 , d_cycles_p(0)
00148 , d_weights_p(0)
00149 , d_cycleIndices_p(0)
00150 , d_numComponents(-1)
00151 , d_numLevels(-1)
00152 , d_numCycles(-1)
00153 , d_numMembers(-1)
00154 , d_ccd(-1)
00155 {
00156 }

idep_LinkDep_i::~idep_LinkDep_i (  ) 

Definition at line 158 of file idep_ldep.cxx.

References d_componentNames_p, d_cycleIndices_p, d_cycles_p, d_dependencies_p, d_levelNumbers_p, d_levels_p, d_map_p, and d_weights_p.

00159 {
00160     delete d_componentNames_p;
00161     delete d_dependencies_p;
00162     delete [] d_map_p;
00163     delete [] d_levels_p;
00164     delete [] d_levelNumbers_p;
00165     delete [] d_cycles_p;
00166     delete [] d_weights_p;
00167     delete [] d_cycleIndices_p;
00168 }


Member Function Documentation

int idep_LinkDep_i::calculate ( std::ostream &  orr,
int  canonicalFlag,
int  suffixFlag 
)

Definition at line 331 of file idep_ldep.cxx.

References idep_BinRel::clr(), createCycleArray(), d_ccd, d_componentNames_p, d_cycleIndices_p, d_cycles_p, d_dependencies_p, d_dependencyFiles, d_levelNumbers_p, d_levels_p, d_map_p, d_numComponents, d_numCycles, d_numLevels, d_numMembers, d_weights_p, err(), idep_BinRel::get(), IOERROR, idep_NameArray::length(), idep_BinRel::length(), idep_NameIndexMap::length(), loadDependencies(), idep_BinRel::makeNonTransitive(), idep_BinRel::makeTransitive(), and idep_BinRel::set().

Referenced by idep_LinkDep::calculate().

00332 {
00333     enum { IOERRR = -1 };
00334 
00335     // clean up any previous calculation artifacts
00336     delete d_componentNames_p;  
00337     delete d_dependencies_p;
00338     delete [] d_map_p;
00339     delete [] d_levels_p;
00340     delete [] d_levelNumbers_p;
00341     delete [] d_cycles_p;
00342     delete [] d_weights_p;
00343     delete [] d_cycleIndices_p;
00344 
00345     // allocate new data structures for this calculation
00346     d_componentNames_p = new idep_NameIndexMap;
00347     d_dependencies_p = new idep_BinRel;     
00348     d_map_p = 0;                // allocated later when length is known
00349     d_levels_p = 0;             // allocated later when length is known
00350     d_levelNumbers_p = 0;       // allocated later when length is known
00351     d_cycles_p = 0;             // allocated later when length is known
00352     d_numLevels = -1;           // invalidate for now
00353     d_numComponents = -1;       // invalidate for now (-1 value is important)
00354     d_numCycles = -1;           // invalidate for now
00355     d_numMembers = -1;          // invalidate for now
00356     d_ccd = -1;                 // invalidate for now
00357 
00358     // Now try to read dependencies from specified set of files.
00359     // If an I/O error occurs, abort; otherwise keep on processing.
00360     int i;
00361     for (i = 0; i < d_dependencyFiles.length(); ++i) {
00362         const int INSANITY = 1000;
00363         if (d_dependencies_p->length() > INSANITY) {
00364             orr << "SANITY CHECK: Number of components is currently " 
00365                << d_dependencies_p->length() << " !!!!" << std::endl;
00366 
00367         }
00368         enum { IOERROR = -1 };
00369         const char *file = d_dependencyFiles[i];
00370 
00371         if ('\0' == *file) {
00372             loadDependencies(std::cin, suffixFlag);
00373             // reset eof for standard input
00374             std::cin.clear(std::ios::iostate(0));
00375         }
00376         else {
00377             std::ifstream in(file);
00378             if (!in) {
00379                 err(orr) << "dependency file \"" << file 
00380                         << "\" not found." << std::endl;
00381                 return IOERROR;
00382             }
00383             loadDependencies(in, suffixFlag);
00384         }
00385     }
00386 
00387     // We can now allocate fixed size arrays:
00388 
00389     d_numComponents = d_dependencies_p->length();
00390     assert (d_componentNames_p->length() == d_numComponents);
00391 
00392     // Create the level array for component name indices.  We will fill in the 
00393     // level array with the number of components on each level.  
00394 
00395     d_levels_p = new int[d_numComponents]; // will holds # of components/level
00396     d_numLevels = 0;                       // initially there are no levels
00397 
00398     // Create the level number array to hold the level number for each 
00399     // component.  This array will be filled in at the end of this function.
00400 
00401     d_levelNumbers_p = new int[d_numComponents]; // will holds level #'s
00402 
00403     // Create the mapping array for component name indices.  This array
00404     // will hold the sorted indices of the original component names.
00405 
00406     d_map_p = new int[d_numComponents]; // array of levelized component indices
00407     int pIndex = 0;                     // current length of mapping
00408 
00409     // Create an array of byte vectors.  Each byte vector identifies the 
00410     // components that are below the indicated level index.  The rows are 
00411     // allocated as the levels in the system are defined, beginning with level 
00412     // corresponding to d_numLevels = 0.  At the end of this calculation, the 
00413     // first d_numLevels + 1 byte vectors in this array must be deleted 
00414     // explicitly.
00415     //
00416     // level
00417     // index
00418     //       +-------+   
00419     //   N   |   ?   |
00420     //       +-------+
00421     //  N-1  |   ?   |         +----------------------------------+
00422     //       +-------+         | `i' is defined to be d_numLevels |
00423     //       :       :         +----------------------------------+---+
00424     //       :       :         | `N' is defined to be d_numComponents |
00425     //       +-------+         +--------------------------------------+
00426     //  i+1  |   ?   |
00427     //       +-------+
00428     //   i   |   o---|--->[ 1 ][ 1 ][ 0 ][ 1 ][ 1 ][ 1 ][ 0 ] ... [ 0 ]
00429     //       +-------+
00430     //       :       :
00431     //       :       :
00432     //       +-------+
00433     //   1   |   o---|--->[ 0 ][ 1 ][ 0 ][ 0 ][ 1 ][ 0 ][ 0 ] ... [ 0 ]
00434     //       +-------+
00435     //   0   |   o---|--->[ 0 ][ 0 ][ 0 ][ 0 ][ 0 ][ 0 ][ 0 ] ... [ 0 ]
00436     //       +-------+    
00437     // component index:     0    1    2    3    4    5    6        N-1
00438 
00439     char **lowerThan = new char *[d_numComponents + 1]; // array of byte sets 
00440 
00441     lowerThan[0] = new char[d_numComponents];  // set of lower-level components
00442     memset(lowerThan[0], 0, d_numComponents);  // initially this set is empty
00443     char *current = new char[d_numComponents]; // components on current level
00444 
00445     d_dependencies_p->makeTransitive(); // perform transitive closure algorithm
00446 
00447     createCycleArray();            // determine and label members of all cycles
00448 
00449     // We can now use the transitive dependency relation to sort the 
00450     // components in this system into levelized order (provided the
00451     // graph is asyclic).  In order to facilitate the levelization 
00452     // algorithm, the principal members of each cycle will be temporarily 
00453     // stripped of their dependency on the other members of that cycle.
00454     // All of the remaining members will be ignored by the levelization
00455     // algorithm (by marking them as already belonging to a lower level). 
00456 
00457     for (i = 0; i < d_numComponents; ++i) {
00458         if (d_cycles_p[i] == i) {
00459           int j;
00460           for (j = i + 1; j < d_numComponents; ++j) {
00461             if (d_cycles_p[j] == i) {
00462               assert(d_dependencies_p->get(i,j));
00463               d_dependencies_p->clr(i,j); // strip cyclic dependency
00464               lowerThan[0][j] = 1; // ignore other members in algorithm
00465             }
00466           }
00467         }
00468     }
00469 
00470     // We will now construct the levelized array of component indices.  For
00471     // each level in this system, we will examine each component in the system
00472     // to see if it depends on any higher level components.  Note that we have 
00473     // already stripped out cyclic dependencies as described above.  If a 
00474     // component is part of a lower level we will ignore it.  Otherwise, we 
00475     // will check to see if that component depends on any other components 
00476     // that are _not_ at a lower level.  If so, the component is skipped over; 
00477     // otherwise the component index is added to the current level and 
00478     // appended to the end of the levelized list.  If this index corresponds
00479     // to the principal member of a cycle, we use the weight of the cycle to 
00480     // determine the level below the current level to use to to check
00481     // dependencies.  If the principal member of the cycle depends only on
00482     // components at a level "weight" (or more) lower than the current level,
00483     // all other members are immediately appended to the list in their
00484     // original order.  At this point, we restore the cyclic dependencies of 
00485     // that principal component on the other members of its cycle.  After 
00486     // iterating through all of the components, the number of components on 
00487     // the current level is appended to the level array and the current level 
00488     // set is united with the lower level set.  This process repeats until all
00489     // components are assigned a level.
00490 
00491     while (pIndex < d_numComponents) {  // not all components assigned a level
00492         int componentCount = 0;         // number of components on this level
00493         memset(current, 0, d_numComponents); // initially current level empty
00494         int i;
00495         for (i = 0; i < d_numComponents; ++i) {
00496             if (d_cycles_p[i] >= 0 && d_cycles_p[i] != i) {
00497                 continue;   // component is non principal member of a cycle
00498             }
00499 
00500             if (lowerThan[d_numLevels][i]) {    
00501                 continue;   // already at a lower level;
00502             }
00503 
00504             int weight = 1; // weight of non-cyclically dependent component
00505 
00506             if (d_cycles_p[i] == i) {   // if principal member of cycle
00507                 weight = d_weights_p[i];
00508                 if (d_weights_p[i] > d_numLevels + 1) {
00509                     continue; // weight of cycle two heigh for current level
00510                 }
00511             }
00512 
00513             int searchLevel = d_numLevels + 1 - weight; // allowed dependencies
00514             int j;
00515             for (j = 0; j < d_numComponents; ++j) {
00516                 if (i == j) {
00517                     continue;
00518                 }
00519                 if (d_dependencies_p->get(i,j) && !lowerThan[searchLevel][j]) {
00520                     break; // depends on component not at or below search level
00521                 }
00522             }
00523             if (j < d_numComponents) {
00524                 continue;   // consider next candidate i
00525             }
00526             current[i] = 1; // record component as being at the current level
00527             d_map_p[pIndex++] = i; // append component in levelized order
00528             ++componentCount;   
00529             if (d_cycles_p[i] == i) {   // if principal member of a cycle
00530                 for (j = i + 1; j < d_numComponents; ++j) {
00531                     if (d_cycles_p[j] == i) {  // if other member of this cycle
00532                         d_map_p[pIndex++] = j; // append it to current level
00533                         ++componentCount;
00534                         d_dependencies_p->set(i,j); // restore dependencies
00535                     }
00536                 }
00537             }
00538         }
00539 
00540         // advance to next level
00541         for (i = 0; i < d_numComponents; ++i) {
00542             current[i] |= lowerThan[d_numLevels][i]; 
00543         }
00544         d_levels_p[d_numLevels++] = componentCount; // components per level
00545         lowerThan[d_numLevels] = current;    // attach new lower level
00546         current = new char[d_numComponents]; // reallocate current array
00547     }
00548 
00549     assert (pIndex == d_numComponents);
00550 
00551     // at this point we can load the level number array
00552 
00553     int start = 0;
00554 
00555     for (i = 0; i < d_numLevels; ++i) {
00556         int top = start + d_levels_p[i];
00557         int j;
00558         for (j = start; j < top; ++j) {
00559             d_levelNumbers_p[d_map_p[j]] = i;
00560         }
00561         start = top;
00562     }
00563 
00564     // Sort components within each level lexicographically to make names 
00565     // easier to find and to provide a canonical order to facilitate finding
00566     // differences as software is modified (e.g., via the Unix diff command).
00567 
00568     start = 0;
00569     int k;
00570     for (k = 0; k < d_numLevels; ++k) {
00571       int top = start + d_levels_p[k];
00572       int i;
00573       for (i = start + 1; i < top; ++i) {
00574         int j;
00575         for (j = start; j < i; ++j) {
00576           if (strcmp((*d_componentNames_p)[d_map_p[i]],
00577                      (*d_componentNames_p)[d_map_p[j]]) < 0) {
00578             int tmp = d_map_p[i];
00579             d_map_p[i] = d_map_p[j];
00580             d_map_p[j] = tmp;
00581           }
00582         }
00583       }
00584       start = top;
00585     }
00586 
00587     // We can now uses the cycles array and the level map to create the 
00588     // cycleIndex array.  This array assigns all components of each cycle
00589     // a unique cycle index (in increasing order w.r.t. level).
00590 
00591     int cycleCount = 0;
00592     for (i = 0; i < d_numComponents; ++i) { 
00593         const int label = d_cycles_p[d_map_p[i]];
00594         if (label < 0) {
00595             continue; // not part of any cycle
00596         }
00597 
00598         const int index = d_cycleIndices_p[d_map_p[i]];
00599         if (index >= 0 && index < cycleCount) {
00600             continue; // part of lower level cycle
00601         }
00602 
00603         // Found the next cycle, go through the remander of the sequence and
00604         // annotate each correspondingly labeled component with current cycle 
00605         // index in the cycleIndices array.
00606         int j;
00607         for (j = i; j < d_numComponents; ++j) { 
00608           if (label == d_cycles_p[d_map_p[j]]) {
00609             d_cycleIndices_p[d_map_p[j]] = cycleCount;
00610           }
00611         }
00612 
00613         ++cycleCount;
00614     }
00615 
00616     assert(cycleCount == d_numCycles); 
00617         
00618     // Now sort components within each level again, but this time
00619     // group cyclically dependent components together in order of
00620     // cycle index to facilitate understanding of cycle composition.
00621     // The previous sort ensured that cycle indices will be in the 
00622     // order of the lexicographically smallest member of the cycle 
00623     // on a given level.
00624 
00625     start = 0;
00626     for (k = 0; k < d_numLevels; ++k) {
00627       int top = start + d_levels_p[k];
00628       int i;
00629       for (i = start + 1; i < top; ++i) {
00630         int j;
00631         for (j = start; j < i; ++j) {
00632           int ci = d_cycleIndices_p[d_map_p[i]];
00633           int cj = d_cycleIndices_p[d_map_p[j]];
00634           if (ci < cj || ci == cj &&
00635               strcmp((*d_componentNames_p)[d_map_p[i]],
00636                      (*d_componentNames_p)[d_map_p[j]]) < 0) {
00637             int tmp = d_map_p[i];
00638             d_map_p[i] = d_map_p[j];
00639             d_map_p[j] = tmp;
00640           }
00641         }
00642       }
00643       start = top;
00644     }
00645 
00646     // Clean up local data structures.
00647     for (i = 0; i <= d_numLevels; ++i) {
00648         delete [] lowerThan[i];
00649     }
00650     delete [] lowerThan;
00651     delete [] current;
00652 
00653     // Calculate CCD and cache the value in a data member of the object.
00654     idep_BinRel tmp = *d_dependencies_p; // temporary for calculating CCD
00655     for (i = 0; i < d_numComponents; ++i) {
00656         if (0 == d_levelNumbers_p[i]) { 
00657             for (int j = 0; j < d_numComponents; ++j) {
00658                 tmp.clr(j, i); // ignore dependencies on all level 0 components
00659             }
00660         }
00661         else {
00662             tmp.set(i, i);     // each component itself contributes unit weight
00663         }
00664     }
00665 
00666     int sum = 0;
00667 
00668     for (i = 0; i < d_numComponents; ++i) {
00669         for (int j = 0; j < d_numComponents; ++j) {
00670             if (tmp.get(i,j)) {
00671                 ++sum;
00672             }
00673         }
00674     }
00675 
00676     d_ccd = sum;        // Cache this value -- too hard to calculate later.
00677 
00678     if (canonicalFlag) {
00679         // In order to ensure a canonical representations with redundant
00680         // dependencies removed, it is necessary to create a canonical
00681         // sorted binary relation based on the d_map_p array.  After removing
00682         // transitive entries from that relation, the results are then mapped 
00683         // back to the d_dependencies_p relation.
00684 
00685         idep_BinRel tmp(d_numComponents);
00686         int i;
00687         for (i = 0; i < d_numComponents; ++i) {
00688             int u = d_map_p[i];
00689             for (int j = 0; j < d_numComponents; ++j) {
00690                 int v = d_map_p[j];
00691                 int bit = d_dependencies_p->get(u, v);
00692                 tmp.set(i, j, bit);
00693             }
00694         }
00695 
00696         tmp.makeNonTransitive();
00697 
00698         for (i = 0; i < d_numComponents; ++i) {
00699             int u = d_map_p[i];
00700             for (int j = 0; j < d_numComponents; ++j) {
00701                 int v = d_map_p[j];
00702                 int bit = tmp.get(i, j);
00703                 d_dependencies_p->set(u, v, bit);
00704             }
00705         }
00706     }
00707 
00708     return d_numMembers;
00709 }

void idep_LinkDep_i::createCycleArray (  ) 

Definition at line 255 of file idep_ldep.cxx.

References d_cycleIndices_p, d_cycles_p, d_dependencies_p, d_numComponents, d_numCycles, d_numMembers, d_weights_p, and idep_BinRel::get().

Referenced by calculate().

00256 {
00257     assert (!d_cycles_p);               // should not already exist
00258     assert (!d_weights_p);              // should not already exist
00259     assert (!d_cycleIndices_p);         // should not already exist
00260     assert (d_numComponents >= 0);      // should be valid
00261 
00262     // Create the cycle array used to detect and identify potential cycles.
00263     
00264     d_cycles_p = new int[d_numComponents];  // identifies members of cycles
00265     d_weights_p = new int[d_numComponents]; // identifies weights of cycles
00266     d_cycleIndices_p = new int[d_numComponents];  // consecutive indices
00267 
00268     // Members of each cycle are identified by the index of their first member.
00269 
00270     enum { NO_CYCLE = -1 };                 
00271     int i;
00272     for (i = 0; i < d_numComponents; ++i) {  
00273         d_cycles_p[i] = NO_CYCLE;       // Initially each entry is invalid. 
00274         d_weights_p[i] = 0;             // Initially weight of each cycle is 0.
00275         d_cycleIndices_p[i] = NO_CYCLE; // Initially each entry is invalid. 
00276                                         // These indices will be determined
00277                                         // after levelization has occurred.
00278     }
00279 
00280     d_numCycles = 0;                    // # of unique design cycles
00281     d_numMembers = 0;                   // # of cyclicly-dependent components
00282 
00283     // Load the cycle array.  For each cycle detected, the non-negative 
00284     // index of the lowest participating component is used as a tag to 
00285     // identify that cycle.  For each component we will scan ahead to see 
00286     // on what other components this component is mutually dependent.  
00287     // If one or more is found, each of these locations will be set to 
00288     // the index value of the first (primary) component in the cycle.  
00289     // Ideally there will be no cycles, in which case each entry in the 
00290     // array will be left set to -1.  We will use the cycle array initially 
00291     // to report all cyclic dependencies and again later to facilitate
00292     // the levelization algorithm in the presence of cycles.
00293 
00294     for (i = 0; i < d_numComponents; ++i) { 
00295         if (d_cycles_p[i] >= 0) {
00296             continue;               // part of a previously reported cycle
00297         }
00298         int cycleFound = 0;
00299         d_cycles_p[i] = i;          // first component in potential cycle
00300         int j;
00301         for (j = i + 1; j < d_numComponents; ++j) {
00302             if (d_cycles_p[j] >= 0) {
00303                 continue;           // part of a previously reported cycle
00304             }
00305             if (d_dependencies_p->get(i, j) && d_dependencies_p->get(j, i)) { 
00306                 cycleFound = 1;     // record that we have a cycle
00307                 d_cycles_p[j] = i;  // record index of first component
00308             }
00309         }
00310         if (cycleFound) {           // if cycle found involving component `i'
00311             int weight = 0;
00312             for (j = i; j < d_numComponents; ++j) { // find each cycle member
00313                 if (d_cycles_p[j] == i) {
00314                     ++weight;       // # members in this cycle
00315                 }
00316             }
00317             for (j = i; j < d_numComponents; ++j) { // find each cycle member
00318                 if (d_cycles_p[j] == i) {
00319                     d_weights_p[j] = weight;  // store weight for each member
00320                 }
00321             }
00322             d_numMembers += weight;   // total # of members in cycles   
00323             ++d_numCycles;
00324         }
00325         else {
00326             d_cycles_p[i] = NO_CYCLE; // component `i' is not part of a cycle
00327         }
00328     }
00329 }

int idep_LinkDep_i::entry ( const char *  name,
int  suffixFlag 
)

Definition at line 170 of file idep_ldep.cxx.

References idep_BinRel::appendEntry(), d_aliases, d_componentNames_p, d_dependencies_p, d_unaliases, idep_NameIndexMap::entry(), isLocal(), len, idep_NameIndexMap::length(), idep_AliasTable::lookup(), idep_NameIndexMap::lookup(), NULL_CHAR, removeFileName(), removeSuffix(), and size.

Referenced by loadDependencies().

00171 {
00172     int size = strlen(name) + 1;
00173     char *buf = new char[size];
00174     memcpy(buf, name, size);
00175 
00176     if (!isLocal(buf)) {
00177         removeFileName(buf);
00178         if (d_unaliases.lookup(buf) >= 0) {             // found unalias
00179             memcpy(buf, name, size);                    // restore buffer
00180         }
00181     }
00182 
00183     if (suffixFlag) {
00184         removeSuffix(buf);
00185     }
00186 
00187     const char *componentName = d_aliases.lookup(buf);
00188     if (!componentName) {
00189         const char SLASH_CHAR = '/';
00190         const char NULL_CHAR = '\0';
00191         int len = strlen(buf);
00192         int last = len - 1;
00193         if (SLASH_CHAR == buf[last]) {             // If the input ends in '/' 
00194             buf[last] = NULL_CHAR;                 // try removing the '/' and
00195             componentName = d_aliases.lookup(buf); // checking for that alias.
00196             if (!componentName) {
00197                 buf[last] = SLASH_CHAR; // restore
00198             }
00199         }
00200     }
00201 
00202     if (!componentName) {
00203         componentName = buf;
00204     }
00205 
00206     int length = d_componentNames_p->length();
00207     int index = d_componentNames_p->entry(componentName);
00208     if (d_componentNames_p->length() > length) {
00209         d_dependencies_p->appendEntry();
00210     }
00211 
00212     delete [] buf;
00213 
00214     return index;
00215 }

void idep_LinkDep_i::loadDependencies ( std::istream &  in,
int  suffixFlag 
)

Definition at line 217 of file idep_ldep.cxx.

References d_dependencies_p, entry(), it, NEWLINE_CHAR, and idep_BinRel::set().

Referenced by calculate().

00218 {
00219     enum { INVALID_INDEX = -1 };
00220     const char NEWLINE_CHAR = '\n';
00221     int lineno = 1;
00222     int fromIndex = INVALID_INDEX;
00223     int lastTokenWasNewline = 1;
00224 
00225     for (idep_TokenIter it(in); it; ++it) {     
00226         if ('#' == *it()) {                          // strip comment if any
00227             while (it && '\n' != *it()) {
00228                 ++it;
00229             }
00230             if (!it) {                               // either !it or '\n'
00231                 continue;
00232             }
00233         }
00234 
00235         if (NEWLINE_CHAR == *it()) {                    
00236             ++lineno;                                // end of line
00237             if (lastTokenWasNewline) {
00238                 fromIndex = INVALID_INDEX;           // end of current sequence
00239             }
00240             lastTokenWasNewline = 1;                 // record newline state
00241         }
00242         else {
00243             if (INVALID_INDEX == fromIndex) {
00244                 fromIndex = entry(it(), suffixFlag); // start of new sequence
00245             }
00246             else {                                   // found a dependency
00247                 int toIndex = entry(it(), suffixFlag);     
00248                 d_dependencies_p->set(fromIndex, toIndex); 
00249             }
00250             lastTokenWasNewline = 0;                 // record newline state
00251         }
00252     }
00253 }


Member Data Documentation

Definition at line 115 of file idep_ldep.cxx.

Referenced by idep_LinkDep::addAlias(), entry(), and idep_LinkDep::readAliases().

Definition at line 130 of file idep_ldep.cxx.

Referenced by calculate(), and idep_LinkDep::ccd().

Definition at line 123 of file idep_ldep.cxx.

Referenced by calculate(), createCycleArray(), and ~idep_LinkDep_i().

Definition at line 116 of file idep_ldep.cxx.

Referenced by idep_LinkDep::addDependencyFile(), and calculate().

Definition at line 122 of file idep_ldep.cxx.

Referenced by calculate(), idep_DependencyIter::level(), and ~idep_LinkDep_i().

Definition at line 128 of file idep_ldep.cxx.

Referenced by calculate(), createCycleArray(), and idep_LinkDep::numCycles().

Definition at line 129 of file idep_ldep.cxx.

Referenced by calculate(), createCycleArray(), and idep_LinkDep::numMembers().


The documentation for this struct was generated from the following file:

Generated on 13 Dec 2018 for loon by  doxygen 1.6.1