![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to util.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 util.c CVS log | Up to [Research Unix] / researchv10no / cmd / ideal |
1.1 root 1: #include "ideal.h"
2: #include "y.tab.h"
3:
4: #define SYMSIZE 5000
5:
6: static char *symtab[SYMSIZE+1] = {
7: "(unnamed)"
8: };
9: static int syminstal = 1;
10:
11: int lookup(identifier)
12: char *identifier;
13: {
14: register int i;
15: i = 0;
16: symtab[syminstal] = identifier;
17: while (strcmp(identifier, symtab[i]))
18: i++;
19: if (i == syminstal) {
20: dprintf "installing NAME: %s\n", identifier);
21: if (i < SYMSIZE) {
22: if (!(symtab[i] = malloc((unsigned) (1+strlen(identifier))))) {
23: fprintf(stderr,"ideal: memory overflow in lookup\n");
24: exit(1);
25: }
26: }
27: else {
28: fprintf(stderr,"ideal: too many identifiers\n");
29: exit(1);
30: }
31: strcpy(symtab[syminstal++], identifier);
32: }
33: return(i);
34: }
35:
36: char *idprint(idnum)
37: int idnum;
38: {
39: if ((idnum > -1) && (idnum < syminstal))
40: return(symtab[idnum]);
41: else {
42: fprintf(stderr,"ideal: invalid identifier index: %d\n", idnum);
43: return(NULL);
44: }
45: }
46:
47: extern BOXPTR boxlist;
48:
49: BOXPTR findbox (sought, alarm)
50: int sought,
51: alarm;
52: {
53: BOXPTR bxwalk;
54: for (bxwalk = boxlist;
55: bxwalk && (bxwalk->name != sought);
56: bxwalk = bxwalk->next)
57: ;
58: if (!bxwalk) {
59: if (!alarm)
60: fprintf (stderr, "ideal: undefined box: %s\n", idprint (sought));
61: return (boxgen (sought, (STMTPTR) NULL));
62: } else
63: return (bxwalk);
64: }
65:
66:
67: INTLPTR varfind (name, givennoad)
68: int name;
69: NOADPTR givennoad;
70: {
71: /* finds simple variable 'name' from 'givennoad' */
72: register VARPTR varwalk;
73: if (!givennoad) {
74: fprintf (stderr, "ideal: no such variable, %s\n >>>Returning 0.0\n",
75: idprint (name)
76: );
77: return (commagen (0.0, 0.0));
78: }
79: dprintf "Looking for %s in %s\n", idprint (name), idprint (givennoad->defnode->name));
80: for (varwalk = givennoad->edgevarlist;
81: varwalk && THENAME(varwalk) != name;
82: varwalk = varwalk->next)
83: ;
84: if (!varwalk)
85: for (varwalk = givennoad->boxvarlist;
86: varwalk && THENAME(varwalk) != name;
87: varwalk = varwalk->next)
88: ;
89: if (!varwalk)
90: return (varfind (name, givennoad->father));
91: else
92: return (intlgen (
93: ';',
94: (EXPR) depadd ((DEPPTR) NULL, 0.0, varwalk->deplist, 1.0),
95: (EXPR) depadd ((DEPPTR) NULL, 0.0, varwalk->next->deplist, 1.0)
96: ));
97: }
98:
99: INTLPTR pathfind (ptname, givennoad)
100: NAMEPTR ptname;
101: NOADPTR givennoad;
102: {
103: /* finds compound variable 'ptname' from 'givennoad' */
104: int i;
105: STMTPTR putwalk;
106: NOADPTR noadwalk;
107: if (!ptname->next)
108: return (varfind (ptname->name, givennoad));
109: for (i = 0; i < 2; i++) {
110: noadwalk = givennoad->son;
111: for (putwalk = nextstmt (PUT, givennoad->defnode->parm->stmtlist);
112: putwalk && ((PUTPTR) putwalk->stmt)->name != ptname->name;
113: putwalk = nextstmt (PUT, putwalk->next))
114: noadwalk = noadwalk->brother;
115: if (!putwalk)
116: for (putwalk = nextstmt (PUT, findbox (givennoad->defnode->parm->name,FALSE)->stmtlist);
117: putwalk && ((PUTPTR) putwalk->stmt)->name != ptname->name;
118: putwalk = nextstmt (PUT, putwalk->next))
119: noadwalk = noadwalk->brother;
120: if (putwalk) {
121: dprintf "found %s, now looking for %s\n",
122: idprint (ptname->name),
123: idprint (ptname->next->name)
124: );
125: return (pathfind (ptname->next, noadwalk));
126: }
127: if (!(givennoad = givennoad->father)) {
128: dprintf "reached root of noad tree\n");
129: break;
130: } else {
131: dprintf "looking for %s at father of %s\n",
132: idprint (ptname->name),
133: idprint (givennoad->defnode->name)
134: );
135: }
136: }
137: fprintf (stderr, "ideal: invalid variable path name beginning %s\n >>>Returning 0.0\n",
138: idprint (ptname->name));
139: return (commagen (0.0, 0.0));
140: }
141:
142: BOXPTR tail (head)
143: BOXPTR head;
144: {
145: while (head->next)
146: head = head->next;
147: return (head);
148: }
149:
150: void forget (sought)
151: int sought;
152: {
153: BOXPTR bxwalk;
154: BOXPTR prevbox;
155: prevbox = NULL;
156: for (bxwalk = boxlist;
157: bxwalk && (bxwalk->name != sought);
158: bxwalk = bxwalk->next)
159: prevbox = bxwalk;
160: if (bxwalk) {
161: if (prevbox) {
162: prevbox->next = bxwalk->next;
163: } else {
164: boxlist = bxwalk->next;
165: }
166: boxfree (bxwalk);
167: }
168: }
169:
170: void exprprint (exprn)
171: EXPR exprn;
172: {
173: INTLPTR intl;
174: EXTLPTR extl;
175: if (!exprn)
176: return;
177: if (((EXTLPTR) exprn)->leaf) {
178: extl = (EXTLPTR) exprn;
179: switch (extl->kind) {
180: case PATH:
181: {
182: NAMEPTR pathwalk;
183: for (pathwalk = extl->info.path;
184: pathwalk->next;
185: pathwalk = pathwalk->next)
186: fprintf (stderr, "%s.", idprint (pathwalk->name));
187: fprintf (stderr, "%s", idprint (pathwalk->name));
188: }
189: break;
190: case CONST:
191: fprintf (stderr, "%f", extl->info.const);
192: break;
193: }
194: } else {
195: intl = (INTLPTR) exprn;
196: switch (intl->oper) {
197: case NAME:
198: fprintf (stderr, "%s(", idprint ((int) intl->left));
199: exprprint (((EXPRPTR) intl->right)->expr);
200: fprintf (stderr, ")");
201: break;
202: case '=':
203: case '~':
204: exprprint ((EXPR) intl->right);
205: break;
206: case ',':
207: fprintf (stderr, "(");
208: exprprint ((EXPR) intl->left);
209: fprintf (stderr, ",");
210: exprprint ((EXPR) intl->right);
211: fprintf (stderr, ")");
212: break;
213: case ';':
214: fprintf (stderr, "(");
215: depprint ((DEPPTR) intl->left);
216: fprintf (stderr, ",");
217: depprint ((DEPPTR) intl->right);
218: fprintf (stderr, ")");
219: break;
220: default:
221: fprintf (stderr, "(");
222: exprprint ((EXPR) intl->left);
223: fprintf (stderr, " %c ", intl->oper);
224: exprprint ((EXPR) intl->right);
225: fprintf (stderr, ")");
226: break;
227: }
228: }
229: }
230:
231: STMTPTR nextstmt (kind, curstmt)
232: int kind;
233: STMTPTR curstmt;
234: {
235: register STMTPTR stmtwalk;
236: stmtwalk = curstmt;
237: for (stmtwalk;
238: stmtwalk && (stmtwalk->kind != kind);
239: stmtwalk = stmtwalk->next)
240: ;
241: return (stmtwalk);
242: }
243:
244: EXPR bracket (alpha, x, y)
245: EXPR alpha,
246: x,
247: y;
248: {
249: return (
250: (EXPR) intlgen (
251: '+',
252: x,
253: (EXPR) intlgen (
254: '*',
255: alpha,
256: (EXPR) intlgen (
257: '-',
258: y,
259: x
260: )
261: )
262: )
263: );
264: }
265:
266: void depprint (depnd)
267: DEPPTR depnd;
268: {
269: for (depnd;
270: depnd->next;
271: depnd = depnd->next)
272: fprintf (stderr, "%f %s(%s) + ",
273: depnd->coeff,
274: ISREAL(depnd->var)?"re":"im",
275: idprint (THENAME(depnd->var))
276: );
277: fprintf (stderr, "%f", depnd->coeff);
278: if (depnd->var)
279: fprintf (stderr, " %s(%s)",
280: ISREAL(depnd->var)?"re":"im",
281: idprint (THENAME(depnd->var))
282: );
283: }
284:
285: void dexch (a,b)
286: double *a;
287: double *b;
288: {
289: double temp;
290: temp = *a;
291: *a = *b;
292: *b = temp;
293: }
294:
295: void fexch (a,b)
296: float *a;
297: float *b;
298: {
299: float temp;
300: temp = *a;
301: *a = *b;
302: *b = temp;
303: }
304:
305: float rprin (angle)
306: float angle;
307: {
308: while (angle < 0.0)
309: angle += 2*PI;
310: while (angle > 2*PI + EPSILON)
311: angle -= 2*PI;
312: return (angle);
313: }
314:
315: /*
316: float dprin (angle)
317: float angle;
318: {
319: while (angle < 0.0)
320: angle += 360;
321: while (angle > 2*PI)
322: angle -= 360;
323: return (angle);
324: }
325: */
326:
327: void angorder (startang, midang, endang)
328: float *startang;
329: float midang;
330: float *endang;
331: {
332: if (
333: ((*endang < -EPSILON + midang) && (midang < -EPSILON + *startang))
334: || ((*startang < -EPSILON + *endang) && (*endang < -EPSILON + midang))
335: || ((midang < -EPSILON + *startang) && (*startang < -EPSILON + *endang))
336: )
337: fexch (startang, endang);
338: }
339:
340: STMTPTR reverse (stmtlist)
341: STMTPTR stmtlist;
342: {
343: STMTPTR curstmt, prevstmt, temp;
344: prevstmt = curstmt = stmtlist;
345: temp = NULL;
346: while (curstmt) {
347: curstmt = prevstmt->next;
348: prevstmt->next = temp;
349: temp = prevstmt;
350: prevstmt = curstmt;
351: }
352: return (temp);
353: }
354:
355: void impossible (msg)
356: char *msg;
357: {
358: fprintf (stderr, "ideal: %s: can't happen\n", msg);
359: exit (1);
360: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.