![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to sym.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10no / cmd / pico|
Return to sym.c CVS log | Up to [Research Unix] / researchv10no / cmd / pico |
1.1 root 1: #include <stdio.h>
2: #include "pico.h"
3: #include "y.tab.h"
4:
5: Symbol *comlist = 0; /* commands */
6: Symbol *symlist = 0; /* keywords, functions, variables, names */
7: Symbol *lastkey = 0;
8:
9: Symbol *install(), *newbltin(), *remove();
10:
11: int rand(), println(), Clamp(), Abs();
12: int patan2(), psin(), pcos(), Psin(), Pcos(), Patan2();
13: int intexp(), intsqrt(), intlog(), intlog10(), intpow();
14: int a_polar(), r_polar(), x_cart(), y_cart();
15: int setcmap(), setzmap(), getcmap();
16: int redcmap(), grncmap(), blucmap();
17: int putframe(), getframe(), swap();
18: int X_cart(), Y_cart(), A_polar();
19: int putbitmap(), put0bitmap();
20:
21: static struct {
22: char *name;
23: int (*faddr)();
24: char nrparams;
25: } bltin[] = {
26: "A_polar", A_polar, 2,
27: "Atan", Patan2, 2,
28: "Cos", Pcos, 1,
29: "Sin", Psin, 1,
30: "X_cart", X_cart, 2,
31: "Y_cart", Y_cart, 2,
32:
33: "a_polar", a_polar, 2,
34: "abs", Abs, 1,
35: "atan", patan2, 2,
36: "blucmap", blucmap, 2,
37: "clamp", Clamp, 1,
38: "cos", pcos, 1,
39: "dump", putbitmap, 1,
40: "dump0", put0bitmap, 1,
41: "exp", intexp, 1,
42: "getcmap", getcmap, 4,
43: "getframe", getframe, 1,
44: "grncmap", grncmap, 2,
45: "log", intlog, 1,
46: "log10", intlog10, 1,
47: "pow", intpow, 2,
48: "printf", println, 1,
49: "putframe", putframe, 1,
50: "r_polar", r_polar, 2,
51: "rand", rand, 0,
52: "redcmap", redcmap, 2,
53: "setcmap", setcmap, 4,
54: "sin", psin, 1,
55: "sqrt", intsqrt, 1,
56: "swap", swap, 0,
57: "x_cart", x_cart, 2,
58: "y_cart", y_cart, 2,
59: 0, 0, 0,
60: };
61:
62: static struct {
63: char *name;
64: int kval;
65: } keywords[] = {
66: "array", DECL,
67: "blu", BCHAN,
68: "bw", BW,
69: "cmap", CMAP,
70: "do", DO,
71: "else", ELSE,
72: "for", FOR,
73: "global", GLOBAL,
74: "goto", JUMP,
75: "grn", GCHAN,
76: "i", I,
77: "if", IF,
78: "int", INT,
79: "new", TMP,
80: "old", OLD,
81: "return", RETURN,
82: "rgb", RGB,
83: "red", RCHAN,
84: "while", WHILE,
85: "x", X,
86: "y", Y,
87: 0, 0,
88: };
89:
90: static struct {
91: char *name;
92: int cval;
93: } consts[] = {
94: "Z", 255,
95: 0, 0
96: };
97:
98: static struct {
99: char *name;
100: int kval;
101: } commands[] = {
102: "a", A,
103: "blind", BLIND,
104: "color", COLOR,
105: "d", DEL,
106: "def", DEF,
107: "down", DOWN,
108: "f", F,
109: "faster", FASTER,
110: "framebuffer", FRAMEBUFFER,
111: "functions", SETF,
112: "get", GET,
113: "h", H,
114: "help", HELP,
115: "metheus", METHEUS,
116: "nocolor", NOCOLOR,
117: "optim", OPTIM,
118: "q", Q,
119: "r", R,
120: "ramzap", ZAP,
121: "show", SET,
122: "slower", SLOWER,
123: "tree", SEETREE,
124: "up", UP,
125: "w", W,
126: "window", WINDOW,
127: "x", RUN,
128: "zap", ZAP,
129: 0, 0,
130: };
131:
132: syminit()
133: { int i;
134: extern int DEF_LL, DEF_NL;
135: extern char *progr;
136:
137: progr = (char *) Emalloc(NPROG * sizeof(char));
138:
139: for (i = 0; keywords[i].name; i++)
140: install(keywords[i].name, keywords[i].kval, 0);
141: lastkey = symlist;
142: for (i = 0; bltin[i].name; i++)
143: newbltin(bltin[i].name, bltin[i].faddr, bltin[i].nrparams);
144: install("X", VARIABLE, DEF_LL);
145: install("Y", VARIABLE, DEF_NL);
146: for (i = 0; consts[i].name; i++)
147: install(consts[i].name, VARIABLE, consts[i].cval);
148: for (i = 0; commands[i].name; i++)
149: newcom(commands[i].name, commands[i].kval);
150: }
151:
152: fakeparams(n)
153: { int i, j;
154: char s[128];
155:
156: for (i = j = 0; i < n-1; i++)
157: { s[j++] = 'a'+i;
158: s[j++] = ',';
159: }
160: if (n > 0)
161: s[j++] = 'a'+i;
162: s[j] = '\0';
163:
164: fprintf(stderr, "(%s)", s);
165: }
166:
167: spaces(n)
168: { int i; char aa[32];
169: for (i = 0; i < n; i++)
170: aa[i] = ' ';
171: aa[i] = '\0';
172: fprintf(stderr, " %s", aa);
173: }
174:
175: showfcts()
176: { register Symbol *sym;
177: register int i, j;
178:
179: for (sym = symlist, i=j=0; sym != lastkey; sym = sym->next)
180: if (sym->type == FCT)
181: { if (i == 0)
182: fprintf(stderr, "functions:\n");
183: if ((i++)%4)
184: spaces(15-j);
185: else
186: fprintf(stderr, "\n");
187: fprintf(stderr, "%s", sym->name);
188: fakeparams(sym->u.fu->nrparams);
189: j = strlen(sym->name) + 2*(sym->u.fu->nrparams);
190: j -= (sym->u.fu->nrparams != 0);
191: }
192: if (i)
193: fprintf(stderr, "\n");
194: for (sym = symlist, i=j=0; sym != lastkey; sym = sym->next)
195: if (sym->type == BLTN)
196: { if (i == 0)
197: fprintf(stderr, "builtins:\n");
198: if ((i++)%4)
199: spaces(15-j);
200: else
201: fprintf(stderr, "\n");
202: fprintf(stderr, "%s", sym->name);
203: fakeparams(sym->u.bl->nrparams);
204: j = strlen(sym->name) + 2*(sym->u.bl->nrparams);
205: j -= (sym->u.bl->nrparams != 0);
206: }
207: if (i)
208: fprintf(stderr, "\n");
209: }
210:
211: showsym(sym)
212: Symbol *sym;
213: { register int i, j, last;
214: register struct AR *tmp;
215:
216: switch (sym->type) {
217: case VARIABLE:
218: fprintf(stderr, "%s = %d\n", sym->name, sym->u.val);
219: break;
220: case AUTO:
221: fprintf(stderr, "%s = fct arg %d\n", sym->name, sym->u.val);
222: break;
223: case ARRAY:
224: tmp = sym->u.ar;
225: fprintf(stderr, "%s[%d]\n", sym->name, tmp->sz);
226: fprintf(stderr, "\t%2d\t%5d\n", 0, last = tmp->base[0]);
227: for (j = 0, i = 1; i < tmp->sz; i++)
228: { if (last != tmp->base[i])
229: { if (i > j+1)
230: { if (i > j+2)
231: fprintf(stderr, "\t...\t ...\n");
232: fprintf(stderr, "\t%2d\t%5d\n", i-1, last);
233: }
234: fprintf(stderr, "\t%2d\t%5d\n", i, tmp->base[i]);
235: last = tmp->base[j=i];
236: }
237: }
238: if (i > j+1)
239: { if (i > j+2) fprintf(stderr, "\t...\t ...\n");
240: fprintf(stderr, "\t%2d\t%5d\n", i-1, last);
241: }
242: break;
243: case FCT:
244: fprintf(stderr, "%s", sym->name);
245: fakeparams(sym->u.fu->nrparams);
246: i = strlen(sym->name) + 2*(sym->u.fu->nrparams);
247: i -= (sym->u.bl->nrparams != 0);
248: fprintf(stderr, ": "); spaces(15-i);
249: fprintf(stderr, "user defined function\n");
250: break;
251: case BLTN:
252: fprintf(stderr, "%s", sym->name);
253: fakeparams(sym->u.bl->nrparams);
254: i = strlen(sym->name) + 2*(sym->u.bl->nrparams);
255: i -= (sym->u.bl->nrparams != 0);
256: fprintf(stderr, ": "); spaces(15-i);
257: fprintf(stderr, "builtin function\n");
258: break;
259: case NAME:
260: fprintf(stderr, "%s", sym->name);
261: i = strlen(sym->name);
262: fprintf(stderr, ": "); spaces(17-i);
263: fprintf(stderr, "name\n");
264: break;
265: default:
266: fprintf(stderr, "%s", sym->name);
267: i = strlen(sym->name);
268: fprintf(stderr, ": "); spaces(17-i);
269: fprintf(stderr, "unknown type (%d)\n", sym->type);
270: break;
271: }
272: }
273:
274: showvars()
275: { register Symbol *sym;
276:
277: for (sym = symlist; sym != lastkey; sym = sym->next)
278: if (sym->type == VARIABLE || sym->type == AUTO)
279: showsym(sym);
280: for (sym = symlist; sym != lastkey; sym = sym->next)
281: if (sym->type == ARRAY)
282: showsym(sym);
283: for (sym = symlist; sym != lastkey; sym = sym->next)
284: switch (sym->type)
285: { default: showsym(sym);
286: case AUTO: case VARIABLE: case ARRAY: break;
287: }
288: }
289:
290: sympurge()
291: { Symbol *sym, *last = (Symbol *) 0;
292: extern char nesting;
293:
294: for (sym = symlist; sym != lastkey; )
295: { if (sym->type == VARIABLE || sym->type == ARRAY)
296: { if (sym->depth >= nesting && sym->depth > 0)
297: { sym = remove(sym, last);
298: continue;
299: }
300: } else
301: if (sym->type == AUTO && nesting == 1)
302: { sym = remove(sym, last);
303: continue;
304: }
305: last = sym;
306: sym = sym->next;
307: }
308: }
309:
310: Symbol *
311: remove(s, l)
312: Symbol *s, *l;
313: {
314: if (s == symlist)
315: { symlist = s->next;
316: return symlist;
317: } else
318: { l->next = s->next;
319: return l->next;
320: }
321: }
322:
323: Symbol *
324: lookup(s)
325: char *s;
326: { Symbol *sym;
327: Symbol *zym;
328: int found = -1;
329:
330: for (sym = symlist; sym != (Symbol *) 0; sym = sym->next)
331: if (strcmp(sym->name, s) == 0 && sym->depth >= found)
332: { found = sym->depth;
333: zym = sym;
334: }
335: if (found != -1)
336: return zym;
337:
338: if (strcmp(s, "old") == 0 || strcmp(s, "new") == 0)
339: yyerror("cannot redefine %s", s);
340:
341: return install(s, NAME, 0);
342: }
343:
344: Symbol *
345: whichcmd(s)
346: char *s;
347: { Symbol *sym;
348:
349: for (sym = comlist; sym != (Symbol *) 0; sym = sym->next)
350: if (strcmp(sym->name, s) == 0)
351: return sym;
352: return lookup(s);
353: }
354:
355: Symbol *
356: newsym(s)
357: char *s;
358: { Symbol *tmp;
359:
360: tmp = (Symbol *) Emalloc(sizeof(Symbol));
361: tmp->name = Emalloc(strlen(s)+1);
362: strcpy(tmp->name, s);
363:
364: return tmp; /* not linked in list */
365: }
366:
367: Symbol *
368: install(s, t, v)
369: char *s;
370: { Symbol *sp;
371: extern char nesting;
372:
373: sp = (Symbol *) Emalloc(sizeof(Symbol));
374: sp->name = Emalloc(strlen(s)+1);
375: strcpy(sp->name, s);
376: sp->type = t; /* NAME, VAR or keyword */
377: sp->depth = nesting;
378: sp->u.val = v;
379: sp->next = symlist;
380: symlist = sp;
381:
382: return sp;
383: }
384:
385: Symbol *
386: newbltin(s, v, p)
387: char *s;
388: int (*v)();
389: { Symbol *sp;
390: extern char nesting;
391:
392: sp = (Symbol *) Emalloc(sizeof(Symbol));
393: sp->name = Emalloc(strlen(s)+1);
394: strcpy(sp->name, s);
395: sp->type = BLTN;
396: sp->depth = nesting;
397: sp->u.bl = (struct BL *) Emalloc(sizeof(struct BL));
398: sp->u.bl->faddr = v;
399: sp->u.bl->nrparams = p;
400: sp->u.bl->usednew = 0;
401: sp->next = symlist;
402: symlist = sp;
403:
404: return sp;
405: }
406:
407: newcom(s, t)
408: char *s;
409: { Symbol *sp;
410:
411: sp = (Symbol *) Emalloc(sizeof(Symbol));
412: sp->name = Emalloc(strlen(s)+1);
413: strcpy(sp->name, s);
414: sp->type = t; /* only commands */
415: sp->next = comlist;
416: comlist = sp;
417: }
418:
419: decarray(s, d)
420: Symbol *s;
421: long d;
422: { register int i;
423: extern char nesting, isglobal;
424:
425: if (s->type == ARRAY)
426: { if (s->depth == nesting || (s->depth == 0 && isglobal))
427: { fprintf(stderr, "warning: array %s re-declared\n", s->name);
428: if (isglobal) s->depth = 0;
429: if (s->u.ar->sz != d)
430: { free(s->u.ar->base);
431: goto newa;
432: } else goto olda;
433: } else if (s->depth < nesting)
434: { decarray(install(s->name, NAME, 0), d);
435: return;
436: }
437: } else
438: s->type = ARRAY;
439:
440: s->depth = (isglobal)?0:nesting;
441: s->u.ar = (struct AR *) Emalloc(sizeof(struct AR));
442: newa: s->u.ar->sz = d;
443: s->u.ar->base = (long *) Emalloc(d * sizeof(long));
444: olda: for (i = 0; i < d; i++)
445: s->u.ar->base[i] = 0;
446: }
447:
448: decsame(t, s, d)
449: short t;
450: Symbol *s;
451: long d;
452: { extern char nesting, isglobal;
453:
454: if (s->type == t)
455: { if (s->depth == nesting || (s->depth == 0 && isglobal))
456: { fprintf(stderr, "warning: variable %s re-declared\n", s->name);
457: if (isglobal) s->depth = 0;
458: s->u.val = d;
459: } else if (s->depth < nesting)
460: install(s->name, t, d);
461:
462: return;
463: }
464:
465: s->type = t;
466: s->depth = (isglobal)?0:nesting;
467: s->u.val = d;
468: }
469:
470: decvar(s, d)
471: Symbol *s;
472: long d;
473: {
474: decsame(VARIABLE, s, d);
475: }
476:
477: automa(s, d)
478: Symbol *s;
479: long d;
480: {
481: decsame(AUTO, s, d);
482: }
483:
484: char *thisfun;
485:
486: prefunct(s, nrp)
487: Symbol *s;
488: { extern char *progr;
489:
490: if (s->type != FCT)
491: { s->type = FCT;
492: s->u.fu = (struct FU *) Emalloc(sizeof(struct FU));
493: } else
494: { fprintf(stderr, "function %s redefined\n", s->name);
495: if (s->u.fu->usednew != -1) free(s->u.fu->fct);
496: }
497: s->u.fu->fct = progr;
498: thisfun = s->name;
499: s->u.fu->usednew = -1;
500: s->u.fu->nrparams = nrp;
501: }
502:
503: notrecurcall(s)
504: Symbol *s;
505: {
506: return strcmp(s->name, thisfun);
507: }
508:
509: notafunc()
510: {
511: extern char nesting;
512: return (nesting == 0 && thisfun == NULL);
513: }
514:
515: postfunct(s)
516: Symbol *s;
517: { extern char nesting, usednew, usedold, *progr;
518:
519: progr = (char *) Emalloc(NPROG * sizeof(char));
520: thisfun = '\0';
521: s->depth = nesting;
522: s->u.fu->usednew = usednew;
523: s->u.fu->usedold = usedold;
524: }
525:
526: #include "pico2.h"
527:
528: Node *mapred(n)
529: Node *n;
530: { return new(CCALL, new(ACOMMA, AREG(IREG), n, Z), Z, redcmap);
531: }
532:
533: Node *mapgrn(n)
534: Node *n;
535: { return new(CCALL, new(ACOMMA, AREG(IREG), n, Z), Z, grncmap);
536: }
537:
538: Node *mapblu(n)
539: Node *n;
540: { return new(CCALL, new(ACOMMA, AREG(IREG), n, Z), Z, blucmap);
541: }
542:
543: Node *
544: mapall(n)
545: Node *n;
546: {
547: if (n->type == COMP)
548: return new(CCALL, new(ACOMMA, AREG(IREG), n, Z), Z, setcmap);
549: else
550: return new(CCALL, new(ACOMMA, AREG(IREG), n, Z), Z, setzmap);
551: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.