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 /*
26 * CDDL HEADER START
27 *
28 * The contents of this file are subject to the terms of the
29 * Common Development and Distribution License, Version 1.0 only
30 * (the "License"). You may not use this file except in compliance
31 * with the License.
32 *
33 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
34 * or http://www.opensolaris.org/os/licensing.
35 * See the License for the specific language governing permissions
36 * and limitations under the License.
37 *
38 * When distributing Covered Code, include this CDDL HEADER in each
39 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
40 * If applicable, add the following below this CDDL HEADER, with the
41 * fields enclosed by brackets "[]" replaced with your own identifying
42 * information: Portions Copyright [yyyy] [name of copyright owner]
43 *
44 * CDDL HEADER END
45 */
46
47 /*
48 * Copyright 2005 Sun Microsystems, Inc. All rights reserved.
49 * Use is subject to license terms.
50 */
51
52 /* Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */
53 /* All Rights Reserved */
54
55 #define DEBUG
56 #include "awk.h"
57 #include "y.tab.h"
58
59 Node *
nodealloc(int n)60 nodealloc(int n)
61 {
62 Node *x;
63
64 x = (Node *)malloc(sizeof (Node) + (n - 1) * sizeof (Node *));
65 if (x == NULL)
66 FATAL("out of space in nodealloc");
67 x->nnext = NULL;
68 x->lineno = lineno;
69 return (x);
70 }
71
72 Node *
exptostat(Node * a)73 exptostat(Node *a)
74 {
75 a->ntype = NSTAT;
76 return (a);
77 }
78
79 Node *
node1(int a,Node * b)80 node1(int a, Node *b)
81 {
82 Node *x;
83
84 x = nodealloc(1);
85 x->nobj = a;
86 x->narg[0] = b;
87 return (x);
88 }
89
90 Node *
node2(int a,Node * b,Node * c)91 node2(int a, Node *b, Node *c)
92 {
93 Node *x;
94
95 x = nodealloc(2);
96 x->nobj = a;
97 x->narg[0] = b;
98 x->narg[1] = c;
99 return (x);
100 }
101
102 Node *
node3(int a,Node * b,Node * c,Node * d)103 node3(int a, Node *b, Node *c, Node *d)
104 {
105 Node *x;
106
107 x = nodealloc(3);
108 x->nobj = a;
109 x->narg[0] = b;
110 x->narg[1] = c;
111 x->narg[2] = d;
112 return (x);
113 }
114
115 Node *
node4(int a,Node * b,Node * c,Node * d,Node * e)116 node4(int a, Node *b, Node *c, Node *d, Node *e)
117 {
118 Node *x;
119
120 x = nodealloc(4);
121 x->nobj = a;
122 x->narg[0] = b;
123 x->narg[1] = c;
124 x->narg[2] = d;
125 x->narg[3] = e;
126 return (x);
127 }
128
129 Node *
stat1(int a,Node * b)130 stat1(int a, Node *b)
131 {
132 Node *x;
133
134 x = node1(a, b);
135 x->ntype = NSTAT;
136 return (x);
137 }
138
139 Node *
stat2(int a,Node * b,Node * c)140 stat2(int a, Node *b, Node *c)
141 {
142 Node *x;
143
144 x = node2(a, b, c);
145 x->ntype = NSTAT;
146 return (x);
147 }
148
149 Node *
stat3(int a,Node * b,Node * c,Node * d)150 stat3(int a, Node *b, Node *c, Node *d)
151 {
152 Node *x;
153
154 x = node3(a, b, c, d);
155 x->ntype = NSTAT;
156 return (x);
157 }
158
159 Node *
stat4(int a,Node * b,Node * c,Node * d,Node * e)160 stat4(int a, Node *b, Node *c, Node *d, Node *e)
161 {
162 Node *x;
163
164 x = node4(a, b, c, d, e);
165 x->ntype = NSTAT;
166 return (x);
167 }
168
169 Node *
op1(int a,Node * b)170 op1(int a, Node *b)
171 {
172 Node *x;
173
174 x = node1(a, b);
175 x->ntype = NEXPR;
176 return (x);
177 }
178
179 Node *
op2(int a,Node * b,Node * c)180 op2(int a, Node *b, Node *c)
181 {
182 Node *x;
183
184 x = node2(a, b, c);
185 x->ntype = NEXPR;
186 return (x);
187 }
188
189 Node *
op3(int a,Node * b,Node * c,Node * d)190 op3(int a, Node *b, Node *c, Node *d)
191 {
192 Node *x;
193
194 x = node3(a, b, c, d);
195 x->ntype = NEXPR;
196 return (x);
197 }
198
199 Node *
op4(int a,Node * b,Node * c,Node * d,Node * e)200 op4(int a, Node *b, Node *c, Node *d, Node *e)
201 {
202 Node *x;
203
204 x = node4(a, b, c, d, e);
205 x->ntype = NEXPR;
206 return (x);
207 }
208
209 Node *
celltonode(Cell * a,int b)210 celltonode(Cell *a, int b)
211 {
212 Node *x;
213
214 a->ctype = OCELL;
215 a->csub = b;
216 x = node1(0, (Node *)a);
217 x->ntype = NVALUE;
218 return (x);
219 }
220
221 Node *
rectonode(void)222 rectonode(void) /* make $0 into a Node */
223 {
224 extern Cell *literal0;
225 return (op1(INDIRECT, celltonode(literal0, CUNK)));
226 }
227
228 Node *
makearr(Node * p)229 makearr(Node *p)
230 {
231 Cell *cp;
232
233 if (isvalue(p)) {
234 cp = (Cell *)(p->narg[0]);
235 if (isfcn(cp))
236 SYNTAX("%s is a function, not an array", cp->nval);
237 else if (!isarr(cp)) {
238 xfree(cp->sval);
239 cp->sval = (char *)makesymtab(NSYMTAB);
240 cp->tval = ARR;
241 }
242 }
243 return (p);
244 }
245
246 int paircnt; /* number of them in use */
247 int *pairstack; /* state of each pat,pat */
248
249 Node *
pa2stat(Node * a,Node * b,Node * c)250 pa2stat(Node *a, Node *b, Node *c) /* pat, pat {...} */
251 {
252 Node *x;
253
254 x = node4(PASTAT2, a, b, c, itonp(paircnt));
255 paircnt++;
256 x->ntype = NSTAT;
257 return (x);
258 }
259
260 Node *
linkum(Node * a,Node * b)261 linkum(Node *a, Node *b)
262 {
263 Node *c;
264
265 if (errorflag) /* don't link things that are wrong */
266 return (a);
267 if (a == NULL)
268 return (b);
269 else if (b == NULL)
270 return (a);
271 for (c = a; c->nnext != NULL; c = c->nnext)
272 ;
273 c->nnext = b;
274 return (a);
275 }
276
277 /* turn on FCN bit in definition, */
278 /* body of function, arglist */
279 void
defn(Cell * v,Node * vl,Node * st)280 defn(Cell *v, Node *vl, Node *st)
281 {
282 Node *p;
283 int n;
284
285 if (isarr(v)) {
286 SYNTAX("`%s' is an array name and a function name", v->nval);
287 return;
288 }
289 if (isarg(v->nval) != -1) {
290 SYNTAX("`%s' is both function name and argument name", v->nval);
291 return;
292 }
293
294 v->tval = FCN;
295 v->sval = (char *)st;
296 n = 0; /* count arguments */
297 for (p = vl; p != NULL; p = p->nnext)
298 n++;
299 v->fval = n;
300 dprintf(("defining func %s (%d args)\n", v->nval, n));
301 }
302
303 /* is s in argument list for current function? */
304 /* return -1 if not, otherwise arg # */
305 int
isarg(const char * s)306 isarg(const char *s)
307 {
308 extern Node *arglist;
309 Node *p = arglist;
310 int n;
311
312 for (n = 0; p != NULL; p = p->nnext, n++)
313 if (strcmp(((Cell *)(p->narg[0]))->nval, s) == 0)
314 return (n);
315 return (-1);
316 }
317
318 int
ptoi(void * p)319 ptoi(void *p) /* convert pointer to integer */
320 {
321 return ((int)(long)p); /* swearing that p fits, of course */
322 }
323
324 Node *
itonp(int i)325 itonp(int i) /* and vice versa */
326 {
327 return ((Node *)(long)i);
328 }
329