Return to word.c CVS log

Up to [Research Unix] / researchv10no / cmd / mk / src

Annotation of researchv10no/cmd/mk/src/word.c, revision 1.1.1.1

1.1       root        1: #include       "mk.h"
                      2: 
                      3: Word *
                      4: newword(s)
                      5:        char *s;
                      6: {
                      7:        register Word *w = (Word *)Malloc(sizeof(Word));
                      8: 
                      9:        w->s = strdup(s);
                     10:        w->next = 0;
                     11:        return(w);
                     12: }
                     13: 
                     14: Word *
                     15: stow(s)
                     16:        char *s;
                     17: {
                     18:        char save;
                     19:        register char *t;
                     20:        Word *head, *w;
                     21: 
                     22:        w = head = newword("");
                     23:        while(*s){
                     24:                while(SEP(*s))
                     25:                        s++;
                     26:                if(*s == 0) break;
                     27:                for(t = s; *t && !SEP(*t); t++)
                     28:                        ;
                     29:                save = *t;
                     30:                *t = 0;
                     31:                w->next = newword(s);
                     32:                w = w->next;
                     33:                *t = save;
                     34:                s = t;
                     35:        }
                     36:        w = head->next;
                     37:        delword(head);
                     38:        return(w);
                     39: }
                     40: 
                     41: char *
                     42: wtos(w)
                     43:        register Word *w;
                     44: {
                     45:        static char buf[BIGBLOCK];
                     46:        register char *s = buf;
                     47:        register char *t;
                     48: 
                     49:        for(; w; w = w->next){
                     50:                for(t = w->s; *t;)
                     51:                        *s++ = *t++;
                     52:                if(w->next)
                     53:                        *s++ = ' ';
                     54:        }
                     55:        *s = 0;
                     56:        return(strdup(buf));
                     57: }
                     58: 
                     59: delword(w)
                     60:        Word *w;
                     61: {
                     62:        free(w->s);
                     63:        free((char *)w);
                     64: }
                     65: 
                     66: dumpw(s, w)
                     67:        char *s;
                     68:        Word *w;
                     69: {
                     70:        Fprint(1, "%s", s);
                     71:        for(; w; w = w->next)
                     72:                Fprint(1, " '%s'", w->s);
                     73:        Fputc(1, '\n');
                     74: }

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