op public repos

Blob

Date:: Fri Apr 14 00:15:16 2006 UTC
Message:: fixes
Actions:: History | Blame | Raw File
1 #include	<stdio.h>
2 #include	<string.h>
3 #include	<math.h>
4 #include	"pic.h"
5 #include	"y.tab.h"
6 
7 int
8 setdir(int n)	/* set direction (hvmode) from LEFT, RIGHT, etc. */
9 {
10 	switch (n) {
11 	case UP:	hvmode = U_DIR; break;
12 	case DOWN:	hvmode = D_DIR; break;
13 	case LEFT:	hvmode = L_DIR; break;
14 	case RIGHT:	hvmode = R_DIR; break;
15 	}
16  	return(hvmode);
17 }
18 
19 int
20 curdir(void)	/* convert current dir (hvmode) to RIGHT, LEFT, etc. */
21 {
22 	switch (hvmode) {
23 	case R_DIR:	return RIGHT;
24 	case L_DIR:	return LEFT;
25 	case U_DIR:	return UP;
26 	case D_DIR:	return DOWN;
27 	}
28 	ERROR "can't happen curdir" FATAL;
29 	return 0;
30 }
31 
32 double
33 getcomp(obj *p, int t)	/* return component of a position */
34 {
35 	switch (t) {
36 	case DOTX:
37 		return p->o_x;
38 	case DOTY:
39 		return p->o_y;
40 	case DOTWID:
41 		switch (p->o_type) {
42 		case BOX:
43 		case BLOCK:
44 		case TEXT:
45 			return p->o_val[0];
46 		case CIRCLE:
47 		case ELLIPSE:
48 			return 2 * p->o_val[0];
49 		case LINE:
50 		case ARROW:
51 			return p->o_val[0] - p->o_x;
52 		case PLACE:
53 			return 0;
54 		}
55 	case DOTHT:
56 		switch (p->o_type) {
57 		case BOX:
58 		case BLOCK:
59 		case TEXT:
60 			return p->o_val[1];
61 		case CIRCLE:
62 		case ELLIPSE:
63 			return 2 * p->o_val[1];
64 		case LINE:
65 		case ARROW:
66 			return p->o_val[1] - p->o_y;
67 		case PLACE:
68 			return 0;
69 		}
70 	case DOTRAD:
71 		switch (p->o_type) {
72 		case CIRCLE:
73 		case ELLIPSE:
74 			return p->o_val[0];
75 		}
76 	}
77 	ERROR "you asked for a weird dimension or position" WARNING;
78 	return 0;
79 }
80 
81 double	exprlist[100];
82 int	nexpr	= 0;
83 
84 void
85 exprsave(double f)
86 {
87 	exprlist[nexpr++] = f;
88 }
89 
90 char*
91 sprintgen(char *fmt)
92 {
93 	char buf[1000];
94 
95 	sprintf(buf, fmt, exprlist[0], exprlist[1], exprlist[2], exprlist[3], exprlist[4]);
96 	nexpr = 0;
97 	free(fmt);
98 	return tostring(buf);
99 }
100 
101 void
102 makefattr(int type, int sub, double f)	/* double attr */
103 {
104 	YYSTYPE val;
105 	val.f = f;
106 	makeattr(type, sub, val);
107 }
108 
109 void
110 makeoattr(int type, obj *o)	/* obj* attr */
111 {
112 	YYSTYPE val;
113 	val.o = o;
114 	makeattr(type, 0, val);
115 }
116 
117 void
118 makeiattr(int type, int i)	/* int attr */
119 {
120 	YYSTYPE val;
121 	val.i = i;
122 	makeattr(type, 0, val);
123 }
124 
125 void
126 maketattr(int sub, char *p)	/* text attribute: takes two */
127 {
128 	YYSTYPE val;
129 	val.p = p;
130 	makeattr(TEXTATTR, sub, val);
131 }
132 
133 void
134 addtattr(int sub)		/* add text attrib to existing item */
135 {
136 	attr[nattr-1].a_sub |= sub;
137 }
138 
139 void
140 makevattr(char *p)	/* varname attribute */
141 {
142 	YYSTYPE val;
143 	val.p = p;
144 	makeattr(VARNAME, 0, val);
145 }
146 
147 void
148 makeattr(int type, int sub, YYSTYPE val)	/* add attribute type and val */
149 {
150 	if (type == 0 && val.i == 0) {	/* clear table for next stat */
151 		nattr = 0;
152 		return;
153 	}
154 	if (nattr >= nattrlist)
155 		attr = (Attr *) grow((char *)attr, "attr", nattrlist += 100, sizeof(Attr));
156 	dprintf("attr %d:  %d %d %d\n", nattr, type, sub, val.i);
157 	attr[nattr].a_type = type;
158 	attr[nattr].a_sub = sub;
159 	attr[nattr].a_val = val;
160 	nattr++;
161 }
162 
163 void
164 printexpr(double f)	/* print expression for debugging */
165 {
166 	printf("%g\n", f);
167 }
168 
169 void
170 printpos(obj *p)	/* print position for debugging */
171 {
172 	printf("%g, %g\n", p->o_x, p->o_y);
173 }
174 
175 char*
176 tostring(char *s)
177 {
178 	char *p;
179 
180 	p = malloc(strlen(s)+1);
181 	if (p == NULL)
182 		ERROR "out of space in tostring on %s", s FATAL;
183 	strcpy(p, s);
184 	return(p);
185 }
186 
187 obj*
188 makepos(double x, double y)	/* make a position cell */
189 {
190 	obj *p;
191 
192 	p = makenode(PLACE, 0);
193 	p->o_x = x;
194 	p->o_y = y;
195 	return(p);
196 }
197 
198 obj*
199 makebetween(double f, obj *p1, obj* p2)	/* make position between p1 and p2 */
200 {
201 	obj *p;
202 
203 	dprintf("fraction = %.2f\n", f);
204 	p = makenode(PLACE, 0);
205 	p->o_x = p1->o_x + f * (p2->o_x - p1->o_x);
206 	p->o_y = p1->o_y + f * (p2->o_y - p1->o_y);
207 	return(p);
208 }
209 
210 obj*
211 getpos(obj *p, int corner)	/* find position of point */
212 {
213 	double x, y;
214 
215 	whatpos(p, corner, &x, &y);
216 	return makepos(x, y);
217 }
218 
219 int
220 whatpos(obj *p, int corner, double *px, double *py)	/* what is the position (no side effect) */
221 {
222 	double x, y, x1, y1;
223 
224 	dprintf("whatpos %p %d %d\n", p, p->o_type, corner);
225 	x = p->o_x;
226 	y = p->o_y;
227 	x1 = 0;
228 	y1 = 0;
229 	if (p->o_type != PLACE) {
230 		x1 = p->o_val[0];
231 		y1 = p->o_val[1];
232 	}
233 	switch (p->o_type) {
234 	case PLACE:
235 		break;
236 	case BOX:
237 	case BLOCK:
238 	case TEXT:
239 		switch (corner) {
240 		case NORTH:	y += y1 / 2; break;
241 		case SOUTH:	y -= y1 / 2; break;
242 		case EAST:	x += x1 / 2; break;
243 		case WEST:	x -= x1 / 2; break;
244 		case NE:	x += x1 / 2; y += y1 / 2; break;
245 		case SW:	x -= x1 / 2; y -= y1 / 2; break;
246 		case SE:	x += x1 / 2; y -= y1 / 2; break;
247 		case NW:	x -= x1 / 2; y += y1 / 2; break;
248 		case START:
249 			if (p->o_type == BLOCK)
250 				return whatpos(objlist[(int)p->o_val[2]], START, px, py);
251 		case END:
252 			if (p->o_type == BLOCK)
253 				return whatpos(objlist[(int)p->o_val[3]], END, px, py);
254 		}
255 		break;
256 	case ARC:
257 		switch (corner) {
258 		case START:
259 			if (p->o_attr & CW_ARC) {
260 				x = p->o_val[2]; y = p->o_val[3];
261 			} else {
262 				x = x1; y = y1;
263 			}
264 			break;
265 		case END:
266 			if (p->o_attr & CW_ARC) {
267 				x = x1; y = y1;
268 			} else {
269 				x = p->o_val[2]; y = p->o_val[3];
270 			}
271 			break;
272 		}
273 		if (corner == START || corner == END)
274 			break;
275 		x1 = y1 = sqrt((x1-x)*(x1-x) + (y1-y)*(y1-y));
276 		/* Fall Through! */
277 	case CIRCLE:
278 	case ELLIPSE:
279 		switch (corner) {
280 		case NORTH:	y += y1; break;
281 		case SOUTH:	y -= y1; break;
282 		case EAST:	x += x1; break;
283 		case WEST:	x -= x1; break;
284 		case NE:	x += 0.707 * x1; y += 0.707 * y1; break;
285 		case SE:	x += 0.707 * x1; y -= 0.707 * y1; break;
286 		case NW:	x -= 0.707 * x1; y += 0.707 * y1; break;
287 		case SW:	x -= 0.707 * x1; y -= 0.707 * y1; break;
288 		}
289 		break;
290 	case LINE:
291 	case SPLINE:
292 	case ARROW:
293 		switch (corner) {
294 		case START:	break;	/* already in place */
295 		case END:	x = x1; y = y1; break;
296 		default: /* change! */
297 		case CENTER:	x = (x+x1)/2; y = (y+y1)/2; break;
298 		case NORTH:	if (y1 > y) { x = x1; y = y1; } break;
299 		case SOUTH:	if (y1 < y) { x = x1; y = y1; } break;
300 		case EAST:	if (x1 > x) { x = x1; y = y1; } break;
301 		case WEST:	if (x1 < x) { x = x1; y = y1; } break;
302 		}
303 		break;
304 	case MOVE:
305 		/* really ought to be same as line... */
306 		break;
307 	}
308 	dprintf("whatpos returns %g %g\n", x, y);
309 	*px = x;
310 	*py = y;
311 	return 1;
312 }
313 
314 obj*
315 gethere(void)	/* make a place for curx,cury */
316 {
317 	dprintf("gethere %g %g\n", curx, cury);
318 	return(makepos(curx, cury));
319 }
320 
321 obj*
322 getlast(int n, int t)	/* find n-th previous occurrence of type t */
323 {
324 	int i, k;
325 	obj *p;
326 
327 	k = n;
328 	for (i = nobj-1; i >= 0; i--) {
329 		p = objlist[i];
330 		if (p->o_type == BLOCKEND) {
331 			i = p->o_val[4];
332 			continue;
333 		}
334 		if (p->o_type != t)
335 			continue;
336 		if (--k > 0)
337 			continue;	/* not there yet */
338 		dprintf("got a last of x,y= %g,%g\n", p->o_x, p->o_y);
339 		return(p);
340 	}
341 	ERROR "there is no %dth last", n WARNING;
342 	return(NULL);
343 }
344 
345 obj*
346 getfirst(int n, int t)	/* find n-th occurrence of type t */
347 {
348 	int i, k;
349 	obj *p;
350 
351 	k = n;
352 	for (i = 0; i < nobj; i++) {
353 		p = objlist[i];
354 		if (p->o_type == BLOCK && t != BLOCK) {	/* skip whole block */
355 			i = p->o_val[5] + 1;
356 			continue;
357 		}
358 		if (p->o_type != t)
359 			continue;
360 		if (--k > 0)
361 			continue;	/* not there yet */
362 		dprintf("got a first of x,y= %g,%g\n", p->o_x, p->o_y);
363 		return(p);
364 	}
365 	ERROR "there is no %dth ", n WARNING;
366 	return(NULL);
367 }
368 
369 double
370 getblkvar(obj *p, char *s)	/* find variable s2 in block p */
371 {
372 	YYSTYPE y;
373 
374 	y = getblk(p, s);
375 	return y.f;
376 }
377 
378 obj*
379 getblock(obj *p, char *s)	/* find variable s in block p */
380 {
381 	YYSTYPE y;
382 
383 	y = getblk(p, s);
384 	return y.o;
385 }
386 
387 YYSTYPE
388 getblk(obj *p, char *s)	/* find union type for s in p */
389 {
390 	static YYSTYPE bug;
391 	struct symtab *stp;
392 
393 	if (p->o_type != BLOCK) {
394 		ERROR ".%s is not in that block", s WARNING;
395 		return(bug);
396 	}
397 	for (stp = p->o_symtab; stp != NULL; stp = stp->s_next)
398 		if (strcmp(s, stp->s_name) == 0) {
399 			dprintf("getblk %s found x,y= %g,%g\n",
400 				s, (stp->s_val.o)->o_x, (stp->s_val.o)->o_y);
401 			return(stp->s_val);
402 		}
403 	ERROR "there is no .%s in that []", s WARNING;
404 	return(bug);
405 }
406 
407 obj*
408 fixpos(obj *p, double x, double y)
409 {
410 	dprintf("fixpos returns %g %g\n", p->o_x + x, p->o_y + y);
411 	return makepos(p->o_x + x, p->o_y + y);
412 }
413 
414 obj*
415 addpos(obj *p, obj *q)
416 {
417 	dprintf("addpos returns %g %g\n", p->o_x+q->o_x, p->o_y+q->o_y);
418 	return makepos(p->o_x+q->o_x, p->o_y+q->o_y);
419 }
420 
421 obj*
422 subpos(obj *p, obj *q)
423 {
424 	dprintf("subpos returns %g %g\n", p->o_x-q->o_x, p->o_y-q->o_y);
425 	return makepos(p->o_x-q->o_x, p->o_y-q->o_y);
426 }
427 
428 obj*
429 makenode(int type, int n)
430 {
431 	obj *p;
432 
433 	p = (obj *) calloc(1, sizeof(obj) + (n-1)*sizeof(ofloat));
434 	if (p == NULL)
435 		ERROR "out of space in makenode" FATAL;
436 	p->o_type = type;
437 	p->o_count = n;
438 	p->o_nobj = nobj;
439 	p->o_mode = hvmode;
440 	p->o_x = curx;
441 	p->o_y = cury;
442 	p->o_nt1 = ntext1;
443 	p->o_nt2 = ntext;
444 	ntext1 = ntext;	/* ready for next caller */
445 	if (nobj >= nobjlist)
446 		objlist = (obj **) grow((char *) objlist, "objlist",
447 			nobjlist *= 2, sizeof(obj *));
448 	objlist[nobj++] = p;
449 	return(p);
450 }
451 
452 void
453 extreme(double x, double y)	/* record max and min x and y values */
454 {
455 	if (x > xmax)
456 		xmax = x;
457 	if (y > ymax)
458 		ymax = y;
459 	if (x < xmin)
460 		xmin = x;
461 	if (y < ymin)
462 		ymin = y;
463 }