![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to action.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10no / cmd / ideal|
Return to action.c CVS log | Up to [Research Unix] / researchv10no / cmd / ideal |
1.1 root 1: #include "ideal.h"
2: #include "y.tab.h"
3:
4: LINEPTR rbuild (noadtree, linelist)
5: NOADPTR noadtree;
6: LINEPTR linelist;
7: {
8: STMTPTR slist[2];
9: STMTPTR curstmt, opqstmt;
10: NOADPTR nextnoad;
11: int i;
12: slist[0] = noadtree->defnode->parm->stmtlist;
13: slist[1] = findbox (noadtree->defnode->parm->name,FALSE)->stmtlist;
14: nextnoad = noadtree->son;
15: if ((opqstmt = nextstmt (OPAQUE, slist[0])) || (opqstmt = nextstmt (OPAQUE, slist[1])))
16: linelist = opqact (opqstmt, noadtree, linelist);
17: if (noadtree->defnode->parm->name == lookup ("circle"))
18: linelist = circact (noadtree, linelist);
19: else if (noadtree->defnode->parm->name == lookup ("arc"))
20: linelist = arcact (noadtree, linelist);
21: for (i = 0; i < 2; i ++)
22: for (curstmt = slist[i]; curstmt; curstmt = curstmt->next) {
23: switch (curstmt->kind) {
24: case '=':
25: break;
26: case CONN:
27: linelist = connact (
28: (EXPRPTR) curstmt->stmt,
29: noadtree,
30: linelist
31: );
32: break;
33: case USING:
34: linelist = penact (
35: (PENPTR) curstmt->stmt,
36: noadtree,
37: linelist
38: );
39: break;
40: case PUT:
41: if (((PUTPTR)curstmt->stmt)->p_or_c == PUT)
42: linelist = rbuild (nextnoad, linelist);
43: else if (((PUTPTR)curstmt->stmt)->p_or_c == CONSTRUCT)
44: nextnoad->linelist = rbuild (nextnoad, nextnoad->linelist);
45: else impossible ("rbuild (PUT)");
46: nextnoad = nextnoad->brother;
47: break;
48: case DRAW:
49: linelist = drawact (
50: (MISCPTR) curstmt->stmt,
51: noadtree,
52: linelist
53: );
54: break;
55: case STRING:
56: linelist = stract (
57: (STRPTR) curstmt->stmt,
58: noadtree,
59: linelist
60: );
61: break;
62: case SPLINE:
63: linelist = splact (
64: (EXPRPTR) curstmt->stmt,
65: noadtree,
66: linelist
67: );
68: break;
69: case OPAQUE:
70: break;
71: case BDLIST:
72: break;
73: case VAR:
74: break;
75: default:
76: impossible ("rbuild");
77: }
78: }
79: return (linelist);
80: }
81:
82: LINEPTR build (noadtree, linelist)
83: NOADPTR noadtree;
84: LINEPTR linelist;
85: {
86: LINEPTR retval;
87: if (when_bug & 040) bug_on;
88: retval = rbuild (noadtree, linelist);
89: bug_off;
90: return (retval);
91: }
92:
93: LINEPTR connact (connstmt, noadtree, linelist)
94: EXPRPTR connstmt;
95: NOADPTR noadtree;
96: LINEPTR linelist;
97: {
98: INTLPTR frompt, topt;
99: LINEPTR newline;
100: EXPRPTR linwalk;
101: newline = NULL;
102: frompt = expreval (connstmt->expr, noadtree);
103: linwalk = connstmt->next;
104: while (linwalk) {
105: topt = expreval (linwalk->expr, noadtree);
106: if (!known(frompt) || !known(topt)) {
107: fprintf (stderr, "ideal: indeterminate endpoints\n >>>conn ignored\n");
108: } else {
109: newline = linegen (
110: Re(frompt), Im(frompt),
111: Re(topt), Im(topt)
112: );
113: dprintf "Adding line (%f,%f) to (%f,%f)\n",
114: Re(frompt), Im(frompt),
115: Re(topt), Im(topt)
116: );
117: newline->next = linelist;
118: linelist = newline;
119: }
120: intlfree (frompt);
121: frompt = topt;
122: linwalk = linwalk->next;
123: }
124: intlfree (topt);
125: return (newline);
126: }
127:
128: LINEPTR penact (penstmt, noadtree, linelist)
129: PENPTR penstmt;
130: NOADPTR noadtree;
131: LINEPTR linelist;
132: {
133: INTLPTR frompt, topt, copies;
134: LINEPTR newline;
135: frompt = expreval (penstmt->from, noadtree);
136: topt = expreval (penstmt->to, noadtree);
137: copies = expreval (penstmt->copies, noadtree);
138: newline = linelist;
139: if (!known(frompt) || !known(topt) || !known(copies)) {
140: fprintf (stderr, "ideal: indeterminate pen\n >>>pen ignored\n");
141: } else {
142: PUTNODE dummyput;
143: NOADPTR pennoad;
144: STMTPTR ostmthead;
145: int i;
146:
147: dprintf "Drawing pen from (%f,%f) to (%f,%f)\n",
148: Re(frompt),
149: Im(frompt),
150: Re(topt),
151: Im(topt)
152: );
153:
154: /* add key statements to beginning of parameter section */
155: dummyput.name = 0;
156: dummyput.parm = penstmt->pen;
157: ostmthead = dummyput.parm->stmtlist;
158: dummyput.parm->stmtlist = stmtgen (
159: '=',
160: (char *) intlgen (
161: '=',
162: (EXPR) extlgen (namegen (lookup ("$pencnt"))),
163: (EXPR) fextlgen (0.0)
164: )
165: );
166: dummyput.parm->stmtlist->next = stmtgen (
167: '=',
168: (char *) intlgen (
169: '=',
170: penstmt->start,
171: bracket (
172: (EXPR) intlgen (
173: '/',
174: (EXPR) extlgen(namegen(lookup("$pencnt"))),
175: (EXPR) copies
176: ),
177: (EXPR) frompt,
178: (EXPR) topt
179: )
180: )
181: );
182: dummyput.parm->stmtlist->next->next = stmtgen (
183: '=',
184: (char *) intlgen (
185: '=',
186: penstmt->end,
187: bracket (
188: (EXPR) intlgen (
189: '/',
190: (EXPR) intlgen (
191: '+',
192: (EXPR) extlgen(namegen(lookup("$pencnt"))),
193: (EXPR) fextlgen(1.0)
194: ),
195: (EXPR) copies
196: ),
197: (EXPR) frompt,
198: (EXPR) topt
199: )
200: )
201: );
202: dummyput.parm->stmtlist->next->next->next = stmtgen (
203: VAR,
204: (char *) namegen (lookup ("$pencnt"))
205: );
206: dummyput.parm->stmtlist->next->next->next->next = ostmthead;
207: /* make N copies */
208: for (i = 0; i < Re(copies); i ++) {
209: ((EXTLPTR) ((INTLPTR) dummyput.parm->stmtlist->stmt)->right)->info.const = i;
210: pennoad = buildnoadtree (&dummyput);
211: pennoad->father = noadtree;
212: eqneval (pennoad);
213: nl_eval ();
214: newline = build (pennoad, newline);
215: depvarkill ();
216: noadfree (pennoad);
217: }
218: if (dummyput.parm->stmtlist->next->next->next->next != ostmthead)
219: impossible ("penact");
220: dummyput.parm->stmtlist->next->next->next->next = NULL;
221: /* will have to let garbage collector get dummyput.parm */
222: penstmt->pen->stmtlist = ostmthead;
223: }
224: intlfree (frompt);
225: intlfree (topt);
226: intlfree (copies);
227: return (newline);
228: }
229:
230: LINEPTR drawact (noadname, noadtree, linelist)
231: MISCPTR noadname;
232: NOADPTR noadtree;
233: LINEPTR linelist;
234: {
235: NOADPTR noadwalk;
236: LINEPTR nuline;
237: for (noadwalk = noadtree->son;
238: noadwalk && (noadwalk->defnode->name != noadname->info);
239: noadwalk = noadwalk->brother)
240: dprintf "%s %s",
241: idprint(noadwalk->defnode->name),
242: idprint(noadname->info)
243: );
244: ;
245: if (noadwalk) {
246: ((LINEPTR) tail ((BOXPTR) noadwalk->linelist))->next = linelist;
247: nuline = noadwalk->linelist;
248: noadwalk->linelist = NULL;
249: return (nuline);
250:
251: } else {
252: fprintf (stderr, "ideal: can't find %s to draw it\n",
253: idprint (noadname->info)
254: );
255: return (linelist);
256: }
257: }
258:
259: LINEPTR stract (strstmt, noadtree, linelist)
260: STRPTR strstmt;
261: NOADPTR noadtree;
262: LINEPTR linelist;
263: {
264: LINEPTR newline;
265: INTLPTR atpt;
266: atpt = expreval (strstmt->at, noadtree);
267: if (!known(atpt)){
268: fprintf (stderr, "ideal: indeterminate string location\n >>>string ignored\n");
269: newline = linelist;
270: } else {
271: dprintf "Adding string %s\n",
272: strstmt->string);
273: newline = textgen (
274: strstmt->command,
275: strstmt->string,
276: Re(atpt),
277: Im(atpt)
278: );
279: newline->next = linelist;
280: }
281: intlfree (atpt);
282: return (newline);
283: }
284:
285: LINEPTR circact (noadtree, linelist)
286: NOADPTR noadtree;
287: LINEPTR linelist;
288: {
289: LINEPTR newline;
290: INTLPTR radius, center;
291: radius = varfind (lookup ("radius"), noadtree);
292: center = varfind (lookup ("center"), noadtree);
293: if (!known(radius) || !known(center)) {
294: fprintf (stderr, "ideal: indeterminate circle\n >>>ignored\n");
295: newline = linelist;
296: } else {
297: float rad;
298: rad = Re(radius);
299: dprintf "Adding circle %f %f %f\n",
300: Re(center),
301: Im(center),
302: rad
303: );
304: newline = circgen (
305: Re(center),
306: Im(center),
307: rad
308: );
309: newline->next = linelist;
310: }
311: intlfree (radius);
312: intlfree (center);
313: return (newline);
314: }
315:
316: LINEPTR arcact (noadtree, linelist)
317: NOADPTR noadtree;
318: LINEPTR linelist;
319: {
320: LINEPTR newline;
321: INTLPTR start, center, end;
322: INTLPTR temp;
323: float radius;
324: float startang, midang, endang;
325: center = varfind (lookup ("center"), noadtree);
326: start = varfind (lookup ("start"), noadtree);
327: end = varfind (lookup ("end"), noadtree);
328: temp = varfind (lookup ("startang"), noadtree);
329: startang = Re(temp);
330: tryfree(temp);
331: temp = varfind (lookup ("midang"), noadtree);
332: midang = Re(temp);
333: tryfree(temp);
334: temp = varfind (lookup ("endang"), noadtree);
335: endang = Re(temp);
336: tryfree(temp);
337: if (!radflag) {
338: dtor(startang);
339: dtor(midang);
340: dtor(endang);
341: }
342: startang = rprin (startang);
343: midang = rprin (midang);
344: endang = rprin (endang);
345: if ((fabs(startang - midang) < EPSILON) && (startang > endang))
346: endang += 2*PI;
347: radius = ((DEPPTR) (varfind (lookup ("radius"), noadtree))->left)->coeff;
348: if (!known(center) || !known(start) || !known(end)) {
349: fprintf (stderr, "ideal: indeterminate arc\n >>>ignored\n");
350: newline = linelist;
351: } else {
352: angorder (&startang, midang, &endang);
353: dprintf "Adding arc %f %f %f %f %f\n",
354: Re(center),
355: Im(center),
356: radius,
357: startang,
358: endang
359: );
360: newline = angularc (
361: Re(center),
362: Im(center),
363: radius,
364: startang,
365: endang
366: );
367: newline->next = linelist;
368: }
369: intlfree (center);
370: intlfree (start);
371: intlfree (end);
372: return (newline);
373: }
374:
375: LINEPTR splact (splstmt, noadtree, linelist)
376: EXPRPTR splstmt;
377: NOADPTR noadtree;
378: LINEPTR linelist;
379: {
380: EXPRNODE knotlist;
381: EXPRPTR knotwalk;
382: EXPRPTR splwalk;
383: LINEPTR nuline;
384:
385: if (when_bug & 0200) bug_on;
386: knotwalk = &knotlist;
387: knotwalk->next = NULL;
388: for (splwalk = splstmt;
389: splwalk;
390: splwalk = splwalk->next
391: ) {
392: knotwalk->next = exprgen (
393: (EXPR) expreval (
394: splwalk->expr,
395: noadtree
396: )
397: );
398: if (!known(((INTLPTR) knotwalk->next->expr))) {
399: fprintf (stderr, "ideal: unknown spline knot\n >>>spline ignored\n");
400: return (linelist);
401: }
402: knotwalk = knotwalk->next;
403: dprintf "spline knot: %f %f\n",
404: Re(((INTLPTR) knotwalk->expr)),
405: Im(((INTLPTR) knotwalk->expr))
406: );
407: }
408: nuline = splgen (knotlist.next);
409: nuline->next = linelist;
410: return (nuline);
411: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.