xref: /illumos-gate/usr/src/cmd/oawk/tran.c (revision dc5a8425)
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 2003 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 #include "stdio.h"
34 #include "awk.def"
35 #include "awk.h"
36 #include <stdlib.h>
37 
38 CELL *symtab[MAXSYM];	/* symbol table pointers */
39 
40 
41 wchar_t	**FS;	/* initial field sep */
42 wchar_t	**RS;	/* initial record sep */
43 wchar_t	**OFS;	/* output field sep */
44 wchar_t	**ORS;	/* output record sep */
45 wchar_t	**OFMT;	/* output format for numbers */
46 awkfloat *NF;	/* number of fields in current record */
47 awkfloat *NR;	/* number of current record */
48 wchar_t	**FILENAME;	/* current filename argument */
49 
50 
51 CELL	*recloc;	/* location of record */
52 CELL	*nrloc;		/* NR */
53 CELL	*nfloc;		/* NF */
54 
55 void recbld(void);
56 
57 void
syminit(void)58 syminit(void)
59 {
60 	static wchar_t L_0[] = L"0";
61 	static wchar_t L_zeronull[] = L"$zero&null";
62 	static wchar_t L_record[] = L"$record";
63 	static wchar_t L_FS[] = L"FS";
64 	static wchar_t L_OFS[] = L"OFS";
65 	static wchar_t L_ORS[] = L"ORS";
66 	static wchar_t L_RS[] = L"RS";
67 	static wchar_t L_OFMT[] = L"OFMT";
68 	static wchar_t L_space[] = L" ";
69 	static wchar_t L_newline[] = L"\n";
70 	static wchar_t L_dot6g[] = L"%.6g";
71 	static wchar_t L_FILENAME[] = L"FILENAME";
72 	static wchar_t L_NF[] = L"NF";
73 	static wchar_t L_NR[] = L"NR";
74 
75 
76 	setsymtab(L_0, tostring(L_0), 0.0, NUM|STR|CON|FLD, symtab);
77 	/* this one is used for if (x)... tests: */
78 	setsymtab(L_zeronull, tostring(L_NULL), 0.0, NUM|STR|CON|FLD, symtab);
79 	recloc = setsymtab(L_record, record, 0.0, STR|FLD, symtab);
80 	dprintf("recloc %o lookup %o\n",
81 		recloc, lookup(L_record, symtab, 0), NULL);
82 	FS = &setsymtab(L_FS, tostring(L_space), 0.0, STR|FLD, symtab)->sval;
83 	RS = &setsymtab(L_RS, tostring(L_newline), 0.0, STR|FLD, symtab)->sval;
84 	OFS = &setsymtab(L_OFS, tostring(L_space), 0.0, STR|FLD, symtab)->sval;
85 	ORS = &setsymtab(L_ORS, tostring(L_newline), 0.0, STR|FLD,
86 		symtab)->sval;
87 	OFMT = &setsymtab(L_OFMT, tostring(L_dot6g), 0.0, STR|FLD,
88 		symtab)->sval;
89 	FILENAME = &setsymtab(L_FILENAME, NULL, 0.0, STR|FLD, symtab)->sval;
90 	nfloc = setsymtab(L_NF, NULL, 0.0, NUM, symtab);
91 	NF = &nfloc->fval;
92 	nrloc = setsymtab(L_NR, NULL, 0.0, NUM, symtab);
93 	NR = &nrloc->fval;
94 }
95 
96 
97 CELL **
makesymtab(void)98 makesymtab(void)
99 {
100 	int i;
101 	CELL **cp;
102 
103 
104 	cp = (CELL **) malloc(MAXSYM * sizeof (CELL *));
105 	if (cp == NULL)
106 		error(FATAL, "out of space in makesymtab");
107 	for (i = 0; i < MAXSYM; i++)
108 		cp[i] = 0;
109 	return (cp);
110 }
111 
112 
113 void
freesymtab(CELL * ap)114 freesymtab(CELL *ap)	/* free symbol table */
115 {
116 	CELL *cp, **tp, *next;
117 	int i;
118 
119 
120 	if (!(ap->tval & ARR))
121 		return;
122 	tp = (CELL **) ap->sval;
123 	for (i = 0; i < MAXSYM; i++) {
124 		for (cp = tp[i]; cp != NULL; cp = next) {
125 			next = cp->nextval;
126 			xfree(cp->nval);
127 			xfree(cp->sval);
128 			free(cp);
129 		}
130 	}
131 	xfree(tp);
132 }
133 
134 
135 CELL *
setsymtab(wchar_t * n,wchar_t * s,awkfloat f,unsigned t,CELL ** tab)136 setsymtab(wchar_t *n, wchar_t *s, awkfloat f, unsigned t, CELL **tab)
137 {
138 	int h;
139 	CELL *p;
140 	CELL *lookup();
141 
142 
143 	if (n != NULL && (p = lookup(n, tab, 0)) != NULL) {
144 		xfree(s);
145 		dprintf("setsymtab found %o: %ws\n", p, p->nval, NULL);
146 		dprintf(" %ws %g %o\n", p->sval, p->fval, p->tval);
147 		return (p);
148 	}
149 	p = (CELL *) malloc(sizeof (CELL));
150 	if (p == NULL)
151 		error(FATAL, "symbol table overflow at %ws", n);
152 	p->nval = tostring(n);
153 	p->sval = s;
154 	p->fval = f;
155 	p->tval = t;
156 	h = hash(n);
157 	p->nextval = tab[h];
158 	tab[h] = p;
159 	dprintf("setsymtab set %o: %ws\n", p, p->nval, NULL);
160 	dprintf(" %ws %g %o\n", p->sval, p->fval, p->tval);
161 	return (p);
162 }
163 
164 
165 int
hash(wchar_t * s)166 hash(wchar_t *s)	/* form hash value for string s */
167 {
168 	unsigned hashval;
169 
170 
171 	for (hashval = 0; *s != '\0'; /* dummy */)
172 		hashval += *s++;
173 	return (hashval % MAXSYM);
174 }
175 
176 
177 CELL *
lookup(wchar_t * s,CELL ** tab,int flag)178 lookup(wchar_t *s, CELL **tab, int flag)
179 	/* look for s in tab, flag must match */
180 {
181 	CELL *p;
182 
183 
184 	for (p = tab[hash(s)]; p != NULL; p = p->nextval)
185 		if (wscmp(s, p->nval) == 0 &&
186 			(flag == 0 || flag == p->tval))
187 			return (p);	/* found it */
188 	return (NULL);	/* not found */
189 }
190 
191 
192 awkfloat
setfval(CELL * vp,awkfloat f)193 setfval(CELL *vp, awkfloat f)
194 {
195 	dprintf("setfval: %o %g\n", vp, f, NULL);
196 /* imb */
197 	if (vp->tval & ARR)
198 		error(FATAL, "illegal reference to array %s", vp->nval);
199 	if ((vp->tval & (NUM | STR)) == 0)
200 		error(FATAL, "funny variable %o: %ws %ws %g %o", vp, vp->nval,
201 			vp->sval, vp->fval, vp->tval);
202 /* imb */
203 	if (vp == recloc)
204 		error(FATAL, "can't set $0");
205 	vp->tval &= ~STR;	/* mark string invalid */
206 	vp->tval |= NUM;	/* mark number ok */
207 	if ((vp->tval & FLD) && vp->nval == 0) {
208 		/*
209 		 * FLD really means that the string value was not
210 		 * "malloc"ed and should not be freed.  All fields
211 		 * have this property, but not all cells with this
212 		 * property are fields.  However, all cells with
213 		 * this property and with a NULL "nval" are fields.
214 		 * If we are setting the value of a field, indicate
215 		 * that the value of the record has to be recomputed,
216 		 * and if it's a higher field than the last one we
217 		 * assigned to, remember it for when we clear the
218 		 * fields out for the next record.
219 		 */
220 		donerec = 0;
221 		if (vp > maxmfld)
222 			maxmfld = vp;
223 	}
224 	return (vp->fval = f);
225 }
226 
227 
228 wchar_t *
setsval(CELL * vp,wchar_t * s)229 setsval(CELL *vp, wchar_t *s)
230 {
231 	dprintf("setsval: %o %ws\n", vp, s, NULL);
232 	if (vp->tval & ARR)
233 		error(FATAL, "illegal reference to array %ws", vp->nval);
234 	if ((vp->tval & (NUM | STR)) == 0)
235 		error(FATAL, "funny variable %o: %ws %ws %g %o", vp, vp->nval,
236 			vp->sval, vp->fval, vp->tval);
237 	if (vp == recloc)
238 		error(FATAL, "can't set $0");
239 	vp->tval &= ~NUM;
240 	vp->tval |= STR;
241 	if ((vp->tval & FLD) && vp->nval == 0) {
242 		/*
243 		 * See comment in "setfval".
244 		 */
245 		donerec = 0;
246 		if (vp > maxmfld)
247 			maxmfld = vp;
248 	}
249 	if (!(vp->tval&FLD))
250 		xfree(vp->sval);
251 	vp->tval &= ~FLD;
252 	return (vp->sval = tostring(s));
253 }
254 
255 
256 awkfloat
getfval(CELL * vp)257 getfval(CELL *vp)
258 {
259 
260 
261 	if (vp->sval == record && donerec == 0)
262 		recbld();
263 	dprintf("getfval: %o", vp, NULL, NULL);
264 	if (vp->tval & ARR)
265 		error(FATAL, "illegal reference to array %ws", vp->nval);
266 	if ((vp->tval & (NUM | STR)) == 0)
267 		error(FATAL, "funny variable %o: %ws %ws %g %o", vp, vp->nval,
268 			vp->sval, vp->fval, vp->tval);
269 	if ((vp->tval & NUM) == 0) {
270 		/* the problem is to make non-numeric things */
271 		/* have unlikely numeric variables, so that */
272 		/* $1 == $2 comparisons sort of make sense when */
273 		/* one or the other is numeric */
274 		if (isanumber(vp->sval)) {
275 			vp->fval = watof(vp->sval);
276 			if (!(vp->tval & CON))
277 				/* don't change type of a constant */
278 				vp->tval |= NUM;
279 		}
280 		else
281 			vp->fval = 0.0;	/* not a very good idea */
282 	}
283 	dprintf("  %g\n", vp->fval, NULL, NULL);
284 	return (vp->fval);
285 }
286 
287 
288 wchar_t *
getsval(CELL * vp)289 getsval(CELL *vp)
290 {
291 	char s[100];
292 	wchar_t ws[100];
293 
294 
295 	if (vp->sval == record && donerec == 0)
296 		recbld();
297 	dprintf("getsval: %o", vp, NULL, NULL);
298 	if (vp->tval & ARR)
299 		error(FATAL, "illegal reference to array %ws", vp->nval);
300 	if ((vp->tval & (NUM | STR)) == 0)
301 		error(FATAL, "funny variable %o: %ws %ws %g %o", vp, vp->nval,
302 			vp->sval, vp->fval, vp->tval);
303 	if ((vp->tval & STR) == 0) {
304 		if (!(vp->tval&FLD))
305 			xfree(vp->sval);
306 		if ((long long)vp->fval == vp->fval)
307 			sprintf(s, "%.20g", vp->fval);
308 		else
309 			sprintf(s, toeuccode(*OFMT), vp->fval);
310 		mbstowcs(ws, s, sizeof (ws) / sizeof (wchar_t));
311 		vp->sval = tostring(ws);
312 		vp->tval &= ~FLD;
313 		vp->tval |= STR;
314 	}
315 	dprintf("  %ws\n", vp->sval, NULL, NULL);
316 	return (vp->sval);
317 }
318 
319 
320 wchar_t *
tostring(wchar_t * s)321 tostring(wchar_t *s)
322 {
323 	wchar_t *p;
324 
325 
326 	p = (wchar_t *) malloc((wslen(s)+1)*sizeof (wchar_t));
327 	if (p == NULL)
328 		error(FATAL, "out of space in tostring on %ws", s);
329 	wscpy(p, s);
330 	return (p);
331 }
332 
333 
334 #ifndef yfree
yfree(char * a)335 yfree(char *a)
336 {
337 	printf("%o\n", a);
338 	free(a);
339 }
340 #endif
341