Return to munch2.1.c CVS log

Up to [Research Unix] / researchv10no / cmd / cfront

Annotation of researchv10no/cmd/cfront/munch2.1.c, revision 1.1

1.1     ! root        1: /*ident        "@(#)ctrans:lib/static/munch.c  1.4.1.2" */
        !             2: /**************************************************************************
        !             3:                        Copyright (c) 1984 AT&T
        !             4:                          All Rights Reserved   
        !             5: 
        !             6:        THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF AT&T
        !             7:        
        !             8:        The copyright notice above does not evidence any        
        !             9:        actual or intended publication of such source code.
        !            10: 
        !            11: *****************************************************************************/
        !            12: /*
        !            13:        scan nm output and detect constructors and destructors for static objects.
        !            14:        the name on an nm output line is expected to be in the right hand margin.
        !            15:        the name is expected to be on the form __std__ or __sti__ and less than
        !            16:        100 characters long.
        !            17:        nm output lines are assumed to be less than 256 characters long.
        !            18:        constructors found are called by _main() called from main().
        !            19:        destructors found are called by exit().
        !            20:        return 1 if no constructor or destructor is found;
        !            21:        otherwise, returns 0
        !            22:        The output is redirected by CC into _ctdt.c
        !            23:        
        !            24: */
        !            25: 
        !            26: #include <stdio.h>
        !            27: #include <ctype.h>
        !            28: #include <stdlib.h>
        !            29: //extern int strcpy(char*, char*);
        !            30: //extern char * strtok(char*, char*);
        !            31: 
        !            32: struct sbuf {
        !            33:        sbuf* next;
        !            34:        char str[100];
        !            35:        sbuf(sbuf* l, char* p);
        !            36: };
        !            37: 
        !            38: sbuf::sbuf(sbuf* l, char* p)
        !            39: {
        !            40:        next=l;
        !            41:        // strcpy(str,strtok(p," |"));
        !            42:        // ``unrolled'' since strtok() is not on bsd systems
        !            43:        register char* s = str;
        !            44:        for (register char c = *p++; c && c!=' ' && c!='|'; c = *p++) *s++ = c;
        !            45:        *s = 0; 
        !            46: }
        !            47: 
        !            48: sbuf* dtor;    // list of constructors
        !            49: sbuf* ctor;    // list of destructors
        !            50: 
        !            51: main (int, char* argv[])
        !            52: {
        !            53:        char buf[256];
        !            54:        register char* p;
        !            55: 
        !            56: newline:
        !            57:        p = buf;
        !            58:        for(;;) {
        !            59:                int c;
        !            60:                switch (c=getchar()) {
        !            61:                case EOF:
        !            62:                        goto done;
        !            63:                case '\n':
        !            64:                {       *p = 0;         // terminate string
        !            65:                        p = buf;
        !            66:                        while (*p!='_') if (*p++ == 0) goto newline;
        !            67:                        if (p!=buf && !isspace( *(p-1))) goto newline; // '_' not first character
        !            68:                         // accept __st and ___st
        !            69:                         if (*++p != '_') goto newline; // need '__'
        !            70:                        if (*++p != '_')
        !            71:                           { p--; 
        !            72:                             p--;
        !            73:                           }
        !            74:                         else
        !            75:                             p--;
        !            76: 
        !            77:                        register char* st = p;
        !            78:                        if (st[0]!='_' || st[1]!='_' || 
        !            79:                            st[2]!='s' || st[3]!='t' ||
        !            80:                            st[5]!='_' || st[6]!='_' ) 
        !            81:                                goto newline;
        !            82:                        switch (st[4]) {
        !            83:                        case 'd':
        !            84:                                dtor = new sbuf(dtor,st);
        !            85:                                goto newline;
        !            86:                        case 'i':
        !            87:                                ctor = new sbuf(ctor,st);
        !            88:                        default:
        !            89:                                goto newline;
        !            90:                        }
        !            91:                }
        !            92:                default:
        !            93:                        *p++ = c;
        !            94:                }
        !            95:        }
        !            96: 
        !            97: done:
        !            98:        int cond = dtor||ctor;
        !            99:        if (cond == 0) exit(1);
        !           100: 
        !           101:        printf("typedef int (*PFV)();\n");      // "int" to dodge bsd4.2 bug
        !           102:        if (ctor) {
        !           103:                for (sbuf* p = ctor; p; p=p->next) printf("int %s();\n",p->str);
        !           104:                printf("extern PFV _ctors[];\nPFV _ctors[] = {\n");
        !           105:                for (sbuf* q = ctor; q; q=q->next) printf("\t%s,\n",q->str);
        !           106:                printf("\t0\n};\n");
        !           107:        }
        !           108: 
        !           109:        if (dtor) {
        !           110:                for (sbuf* p = dtor; p; p=p->next) printf("int %s();\n",p->str);
        !           111:                printf("extern PFV _dtors[];\nPFV _dtors[] = {\n");
        !           112:                for (sbuf* q = dtor; q; q=q->next) printf("\t%s,\n",q->str);
        !           113:                printf("\t0\n};\n");
        !           114:        }
        !           115: 
        !           116:        exit(0);
        !           117: }
        !           118: 

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