parse.c - 9base - revived minimalist port of Plan 9 userland to Unix | |
git clone git://git.suckless.org/9base | |
Log | |
Files | |
Refs | |
README | |
LICENSE | |
--- | |
parse.c (5069B) | |
--- | |
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 "y.tab.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->nv… | |
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 allowe… | |
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 defi… | |
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->… | |
240 return; | |
241 } | |
242 v->tval = FCN; | |
243 v->sval = (char *) st; | |
244 n = 0; /* count arguments */ | |
245 for (p = vl; p; p = p->nnext) | |
246 n++; | |
247 v->fval = n; | |
248 dprintf( ("defining func %s (%d args)\n", v->nval, n) ); | |
249 } | |
250 | |
251 int isarg(char *s) /* is s in argument list for current f… | |
252 { /* return -1 if not, otherwise arg # */ | |
253 extern Node *arglist; | |
254 Node *p = arglist; | |
255 int n; | |
256 | |
257 for (n = 0; p != 0; p = p->nnext, n++) | |
258 if (strcmp(((Cell *)(p->narg[0]))->nval, s) == 0) | |
259 return n; | |
260 return -1; | |
261 } | |
262 | |
263 int ptoi(void *p) /* convert pointer to integer */ | |
264 { | |
265 return (int) (long) p; /* swearing that p fits, of course… | |
266 } | |
267 | |
268 Node *itonp(int i) /* and vice versa */ | |
269 { | |
270 return (Node *) (long) i; | |
271 } | |
272 |