Return to lpass2.c CVS log

Up to [CSRG BSD Unix] / 3BSD / cmd / lint

Annotation of 3BSD/cmd/lint/lpass2.c, revision 1.1

1.1     ! root        1: # include "lmanifest"
        !             2: # include "manifest"
        !             3: 
        !             4: # define USED 01
        !             5: # define VUSED 02
        !             6: # define EUSED 04
        !             7: # define RVAL 010
        !             8: # define VARARGS 0100
        !             9: 
        !            10: typedef struct { TWORD aty; int extra; } atype;
        !            11: 
        !            12: struct line {
        !            13:        char name[8];
        !            14:        int decflag;
        !            15:        atype type;
        !            16:        int nargs;
        !            17:        atype atyp[50];
        !            18:        int fline;
        !            19:        char file[100];
        !            20:        }
        !            21: 
        !            22:        l1,
        !            23:        l2,
        !            24:        *pd,    /* pointer to line having definition */
        !            25:        *pc,    /* pointer to current line read */
        !            26:        *p3;    /* used for swapping pc and pd */
        !            27: 
        !            28: int uses = USED;
        !            29: int hflag = 0;
        !            30: int pflag = 0;
        !            31: int xflag = 0;
        !            32: int uflag = 1;
        !            33: 
        !            34: 
        !            35: main( argc, argv ) char *argv[]; {
        !            36: 
        !            37:        register char *p;
        !            38: 
        !            39:        /* first argument is - options */
        !            40: 
        !            41:        if( argc>=2 && argv[1][0] == '-' ){
        !            42:                for( p=argv[1]; *p; ++p ){
        !            43:                        switch( *p ){
        !            44: 
        !            45:                        case 'h':
        !            46:                                hflag = 1;
        !            47:                                break;
        !            48: 
        !            49:                        case 'p':
        !            50:                                pflag = 1;
        !            51:                                break;
        !            52: 
        !            53:                        case 'x':
        !            54:                                xflag = 1;
        !            55:                                break;
        !            56: 
        !            57:                        case 'u':
        !            58:                                uflag = 0;
        !            59:                                break;
        !            60: 
        !            61:                                }
        !            62:                        }
        !            63:                }
        !            64: 
        !            65: 
        !            66: 
        !            67:        pd = &l1;
        !            68:        pc = &l2;
        !            69:        pd->name[0] = '\0' ;
        !            70:        pd->fline = 0;
        !            71:        pd->file[0] = '\0';
        !            72:        pd->decflag = LDI;
        !            73: 
        !            74:        /* main loop: read a line;
        !            75:                if same as last line, check compatibility
        !            76:                if not same as last line, becomes df.
        !            77:                */
        !            78: 
        !            79:        for(;;){
        !            80:                lread();
        !            81:                if( steq(pc->name, pd->name) ) chkcompat();
        !            82:                else {
        !            83:                        lastone();
        !            84:                        setuse();
        !            85:                        p3=pc;
        !            86:                        pc = pd;
        !            87:                        pd = p3;
        !            88:                        }
        !            89:                }
        !            90: 
        !            91:        }
        !            92: 
        !            93: lread(){ /* read a line into pc */
        !            94: 
        !            95:        register i, n;
        !            96: 
        !            97:        getnam( pc->name );
        !            98: 
        !            99:        pc->decflag = rdin10();
        !           100:        rdinty( &pc->type );
        !           101:        n = pc->nargs = rdin10();
        !           102:        if( n<0 ) n = -n;
        !           103: 
        !           104:        for( i=0; i<n; ++i ){
        !           105:                rdinty( &pc->atyp[i] );
        !           106:                }
        !           107: 
        !           108:        getnam( pc->file );
        !           109:        pc->fline = rdin10();
        !           110: 
        !           111:        while( getchar() != '\n' ) ; /* VOID */
        !           112:        }
        !           113: 
        !           114: rdin10(){
        !           115:        register val, c, s;
        !           116: 
        !           117:        val = 0;
        !           118:        s = 1;
        !           119: 
        !           120:        while( (c=getchar()) != '\t' ){
        !           121:                if( c <= 0 ) error( "unexpected EOF" );
        !           122:                else if( c == '-' ) {
        !           123:                        s = -1;
        !           124:                        continue;
        !           125:                        }
        !           126:                else if( c<'0' || c>'9' ) {
        !           127:                        error("rotten digit: %o\n", c );
        !           128:                        }
        !           129:                val = val*10 + c - '0';
        !           130:                }
        !           131:        return( val*s );
        !           132:        }
        !           133: 
        !           134: rdinty( p ) atype *p; {
        !           135:        register val, c, s;
        !           136: 
        !           137:        val = 0;
        !           138:        s = 1;
        !           139: 
        !           140:        while( (c=getchar()) != '\t' && c!= '<' ){
        !           141:                if( c <= 0 ) error( "unexpected EOF" );
        !           142:                else if( c == '-' ) {
        !           143:                        s = -1;
        !           144:                        continue;
        !           145:                        }
        !           146:                else if( c<'0' || c>'7' ) {
        !           147:                        error("rotten digit: %o\n", c );
        !           148:                        }
        !           149:                val = (val<<3) + c - '0';
        !           150:                }
        !           151:        p->aty = val*s;
        !           152:        if( c == '<' ) p->extra = rdin10();
        !           153:        else p->extra = 0;
        !           154:        }
        !           155: 
        !           156: getnam(p) char *p; {
        !           157:        register c;
        !           158:        while( (c=getchar()) != '\t' ){
        !           159:                if( c == '\n' ) error( "rotten name\n" );
        !           160:                if( c <= 0 ) cleanup();
        !           161:                *p++ = c;
        !           162:                }
        !           163:        *p = '\0';
        !           164:        }
        !           165: 
        !           166: /* VARARGS */
        !           167: error( s, a ) char *s; {
        !           168: 
        !           169:        fprintf( stderr, "pass 2 error: " );
        !           170:        fprintf( stderr, s, a );
        !           171:        fprintf( stderr, "\n" );
        !           172:        exit(1);
        !           173:        }
        !           174: 
        !           175: steq(p,q) char *p,*q; { /* check that the p and q names are the same */
        !           176: 
        !           177: 
        !           178:        while( *p == *q ){
        !           179:                if( *p == 0 ) return(1);
        !           180:                ++p;
        !           181:                ++q;
        !           182:                }
        !           183: 
        !           184:        return(0);
        !           185:        }
        !           186: 
        !           187: chkcompat(){
        !           188:        /* are the types, etc. in pc and pd compatible */
        !           189:        register int i;
        !           190: 
        !           191:        setuse();
        !           192: 
        !           193:        /* argument check */
        !           194: 
        !           195:        if( pd->decflag & (LDI|LIB|LUV|LUE) ){
        !           196:                if( pc->decflag & (LUV|LIB|LUE) ){
        !           197:                        if( pd->nargs != pc->nargs ){
        !           198:                                if( !(uses&VARARGS) ){
        !           199:                                        printf( "%.7s: variable # of args.", pd->name );
        !           200:                                        viceversa();
        !           201:                                        }
        !           202:                                if( pc->nargs > pd->nargs ) pc->nargs = pd->nargs;
        !           203:                                if( !(pd->decflag & (LDI|LIB) ) ) {
        !           204:                                        pd->nargs = pc->nargs;
        !           205:                                        uses |= VARARGS;
        !           206:                                        }
        !           207:                                }
        !           208:                        for( i=0; i<pc->nargs; ++i ){
        !           209:                                if( chktype(&pd->atyp[i], &pc->atyp[i]) ){
        !           210:                                        printf( "%.7s, arg. %d used inconsistently",
        !           211:                                                pd->name, i+1 );
        !           212:                                        viceversa();
        !           213:                                        }
        !           214:                                }
        !           215:                        }
        !           216:                }
        !           217: 
        !           218:        if( (pd->decflag&(LDI|LIB|LUV)) && pc->decflag==LUV ){
        !           219:                if( chktype( &pc->type, &pd->type ) ){
        !           220:                        printf( "%.7s value used inconsistently", pd->name );
        !           221:                        viceversa();
        !           222:                        }
        !           223:                }
        !           224: 
        !           225:        /* check for multiple declaration */
        !           226: 
        !           227:        if( (pd->decflag&LDI) && (pc->decflag&(LDI|LIB)) ){
        !           228:                printf( "%.7s multiply declared", pd->name );
        !           229:                viceversa();
        !           230:                }
        !           231: 
        !           232:        /* do a bit of checking of definitions and uses... */
        !           233: 
        !           234:        if( (pd->decflag & (LDI|LIB|LDX|LDC)) && (pc->decflag & (LDX|LDC)) && pd->type.aty != pc->type.aty ){
        !           235:                printf( "%.7s value declared inconsistently", pd->name );
        !           236:                viceversa();
        !           237:                }
        !           238: 
        !           239:        /* better not call functions which are declared to be structure or union returning */
        !           240: 
        !           241:        if( (pd->decflag & (LDI|LIB|LDX|LDC)) && (pc->decflag & LUE) && pd->type.aty != pc->type.aty ){
        !           242:                /* only matters if the function returns union or structure */
        !           243:                TWORD ty;
        !           244:                ty = pd->type.aty;
        !           245:                if( ISFTN(ty) && ((ty = DECREF(ty))==STRTY || ty==UNIONTY ) ){
        !           246:                        printf( "%.7s function value type must be declared before use", pd->name );
        !           247:                        viceversa();
        !           248:                        }
        !           249:                }
        !           250: 
        !           251:        if( pflag && pd->decflag==LDX && pc->decflag == LUM && !ISFTN(pd->type.aty) ){
        !           252:                /* make the external declaration go away */
        !           253:                /* in effect, it was used without being defined */
        !           254: 
        !           255:                /* swap pc and pd */
        !           256:                p3 = pc;
        !           257:                pc = pd;
        !           258:                pd = p3;
        !           259:                }
        !           260: 
        !           261:        }
        !           262: 
        !           263: viceversa(){
        !           264:        /* print out file comparison */
        !           265:        printf( "       %s(%d)  ::  %s(%d)\n", pd->file, pd->fline, pc->file, pc->fline );
        !           266:        }
        !           267: 
        !           268:        /* messages for defintion/use */
        !           269: char *
        !           270: mess[2][2] = {
        !           271:        "",
        !           272:        "%.7s used( %s(%d) ), but not defined\n",
        !           273:        "%.7s defined( %s(%d) ), but never used\n",
        !           274:        "%.7s declared( %s(%d) ), but never used or defined\n"
        !           275:        };
        !           276: 
        !           277: lastone(){
        !           278: 
        !           279:        /* called when pc and pd are at last different */
        !           280:        register nu, nd;
        !           281: 
        !           282:        nu = nd = 0;
        !           283: 
        !           284:        if( !(uses&USED) && pd->decflag != LIB ) {
        !           285:                if( !steq(pd->name,"main") )
        !           286:                        nu = 1;
        !           287:                }
        !           288: 
        !           289:        if( !ISFTN(pd->type.aty) ){
        !           290:                switch( pd->decflag ){
        !           291: 
        !           292:                case LIB:
        !           293:                        nu = nd = 0;  /* don't complain about uses on libraries */
        !           294:                        break;
        !           295:                case LDX:
        !           296:                        if( !xflag ) break;
        !           297:                case LUV:
        !           298:                case LUE:
        !           299:                case LUM:
        !           300:                        nd = 1;
        !           301:                        }
        !           302:                }
        !           303: 
        !           304:        if( uflag && ( nu || nd ) ) printf( mess[nu][nd], pd->name, pd->file, pd->fline );
        !           305: 
        !           306:        if( (uses&(RVAL+EUSED)) == (RVAL+EUSED) ){
        !           307:                printf( "%.7s returns value which is %s ignored\n", pd->name,
        !           308:                        uses&VUSED ? "sometimes" : "always" );
        !           309:                }
        !           310: 
        !           311:        if( (uses&(RVAL+VUSED)) == (VUSED) && (pd->decflag&(LDI|LIB)) ){
        !           312:                printf( "%.7s value is used, but none returned\n", pd->name );
        !           313:                }
        !           314: 
        !           315:        /* clean up pc, in preparation for the next thing */
        !           316: 
        !           317:        uses = 0;
        !           318:        if( pc->nargs < 0 ){
        !           319:                pc->nargs = -pc->nargs;
        !           320:                uses = VARARGS;
        !           321:                }
        !           322: 
        !           323:        }
        !           324: 
        !           325: cleanup(){ /* call lastone and die gracefully */
        !           326:        lastone();
        !           327:        exit(0);
        !           328:        }
        !           329: 
        !           330: setuse(){ /* check new type to ensure that it is used */
        !           331: 
        !           332:        switch( pc->decflag ){
        !           333: 
        !           334:        case LRV:
        !           335:                uses |= RVAL;
        !           336:                return;
        !           337:        case LUV:
        !           338:                uses |= VUSED+USED;
        !           339:                return;
        !           340:        case LUE:
        !           341:                uses |= EUSED+USED;
        !           342:                return;
        !           343:        case LUM:
        !           344:                uses |= USED;
        !           345:                return;
        !           346: 
        !           347:                }
        !           348:        }
        !           349: 
        !           350: chktype( pt1, pt2 ) register atype *pt1, *pt2; {
        !           351: 
        !           352:        /* check the two type words to see if they are compatible */
        !           353:        /* for the moment, enums are turned into ints, and should be checked as such */
        !           354:        if( pt1->aty == ENUMTY ) pt1->aty =  INT;
        !           355:        if( pt2->aty == ENUMTY ) pt2->aty = INT;
        !           356: 
        !           357:        if( pt2->extra ){ /* constant passed in */
        !           358:                if( pt1->aty == UNSIGNED && pt2->aty == INT ) return( 0 );
        !           359:                else if( pt1->aty == ULONG && pt2->aty == LONG ) return( 0 );
        !           360:                }
        !           361:        else if( pt1->extra ){ /* for symmetry */
        !           362:                if( pt2->aty == UNSIGNED && pt1->aty == INT ) return( 0 );
        !           363:                else if( pt2->aty == ULONG && pt1->aty == LONG ) return( 0 );
        !           364:                }
        !           365: 
        !           366:        return( pt1->aty != pt2->aty );
        !           367:        }

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