5004023 *nawk* nawk fails when called from buildpatch with long path names

5040318 nawk is limited to 500 fields.
5090114 nawk core dumps
6268954 cmd/awk and gcc don't get along

1 files changed, 112 insertions, 71 deletions

diff --git a/usr/src/cmd/awk/parse.c b/usr/src/cmd/awk/parse.c
index db9f1ac692..909977f10f 100644
--- a/usr/src/cmd/awk/parse.c
+++ b/usr/src/cmd/awk/parse.c
@@ -19,65 +19,79 @@
  *
  * CDDL HEADER END
  */
+
+/*
+ * Copyright 2005 Sun Microsystems, Inc.  All rights reserved.
+ * Use is subject to license terms.
+ */
+
 /*	Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T	*/
 /*	  All Rights Reserved  	*/
 
+#pragma ident	"%Z%%M%	%I%	%E% SMI"
 
-#ident	"%Z%%M%	%I%	%E% SMI"	/* SVr4.0 2.8	*/
-
-#define DEBUG
-#include <stdio.h>
+#define	DEBUG
 #include "awk.h"
 #include "y.tab.h"
 
-Node *nodealloc(n)
+Node *
+nodealloc(int n)
 {
 	register Node *x;
-	x = (Node *) malloc(sizeof(Node) + (n-1)*sizeof(Node *));
+
+	x = (Node *)malloc(sizeof (Node) + (n - 1) * sizeof (Node *));
 	if (x == NULL)
 		ERROR "out of space in nodealloc" FATAL;
 	x->nnext = NULL;
 	x->lineno = lineno;
-	return(x);
+	return (x);
 }
 
-Node *exptostat(a) Node *a;
+Node *
+exptostat(Node *a)
 {
 	a->ntype = NSTAT;
-	return(a);
+	return (a);
 }
 
-Node *node1(a,b) Node *b;
+Node *
+node1(int a, Node *b)
 {
 	register Node *x;
+
 	x = nodealloc(1);
 	x->nobj = a;
-	x->narg[0]=b;
-	return(x);
+	x->narg[0] = b;
+	return (x);
 }
 
-Node *node2(a,b,c) Node *b, *c;
+Node *
+node2(int a, Node *b, Node *c)
 {
 	register Node *x;
+
 	x = nodealloc(2);
 	x->nobj = a;
 	x->narg[0] = b;
 	x->narg[1] = c;
-	return(x);
+	return (x);
 }
 
-Node *node3(a,b,c,d) Node *b, *c, *d;
+Node *
+node3(int a, Node *b, Node *c, Node *d)
 {
 	register Node *x;
+
 	x = nodealloc(3);
 	x->nobj = a;
 	x->narg[0] = b;
 	x->narg[1] = c;
 	x->narg[2] = d;
-	return(x);
+	return (x);
 }
 
-Node *node4(a,b,c,d,e) Node *b, *c, *d, *e;
+Node *
+node4(int a, Node *b, Node *c, Node *d, Node *e)
 {
 	register Node *x;
 	x = nodealloc(4);
@@ -86,159 +100,186 @@ Node *node4(a,b,c,d,e) Node *b, *c, *d, *e;
 	x->narg[1] = c;
 	x->narg[2] = d;
 	x->narg[3] = e;
-	return(x);
+	return (x);
 }
 
-Node *stat3(a,b,c,d) Node *b, *c, *d;
+Node *
+stat3(int a, Node *b, Node *c, Node *d)
 {
 	register Node *x;
-	x = node3(a,b,c,d);
+
+	x = node3(a, b, c, d);
 	x->ntype = NSTAT;
-	return(x);
+	return (x);
 }
 
-Node *op2(a,b,c) Node *b, *c;
+Node *
+op2(int a, Node *b, Node *c)
 {
 	register Node *x;
-	x = node2(a,b,c);
+
+	x = node2(a, b, c);
 	x->ntype = NEXPR;
-	return(x);
+	return (x);
 }
 
-Node *op1(a,b) Node *b;
+Node *
+op1(int a, Node *b)
 {
 	register Node *x;
-	x = node1(a,b);
+
+	x = node1(a, b);
 	x->ntype = NEXPR;
-	return(x);
+	return (x);
 }
 
-Node *stat1(a,b) Node *b;
+Node *
+stat1(int a, Node *b)
 {
 	register Node *x;
-	x = node1(a,b);
+
+	x = node1(a, b);
 	x->ntype = NSTAT;
-	return(x);
+	return (x);
 }
 
-Node *op3(a,b,c,d) Node *b, *c, *d;
+Node *
+op3(int a, Node *b, Node *c, Node *d)
 {
 	register Node *x;
-	x = node3(a,b,c,d);
+
+	x = node3(a, b, c, d);
 	x->ntype = NEXPR;
-	return(x);
+	return (x);
 }
 
