![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to sno4.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10no / cmd / sno|
Return to sno4.c CVS log | Up to [Research Unix] / researchv10no / cmd / sno |
1.1 root 1: /* @(#)sno4.c 1.1 */
2: #include "sno.h"
3: /*
4: * sno4
5: */
6:
7:
8: struct node *
9: and (ptr)
10: struct node *ptr;
11: {
12: register struct node *a, *p;
13:
14: p = ptr;
15: a = p->p1;
16: if (p->typ == 0) {
17: switch (a->typ) {
18: case0:
19: case 0:
20: a->typ = 1;
21: case 1:
22: goto l1;
23: case 3:
24: fflush (stdout);
25: return (syspit());
26: case 5:
27: a = a->p2->p1;
28: goto l1;
29: case 6:
30: return (binstr (nfree()));
31: }
32: writes ("attempt to take an illegal value");
33: goto case0;
34: l1:
35: a = copy (a->p2);
36: }
37: return (a);
38: }
39:
40: struct node *
41: eval (e, t)
42: struct node *e;
43: {
44: struct node *list, *a2, *a3, *a4, *a3base;
45: register struct node *a1, *stack, *op;
46:
47: if (rfail == 1)
48: return (0);
49: stack = 0;
50: list = e;
51: goto l1;
52: advanc:
53: list = list->p1;
54: l1:
55: switch (list->typ) {
56: default:
57: case 0:
58: if (t == 1) {
59: a1 = and (stack);
60: goto e1;
61: }
62: if (stack->typ == 1)
63: writes ("attempt to store in a value");
64: a1 = stack->p1;
65: e1:
66: stack = pop (stack);
67: if (stack)
68: writes ("phase error");
69: return (a1);
70: case 12:
71: a1 = and (stack);
72: stack->p1 = look (a1);
73: delete (a1);
74: stack->typ = 0;
75: goto advanc;
76: case 13:
77: if (stack->typ)
78: writes ("illegal function");
79: a1 = stack->p1;
80: if (a1->typ!=5)
81: writes ("illegal function");
82: a1 = a1->p2;
83: op = a1->p1;
84: a3base = a3 = salloc();
85: a3->p2 = op->p2;
86: op->p2 = 0;
87: a1 = a1->p2;
88: a2 = list->p2;
89: f1:
90: if (a1!=0 && a2!=0)
91: goto f2;
92: if (a1!=a2)
93: writes ("parameters do not match");
94: op = op->p1;
95: goto f3;
96: f2:
97: a3->p1 = a4 = salloc();
98: a3 = a4;
99: a3->p2 = and (a1);
100: assign (a1->p1, eval (a2->p2, 1));/* recursive */
101: a1 = a1->p2;
102: a2 = a2->p1;
103: goto f1;
104: f3:
105: op = execute (op); /* recursive */
106: if (op)
107: goto f3;
108: a1 = stack->p1->p2;
109: op = a1->p1;
110: a3 = a3base;
111: stack->p1 = op->p2;
112: stack->typ = 1;
113: op->p2 = a3->p2;
114: f4:
115: a4 = a3->p1;
116: sfree (a3);
117: a3 = a4;
118: a1 = a1->p2;
119: if (a1 == 0)
120: goto advanc;
121: assign (a1->p1, a3->p2);
122: goto f4;
123: case 11:
124: case 10:
125: case 9:
126: case 8:
127: case 7:
128: a1 = and (stack);
129: stack = pop (stack);
130: a2 = and (stack);
131: a3 = doop (list->typ, a2, a1);
132: delete (a1);
133: delete (a2);
134: stack->p1 = a3;
135: stack->typ = 1;
136: goto advanc;
137: case 15:
138: a1 = copy (list->p2);
139: a2 = (struct node *) 1;
140: goto l3;
141: case 14:
142: a1 = list->p2;
143: a2 = 0;
144: l3:
145: stack = push (stack);
146: stack->p1 = a1;
147: stack->typ = (int) a2;
148: goto advanc;
149: }
150: }
151:
152: struct node *
153: doop (op, arg1, arg2)
154: struct node *arg1, *arg2;
155: {
156: register struct node *a1, *a2;
157:
158: a1 = arg1;
159: a2 = arg2;
160: switch (op) {
161:
162: case 11:
163: return (div (a1, a2));
164: case 10:
165: return (mult (a1, a2));
166: case 8:
167: return (add (a1, a2));
168: case 9:
169: return (sub (a1, a2));
170: case 7:
171: return (cat (a1, a2));
172: }
173: return (0);
174: }
175:
176: struct node *
177: execute (e)
178: struct node *e;
179: {
180: register struct node *r, *b, *c;
181: struct node *m, *ca, *d, *a;
182:
183: r = e->p2;
184: lc = e->ch;
185: switch (e->typ) {
186: case 0: /* r g */
187: a = r->p1;
188: delete (eval (r->p2, 1));
189: goto xsuc;
190: case 1: /* r m g */
191: m = r->p1;
192: a = m->p1;
193: b = eval (r->p2, 1);
194: c = search (m, b);
195: delete (b);
196: if (c == 0)
197: goto xfail;
198: sfree (c);
199: goto xsuc;
200: case 2: /* r a g */
201: ca = r->p1;
202: a = ca->p1;
203: b = eval (r->p2, 0);
204: assign (b, eval (ca->p2, 1));
205: goto xsuc;
206: case 3: /* r m a g */
207: m = r->p1;
208: ca = m->p1;
209: a = ca->p1;
210: b = eval (r->p2, 0);
211: d = search (m, b->p2);
212: if (d == 0)
213: goto xfail;
214: c = eval (ca->p2, 1);
215: if (d->p1 == 0) {
216: sfree (d);
217: assign (b, cat (c, b->p2));
218: delete (c);
219: goto xsuc;
220: }
221: if (d->p2 == b->p2->p2) {
222: assign (b, c);
223: sfree (d);
224: goto xsuc;
225: }
226: (r=salloc())->p1 = d->p2->p1;
227: r->p2 = b->p2->p2;
228: assign (b, cat (c, r));
229: sfree (d);
230: sfree (r);
231: delete (c);
232: goto xsuc;
233: }
234: xsuc:
235: if (rfail)
236: goto xfail;
237: b = a->p1;
238: goto xboth;
239: xfail:
240: rfail = 0;
241: b = a->p2;
242: xboth:
243: if (b == 0) {
244: return (e->p1);
245: }
246: b = eval (b, 0);
247: if (b == lookret)
248: return (0);
249: if (b == lookfret) {
250: rfail = 1;
251: return (0);
252: }
253: if (b->typ!=2)
254: writes ("attempt to transfer to non-label");
255: return (b->p2);
256: }
257:
258: assign (adr, val)
259: struct node *adr, *val;
260: {
261: register struct node *a, *addr, *value;
262:
263: addr = adr;
264: value = val;
265: if (rfail == 1) {
266: delete (value);
267: return;
268: }
269: switch (addr->typ) {
270: default:
271: writes ("attempt to make an illegal assignment");
272: case 0:
273: addr->typ = 1;
274: case 1:
275: delete (addr->p2);
276: addr->p2 = value;
277: return;
278: case 4:
279: sysput (value);
280: return;
281: case 5:
282: a = addr->p2->p1;
283: delete (a->p2);
284: a->p2 = value;
285: return;
286: }
287: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.