/[pearpc]/src/io/prom/fcode.cc
This is repository of my old source code which isn't updated any more. Go to git.rot13.org for current projects!
ViewVC logotype

Contents of /src/io/prom/fcode.cc

Parent Directory Parent Directory | Revision Log Revision Log


Revision 1 - (show annotations)
Wed Sep 5 17:11:21 2007 UTC (16 years, 6 months ago) by dpavlin
File size: 39715 byte(s)
import upstream CVS
1 /*
2 * PearPC
3 * fcode.cc
4 *
5 * Copyright (C) 2003 Sebastian Biallas (sb@biallas.net)
6 *
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License version 2 as
9 * published by the Free Software Foundation.
10 *
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
15 *
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write to the Free Software
18 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
19 */
20
21 #include "fcode.h"
22
23 // .104
24 void fcode_opc_ex(ForthVM &vm)
25 {
26 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
27 }
28 void fcode_opc_sharp(ForthVM &vm)
29 {
30 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
31 }
32 // .105
33 void fcode_opc_sharpgt(ForthVM &vm)
34 {
35 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
36 }
37 void fcode_opc_mul(ForthVM &vm)
38 {
39 uint32 a = vm.dataPop();
40 uint32 b = vm.dataPop();
41 vm.dataPush(b*a);
42 }
43 void fcode_opc_plus(ForthVM &vm)
44 {
45 uint32 a = vm.dataPop();
46 uint32 b = vm.dataPop();
47 vm.dataPush(b+a);
48 }
49 void fcode_opc_plusex(ForthVM &vm)
50 {
51 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
52 }
53 void fcode_opc_comma(ForthVM &vm)
54 {
55 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
56 }
57 void fcode_opc_minus(ForthVM &vm)
58 {
59 uint32 a = vm.dataPop();
60 uint32 b = vm.dataPop();
61 vm.dataPush(b-a);
62 }
63 void fcode_opc_dot(ForthVM &vm)
64 {
65 uint32 t = vm.dataPop();
66 vm.outf("%d ", t);
67 }
68 // .106
69 void fcode_opc_div(ForthVM &vm)
70 {
71 sint32 a = vm.dataPop();
72 sint32 b = vm.dataPop();
73 if (a==0) throw ForthRunException(vm.mErrorPos, "division by zero");
74 vm.dataPush(b/a);
75 }
76 void fcode_opc_lt(ForthVM &vm)
77 {
78 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
79 }
80 void fcode_opc_ltsharp(ForthVM &vm)
81 {
82 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
83 }
84 void fcode_opc_ltequal(ForthVM &vm)
85 {
86 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
87 }
88 void fcode_opc_ltgt(ForthVM &vm)
89 {
90 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
91 }
92 void fcode_opc_equal(ForthVM &vm)
93 {
94 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
95 }
96 void fcode_opc_gt(ForthVM &vm)
97 {
98 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
99 }
100 void fcode_opc_gtequal(ForthVM &vm)
101 {
102 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
103 }
104 // .107
105 void fcode_opc_at(ForthVM &vm)
106 {
107 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
108 }
109 void fcode_opc_0(ForthVM &vm)
110 {
111 vm.dataPush(0);
112 }
113 void fcode_opc_0lt(ForthVM &vm)
114 {
115 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
116 }
117 void fcode_opc_0ltequal(ForthVM &vm)
118 {
119 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
120 }
121 void fcode_opc_0ltgt(ForthVM &vm)
122 {
123 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
124 }
125 void fcode_opc_0equal(ForthVM &vm)
126 {
127 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
128 }
129 void fcode_opc_0gt(ForthVM &vm)
130 {
131 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
132 }
133 // .108
134 void fcode_opc_0gtequal(ForthVM &vm)
135 {
136 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
137 }
138 void fcode_opc_1(ForthVM &vm)
139 {
140 vm.dataPush(1);
141 }
142 void fcode_opc_minus1(ForthVM &vm)
143 {
144 vm.dataPush((uint)-1);
145 }
146 void fcode_opc_2(ForthVM &vm)
147 {
148 vm.dataPush(2);
149 }
150 void fcode_opc_2ex(ForthVM &vm)
151 {
152 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
153 }
154 void fcode_opc_2mul(ForthVM &vm)
155 {
156 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
157 }
158 void fcode_opc_2div(ForthVM &vm)
159 {
160 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
161 }
162 void fcode_opc_2at(ForthVM &vm)
163 {
164 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
165 }
166 void fcode_opc_3(ForthVM &vm)
167 {
168 vm.dataPush(3);
169 }
170 // .109
171 void fcode_opc_gtgtA(ForthVM &vm)
172 {
173 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
174 }
175 void fcode_opc_ABORT(ForthVM &vm)
176 {
177 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
178 }
179 void fcode_opc_ABS(ForthVM &vm)
180 {
181 sint32 a = vm.dataPop();
182 vm.dataPush((a<0)?-a:a);
183 }
184 // .111
185 void fcode_opc_ALARM(ForthVM &vm)
186 {
187 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
188 }
189 void fcode_opc_ALIGNED(ForthVM &vm)
190 {
191 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
192 }
193 void fcode_opc_ALLOC_MEM(ForthVM &vm)
194 {
195 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
196 }
197 // .112
198 void fcode_opc_AND(ForthVM &vm)
199 {
200 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
201 }
202 // .113
203 void fcode_opc_Bstring(ForthVM &vm)
204 {
205 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
206 }
207 void fcode_opc_Btick(ForthVM &vm)
208 {
209 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
210 }
211 void fcode_opc_Bcolon(ForthVM &vm)
212 {
213 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
214 }
215 void fcode_opc_Bsemincolon(ForthVM &vm)
216 {
217 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
218 }
219 // .114
220 void fcode_opc_BASE(ForthVM &vm)
221 {
222 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
223 }
224 void fcode_opc_BBRANCH(ForthVM &vm)
225 {
226 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
227 }
228 // .115
229 void fcode_opc_BqBRANCH(ForthVM &vm)
230 {
231 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
232 }
233 void fcode_opc_BBUFFERcol(ForthVM &vm)
234 {
235 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
236 }
237 void fcode_opc_BCASE(ForthVM &vm)
238 {
239 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
240 }
241 // .116
242 void fcode_opc_BCONSTANT(ForthVM &vm)
243 {
244 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
245 }
246 void fcode_opc_BCREATE(ForthVM &vm)
247 {
248 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
249 }
250 void fcode_opc_BDEFER(ForthVM &vm)
251 {
252 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
253 }
254 void fcode_opc_BDO(ForthVM &vm)
255 {
256 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
257 }
258 void fcode_opc_BqDO(ForthVM &vm)
259 {
260 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
261 }
262 // .117
263 void fcode_opc_BEHAVIOR(ForthVM &vm)
264 {
265 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
266 }
267 void fcode_opc_BELL(ForthVM &vm)
268 {
269 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
270 }
271 void fcode_opc_BENDCASE(ForthVM &vm)
272 {
273 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
274 }
275 // .118
276 void fcode_opc_BENDOF(ForthVM &vm)
277 {
278 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
279 }
280 void fcode_opc_BETWEEN(ForthVM &vm)
281 {
282 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
283 }
284 void fcode_opc_BFIELD(ForthVM &vm)
285 {
286 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
287 }
288 void fcode_opc_BL(ForthVM &vm)
289 {
290 vm.outf(" ");
291 }
292 void fcode_opc_BLEAVE(ForthVM &vm)
293 {
294 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
295 }
296 void fcode_opc_BLINK_SCREEN(ForthVM &vm)
297 {
298 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
299 }
300 // .119
301 void fcode_opc_BLIT(ForthVM &vm)
302 {
303 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
304 }
305 void fcode_opc_BLJOIN(ForthVM &vm)
306 {
307 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
308 }
309 void fcode_opc_BLOOP(ForthVM &vm)
310 {
311 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
312 }
313 void fcode_opc_BplusLOOP(ForthVM &vm)
314 {
315 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
316 }
317 // .120
318 void fcode_opc_BltMARK(ForthVM &vm)
319 {
320 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
321 }
322 void fcode_opc_BODYgt(ForthVM &vm)
323 {
324 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
325 }
326 void fcode_opc_gtBODY(ForthVM &vm)
327 {
328 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
329 }
330 void fcode_opc_BOF(ForthVM &vm)
331 {
332 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
333 }
334 // .121
335 void fcode_opc_BOUNDS(ForthVM &vm)
336 {
337 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
338 }
339 void fcode_opc_BgtRESOLVE(ForthVM &vm)
340 {
341 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
342 }
343 void fcode_opc_BS(ForthVM &vm)
344 {
345 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
346 }
347 // .122
348 void fcode_opc_BTO(ForthVM &vm)
349 {
350 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
351 }
352 void fcode_opc_BVALUE(ForthVM &vm)
353 {
354 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
355 }
356 void fcode_opc_BVARIABLE(ForthVM &vm)
357 {
358 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
359 }
360 void fcode_opc_BWJOIN(ForthVM &vm)
361 {
362 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
363 }
364 // .123
365 void fcode_opc_BYTE_LOAD(ForthVM &vm)
366 {
367 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
368 }
369 void fcode_opc_Cex(ForthVM &vm)
370 {
371 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
372 }
373 void fcode_opc_Ccomma(ForthVM &vm)
374 {
375 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
376 }
377 // .124
378 void fcode_opc_slashC(ForthVM &vm)
379 {
380 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
381 }
382 void fcode_opc_Cat(ForthVM &vm)
383 {
384 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
385 }
386 void fcode_opc_CAplus(ForthVM &vm)
387 {
388 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
389 }
390 // .125
391 void fcode_opc_dCALL_METHOD(ForthVM &vm)
392 {
393 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
394 }
395 void fcode_opc_CALL_PACKAGE(ForthVM &vm)
396 {
397 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
398 }
399 void fcode_opc_dCALL_PARENT(ForthVM &vm)
400 {
401 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
402 }
403 // .126
404 void fcode_opc_CATCH(ForthVM &vm)
405 {
406 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
407 }
408 void fcode_opc_CELLplus(ForthVM &vm)
409 {
410 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
411 }
412 void fcode_opc_CELLS(ForthVM &vm)
413 {
414 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
415 }
416 void fcode_opc_CHARplus(ForthVM &vm)
417 {
418 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
419 }
420 // .127
421 void fcode_opc_CHAR_HEIGHT(ForthVM &vm)
422 {
423 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
424 }
425 void fcode_opc_CHARS(ForthVM &vm)
426 {
427 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
428 }
429 void fcode_opc_CHAR_WIDTH(ForthVM &vm)
430 {
431 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
432 }
433 void fcode_opc_CHILD(ForthVM &vm)
434 {
435 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
436 }
437 // .128
438 void fcode_opc_CLOSE_PACKAGE(ForthVM &vm)
439 {
440 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
441 }
442 void fcode_opc_sharpCOLUMN(ForthVM &vm)
443 {
444 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
445 }
446 void fcode_opc_sharpCOLUMNS(ForthVM &vm)
447 {
448 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
449 }
450 void fcode_opc_COMP(ForthVM &vm)
451 {
452 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
453 }
454 // .129
455 void fcode_opc_COMPILEcomma(ForthVM &vm)
456 {
457 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
458 }
459 // .130
460 void fcode_opc_COUNT(ForthVM &vm)
461 {
462 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
463 }
464 void fcode_opc_CPEEK(ForthVM &vm)
465 {
466 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
467 }
468 void fcode_opc_CPOKE(ForthVM &vm)
469 {
470 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
471 }
472 void fcode_opc_CR(ForthVM &vm)
473 {
474 vm.outf("\n");
475 }
476 void fcode_opc_bracketCR(ForthVM &vm)
477 {
478 vm.outf("\r");
479 }
480 // .131
481 void fcode_opc_Dplus(ForthVM &vm)
482 {
483 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
484 }
485 void fcode_opc_Dminus(ForthVM &vm)
486 {
487 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
488 }
489 // .132
490 void fcode_opc_DECODE_INT(ForthVM &vm)
491 {
492 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
493 }
494 void fcode_opc_DECODE_PHYS(ForthVM &vm)
495 {
496 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
497 }
498 void fcode_opc_DECODE_STRING(ForthVM &vm)
499 {
500 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
501 }
502 void fcode_opc_DEFAULT_FONT(ForthVM &vm)
503 {
504 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
505 }
506 // .133
507 void fcode_opc_DELETE_CHARS(ForthVM &vm)
508 {
509 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
510 }
511 void fcode_opc_DELETE_LINES(ForthVM &vm)
512 {
513 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
514 }
515 void fcode_opc_DELETE_PROPERTY(ForthVM &vm)
516 {
517 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
518 }
519 void fcode_opc_DEPTH(ForthVM &vm)
520 {
521 vm.dataPush(vm.dataDepth());
522 }
523 // .134
524 void fcode_opc_DEVICE_NAME(ForthVM &vm)
525 {
526 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
527 }
528 void fcode_opc_DEVICE_TYPE(ForthVM &vm)
529 {
530 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
531 }
532 // .135
533 void fcode_opc_DIAGNOSTIC_MODEq(ForthVM &vm)
534 {
535 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
536 }
537 void fcode_opc_DIGIT(ForthVM &vm)
538 {
539 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
540 }
541 // .138
542 void fcode_opc_DRAW_CHARACTER(ForthVM &vm)
543 {
544 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
545 }
546 void fcode_opc_DRAW_LOGO(ForthVM &vm)
547 {
548 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
549 }
550 void fcode_opc_DROP(ForthVM &vm)
551 {
552 vm.dataPop();
553 }
554 void fcode_opc_2DROP(ForthVM &vm)
555 {
556 vm.dataPop();
557 vm.dataPop();
558 }
559 // .139
560 void fcode_opc_DUP(ForthVM &vm)
561 {
562 uint32 t = vm.dataGet();
563 vm.dataPush(t);
564 }
565 void fcode_opc_2DUP(ForthVM &vm)
566 {
567 uint32 t1 = vm.dataGet(0);
568 uint32 t2 = vm.dataGet(1);
569 vm.dataPush(t2);
570 vm.dataPush(t1);
571 }
572 void fcode_opc_qDUP(ForthVM &vm)
573 {
574 uint32 t = vm.dataGet();
575 if (t) vm.dataPush(t);
576 }
577 void fcode_opc_EMIT(ForthVM &vm)
578 {
579 vm.outf("%c", vm.dataPop());
580 }
581 void fcode_opc_ENCODEplus(ForthVM &vm)
582 {
583 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
584 }
585 void fcode_opc_ENCODE_BYTES(ForthVM &vm)
586 {
587 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
588 }
589 // .140
590 void fcode_opc_ENCODE_INT(ForthVM &vm)
591 {
592 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
593 }
594 void fcode_opc_ENCODE_PHYS(ForthVM &vm)
595 {
596 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
597 }
598 void fcode_opc_ENCODE_STRING(ForthVM &vm)
599 {
600 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
601 }
602 // .141
603 void fcode_opc_END0(ForthVM &vm)
604 {
605 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
606 }
607 void fcode_opc_END1(ForthVM &vm)
608 {
609 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
610 }
611 // .142
612 void fcode_opc_ERASE_SCREEN(ForthVM &vm)
613 {
614 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
615 }
616 void fcode_opc_EVALUATE(ForthVM &vm)
617 {
618 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
619 }
620 void fcode_opc_EXECUTE(ForthVM &vm)
621 {
622 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
623 }
624 void fcode_opc_EXIT(ForthVM &vm)
625 {
626 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
627 }
628 // .143
629 void fcode_opc_EXPECT(ForthVM &vm)
630 {
631 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
632 }
633 void fcode_opc_EXTERNAL_TOKEN(ForthVM &vm)
634 {
635 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
636 }
637 // .144
638 void fcode_opc_FB8_BLINK_SCREEN(ForthVM &vm)
639 {
640 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
641 }
642 void fcode_opc_FB8_DELETE_CHARS(ForthVM &vm)
643 {
644 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
645 }
646 void fcode_opc_FB8_DELETE_LINES(ForthVM &vm)
647 {
648 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
649 }
650 void fcode_opc_FB8_DRAW_CHARACTER(ForthVM &vm)
651 {
652 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
653 }
654 void fcode_opc_FB8_DRAW_LOGO(ForthVM &vm)
655 {
656 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
657 }
658 void fcode_opc_FB8_ERASE_SCREEN(ForthVM &vm)
659 {
660 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
661 }
662 void fcode_opc_FB8_INSERT_CHARACTERS(ForthVM &vm)
663 {
664 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
665 }
666 void fcode_opc_FB8_INSERT_LINES(ForthVM &vm)
667 {
668 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
669 }
670 void fcode_opc_FB8_INSTALL(ForthVM &vm)
671 {
672 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
673 }
674 void fcode_opc_FB8_INVERT_SCREEN(ForthVM &vm)
675 {
676 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
677 }
678 // .145
679 void fcode_opc_FB8_RESET_SCREEN(ForthVM &vm)
680 {
681 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
682 }
683 void fcode_opc_FB8_TOGGLE_CURSOR(ForthVM &vm)
684 {
685 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
686 }
687 void fcode_opc_FCODE_REVISION(ForthVM &vm)
688 {
689 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
690 }
691 void fcode_opc_FERROR(ForthVM &vm)
692 {
693 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
694 }
695 // .146
696 void fcode_opc_FILL(ForthVM &vm)
697 {
698 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
699 }
700 void fcode_opc_dFIND(ForthVM &vm)
701 {
702 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
703 }
704 void fcode_opc_FIND_METHOD(ForthVM &vm)
705 {
706 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
707 }
708 void fcode_opc_FIND_PACKAGE(ForthVM &vm)
709 {
710 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
711 }
712 // .147
713 void fcode_opc_FINISH_DEVICE(ForthVM &vm)
714 {
715 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
716 }
717 void fcode_opc_gtFONT(ForthVM &vm)
718 {
719 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
720 }
721 void fcode_opc_FONTBYTES(ForthVM &vm)
722 {
723 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
724 }
725 void fcode_opc_FRAME_BUFFER_ADR(ForthVM &vm)
726 {
727 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
728 }
729 void fcode_opc_FREE_MEM(ForthVM &vm)
730 {
731 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
732 }
733 void fcode_opc_FREE_VIRTUAL(ForthVM &vm)
734 {
735 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
736 }
737 // .148
738 void fcode_opc_GET_INHERITED_PROPERTIY(ForthVM &vm)
739 {
740 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
741 }
742 void fcode_opc_GET_MSECS(ForthVM &vm)
743 {
744 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
745 }
746 void fcode_opc_GET_MY_PROPERTY(ForthVM &vm)
747 {
748 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
749 }
750 void fcode_opc_GET_PACKAGE_PROPERTY(ForthVM &vm)
751 {
752 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
753 }
754 void fcode_opc_GET_TOKEN(ForthVM &vm)
755 {
756 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
757 }
758 // .151
759 void fcode_opc_HERE(ForthVM &vm)
760 {
761 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
762 }
763 // .150
764 void fcode_opc_HOLD(ForthVM &vm)
765 {
766 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
767 }
768 void fcode_opc_I(ForthVM &vm)
769 {
770 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
771 }
772 void fcode_opc_IHANDLEgtPHANDLE(ForthVM &vm)
773 {
774 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
775 }
776 // .151
777 void fcode_opc_INSERT_CHARACTERS(ForthVM &vm)
778 {
779 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
780 }
781 void fcode_opc_INSERT_LINES(ForthVM &vm)
782 {
783 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
784 }
785 // .152
786 void fcode_opc_INSTANCE(ForthVM &vm)
787 {
788 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
789 }
790 // .153
791 void fcode_opc_INVERSEq(ForthVM &vm)
792 {
793 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
794 }
795 void fcode_opc_INVERSE_SCREENq(ForthVM &vm)
796 {
797 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
798 }
799 void fcode_opc_INVERT(ForthVM &vm)
800 {
801 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
802 }
803 // .154
804 void fcode_opc_INVERT_SCREEN(ForthVM &vm)
805 {
806 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
807 }
808 void fcode_opc_IS_INSTALL(ForthVM &vm)
809 {
810 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
811 }
812 void fcode_opc_IS_REMOVE(ForthVM &vm)
813 {
814 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
815 }
816 void fcode_opc_IS_SELFTEST(ForthVM &vm)
817 {
818 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
819 }
820 void fcode_opc_bIS_USER_WORDd(ForthVM &vm)
821 {
822 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
823 }
824 // .155
825 void fcode_opc_J(ForthVM &vm)
826 {
827 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
828 }
829 void fcode_opc_KEY(ForthVM &vm)
830 {
831 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
832 }
833 void fcode_opc_KEYq(ForthVM &vm)
834 {
835 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
836 }
837 void fcode_opc_Lex(ForthVM &vm)
838 {
839 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
840 }
841 void fcode_opc_Lcomma(ForthVM &vm)
842 {
843 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
844 }
845 void fcode_opc_Lat(ForthVM &vm)
846 {
847 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
848 }
849 void fcode_opc_divL(ForthVM &vm)
850 {
851 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
852 }
853 void fcode_opc_divLmul(ForthVM &vm)
854 {
855 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
856 }
857 void fcode_opc_LAplus(ForthVM &vm)
858 {
859 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
860 }
861 void fcode_opc_LA1plus(ForthVM &vm)
862 {
863 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
864 }
865 // .156
866 void fcode_opc_LBFLIP(ForthVM &vm)
867 {
868 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
869 }
870 void fcode_opc_LBFLIPS(ForthVM &vm)
871 {
872 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
873 }
874 void fcode_opc_LBSPLIT(ForthVM &vm)
875 {
876 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
877 }
878 void fcode_opc_LCC(ForthVM &vm)
879 {
880 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
881 }
882 void fcode_opc_LEFT_PARSE_STRING(ForthVM &vm)
883 {
884 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
885 }
886 // .157
887 void fcode_opc_LINEsharp(ForthVM &vm)
888 {
889 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
890 }
891 void fcode_opc_sharpLINE(ForthVM &vm)
892 {
893 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
894 }
895 void fcode_opc_sharpLINES(ForthVM &vm)
896 {
897 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
898 }
899 // .159
900 void fcode_opc_LPEEK(ForthVM &vm)
901 {
902 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
903 }
904 void fcode_opc_LPOKE(ForthVM &vm)
905 {
906 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
907 }
908 void fcode_opc_LSHIFT(ForthVM &vm)
909 {
910 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
911 }
912 void fcode_opc_LWFLIP(ForthVM &vm)
913 {
914 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
915 }
916 void fcode_opc_LWFLIPS(ForthVM &vm)
917 {
918 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
919 }
920 void fcode_opc_LWSPLIT(ForthVM &vm)
921 {
922 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
923 }
924 void fcode_opc_MAC_ADDRESS(ForthVM &vm)
925 {
926 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
927 }
928 // .160
929 void fcode_opc_MAP_LOW(ForthVM &vm)
930 {
931 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
932 }
933 void fcode_opc_MASK(ForthVM &vm)
934 {
935 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
936 }
937 // .161
938 void fcode_opc_MAX(ForthVM &vm)
939 {
940 sint32 a = vm.dataPop();
941 sint32 b = vm.dataPop();
942 vm.dataPush(MAX(a,b));
943 }
944 void fcode_opc_MEMORY_TEST_SUITE(ForthVM &vm)
945 {
946 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
947 }
948 void fcode_opc_MIN(ForthVM &vm)
949 {
950 sint32 a = vm.dataPop();
951 sint32 b = vm.dataPop();
952 vm.dataPush(MIN(a,b));
953 }
954 // .162
955 void fcode_opc_MOD(ForthVM &vm)
956 {
957 sint32 a = vm.dataPop();
958 sint32 b = vm.dataPop();
959 if (a==0) throw ForthRunException(vm.mErrorPos, "division by zero");
960 vm.dataPush(b%a);
961 }
962 void fcode_opc_divMOD(ForthVM &vm)
963 {
964 sint32 a = vm.dataPop();
965 sint32 b = vm.dataPop();
966 if (a==0) throw ForthRunException(vm.mErrorPos, "division by zero");
967 vm.dataPush(b%a);
968 vm.dataPush(b/a);
969 }
970 void fcode_opc_MODEL(ForthVM &vm)
971 {
972 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
973 }
974 void fcode_opc_MOVE(ForthVM &vm)
975 {
976 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
977 }
978 void fcode_opc_MS(ForthVM &vm)
979 {
980 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
981 }
982 // .163
983 void fcode_opc_MY_ADDRESS(ForthVM &vm)
984 {
985 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
986 }
987 void fcode_opc_MY_ARGS(ForthVM &vm)
988 {
989 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
990 }
991 void fcode_opc_MY_PARENT(ForthVM &vm)
992 {
993 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
994 }
995 void fcode_opc_MY_SELF(ForthVM &vm)
996 {
997 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
998 }
999 void fcode_opc_MY_SPACE(ForthVM &vm)
1000 {
1001 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
1002 }
1003 void fcode_opc_MY_UNIT(ForthVM &vm)
1004 {
1005 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
1006 }
1007 void fcode_opc_slashN(ForthVM &vm)
1008 {
1009 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
1010 }
1011 // .164
1012 void fcode_opc_NAplus(ForthVM &vm)
1013 {
1014 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
1015 }
1016 // .165
1017 void fcode_opc_NAMED_TOKEN(ForthVM &vm)
1018 {
1019 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
1020 }
1021 void fcode_opc_NEGATE(ForthVM &vm)
1022 {
1023 vm.dataPush(-vm.dataPop());
1024 }
1025 void fcode_opc_NEW_DEVICE(ForthVM &vm)
1026 {
1027 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
1028 }
1029 // .166
1030 void fcode_opc_NEW_TOKEN(ForthVM &vm)
1031 {
1032 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
1033 }
1034 void fcode_opc_NEXT_PROPERTY(ForthVM &vm)
1035 {
1036 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
1037 }
1038 void fcode_opc_NIP(ForthVM &vm)
1039 {
1040 uint32 t = vm.dataPop();
1041 vm.dataPop();
1042 vm.dataPush(t);
1043 }
1044 void fcode_opc_NOOP(ForthVM &vm)
1045 {
1046 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
1047 }
1048 // .167
1049 void fcode_opc_dNUMBER(ForthVM &vm)
1050 {
1051 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
1052 }
1053 // .169
1054 void fcode_opc_OFF(ForthVM &vm)
1055 {
1056 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
1057 }
1058 // .170
1059 void fcode_opc_OFFSET16(ForthVM &vm)
1060 {
1061 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
1062 }
1063 void fcode_opc_ON(ForthVM &vm)
1064 {
1065 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
1066 }
1067 void fcode_opc_OPEN_PACKAGE(ForthVM &vm)
1068 {
1069 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
1070 }
1071 // .171
1072 void fcode_opc_dOPEN_PACKAGE(ForthVM &vm)
1073 {
1074 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
1075 }
1076 void fcode_opc_OR(ForthVM &vm)
1077 {
1078 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
1079 }
1080 void fcode_opc_sharpOUT(ForthVM &vm)
1081 {
1082 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
1083 }
1084 void fcode_opc_OVER(ForthVM &vm)
1085 {
1086 vm.dataPush(vm.dataGet(1));
1087 }
1088 void fcode_opc_2OVER(ForthVM &vm)
1089 {
1090 uint32 t1 = vm.dataGet(2);
1091 uint32 t2 = vm.dataGet(3);
1092 vm.dataPush(t2);
1093 vm.dataPush(t1);
1094 }
1095 void fcode_opc_PACK(ForthVM &vm)
1096 {
1097 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
1098 }
1099 // .172
1100 void fcode_opc_PARSE_2INT(ForthVM &vm)
1101 {
1102 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
1103 }
1104 // .173
1105 void fcode_opc_PEER(ForthVM &vm)
1106 {
1107 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
1108 }
1109 void fcode_opc_PICK(ForthVM &vm)
1110 {
1111 uint32 u = vm.dataPop();
1112 uint32 t = vm.dataGet(u);
1113 vm.dataPush(t);
1114 }
1115 // .174
1116 void fcode_opc_PROPERTY(ForthVM &vm)
1117 {
1118 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
1119 }
1120 void fcode_opc_Rgt(ForthVM &vm)
1121 {
1122 vm.dataPush(vm.codePop());
1123 }
1124 void fcode_opc_Rat(ForthVM &vm)
1125 {
1126 vm.dataPush(vm.codeGet());
1127 }
1128 void fcode_opc_dotR(ForthVM &vm)
1129 {
1130 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
1131 }
1132 void fcode_opc_gtR(ForthVM &vm)
1133 {
1134 vm.codePush(vm.dataPop());
1135 }
1136 // .175
1137 void fcode_opc_RBex(ForthVM &vm)
1138 {
1139 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
1140 }
1141 void fcode_opc_RBat(ForthVM &vm)
1142 {
1143 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
1144 }
1145 // .177
1146 void fcode_opc_REG(ForthVM &vm)
1147 {
1148 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
1149 }
1150 // .179
1151 void fcode_opc_RESET_SCREEN(ForthVM &vm)
1152 {
1153 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
1154 }
1155 void fcode_opc_RLex(ForthVM &vm)
1156 {
1157 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
1158 }
1159 // .180
1160 void fcode_opc_RLat(ForthVM &vm)
1161 {
1162 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
1163 }
1164 void fcode_opc_ROLL(ForthVM &vm)
1165 {
1166 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
1167 }
1168 void fcode_opc_ROT(ForthVM &vm)
1169 {
1170 uint32 t3 = vm.dataPop();
1171 uint32 t2 = vm.dataPop();
1172 uint32 t1 = vm.dataPop();
1173 vm.dataPush(t2);
1174 vm.dataPush(t3);
1175 vm.dataPush(t1);
1176 }
1177 void fcode_opc_mROT(ForthVM &vm)
1178 {
1179 uint32 t3 = vm.dataPop();
1180 uint32 t2 = vm.dataPop();
1181 uint32 t1 = vm.dataPop();
1182 vm.dataPush(t3);
1183 vm.dataPush(t1);
1184 vm.dataPush(t2);
1185 }
1186 void fcode_opc_2ROT(ForthVM &vm)
1187 {
1188 uint32 t6 = vm.dataPop();
1189 uint32 t5 = vm.dataPop();
1190 uint32 t4 = vm.dataPop();
1191 uint32 t3 = vm.dataPop();
1192 uint32 t2 = vm.dataPop();
1193 uint32 t1 = vm.dataPop();
1194 vm.dataPush(t3);
1195 vm.dataPush(t4);
1196 vm.dataPush(t5);
1197 vm.dataPush(t6);
1198 vm.dataPush(t1);
1199 vm.dataPush(t2);
1200 }
1201 void fcode_opc_RSHIFT(ForthVM &vm)
1202 {
1203 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
1204 }
1205 void fcode_opc_RWex(ForthVM &vm)
1206 {
1207 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
1208 }
1209 // .181
1210 void fcode_opc_RWat(ForthVM &vm)
1211 {
1212 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
1213 }
1214 void fcode_opc_sharpS(ForthVM &vm)
1215 {
1216 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
1217 }
1218 void fcode_opc_dotS(ForthVM &vm)
1219 {
1220 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
1221 }
1222 // .182
1223 void fcode_opc_SBUS_INTRgtCPU(ForthVM &vm)
1224 {
1225 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
1226 }
1227 void fcode_opc_SCREEN_HEIGHT(ForthVM &vm)
1228 {
1229 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
1230 }
1231 void fcode_opc_SCREEN_WIDTH(ForthVM &vm)
1232 {
1233 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
1234 }
1235 // .184
1236 void fcode_opc_SET_ARGS(ForthVM &vm)
1237 {
1238 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
1239 }
1240 // .185
1241 void fcode_opc_SET_FONT(ForthVM &vm)
1242 {
1243 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
1244 }
1245 void fcode_opc_SIGN(ForthVM &vm)
1246 {
1247 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
1248 }
1249 void fcode_opc_SPAN(ForthVM &vm)
1250 {
1251 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
1252 }
1253 // .187
1254 void fcode_opc_START0(ForthVM &vm)
1255 {
1256 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
1257 }
1258 void fcode_opc_START1(ForthVM &vm)
1259 {
1260 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
1261 }
1262 void fcode_opc_START2(ForthVM &vm)
1263 {
1264 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
1265 }
1266 void fcode_opc_START4(ForthVM &vm)
1267 {
1268 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
1269 }
1270 void fcode_opc_STATE(ForthVM &vm)
1271 {
1272 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
1273 }
1274 // .189
1275 void fcode_opc_SUSPEND_FCODE(ForthVM &vm)
1276 {
1277 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
1278 }
1279 void fcode_opc_SWAP(ForthVM &vm)
1280 {
1281 uint32 t2 = vm.dataPop();
1282 uint32 t1 = vm.dataPop();
1283 vm.dataPush(t2);
1284 vm.dataPush(t1);
1285 }
1286 void fcode_opc_2SWAP(ForthVM &vm)
1287 {
1288 uint32 t4 = vm.dataPop();
1289 uint32 t3 = vm.dataPop();
1290 uint32 t2 = vm.dataPop();
1291 uint32 t1 = vm.dataPop();
1292 vm.dataPush(t3);
1293 vm.dataPush(t4);
1294 vm.dataPush(t1);
1295 vm.dataPush(t2);
1296 }
1297 // .190
1298 void fcode_opc_THROW(ForthVM &vm)
1299 {
1300 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
1301 }
1302 // .191
1303 void fcode_opc_TOGGLE_CURSOR(ForthVM &vm)
1304 {
1305 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
1306 }
1307 void fcode_opc_TUCK(ForthVM &vm)
1308 {
1309 uint32 t1 = vm.dataGet(0);
1310 uint32 t2 = vm.dataGet(1);
1311 vm.dataPush(t1);
1312 vm.dataPush(t2);
1313 vm.dataPush(t1);
1314 }
1315 void fcode_opc_TYPE(ForthVM &vm)
1316 {
1317 uint32 len = vm.dataPop();
1318 uint32 str = vm.dataPop();
1319 const byte *p = (const byte*)vm.dataStr(str, true);
1320 String bla(p, len);
1321 vm.outf("%y", &bla);
1322 }
1323 // .192
1324 void fcode_opc_Usharp(ForthVM &vm)
1325 {
1326 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
1327 }
1328 void fcode_opc_Usharpgt(ForthVM &vm)
1329 {
1330 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
1331 }
1332 void fcode_opc_UsharpS(ForthVM &vm)
1333 {
1334 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
1335 }
1336 void fcode_opc_Udot(ForthVM &vm)
1337 {
1338 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
1339 }
1340 void fcode_opc_Ult(ForthVM &vm)
1341 {
1342 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
1343 }
1344 void fcode_opc_Ultequal(ForthVM &vm)
1345 {
1346 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
1347 }
1348 void fcode_opc_Ugt(ForthVM &vm)
1349 {
1350 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
1351 }
1352 void fcode_opc_Ugtequal(ForthVM &vm)
1353 {
1354 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
1355 }
1356 void fcode_opc_U2div(ForthVM &vm)
1357 {
1358 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
1359 }
1360 void fcode_opc_UMmul(ForthVM &vm)
1361 {
1362 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
1363 }
1364 void fcode_opc_UMdivMOD(ForthVM &vm)
1365 {
1366 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
1367 }
1368 // .193
1369 void fcode_opc_UdivMOD(ForthVM &vm)
1370 {
1371 uint32 a = vm.dataPop();
1372 uint32 b = vm.dataPop();
1373 if (a==0) throw ForthRunException(vm.mErrorPos, "division by zero");
1374 vm.dataPush(b%a);
1375 vm.dataPush(b/a);
1376 }
1377 void fcode_opc_UNLOOP(ForthVM &vm)
1378 {
1379 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
1380 }
1381 void fcode_opc_UPC(ForthVM &vm)
1382 {
1383 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
1384 }
1385 void fcode_opc_UdotR(ForthVM &vm)
1386 {
1387 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
1388 }
1389 // .194
1390 void fcode_opc_USER_ABORT(ForthVM &vm)
1391 {
1392 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
1393 }
1394 void fcode_opc_VERSION1(ForthVM &vm)
1395 {
1396 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
1397 }
1398 void fcode_opc_Wex(ForthVM &vm)
1399 {
1400 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
1401 }
1402 void fcode_opc_Wcomma(ForthVM &vm)
1403 {
1404 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
1405 }
1406 void fcode_opc_Wat(ForthVM &vm)
1407 {
1408 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
1409 }
1410 void fcode_opc_slashW(ForthVM &vm)
1411 {
1412 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
1413 }
1414 // .195
1415 void fcode_opc_slashWmul(ForthVM &vm)
1416 {
1417 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
1418 }
1419 void fcode_opc_ltWat(ForthVM &vm)
1420 {
1421 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
1422 }
1423 void fcode_opc_WAplus(ForthVM &vm)
1424 {
1425 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
1426 }
1427 void fcode_opc_WA1plus(ForthVM &vm)
1428 {
1429 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
1430 }
1431 void fcode_opc_WBFLIP(ForthVM &vm)
1432 {
1433 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
1434 }
1435 void fcode_opc_WBFLIPS(ForthVM &vm)
1436 {
1437 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
1438 }
1439 void fcode_opc_WBSPLIT(ForthVM &vm)
1440 {
1441 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
1442 }
1443 void fcode_opc_WINDOW_LEFT(ForthVM &vm)
1444 {
1445 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
1446 }
1447 void fcode_opc_WINDOW_TOP(ForthVM &vm)
1448 {
1449 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
1450 }
1451 void fcode_opc_WITHIN(ForthVM &vm)
1452 {
1453 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
1454 }
1455 // .196
1456 void fcode_opc_WLJOIN(ForthVM &vm)
1457 {
1458 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
1459 }
1460 void fcode_opc_WPEEK(ForthVM &vm)
1461 {
1462 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
1463 }
1464 void fcode_opc_WPOKE(ForthVM &vm)
1465 {
1466 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
1467 }
1468 void fcode_opc_XOR(ForthVM &vm)
1469 {
1470 throw ForthRunException(vm.mErrorPos, "not implemented: '%s'", vm.mCurToken);
1471 }
1472
1473
1474 /*
1475 * ...
1476 */
1477 void fcode_opc_CLEAR(ForthVM &vm)
1478 {
1479 vm.dataClear();
1480 }
1481
1482 ForthWordTick::ForthWordTick(const char *name)
1483 :ForthWord(name)
1484 {
1485 }
1486
1487 void ForthWordTick::compile(ForthVM &vm)
1488 {
1489 }
1490
1491 void ForthWordTick::interprete(ForthVM &vm)
1492 {
1493 }

  ViewVC Help
Powered by ViewVC 1.1.26