-Node *op4(a,b,c,d,e) Node *b, *c, *d, *e;
+Node *
+op4(int a, Node *b, Node *c, Node *d, Node *e)
 {
 	register Node *x;
-	x = node4(a,b,c,d,e);
+
+	x = node4(a, b, c, d, e);
 	x->ntype = NEXPR;
-	return(x);
+	return (x);
 }
 
-Node *stat2(a,b,c) Node *b, *c;
+Node *
+stat2(int a, Node *b, Node *c)
 {
 	register Node *x;
-	x = node2(a,b,c);
+
+	x = node2(a, b, c);
 	x->ntype = NSTAT;
-	return(x);
+	return (x);
 }
 
-Node *stat4(a,b,c,d,e) Node *b, *c, *d, *e;
+Node *
+stat4(int a, Node *b, Node *c, Node *d, Node *e)
 {
 	register Node *x;
-	x = node4(a,b,c,d,e);
+
+	x = node4(a, b, c, d, e);
 	x->ntype = NSTAT;
-	return(x);
+	return (x);
 }
 
-Node *valtonode(a, b) Cell *a;
+Node *
+valtonode(Cell *a, int b)
 {
 	register Node *x;
 
 	a->ctype = OCELL;
 	a->csub = b;
-	x = node1(0, (Node *) a);
+	x = node1(0, (Node *)a);
 	x->ntype = NVALUE;
-	return(x);
+	return (x);
 }
 
-Node *rectonode()
+Node *
+rectonode(void)
 {
 	/* return valtonode(lookup("$0", symtab), CFLD); */
-	return valtonode(recloc, CFLD);
+	return (valtonode(recloc, CFLD));
 }
 
-Node *makearr(p) Node *p;
+Node *
+makearr(Node *p)
 {
 	Cell *cp;
 
 	if (isvalue(p)) {
-		cp = (Cell *) (p->narg[0]);
+		cp = (Cell *)(p->narg[0]);
 		if (isfunc(cp))
 			ERROR "%s is a function, not an array", cp->nval SYNTAX;
 		else if (!isarr(cp)) {
 			xfree(cp->sval);
-			cp->sval = (uchar *) makesymtab(NSYMTAB);
+			cp->sval = (uchar *)makesymtab(NSYMTAB);
 			cp->tval = ARR;
 		}
 	}
-	return p;
+	return (p);
 }
 
-Node *pa2stat(a,b,c) Node *a, *b, *c;
+Node *
+pa2stat(Node *a, Node *b, Node *c)
 {
 	register Node *x;
-	x = node4(PASTAT2, a, b, c, (Node *) paircnt);
+
+	x = node4(PASTAT2, a, b, c, (Node *)paircnt);
 	paircnt++;
 	x->ntype = NSTAT;
-	return(x);
+	return (x);
 }
 
-Node *linkum(a,b) Node *a, *b;
+Node *
+linkum(Node *a, Node *b)
 {
 	register Node *c;
 
 	if (errorflag)	/* don't link things that are wrong */
-		return a;
-	if (a == NULL) return(b);
-	else if (b == NULL) return(a);
+		return (a);
+	if (a == NULL)
+		return (b);
+	else if (b == NULL)
+		return (a);
 	for (c = a; c->nnext != NULL; c = c->nnext)
 		;
 	c->nnext = b;
-	return(a);
+	return (a);
 }
 
-defn(v, vl, st)	/* turn on FCN bit in definition */
-	Cell *v;
-	Node *st, *vl;	/* body of function, arglist */
+void
+defn(Cell *v, Node *vl, Node *st)	/* turn on FCN bit in definition */
 {
 	Node *p;
 	int n;
 
 	if (isarr(v)) {
-		ERROR "`%s' is an array name and a function name", v->nval SYNTAX;
+		ERROR "`%s' is an array name and a function name",
+		    v->nval SYNTAX;
 		return;
 	}
 	v->tval = FCN;
-	v->sval = (uchar *) st;
+	v->sval = (uchar *)st;
 	n = 0;	/* count arguments */
 	for (p = vl; p; p = p->nnext)
 		n++;
 	v->fval = n;
-	dprintf( ("defining func %s (%d args)\n", v->nval, n) );
+	dprintf(("defining func %s (%d args)\n", v->nval, n));
 }
 
-isarg(s)	/* is s in argument list for current function? */
-	uchar *s;
+int
+isarg(uchar *s)	/* is s in argument list for current function? */
 {
 	extern Node *arglist;
 	Node *p = arglist;
 	int n;
 
-	for (n = 0; p != 0; p = p->nnext, n++)
-		if (strcmp(((Cell *)(p->narg[0]))->nval, s) == 0)
-			return n;
-	return -1;
+	for (n = 0; p != 0; p = p->nnext, n++) {
+		if (strcmp((char *)((Cell *)(p->narg[0]))->nval,
+		    (char *)s) == 0) {
+			return (n);
+		}
+	}
+	return (-1);
 }