Delete old versions of awk and unversion directory name.
[dragonfly.git] / contrib / awk / parse.c
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
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
44 Node *exptostat(Node *a)
45 {
46         a->ntype = NSTAT;
47         return(a);
48 }
49
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
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
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
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
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
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
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
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
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
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
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
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
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
179 Node *rectonode(void)   /* make $0 into a Node */
180 {
181         extern Cell *literal0;
182         return op1(INDIRECT, celltonode(literal0, CUNK));
183 }
184
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
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
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
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
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
268 int ptoi(void *p)       /* convert pointer to integer */
269 {
270         return (int) (long) p;  /* swearing that p fits, of course */
271 }
272
273 Node *itonp(int i)      /* and vice versa */
274 {
275         return (Node *) (long) i;
276 }