Annotation of 43BSDTahoe/bin/awk/lib.c, revision 1.1.1.1

1.1       root        1: #ifndef lint
                      2: static char sccsid[] = "@(#)lib.c      4.6 (Berkeley) 10/6/87";
                      3: #endif
                      4: 
                      5: #include "stdio.h"
                      6: #include "awk.def"
                      7: #include "awk.h"
                      8: #include "ctype.h"
                      9: 
                     10: extern FILE    *yyin;  /* lex input file */
                     11: FILE   *infile = NULL;
                     12: char   *file;
                     13: #define        RECSIZE (5 * 512)
                     14: char   record[RECSIZE];
                     15: char   fields[RECSIZE];
                     16: char   EMPTY[] = "";
                     17: 
                     18: #define        MAXFLD  100
                     19: int    donefld;        /* 1 = implies rec broken into fields */
                     20: int    donerec;        /* 1 = record is valid (no flds have changed) */
                     21: int    mustfld;        /* 1 = NF seen, so always break*/
                     22: 
                     23: #define        FINIT   {EMPTY, EMPTY, 0.0, FLD|STR}
                     24: cell fldtab[MAXFLD] = {        /*room for fields */
                     25:        { "$record", record, 0.0, STR|FLD},
                     26:        FINIT, FINIT, FINIT, FINIT, FINIT, FINIT, FINIT, FINIT, FINIT,
                     27:        FINIT, FINIT, FINIT, FINIT, FINIT, FINIT, FINIT, FINIT, FINIT,
                     28:        FINIT, FINIT, FINIT, FINIT, FINIT, FINIT, FINIT, FINIT, FINIT,
                     29:        FINIT, FINIT, FINIT, FINIT, FINIT, FINIT, FINIT, FINIT, FINIT,
                     30:        FINIT, FINIT, FINIT, FINIT, FINIT, FINIT, FINIT, FINIT, FINIT,
                     31:        FINIT, FINIT, FINIT, FINIT, FINIT, FINIT, FINIT, FINIT, FINIT,
                     32:        FINIT, FINIT, FINIT, FINIT, FINIT, FINIT, FINIT, FINIT, FINIT,
                     33:        FINIT, FINIT, FINIT, FINIT, FINIT, FINIT, FINIT, FINIT, FINIT,
                     34:        FINIT, FINIT, FINIT, FINIT, FINIT, FINIT, FINIT, FINIT, FINIT,
                     35: };
                     36: int    maxfld  = 0;    /* last used field */
                     37: 
                     38: 
                     39: getrec()
                     40: {
                     41:        register char *rr;
                     42:        extern int svargc;
                     43:        extern char **svargv;
                     44:        register c, sep;
                     45: 
                     46:        dprintf("**RS=%o, **FS=%o\n", **RS, **FS, NULL);
                     47:        donefld = 0;
                     48:        donerec = 1;
                     49:        record[0] = 0;
                     50:        while (svargc > 0) {
                     51:                dprintf("svargc=%d, *svargv=%s\n", svargc, *svargv, NULL);
                     52:                if (infile == NULL) {   /* have to open a new file */
                     53:                        if (member('=', *svargv)) {     /* it's a var=value argument */
                     54:                                setclvar(*svargv);
                     55:                                svargv++;
                     56:                                svargc--;
                     57:                                continue;
                     58:                        }
                     59:                        *FILENAME = file = *svargv;
                     60:                        dprintf("opening file %s\n", file, NULL, NULL);
                     61:                        if (*file == '-') {
                     62:                                if (yyin == stdin)
                     63:                                        error(FATAL, "standard input already used for reading commands");
                     64:                                else
                     65:                                        infile = stdin;
                     66:                        }
                     67:                        else if ((infile = fopen(file, "r")) == NULL)
                     68:                                error(FATAL, "can't open %s", file);
                     69:                }
                     70:                if ((sep = **RS) == 0)
                     71:                        sep = '\n';
                     72:                for (rr = record; ; ) {
                     73:                        for (; (c=getc(infile)) != sep && c != EOF; *rr++ = c)
                     74:                                ;
                     75:                        if (**RS == sep || c == EOF)
                     76:                                break;
                     77:                        if ((c = getc(infile)) == '\n' || c == EOF)     /* 2 in a row */
                     78:                                break;
                     79:                        *rr++ = '\n';
                     80:                        *rr++ = c;
                     81:                }
                     82:                if (rr > record+RECSIZE)
                     83:                        error(FATAL, "record `%.20s...' too long", record);
                     84:                *rr = 0;
                     85:                if (mustfld)
                     86:                        fldbld();
                     87:                if (c != EOF || rr > record) {  /* normal record */
                     88:                        recloc->tval &= ~NUM;
                     89:                        recloc->tval |= STR;
                     90:                        ++nrloc->fval;
                     91:                        nrloc->tval &= ~STR;
                     92:                        nrloc->tval |= NUM;
                     93:                        return(1);
                     94:                }
                     95:                /* EOF arrived on this file; set up next */
                     96:                if (infile != stdin)
                     97:                        fclose(infile);
                     98:                infile = NULL;
                     99:                svargc--;
                    100:                svargv++;
                    101:        }
                    102:        return(0);      /* true end of file */
                    103: }
                    104: 
                    105: setclvar(s)    /* set var=value from s */
                    106: char *s;
                    107: {
                    108:        char *p;
                    109:        cell *q;
                    110: 
                    111:        for (p=s; *p != '='; p++)
                    112:                ;
                    113:        *p++ = 0;
                    114:        q = setsymtab(s, tostring(p), 0.0, STR, symtab);
                    115:        setsval(q, p);
                    116:        dprintf("command line set %s to |%s|\n", s, p, NULL);
                    117: }
                    118: 
                    119: fldbld()
                    120: {
                    121:        register char *r, *fr, sep;
                    122:        int i, j;
                    123: 
                    124:        r = record;
                    125:        fr = fields;
                    126:        i = 0;  /* number of fields accumulated here */
                    127:        if ((sep = **FS) == ' ')
                    128:                for (i = 0; ; ) {
                    129:                        while (*r == ' ' || *r == '\t' || *r == '\n')
                    130:                                r++;
                    131:                        if (*r == 0)
                    132:                                break;
                    133:                        i++;
                    134:                        if (i >= MAXFLD)
                    135:                                error(FATAL, "record `%.20s...' has too many fields", record);
                    136:                        if (!(fldtab[i].tval&FLD))
                    137:                                strfree(fldtab[i].sval);
                    138:                        fldtab[i].sval = fr;
                    139:                        fldtab[i].tval = FLD | STR;
                    140:                        do
                    141:                                *fr++ = *r++;
                    142:                        while (*r != ' ' && *r != '\t' && *r != '\n' && *r != '\0');
                    143:                        *fr++ = 0;
                    144:                }
                    145:        else if (*r != 0)       /* if 0, it's a null field */
                    146:                for (;;) {
                    147:                        i++;
                    148:                        if (i >= MAXFLD)
                    149:                                error(FATAL, "record `%.20s...' has too many fields", record);
                    150:                        if (!(fldtab[i].tval&FLD))
                    151:                                strfree(fldtab[i].sval);
                    152:                        fldtab[i].sval = fr;
                    153:                        fldtab[i].tval = FLD | STR;
                    154:                        while (*r != sep && *r != '\n' && *r != '\0')   /* \n always a separator */
                    155:                                *fr++ = *r++;
                    156:                        *fr++ = 0;
                    157:                        if (*r++ == 0)
                    158:                                break;
                    159:                }
                    160:        *fr = 0;
                    161:        for (j=MAXFLD-1; j>i; j--) {    /* clean out junk from previous record */
                    162:                if (!(fldtab[j].tval&FLD))
                    163:                        strfree(fldtab[j].sval);
                    164:                fldtab[j].tval = STR | FLD;
                    165:                fldtab[j].sval = EMPTY;
                    166:        }
                    167:        maxfld = i;
                    168:        donefld = 1;
                    169:        for(i=1; i<=maxfld; i++)
                    170:                if(isnumber(fldtab[i].sval)) {
                    171:                        fldtab[i].fval = atof(fldtab[i].sval);
                    172:                        fldtab[i].tval |= NUM;
                    173:                }
                    174:        setfval(lookup("NF", symtab, 0), (awkfloat) maxfld);
                    175:        if (dbg)
                    176:                for (i = 0; i <= maxfld; i++)
                    177:                        printf("field %d: |%s|\n", i, fldtab[i].sval);
                    178: }
                    179: 
                    180: recbld()
                    181: {
                    182:        int i;
                    183:        register char *r, *p;
                    184: 
                    185:        if (donefld == 0 || donerec == 1)
                    186:                return;
                    187:        r = record;
                    188:        for (i = 1; i <= *NF; i++) {
                    189:                p = getsval(&fldtab[i]);
                    190:                while (*r++ = *p++)
                    191:                        ;
                    192:                *(r-1) = **OFS;
                    193:        }
                    194:        *(r-1) = '\0';
                    195:        dprintf("in recbld FS=%o, recloc=%o\n", **FS, recloc, NULL);
                    196:        recloc->tval = STR | FLD;
                    197:        dprintf("in recbld FS=%o, recloc=%o\n", **FS, recloc, NULL);
                    198:        if (r > record+RECSIZE)
                    199:                error(FATAL, "built giant record `%.20s...'", record);
                    200:        dprintf("recbld = |%s|\n", record, NULL, NULL);
                    201: }
                    202: 
                    203: cell *fieldadr(n)
                    204: {
                    205:        if (n >= MAXFLD)
                    206:                error(FATAL, "trying to access field %d", n);
                    207:        return(&fldtab[n]);
                    208: }
                    209: 
                    210: int    errorflag       = 0;
                    211: 
                    212: yyerror(s) char *s; {
                    213:        fprintf(stderr, "awk: %s near line %d\n", s, lineno);
                    214:        errorflag = 2;
                    215: }
                    216: 
                    217: error(f, s, a1, a2, a3, a4, a5, a6, a7) {
                    218:        fprintf(stderr, "awk: ");
                    219:        fprintf(stderr, s, a1, a2, a3, a4, a5, a6, a7);
                    220:        fprintf(stderr, "\n");
                    221:        if (NR && *NR > 0)
                    222:                fprintf(stderr, " record number %g\n", *NR);
                    223:        if (f)
                    224:                exit(2);
                    225: }
                    226: 
                    227: PUTS(s) char *s; {
                    228:        dprintf("%s\n", s, NULL, NULL);
                    229: }
                    230: 
                    231: #define        MAXEXPON        38      /* maximum exponenet for fp number */
                    232: 
                    233: isnumber(s)
                    234: register char *s;
                    235: {
                    236:        register d1, d2;
                    237:        int point;
                    238:        char *es;
                    239: 
                    240:        if (s == NULL) 
                    241:                return (0);
                    242:        d1 = d2 = point = 0;
                    243:        while (*s == ' ' || *s == '\t' || *s == '\n')
                    244:                s++;
                    245:        if (*s == '\0')
                    246:                return(0);      /* empty stuff isn't number */
                    247:        if (*s == '+' || *s == '-')
                    248:                s++;
                    249:        if (!isdigit(*s) && *s != '.')
                    250:                return(0);
                    251:        if (isdigit(*s)) {
                    252:                do {
                    253:                        d1++;
                    254:                        s++;
                    255:                } while (isdigit(*s));
                    256:        }
                    257:        if(d1 >= MAXEXPON)
                    258:                return(0);      /* too many digits to convert */
                    259:        if (*s == '.') {
                    260:                point++;
                    261:                s++;
                    262:        }
                    263:        if (isdigit(*s)) {
                    264:                d2++;
                    265:                do {
                    266:                        s++;
                    267:                } while (isdigit(*s));
                    268:        }
                    269:        if (!(d1 || point && d2))
                    270:                return(0);
                    271:        if (*s == 'e' || *s == 'E') {
                    272:                s++;
                    273:                if (*s == '+' || *s == '-')
                    274:                        s++;
                    275:                if (!isdigit(*s))
                    276:                        return(0);
                    277:                es = s;
                    278:                do {
                    279:                        s++;
                    280:                } while (isdigit(*s));
                    281:                if (s - es > 2)
                    282:                        return(0);
                    283:                else if (s - es == 2 && 10 * (*es-'0') + *(es+1)-'0' >= MAXEXPON)
                    284:                        return(0);
                    285:        }
                    286:        while (*s == ' ' || *s == '\t' || *s == '\n')
                    287:                s++;
                    288:        if (*s == '\0')
                    289:                return(1);
                    290:        else
                    291:                return(0);
                    292: }
                    293: /*
                    294: isnumber(s) char *s; {return(0);}
                    295: */

unix.superglobalmegacorp.com

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