Return to strings.c CVS log

Up to [Research Unix] / researchv10no / cmd

Annotation of researchv10no/cmd/strings.c, revision 1.1.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.