• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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 <stdlib.h>
29 #include "awk.h"
30 #include "ytab.h"
31 
nodealloc(int n)32 Node *nodealloc(int n)
33 {
34 	Node *x;
35 
36 	x = (Node *) malloc(sizeof(Node) + (n-1)*sizeof(Node *));
37 	if (x == NULL)
38 		FATAL("out of space in nodealloc");
39 	x->nnext = NULL;
40 	x->lineno = lineno;
41 	return(x);
42 }
43 
exptostat(Node * a)44 Node *exptostat(Node *a)
45 {
46 	a->ntype = NSTAT;
47 	return(a);
48 }
49 
node1(int a,Node * b)50 Node *node1(int a, Node *b)
51 {
52 	Node *x;
53 
54 	x = nodealloc(1);
55 	x->nobj = a;
56 	x->narg[0]=b;
57 	return(x);
58 }
59 
node2(int a,Node * b,Node * c)60 Node *node2(int a, Node *b, Node *c)
61 {
62 	Node *x;
63 
64 	x = nodealloc(2);
65 	x->nobj = a;
66 	x->narg[0] = b;
67 	x->narg[1] = c;
68 	return(x);
69 }
70 
node3(int a,Node * b,Node * c,Node * d)71 Node *node3(int a, Node *b, Node *c, Node *d)
72 {
73 	Node *x;
74 
75 	x = nodealloc(3);
76 	x->nobj = a;
77 	x->narg[0] = b;
78 	x->narg[1] = c;
79 	x->narg[2] = d;
80 	return(x);
81 }
82 
node4(int a,Node * b,Node * c,Node * d,Node * e)83 Node *node4(int a, Node *b, Node *c, Node *d, Node *e)
84 {
85 	Node *x;
86 
87 	x = nodealloc(4);
88 	x->nobj = a;
89 	x->narg[0] = b;
90 	x->narg[1] = c;
91 	x->narg[2] = d;
92 	x->narg[3] = e;
93 	return(x);
94 }
95 
stat1(int a,Node * b)96 Node *stat1(int a, Node *b)
97 {
98 	Node *x;
99 
100 	x = node1(a,b);
101 	x->ntype = NSTAT;
102 	return(x);
103 }
104 
stat2(int a,Node * b,Node * c)105 Node *stat2(int a, Node *b, Node *c)
106 {
107 	Node *x;
108 
109 	x = node2(a,b,c);
110 	x->ntype = NSTAT;
111 	return(x);
112 }
113 
stat3(int a,Node * b,Node * c,Node * d)114 Node *stat3(int a, Node *b, Node *c, Node *d)
115 {
116 	Node *x;
117 
118 	x = node3(a,b,c,d);
119 	x->ntype = NSTAT;
120 	return(x);
121 }
122 
stat4(int a,Node * b,Node * c,Node * d,Node * e)123 Node *stat4(int a, Node *b, Node *c, Node *d, Node *e)
124 {
125 	Node *x;
126 
127 	x = node4(a,b,c,d,e);
128 	x->ntype = NSTAT;
129 	return(x);
130 }
131 
op1(int a,Node * b)132 Node *op1(int a, Node *b)
133 {
134 	Node *x;
135 
136 	x = node1(a,b);
137 	x->ntype = NEXPR;
138 	return(x);
139 }
140 
op2(int a,Node * b,Node * c)141 Node *op2(int a, Node *b, Node *c)
142 {
143 	Node *x;
144 
145 	x = node2(a,b,c);
146 	x->ntype = NEXPR;
147 	return(x);
148 }
149 
op3(int a,Node * b,Node * c,Node * d)150 Node *op3(int a, Node *b, Node *c, Node *d)
151 {
152 	Node *x;
153 
154 	x = node3(a,b,c,d);
155 	x->ntype = NEXPR;
156 	return(x);
157 }
158 
op4(int a,Node * b,Node * c,Node * d,Node * e)159 Node *op4(int a, Node *b, Node *c, Node *d, Node *e)
160 {
161 	Node *x;
162 
163 	x = node4(a,b,c,d,e);
164 	x->ntype = NEXPR;
165 	return(x);
166 }
167 
celltonode(Cell * a,int b)168 Node *celltonode(Cell *a, int b)
169 {
170 	Node *x;
171 
172 	a->ctype = OCELL;
173 	a->csub = b;
174 	x = node1(0, (Node *) a);
175 	x->ntype = NVALUE;
176 	return(x);
177 }
178 
rectonode(void)179 Node *rectonode(void)	/* make $0 into a Node */
180 {
181 	extern Cell *literal0;
182 	return op1(INDIRECT, celltonode(literal0, CUNK));
183 }
184 
makearr(Node * p)185 Node *makearr(Node *p)
186 {
187 	Cell *cp;
188 
189 	if (isvalue(p)) {
190 		cp = (Cell *) (p->narg[0]);
191 		if (isfcn(cp))
192 			SYNTAX( "%s is a function, not an array", cp->nval );
193 		else if (!isarr(cp)) {
194 			xfree(cp->sval);
195 			cp->sval = (char *) makesymtab(NSYMTAB);
196 			cp->tval = ARR;
197 		}
198 	}
199 	return p;
200 }
201 
202 #define PA2NUM	50	/* max number of pat,pat patterns allowed */
203 int	paircnt;		/* number of them in use */
204 int	pairstack[PA2NUM];	/* state of each pat,pat */
205 
pa2stat(Node * a,Node * b,Node * c)206 Node *pa2stat(Node *a, Node *b, Node *c)	/* pat, pat {...} */
207 {
208 	Node *x;
209 
210 	x = node4(PASTAT2, a, b, c, itonp(paircnt));
211 	if (paircnt++ >= PA2NUM)
212 		SYNTAX( "limited to %d pat,pat statements", PA2NUM );
213 	x->ntype = NSTAT;
214 	return(x);
215 }
216 
linkum(Node * a,Node * b)217 Node *linkum(Node *a, Node *b)
218 {
219 	Node *c;
220 
221 	if (errorflag)	/* don't link things that are wrong */
222 		return a;
223 	if (a == NULL)
224 		return(b);
225 	else if (b == NULL)
226 		return(a);
227 	for (c = a; c->nnext != NULL; c = c->nnext)
228 		;
229 	c->nnext = b;
230 	return(a);
231 }
232 
defn(Cell * v,Node * vl,Node * st)233 void defn(Cell *v, Node *vl, Node *st)	/* turn on FCN bit in definition, */
234 {					/*   body of function, arglist */
235 	Node *p;
236 	int n;
237 
238 	if (isarr(v)) {
239 		SYNTAX( "`%s' is an array name and a function name", v->nval );
240 		return;
241 	}
242 	if (isarg(v->nval) != -1) {
243 		SYNTAX( "`%s' is both function name and argument name", v->nval );
244 		return;
245 	}
246 
247 	v->tval = FCN;
248 	v->sval = (char *) st;
249 	n = 0;	/* count arguments */
250 	for (p = vl; p; p = p->nnext)
251 		n++;
252 	v->fval = n;
253 	dprintf( ("defining func %s (%d args)\n", v->nval, n) );
254 }
255 
isarg(const char * s)256 int isarg(const char *s)		/* is s in argument list for current function? */
257 {			/* return -1 if not, otherwise arg # */
258 	extern Node *arglist;
259 	Node *p = arglist;
260 	int n;
261 
262 	for (n = 0; p != 0; p = p->nnext, n++)
263 		if (strcmp(((Cell *)(p->narg[0]))->nval, s) == 0)
264 			return n;
265 	return -1;
266 }
267 
ptoi(void * p)268 int ptoi(void *p)	/* convert pointer to integer */
269 {
270 	return (int) (long) p;	/* swearing that p fits, of course */
271 }
272 
itonp(int i)273 Node *itonp(int i)	/* and vice versa */
274 {
275 	return (Node *) (long) i;
276 }
277