/[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

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

Parent Directory Parent Directory | Revision Log Revision Log

Revision 1 - (hide annotations)
Wed Sep 5 17:11:21 2007 UTC (16 years, 7 months ago) by dpavlin
File size: 39715 byte(s) 
import upstream CVS
1 dpavlin 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