Return to strings.c CVS log

Up to [Research Unix] / researchv10no / cmd

Annotation of researchv10no/cmd/strings.c, revision 1.1

1.1     ! root        1: #include <stdio.h>
        !             2: #include <ctype.h>
        !             3: #include <libc.h>
        !             4: #include </usr/include/a.out.h>
        !             5: 
        !             6: #define INF (~0UL>>1)
        !             7: int minlen = 4;
        !             8: int oflag;
        !             9: int tflag, dflag, sflag, aflag;
        !            10: 
        !            11: void strings(FILE*, long, long);
        !            12: char *flush(char*, long);
        !            13: 
        !            14: int
        !            15: main(int argc, char **argv)
        !            16: {
        !            17:        int i;
        !            18:        int errors = 0;
        !            19:        struct exec header;
        !            20:        while(argc>1 && argv[1][0]=='-') {
        !            21:                if(argv[1][1] == 0)     /* oldthink */
        !            22:                        aflag++;
        !            23:                while(*++argv[1]) {
        !            24:                        switch(*argv[1]) {
        !            25:                        case 'o':
        !            26:                                oflag++;
        !            27:                                continue;
        !            28:                        case 't':
        !            29:                                tflag++;
        !            30:                                continue;
        !            31:                        case 'd':
        !            32:                                dflag++;
        !            33:                                continue;
        !            34:                        case 's':
        !            35:                                sflag++;
        !            36:                                continue;
        !            37:                        case 'a':
        !            38:                                aflag++;
        !            39:                                continue;
        !            40:                        case '0':case '1':case '2':case '3':case '4':
        !            41:                        case '5':case '6':case '7':case '8':case '9':
        !            42:                                minlen = atoi(argv[1]);
        !            43:                        }
        !            44:                        break;
        !            45:                }
        !            46:                argc--;
        !            47:                argv++;
        !            48:        }
        !            49:        if(!(tflag|dflag|sflag|aflag)) {
        !            50:                tflag++;
        !            51:                dflag++;
        !            52:        }
        !            53:        for(i=1; i<argc; i++) {
        !            54:                long base = sizeof header;
        !            55:                FILE *f = fopen(argv[i],"r");
        !            56:                if(f == 0) {
        !            57:                        fprintf(stderr,"strings: ");
        !            58:                        perror(argv[i]);
        !            59:                        errors++;
        !            60:                        continue;
        !            61:                }
        !            62:                if(argc > 2) {
        !            63:                        if(i > 1) printf("\n");
        !            64:                        printf("%s:\n", argv[i]);
        !            65:                }
        !            66:                if(aflag)
        !            67:                        goto all;
        !            68:                if(fread(&header,sizeof(header),1,f) != 1)                                      goto all;
        !            69:                switch(header.a_magic) {
        !            70:                all:
        !            71:                default:
        !            72:                        strings(f, 0, INF);
        !            73:                        break;
        !            74:                case ZMAGIC:
        !            75:                        base = 1024;
        !            76:                case OMAGIC:
        !            77:                case NMAGIC:
        !            78:                        if(tflag)
        !            79:                                strings(f, base, header.a_text);
        !            80:                        base += header.a_text;
        !            81:                        if(dflag)
        !            82:                                strings(f, base, header.a_data);
        !            83:                        base += header.a_data + header.a_syms +
        !            84:                                header.a_trsize + header.a_drsize;
        !            85:                        if(sflag)
        !            86:                                strings(f, base, INF);
        !            87:                }
        !            88:                fclose(f);
        !            89:        }
        !            90:        return errors;
        !            91: }
        !            92: 
        !            93: char string[1024];
        !            94: 
        !            95: void
        !            96: strings(FILE *f, long base, long length)
        !            97: {
        !            98:        int c;
        !            99:        char *cp = string;
        !           100:        fseek(f, base, 0);
        !           101:        cp = string;
        !           102:        for( ; --length>=0 && (c=getc(f))!=EOF; base++) {
        !           103:                switch(c) {
        !           104:                case '\n':
        !           105:                case 0:
        !           106:                        cp = flush(cp, base);
        !           107:                        continue;
        !           108:                case '\t':
        !           109:                case '\b':
        !           110:                        break;
        !           111:                default:
        !           112:                        if(isprint(c))
        !           113:                                break;
        !           114:                        cp = string;
        !           115:                        continue;
        !           116:                }
        !           117:                *cp++ = c;
        !           118:                if(cp >= string + sizeof string - 2)
        !           119:                        cp = flush(cp, base);
        !           120:        }
        !           121: }
        !           122: 
        !           123: char *
        !           124: flush(char *cp, long base)
        !           125: {
        !           126:        if(cp-string >= minlen) {
        !           127:                *cp = 0;
        !           128:                if(oflag)
        !           129:                        printf("%9lo ", base - (cp-string));
        !           130:                puts(string);
        !           131:        }
        !           132:        return string;
        !           133: }

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