![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to interp.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / d / bin / bc|
Return to interp.c CVS log | Up to [MW Coherent from dump] / coherent / d / bin / bc |
1.1 root 1: #include <stdio.h>
2: #include <setjmp.h>
3: #include <assert.h>
4: #include "bc.h"
5:
6:
7: /*
8: * The jump buffer bcmenv is used to hold the environment of
9: * the bc-machine interpreter. If some error is detected while
10: * executing some bc-machine code, after an error message is
11: * printed, return is to the environment saved here.
12: */
13:
14: static jmp_buf bcmenv;
15:
16:
17: /*
18: * Interp is the routine which interprets bc-machine code.
19: */
20:
21: interp()
22: {
23: stkent stack[MAXSTACK];
24: register stkent *tos = &stack[-1];
25: register code *pc = cstream;
26: register rvalue *temp;
27: stkent *frame;
28: func *fnc;
29:
30: if (setjmp(bcmenv)) {
31: /* One might wonder if things on the stack
32: * should be cleaned up?
33: */
34: return;
35: }
36: for (;;) {
37: if (tos >= &stack[MAXSTACK - 1])
38: bcmerr("Out of runtime stack");
39: switch (pc++->opcode) {
40: case LOAD:
41: temp = tos->lvalue;
42: minit(&tos->rvalue.mantissa);
43: mcopy(&temp->mantissa, &tos->rvalue.mantissa);
44: tos->rvalue.scale = temp->scale;
45: break;
46: case LIBASE:
47: minit(&(++tos)->rvalue.mantissa);
48: mitom(ibase, &tos->rvalue.mantissa);
49: tos->rvalue.scale = 0;
50: break;
51: case LOBASE:
52: minit(&(++tos)->rvalue.mantissa);
53: mcopy(&outbase, &tos->rvalue.mantissa);
54: tos->rvalue.scale = 0;
55: break;
56: case LSCALE:
57: minit(&(++tos)->rvalue.mantissa);
58: mitom(scale, &tos->rvalue.mantissa);
59: tos->rvalue.scale = 0;
60: break;
61: case STORE:
62: temp = (--tos)->lvalue;
63: *tos = tos[1];
64: mcopy(&tos->rvalue.mantissa, &temp->mantissa);
65: temp->scale = tos->rvalue.scale;
66: break;
67: case SIBASE:
68: sibase(&tos->rvalue);
69: break;
70: case SOBASE:
71: sobase(&tos->rvalue);
72: break;
73: case SSCALE:
74: sscale(&tos->rvalue);
75: break;
76: case POP:
77: mvfree(&tos--->rvalue.mantissa);
78: break;
79: case PRVAL:
80: temp = tos++->lvalue;
81: minit(&tos->rvalue.mantissa);
82: mcopy(&temp->mantissa, &tos->rvalue.mantissa);
83: tos->rvalue.scale = temp->scale;
84: break;
85: case PGLSC:
86: case PLISC:
87: (++tos)->lvalue = pc++->lvalue;
88: break;
89: case PLOSC:
90: (++tos)->lvalue = &frame[pc++->ivalue].rvalue;
91: break;
92: case PGLAE:
93: temp = select(pc++->alvalue, rtoint(&tos->rvalue));
94: mvfree(&tos->rvalue.mantissa);
95: tos->lvalue = temp;
96: break;
97: case PLOAE:
98: temp = select(frame[pc++->ivalue].alvalue,
99: rtoint(&tos->rvalue));
100: mvfree(&tos->rvalue.mantissa);
101: tos->lvalue = temp;
102: break;
103: case PGLAR:
104: (++tos)->alvalue = pc++->alvalue;
105: break;
106: case PLOAR:
107: (++tos)->alvalue = frame[pc++->ivalue].alvalue;
108: break;
109: case STOP:
110: return;
111: case CALL:
112: chkcall(pc[0].dvalue, pc[1].ivalue);
113: fnc = &pc->dvalue->globalv.fvalue;
114: tos = pauto(fnc, tos, &stack[MAXSTACK-1]);
115: tos->bcstate.spc = pc + 2;
116: tos->bcstate.sfp = frame;
117: tos->bcstate.stos = frame = newframe(fnc, tos);
118: pc = fnc->body;
119: break;
120: case RETURN:
121: temp = &tos->rvalue;
122: bcclean(&pc->dvalue->globalv.fvalue, tos - 2);
123: pc = tos[-1].bcstate.spc;
124: frame = tos[-1].bcstate.sfp;
125: tos = tos[-1].bcstate.stos;
126: tos->rvalue = *temp;
127: break;
128: case INC:
129: madd(&tos->rvalue.mantissa, pow10(tos->rvalue.scale),
130: &tos->rvalue.mantissa);
131: break;
132: case DEC:
133: msub(&tos->rvalue.mantissa, pow10(tos->rvalue.scale),
134: &tos->rvalue.mantissa);
135: break;
136: case PRNUM:
137: putnum(&tos->rvalue);
138: mvfree(&dot.mantissa);
139: dot = tos->rvalue;
140: --tos;
141: break;
142: case PRSTR:
143: pstring(pc++->svalue, 0);
144: break;
145: case PRNL:
146: pnewln();
147: break;
148: case LENGTH:
149: mitom(tos->rvalue.mantissa.len, &tos->rvalue.mantissa);
150: tos->rvalue.scale = 0;
151: break;
152: case SCALE:
153: mitom(tos->rvalue.scale, &tos->rvalue.mantissa);
154: tos->rvalue.scale = 0;
155: break;
156: case SQRT:
157: bcsqrt(&tos->rvalue);
158: break;
159: case ADD:
160: bcadd(&tos[0].rvalue, &tos[-1].rvalue);
161: --tos;
162: break;
163: case SUB:
164: mneg(&tos[0].rvalue.mantissa,
165: &tos[0].rvalue.mantissa);
166: bcadd(&tos[0].rvalue, &tos[-1].rvalue);
167: --tos;
168: break;
169: case MUL:
170: bcmul(&tos[0].rvalue, &tos[-1].rvalue);
171: --tos;
172: break;
173: case DIV:
174: bcdiv(&tos[0].rvalue, &tos[-1].rvalue);
175: --tos;
176: break;
177: case REM:
178: bcrem(&tos[0].rvalue, &tos[-1].rvalue);
179: --tos;
180: break;
181: case EXP:
182: bcexp(&tos[0].rvalue, &tos[-1].rvalue);
183: --tos;
184: break;
185: case NEG:
186: mneg(&tos[0].rvalue.mantissa, &tos[0].rvalue.mantissa);
187: break;
188: case BRALW:
189: pc += pc->address;
190: break;
191: case BRNEV:
192: pc += 2;
193: break;
194: case BRLT:
195: if (bccmp(&tos[0].rvalue, &tos[-1].rvalue) < 0)
196: pc += pc->address;
197: else
198: ++pc;
199: tos -= 2;
200: break;
201: case BRLE:
202: if (bccmp(&tos[0].rvalue, &tos[-1].rvalue) <= 0)
203: pc += pc->address;
204: else
205: ++pc;
206: tos -= 2;
207: break;
208: case BREQ:
209: if (bccmp(&tos[0].rvalue, &tos[-1].rvalue) == 0)
210: pc += pc->address;
211: else
212: ++pc;
213: tos -= 2;
214: break;
215: case BRGE:
216: if (bccmp(&tos[0].rvalue, &tos[-1].rvalue) >= 0)
217: pc += pc->address;
218: else
219: ++pc;
220: tos -= 2;
221: break;
222: case BRGT:
223: if (bccmp(&tos[0].rvalue, &tos[-1].rvalue) > 0)
224: pc += pc->address;
225: else
226: ++pc;
227: tos -= 2;
228: break;
229: case BRNE:
230: if (bccmp(&tos[0].rvalue, &tos[-1].rvalue) != 0)
231: pc += pc->address;
232: else
233: ++pc;
234: tos -= 2;
235: break;
236: case EXIT:
237: exit(0);
238: break;
239: default:
240: assert(FALSE);
241: }
242: }
243: }
244:
245: /*
246: * Bcmerr is called when any bc-machine error occurrs.
247: * It prints out an error message and causes interp to
248: * return.
249: */
250:
251: bcmerr(str)
252: char *str;
253: {
254: fprintf(stderr, "%r\n", &str);
255: longjmp(bcmenv, TRUE);
256: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.