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