Return to logic.c CVS log

Up to [MW Coherent from dump] / coherent / d / bin / tsort

Annotation of coherent/d/bin/tsort/logic.c, revision 1.1.1.1

1.1       root        1: #include <stdio.h>
                      2: #include "tsort.h"
                      3: 
                      4: 
                      5: /*
                      6:  *     Remove removes the word pointed to by "wrdp".  The only effect
                      7:  *     of this is to set its "name" to the empty string.
                      8:  */
                      9: 
                     10: #define        remove(wrdp)    ((wrdp)->name[0] = '\0')
                     11: 
                     12: 
                     13: /*
                     14:  *     Gone is used to determine if a word has already been
                     15:  *     written out.  The mechanism used is that when a word
                     16:  *     has been written out, its "name" is set to the empty
                     17:  *     string.
                     18:  */
                     19: 
                     20: #define        gone(wrdp)      ((wrdp)->name[0] == '\0')
                     21: 
                     22: 
                     23: /*
                     24:  *     Clean is used to remove elements of a wordlist.  It takes
                     25:  *     the wordlist pointed to by *"wrdlp" and removes any elements
                     26:  *     for which gone returns true.
                     27:  */
                     28: 
                     29: static void
                     30: clean(wrdlp)
                     31: register struct wordlist **wrdlp;
                     32: {
                     33:        register struct worlist *wrdl;
                     34: 
                     35:        for (wrdl = *wrdlp; wrdl != NULL; wrdlp = &wrdl->next, wrdl = *wrdlp)
                     36:                if (gone(wrdl->element)) {
                     37:                        do {
                     38:                                wrdl = wrdl->next;
                     39:                        } while (wrdl != NULL && gone(wrdl->element));
                     40:                        *wrdlp = wrdl;
                     41:                        if (wrdl == NULL)
                     42:                                break;
                     43:                }
                     44: }
                     45: 
                     46: 
                     47: /*
                     48:  *     Pass makes one pass thru the wordlist pointed to by words,
                     49:  *     cleaning up all ancestor lists and writeing out all words
                     50:  *     with no ancestors.  When it writes out a word, it "remove"s
                     51:  *     it.  When the pass is completed, it makes another pass 
                     52:  *     to actually take all written out words out of the list
                     53:  *     of words.
                     54:  */
                     55: 
                     56: static
                     57: pass()
                     58: {
                     59:        register struct wordlist *wrdlp;
                     60:        register progress = FALSE;
                     61: 
                     62:        for (wrdlp = words; wrdlp != NULL; wrdlp = wrdlp->next) {
                     63:                clean(&wrdlp->element->ancestors);
                     64:                if (wrdlp->element->ancestors == NULL) {
                     65:                        progress = TRUE;
                     66:                        printf("%s\n", wrdlp->element->name);
                     67:                        remove(wrdlp->element);
                     68:                }
                     69:        }
                     70:        clean(&words);
                     71:        return (progress);
                     72: }
                     73: 
                     74: 
                     75: /*
                     76:  *     Dump is used to dump out the remaining words if we find any
                     77:  *     cycles.  It simply prints out all the remaining words in
                     78:  *     a random order.
                     79:  */
                     80: 
                     81: static void
                     82: dump()
                     83: {
                     84:        register struct wordlist *wrdlp;
                     85: 
                     86:        for (wrdlp = words; wrdlp != NULL; wrdlp = wrdlp->next)
                     87:                printf("%s\n", wrdlp->element->name);
                     88: }
                     89: 
                     90: 
                     91: /*
                     92:  *     Order is the routine which actually controls the dumping
                     93:  *     of all entries in the tree.  It repeatedly calls pass until
                     94:  *     the tree is empty or nothing new can be dumped (indicateing
                     95:  *     a cycle).
                     96:  */
                     97: 
                     98: void
                     99: order()
                    100: {
                    101:        while (pass())
                    102:                ;
                    103:        dump();
                    104:        if (words != NULL)
                    105:                die("cycles");
                    106: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.