1 /****************************************************************
2 Copyright (C) Lucent Technologies 1997
3 All Rights Reserved
4
5 Permission to use, copy, modify, and distribute this software and
6 its documentation for any purpose and without fee is hereby
7 granted, provided that the above copyright notice appear in all
8 copies and that both that the copyright notice and this
9 permission notice and warranty disclaimer appear in supporting
10 documentation, and that the name Lucent Technologies or any of
11 its entities not be used in advertising or publicity pertaining
12 to distribution of the software without specific, written prior
13 permission.
14
15 LUCENT DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
16 INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS.
17 IN NO EVENT SHALL LUCENT OR ANY OF ITS ENTITIES BE LIABLE FOR ANY
18 SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
19 WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER
20 IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
21 ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF
22 THIS SOFTWARE.
23 ****************************************************************/
24
25 #define DEBUG
26 #include <stdio.h>
27 #include <string.h>
28 #include <ctype.h>
29 #include <errno.h>
30 #include <stdlib.h>
31 #include <stdarg.h>
32 #include "awk.h"
33 #include "ytab.h"
34
35 FILE *infile = NULL;
36 char *file = "";
37 char *record;
38 int recsize = RECSIZE;
39 char *fields;
40 int fieldssize = RECSIZE;
41
42 Cell **fldtab; /* pointers to Cells */
43 char inputFS[100] = " ";
44
45 #define MAXFLD 2
46 int nfields = MAXFLD; /* last allocated slot for $i */
47
48 int donefld; /* 1 = implies rec broken into fields */
49 int donerec; /* 1 = record is valid (no flds have changed) */
50
51 int lastfld = 0; /* last used field */
52 int argno = 1; /* current input argument number */
53 extern Awkfloat *ARGC;
54
55 static Cell dollar0 = { OCELL, CFLD, NULL, "", 0.0, REC|STR|DONTFREE };
56 static Cell dollar1 = { OCELL, CFLD, NULL, "", 0.0, FLD|STR|DONTFREE };
57
recinit(unsigned int n)58 void recinit(unsigned int n)
59 {
60 if ( (record = (char *) malloc(n)) == NULL
61 || (fields = (char *) malloc(n+1)) == NULL
62 || (fldtab = (Cell **) malloc((nfields+1) * sizeof(Cell *))) == NULL
63 || (fldtab[0] = (Cell *) malloc(sizeof(Cell))) == NULL )
64 FATAL("out of space for $0 and fields");
65 *fldtab[0] = dollar0;
66 fldtab[0]->sval = record;
67 fldtab[0]->nval = tostring("0");
68 makefields(1, nfields);
69 }
70
makefields(int n1,int n2)71 void makefields(int n1, int n2) /* create $n1..$n2 inclusive */
72 {
73 char temp[50];
74 int i;
75
76 for (i = n1; i <= n2; i++) {
77 fldtab[i] = (Cell *) malloc(sizeof (struct Cell));
78 if (fldtab[i] == NULL)
79 FATAL("out of space in makefields %d", i);
80 *fldtab[i] = dollar1;
81 sprintf(temp, "%d", i);
82 fldtab[i]->nval = tostring(temp);
83 }
84 }
85
initgetrec(void)86 void initgetrec(void)
87 {
88 int i;
89 char *p;
90
91 for (i = 1; i < *ARGC; i++) {
92 if (!isclvar(p = getargv(i))) { /* find 1st real filename */
93 setsval(lookup("FILENAME", symtab), getargv(i));
94 return;
95 }
96 setclvar(p); /* a commandline assignment before filename */
97 argno++;
98 }
99 infile = stdin; /* no filenames, so use stdin */
100 }
101
102 static int firsttime = 1;
103
getrec(char ** pbuf,int * pbufsize,int isrecord)104 int getrec(char **pbuf, int *pbufsize, int isrecord) /* get next input record */
105 { /* note: cares whether buf == record */
106 int c;
107 char *buf = *pbuf;
108 uschar saveb0;
109 int bufsize = *pbufsize, savebufsize = bufsize;
110
111 if (firsttime) {
112 firsttime = 0;
113 initgetrec();
114 }
115 dprintf( ("RS=<%s>, FS=<%s>, ARGC=%g, FILENAME=%s\n",
116 *RS, *FS, *ARGC, *FILENAME) );
117 if (isrecord) {
118 donefld = 0;
119 donerec = 1;
120 }
121 saveb0 = buf[0];
122 buf[0] = 0;
123 while (argno < *ARGC || infile == stdin) {
124 dprintf( ("argno=%d, file=|%s|\n", argno, file) );
125 if (infile == NULL) { /* have to open a new file */
126 file = getargv(argno);
127 if (*file == '\0') { /* it's been zapped */
128 argno++;
129 continue;
130 }
131 if (isclvar(file)) { /* a var=value arg */
132 setclvar(file);
133 argno++;
134 continue;
135 }
136 *FILENAME = file;
137 dprintf( ("opening file %s\n", file) );
138 if (*file == '-' && *(file+1) == '\0')
139 infile = stdin;
140 else if ((infile = fopen(file, "r")) == NULL)
141 FATAL("can't open file %s", file);
142 setfval(fnrloc, 0.0);
143 }
144 c = readrec(&buf, &bufsize, infile);
145 if (c != 0 || buf[0] != '\0') { /* normal record */
146 if (isrecord) {
147 if (freeable(fldtab[0]))
148 xfree(fldtab[0]->sval);
149 fldtab[0]->sval = buf; /* buf == record */
150 fldtab[0]->tval = REC | STR | DONTFREE;
151 if (is_number(fldtab[0]->sval)) {
152 fldtab[0]->fval = atof(fldtab[0]->sval);
153 fldtab[0]->tval |= NUM;
154 }
155 }
156 setfval(nrloc, nrloc->fval+1);
157 setfval(fnrloc, fnrloc->fval+1);
158 *pbuf = buf;
159 *pbufsize = bufsize;
160 return 1;
161 }
162 /* EOF arrived on this file; set up next */
163 if (infile != stdin)
164 fclose(infile);
165 infile = NULL;
166 argno++;
167 }
168 buf[0] = saveb0;
169 *pbuf = buf;
170 *pbufsize = savebufsize;
171 return 0; /* true end of file */
172 }
173
nextfile(void)174 void nextfile(void)
175 {
176 if (infile != NULL && infile != stdin)
177 fclose(infile);
178 infile = NULL;
179 argno++;
180 }
181
readrec(char ** pbuf,int * pbufsize,FILE * inf)182 int readrec(char **pbuf, int *pbufsize, FILE *inf) /* read one record into buf */
183 {
184 int sep, c;
185 char *rr, *buf = *pbuf;
186 int bufsize = *pbufsize;
187
188 if (strlen(*FS) >= sizeof(inputFS))
189 FATAL("field separator %.10s... is too long", *FS);
190 strcpy(inputFS, *FS); /* for subsequent field splitting */
191 if ((sep = **RS) == 0) {
192 sep = '\n';
193 while ((c=getc(inf)) == '\n' && c != EOF) /* skip leading \n's */
194 ;
195 if (c != EOF)
196 ungetc(c, inf);
197 }
198 for (rr = buf; ; ) {
199 for (; (c=getc(inf)) != sep && c != EOF; ) {
200 if (rr-buf+1 > bufsize)
201 if (!adjbuf(&buf, &bufsize, 1+rr-buf, recsize, &rr, "readrec 1"))
202 FATAL("input record `%.30s...' too long", buf);
203 *rr++ = c;
204 }
205 if (**RS == sep || c == EOF)
206 break;
207 if ((c = getc(inf)) == '\n' || c == EOF) /* 2 in a row */
208 break;
209 if (!adjbuf(&buf, &bufsize, 2+rr-buf, recsize, &rr, "readrec 2"))
210 FATAL("input record `%.30s...' too long", buf);
211 *rr++ = '\n';
212 *rr++ = c;
213 }
214 if (!adjbuf(&buf, &bufsize, 1+rr-buf, recsize, &rr, "readrec 3"))
215 FATAL("input record `%.30s...' too long", buf);
216 *rr = 0;
217 dprintf( ("readrec saw <%s>, returns %d\n", buf, c == EOF && rr == buf ? 0 : 1) );
218 *pbuf = buf;
219 *pbufsize = bufsize;
220 return c == EOF && rr == buf ? 0 : 1;
221 }
222
getargv(int n)223 char *getargv(int n) /* get ARGV[n] */
224 {
225 Cell *x;
226 char *s, temp[50];
227 extern Array *ARGVtab;
228
229 sprintf(temp, "%d", n);
230 x = setsymtab(temp, "", 0.0, STR, ARGVtab);
231 s = getsval(x);
232 dprintf( ("getargv(%d) returns |%s|\n", n, s) );
233 return s;
234 }
235
setclvar(char * s)236 void setclvar(char *s) /* set var=value from s */
237 {
238 char *p;
239 Cell *q;
240
241 for (p=s; *p != '='; p++)
242 ;
243 *p++ = 0;
244 p = qstring(p, '\0');
245 q = setsymtab(s, p, 0.0, STR, symtab);
246 setsval(q, p);
247 if (is_number(q->sval)) {
248 q->fval = atof(q->sval);
249 q->tval |= NUM;
250 }
251 dprintf( ("command line set %s to |%s|\n", s, p) );
252 }
253
254
fldbld(void)255 void fldbld(void) /* create fields from current record */
256 {
257 /* this relies on having fields[] the same length as $0 */
258 /* the fields are all stored in this one array with \0's */
259 char *r, *fr, sep;
260 Cell *p;
261 int i, j, n;
262
263 if (donefld)
264 return;
265 if (!isstr(fldtab[0]))
266 getsval(fldtab[0]);
267 r = fldtab[0]->sval;
268 n = strlen(r);
269 if (n > fieldssize) {
270 xfree(fields);
271 if ((fields = (char *) malloc(n+1)) == NULL)
272 FATAL("out of space for fields in fldbld %d", n);
273 fieldssize = n;
274 }
275 fr = fields;
276 i = 0; /* number of fields accumulated here */
277 if (strlen(inputFS) > 1) { /* it's a regular expression */
278 i = refldbld(r, inputFS);
279 } else if ((sep = *inputFS) == ' ') { /* default whitespace */
280 for (i = 0; ; ) {
281 while (*r == ' ' || *r == '\t' || *r == '\n')
282 r++;
283 if (*r == 0)
284 break;
285 i++;
286 if (i > nfields)
287 growfldtab(i);
288 if (freeable(fldtab[i]))
289 xfree(fldtab[i]->sval);
290 fldtab[i]->sval = fr;
291 fldtab[i]->tval = FLD | STR | DONTFREE;
292 do
293 *fr++ = *r++;
294 while (*r != ' ' && *r != '\t' && *r != '\n' && *r != '\0');
295 *fr++ = 0;
296 }
297 *fr = 0;
298 } else if ((sep = *inputFS) == 0) { /* new: FS="" => 1 char/field */
299 for (i = 0; *r != 0; r++) {
300 char buf[2];
301 i++;
302 if (i > nfields)
303 growfldtab(i);
304 if (freeable(fldtab[i]))
305 xfree(fldtab[i]->sval);
306 buf[0] = *r;
307 buf[1] = 0;
308 fldtab[i]->sval = tostring(buf);
309 fldtab[i]->tval = FLD | STR;
310 }
311 *fr = 0;
312 } else if (*r != 0) { /* if 0, it's a null field */
313 /* subtlecase : if length(FS) == 1 && length(RS > 0)
314 * \n is NOT a field separator (cf awk book 61,84).
315 * this variable is tested in the inner while loop.
316 */
317 int rtest = '\n'; /* normal case */
318 if (strlen(*RS) > 0)
319 rtest = '\0';
320 for (;;) {
321 i++;
322 if (i > nfields)
323 growfldtab(i);
324 if (freeable(fldtab[i]))
325 xfree(fldtab[i]->sval);
326 fldtab[i]->sval = fr;
327 fldtab[i]->tval = FLD | STR | DONTFREE;
328 while (*r != sep && *r != rtest && *r != '\0') /* \n is always a separator */
329 *fr++ = *r++;
330 *fr++ = 0;
331 if (*r++ == 0)
332 break;
333 }
334 *fr = 0;
335 }
336 if (i > nfields)
337 FATAL("record `%.30s...' has too many fields; can't happen", r);
338 cleanfld(i+1, lastfld); /* clean out junk from previous record */
339 lastfld = i;
340 donefld = 1;
341 for (j = 1; j <= lastfld; j++) {
342 p = fldtab[j];
343 if(is_number(p->sval)) {
344 p->fval = atof(p->sval);
345 p->tval |= NUM;
346 }
347 }
348 setfval(nfloc, (Awkfloat) lastfld);
349 if (dbg) {
350 for (j = 0; j <= lastfld; j++) {
351 p = fldtab[j];
352 printf("field %d (%s): |%s|\n", j, p->nval, p->sval);
353 }
354 }
355 }
356
cleanfld(int n1,int n2)357 void cleanfld(int n1, int n2) /* clean out fields n1 .. n2 inclusive */
358 { /* nvals remain intact */
359 Cell *p;
360 int i;
361
362 for (i = n1; i <= n2; i++) {
363 p = fldtab[i];
364 if (freeable(p))
365 xfree(p->sval);
366 p->sval = "";
367 p->tval = FLD | STR | DONTFREE;
368 }
369 }
370
newfld(int n)371 void newfld(int n) /* add field n after end of existing lastfld */
372 {
373 if (n > nfields)
374 growfldtab(n);
375 cleanfld(lastfld+1, n);
376 lastfld = n;
377 setfval(nfloc, (Awkfloat) n);
378 }
379
fieldadr(int n)380 Cell *fieldadr(int n) /* get nth field */
381 {
382 if (n < 0)
383 FATAL("trying to access out of range field %d", n);
384 if (n > nfields) /* fields after NF are empty */
385 growfldtab(n); /* but does not increase NF */
386 return(fldtab[n]);
387 }
388
growfldtab(int n)389 void growfldtab(int n) /* make new fields up to at least $n */
390 {
391 int nf = 2 * nfields;
392 size_t s;
393
394 if (n > nf)
395 nf = n;
396 s = (nf+1) * (sizeof (struct Cell *)); /* freebsd: how much do we need? */
397 if (s / sizeof(struct Cell *) - 1 == nf) /* didn't overflow */
398 fldtab = (Cell **) realloc(fldtab, s);
399 else /* overflow sizeof int */
400 xfree(fldtab); /* make it null */
401 if (fldtab == NULL)
402 FATAL("out of space creating %d fields", nf);
403 makefields(nfields+1, nf);
404 nfields = nf;
405 }
406
refldbld(const char * rec,const char * fs)407 int refldbld(const char *rec, const char *fs) /* build fields from reg expr in FS */
408 {
409 /* this relies on having fields[] the same length as $0 */
410 /* the fields are all stored in this one array with \0's */
411 char *fr;
412 int i, tempstat, n;
413 fa *pfa;
414
415 n = strlen(rec);
416 if (n > fieldssize) {
417 xfree(fields);
418 if ((fields = (char *) malloc(n+1)) == NULL)
419 FATAL("out of space for fields in refldbld %d", n);
420 fieldssize = n;
421 }
422 fr = fields;
423 *fr = '\0';
424 if (*rec == '\0')
425 return 0;
426 pfa = makedfa(fs, 1);
427 dprintf( ("into refldbld, rec = <%s>, pat = <%s>\n", rec, fs) );
428 tempstat = pfa->initstat;
429 for (i = 1; ; i++) {
430 if (i > nfields)
431 growfldtab(i);
432 if (freeable(fldtab[i]))
433 xfree(fldtab[i]->sval);
434 fldtab[i]->tval = FLD | STR | DONTFREE;
435 fldtab[i]->sval = fr;
436 dprintf( ("refldbld: i=%d\n", i) );
437 if (nematch(pfa, rec)) {
438 pfa->initstat = 2; /* horrible coupling to b.c */
439 dprintf( ("match %s (%d chars)\n", patbeg, patlen) );
440 strncpy(fr, rec, patbeg-rec);
441 fr += patbeg - rec + 1;
442 *(fr-1) = '\0';
443 rec = patbeg + patlen;
444 } else {
445 dprintf( ("no match %s\n", rec) );
446 strcpy(fr, rec);
447 pfa->initstat = tempstat;
448 break;
449 }
450 }
451 return i;
452 }
453
recbld(void)454 void recbld(void) /* create $0 from $1..$NF if necessary */
455 {
456 int i;
457 char *r, *p;
458
459 if (donerec == 1)
460 return;
461 r = record;
462 for (i = 1; i <= *NF; i++) {
463 p = getsval(fldtab[i]);
464 if (!adjbuf(&record, &recsize, 1+strlen(p)+r-record, recsize, &r, "recbld 1"))
465 FATAL("created $0 `%.30s...' too long", record);
466 while ((*r = *p++) != 0)
467 r++;
468 if (i < *NF) {
469 if (!adjbuf(&record, &recsize, 2+strlen(*OFS)+r-record, recsize, &r, "recbld 2"))
470 FATAL("created $0 `%.30s...' too long", record);
471 for (p = *OFS; (*r = *p++) != 0; )
472 r++;
473 }
474 }
475 if (!adjbuf(&record, &recsize, 2+r-record, recsize, &r, "recbld 3"))
476 FATAL("built giant record `%.30s...'", record);
477 *r = '\0';
478 dprintf( ("in recbld inputFS=%s, fldtab[0]=%p\n", inputFS, fldtab[0]) );
479
480 if (freeable(fldtab[0]))
481 xfree(fldtab[0]->sval);
482 fldtab[0]->tval = REC | STR | DONTFREE;
483 fldtab[0]->sval = record;
484
485 dprintf( ("in recbld inputFS=%s, fldtab[0]=%p\n", inputFS, fldtab[0]) );
486 dprintf( ("recbld = |%s|\n", record) );
487 donerec = 1;
488 }
489
490 int errorflag = 0;
491
yyerror(const char * s)492 void yyerror(const char *s)
493 {
494 SYNTAX("%s", s);
495 }
496
SYNTAX(const char * fmt,...)497 void SYNTAX(const char *fmt, ...)
498 {
499 extern char *cmdname, *curfname;
500 static int been_here = 0;
501 va_list varg;
502
503 if (been_here++ > 2)
504 return;
505 fprintf(stderr, "%s: ", cmdname);
506 va_start(varg, fmt);
507 vfprintf(stderr, fmt, varg);
508 va_end(varg);
509 fprintf(stderr, " at source line %d", lineno);
510 if (curfname != NULL)
511 fprintf(stderr, " in function %s", curfname);
512 if (compile_time == 1 && cursource() != NULL)
513 fprintf(stderr, " source file %s", cursource());
514 fprintf(stderr, "\n");
515 errorflag = 2;
516 eprint();
517 }
518
fpecatch(int n)519 void fpecatch(int n)
520 {
521 FATAL("floating point exception %d", n);
522 }
523
524 extern int bracecnt, brackcnt, parencnt;
525
bracecheck(void)526 void bracecheck(void)
527 {
528 int c;
529 static int beenhere = 0;
530
531 if (beenhere++)
532 return;
533 while ((c = input()) != EOF && c != '\0')
534 bclass(c);
535 bcheck2(bracecnt, '{', '}');
536 bcheck2(brackcnt, '[', ']');
537 bcheck2(parencnt, '(', ')');
538 }
539
bcheck2(int n,int c1,int c2)540 void bcheck2(int n, int c1, int c2)
541 {
542 if (n == 1)
543 fprintf(stderr, "\tmissing %c\n", c2);
544 else if (n > 1)
545 fprintf(stderr, "\t%d missing %c's\n", n, c2);
546 else if (n == -1)
547 fprintf(stderr, "\textra %c\n", c2);
548 else if (n < -1)
549 fprintf(stderr, "\t%d extra %c's\n", -n, c2);
550 }
551
FATAL(const char * fmt,...)552 void FATAL(const char *fmt, ...)
553 {
554 extern char *cmdname;
555 va_list varg;
556
557 fflush(stdout);
558 fprintf(stderr, "%s: ", cmdname);
559 va_start(varg, fmt);
560 vfprintf(stderr, fmt, varg);
561 va_end(varg);
562 error();
563 if (dbg > 1) /* core dump if serious debugging on */
564 abort();
565 exit(2);
566 }
567
WARNING(const char * fmt,...)568 void WARNING(const char *fmt, ...)
569 {
570 extern char *cmdname;
571 va_list varg;
572
573 fflush(stdout);
574 fprintf(stderr, "%s: ", cmdname);
575 va_start(varg, fmt);
576 vfprintf(stderr, fmt, varg);
577 va_end(varg);
578 error();
579 }
580
error()581 void error()
582 {
583 extern Node *curnode;
584
585 fprintf(stderr, "\n");
586 if (compile_time != 2 && NR && *NR > 0) {
587 fprintf(stderr, " input record number %d", (int) (*FNR));
588 if (strcmp(*FILENAME, "-") != 0)
589 fprintf(stderr, ", file %s", *FILENAME);
590 fprintf(stderr, "\n");
591 }
592 if (compile_time != 2 && curnode)
593 fprintf(stderr, " source line number %d", curnode->lineno);
594 else if (compile_time != 2 && lineno)
595 fprintf(stderr, " source line number %d", lineno);
596 if (compile_time == 1 && cursource() != NULL)
597 fprintf(stderr, " source file %s", cursource());
598 fprintf(stderr, "\n");
599 eprint();
600 }
601
eprint(void)602 void eprint(void) /* try to print context around error */
603 {
604 char *p, *q;
605 int c;
606 static int been_here = 0;
607 extern char ebuf[], *ep;
608
609 if (compile_time == 2 || compile_time == 0 || been_here++ > 0)
610 return;
611 p = ep - 1;
612 if (p > ebuf && *p == '\n')
613 p--;
614 for ( ; p > ebuf && *p != '\n' && *p != '\0'; p--)
615 ;
616 while (*p == '\n')
617 p++;
618 fprintf(stderr, " context is\n\t");
619 for (q=ep-1; q>=p && *q!=' ' && *q!='\t' && *q!='\n'; q--)
620 ;
621 for ( ; p < q; p++)
622 if (*p)
623 putc(*p, stderr);
624 fprintf(stderr, " >>> ");
625 for ( ; p < ep; p++)
626 if (*p)
627 putc(*p, stderr);
628 fprintf(stderr, " <<< ");
629 if (*ep)
630 while ((c = input()) != '\n' && c != '\0' && c != EOF) {
631 putc(c, stderr);
632 bclass(c);
633 }
634 putc('\n', stderr);
635 ep = ebuf;
636 }
637
bclass(int c)638 void bclass(int c)
639 {
640 switch (c) {
641 case '{': bracecnt++; break;
642 case '}': bracecnt--; break;
643 case '[': brackcnt++; break;
644 case ']': brackcnt--; break;
645 case '(': parencnt++; break;
646 case ')': parencnt--; break;
647 }
648 }
649
errcheck(double x,const char * s)650 double errcheck(double x, const char *s)
651 {
652
653 if (errno == EDOM) {
654 errno = 0;
655 WARNING("%s argument out of domain", s);
656 x = 1;
657 } else if (errno == ERANGE) {
658 errno = 0;
659 WARNING("%s result out of range", s);
660 x = 1;
661 }
662 return x;
663 }
664
isclvar(const char * s)665 int isclvar(const char *s) /* is s of form var=something ? */
666 {
667 const char *os = s;
668
669 if (!isalpha((uschar) *s) && *s != '_')
670 return 0;
671 for ( ; *s; s++)
672 if (!(isalnum((uschar) *s) || *s == '_'))
673 break;
674 return *s == '=' && s > os && *(s+1) != '=';
675 }
676
677 /* strtod is supposed to be a proper test of what's a valid number */
678 /* appears to be broken in gcc on linux: thinks 0x123 is a valid FP number */
679 /* wrong: violates 4.10.1.4 of ansi C standard */
680
681 #include <math.h>
is_number(const char * s)682 int is_number(const char *s)
683 {
684 double r;
685 char *ep;
686 errno = 0;
687 r = strtod(s, &ep);
688 if (ep == s || r == HUGE_VAL || errno == ERANGE)
689 return 0;
690 while (*ep == ' ' || *ep == '\t' || *ep == '\n')
691 ep++;
692 if (*ep == '\0')
693 return 1;
694 else
695 return 0;
696 }
697