/[pearpc]/src/io/prom/forthtable.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/forthtable.cc

Parent Directory Parent Directory | Revision Log Revision Log

Revision 1 - (hide annotations)
Wed Sep 5 17:11:21 2007 UTC (16 years, 8 months ago) by dpavlin
File size: 19500 byte(s) 
import upstream CVS
1 dpavlin 1 /*
2     * PearPC
3     * forthtable.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 "forthtable.h"
22     #include "forth.h"
23     #include "fcode.h"
24    
25     struct forth_word {
26     const char *name;
27     uint32 fcode;
28     FCodeFunction func;
29     };
30    
31     forth_word forth_word_table[] = {
32     {"!", FCODE_ex, fcode_opc_ex},
33     {"#", FCODE_sharp, fcode_opc_sharp},
34     {"#>", FCODE_sharpgt, fcode_opc_sharpgt},
35     {"*", FCODE_mul, fcode_opc_mul},
36     {"+", FCODE_plus, fcode_opc_plus},
37     {"+!", FCODE_plusex, fcode_opc_plusex},
38     {",", FCODE_comma, fcode_opc_comma},
39     {"-", FCODE_minus, fcode_opc_minus},
40     {".", FCODE_dot, fcode_opc_dot},
41     {"/", FCODE_div, fcode_opc_div},
42     {"<", FCODE_lt, fcode_opc_lt},
43     {"<#", FCODE_ltsharp, fcode_opc_ltsharp},
44     {"<=", FCODE_ltequal, fcode_opc_ltequal},
45     {"<>", FCODE_ltgt, fcode_opc_ltgt},
46     {"=", FCODE_equal, fcode_opc_equal},
47     {">", FCODE_gt, fcode_opc_gt},
48     {">=", FCODE_gtequal, fcode_opc_gtequal},
49     {"@", FCODE_at, fcode_opc_at},
50     {"0", FCODE_0, fcode_opc_0},
51     {"0<", FCODE_0lt, fcode_opc_0lt},
52     {"0<=", FCODE_0ltequal, fcode_opc_0ltequal},
53     {"0<>", FCODE_0ltgt, fcode_opc_0ltgt},
54     {"0=", FCODE_0equal, fcode_opc_0equal},
55     {"0>", FCODE_0gt, fcode_opc_0gt},
56     {"0>=", FCODE_0gtequal, fcode_opc_0gtequal},
57     {"1", FCODE_1, fcode_opc_1},
58     {"-1", FCODE_minus1, fcode_opc_minus1},
59     {"2", FCODE_2, fcode_opc_2},
60     {"2!", FCODE_2ex, fcode_opc_2ex},
61     {"2*", FCODE_2mul, fcode_opc_2mul},
62     {"2/", FCODE_2div, fcode_opc_2div},
63     {"2@", FCODE_2at, fcode_opc_2at},
64     {"3", FCODE_3, fcode_opc_3},
65     {">>a", FCODE_gtgtA, fcode_opc_gtgtA},
66     {"abort", FCODE_ABORT, fcode_opc_ABORT},
67     {"abs", FCODE_ABS, fcode_opc_ABS},
68     {"alarm", FCODE_ALARM, fcode_opc_ALARM},
69     {"aligned", FCODE_ALIGNED, fcode_opc_ALIGNED},
70     {"alloc-mem", FCODE_ALLOC_MEM, fcode_opc_ALLOC_MEM},
71     {"and", FCODE_AND, fcode_opc_AND},
72     {"behavior", FCODE_BEHAVIOR, fcode_opc_BEHAVIOR},
73     {"bell", FCODE_BELL, fcode_opc_BELL},
74     {"between", FCODE_BETWEEN, fcode_opc_BETWEEN},
75     {"bl", FCODE_BL, fcode_opc_BL},
76     {"blink-screen", FCODE_BLINK_SCREEN, fcode_opc_BLINK_SCREEN},
77     {"bljoin", FCODE_BLJOIN, fcode_opc_BLJOIN},
78     {"body>", FCODE_BODYgt, fcode_opc_BODYgt},
79     {">body", FCODE_gtBODY, fcode_opc_gtBODY},
80     {"bounds", FCODE_BOUNDS, fcode_opc_BOUNDS},
81     {"bs", FCODE_BS, fcode_opc_BS},
82     {"bwjoin", FCODE_BWJOIN, fcode_opc_BWJOIN},
83     {"byte-load", FCODE_BYTE_LOAD, fcode_opc_BYTE_LOAD},
84     {"c!", FCODE_Cex, fcode_opc_Cex},
85     {"c,", FCODE_Ccomma, fcode_opc_Ccomma},
86     {"/c", FCODE_slashC, fcode_opc_slashC},
87     {"c@", FCODE_Cat, fcode_opc_Cat},
88     {"ca+", FCODE_CAplus, fcode_opc_CAplus},
89     {"$call-method", FCODE_dCALL_METHOD, fcode_opc_dCALL_METHOD},
90     {"call-package", FCODE_CALL_PACKAGE, fcode_opc_CALL_PACKAGE},
91     {"$call-parent", FCODE_dCALL_PARENT, fcode_opc_dCALL_PARENT},
92     {"catch", FCODE_CATCH, fcode_opc_CATCH},
93     {"cell+", FCODE_CELLplus, fcode_opc_CELLplus},
94     {"cells", FCODE_CELLS, fcode_opc_CELLS},
95     {"char+", FCODE_CHARplus, fcode_opc_CHARplus},
96     {"char-height", FCODE_CHAR_HEIGHT, fcode_opc_CHAR_HEIGHT},
97     {"chars", FCODE_CHARS, fcode_opc_CHARS},
98     {"char-width", FCODE_CHAR_WIDTH, fcode_opc_CHAR_WIDTH},
99     {"child", FCODE_CHILD, fcode_opc_CHILD},
100     {"close-package", FCODE_CLOSE_PACKAGE, fcode_opc_CLOSE_PACKAGE},
101     {"#column", FCODE_sharpCOLUMN, fcode_opc_sharpCOLUMN},
102     {"#columns", FCODE_sharpCOLUMNS, fcode_opc_sharpCOLUMNS},
103     {"comp", FCODE_COMP, fcode_opc_COMP},
104     {"compile,", FCODE_COMPILEcomma, fcode_opc_COMPILEcomma},
105     {"count", FCODE_COUNT, fcode_opc_COUNT},
106     {"cpeek", FCODE_CPEEK, fcode_opc_CPEEK},
107     {"cpoke", FCODE_CPOKE, fcode_opc_CPOKE},
108     {"cr", FCODE_CR, fcode_opc_CR},
109     {"(cr", FCODE_bracketCR, fcode_opc_bracketCR},
110     {"d+", FCODE_Dplus, fcode_opc_Dplus},
111     {"d-", FCODE_Dminus, fcode_opc_Dminus},
112     {"decode-int", FCODE_DECODE_INT, fcode_opc_DECODE_INT},
113     {"decode-phys", FCODE_DECODE_PHYS, fcode_opc_DECODE_PHYS},
114     {"decode-string", FCODE_DECODE_STRING, fcode_opc_DECODE_STRING},
115     {"default-font", FCODE_DEFAULT_FONT, fcode_opc_DEFAULT_FONT},
116     {"delete-chars", FCODE_DELETE_CHARS, fcode_opc_DELETE_CHARS},
117     {"delete-lines", FCODE_DELETE_LINES, fcode_opc_DELETE_LINES},
118     {"delete-property", FCODE_DELETE_PROPERTY, fcode_opc_DELETE_PROPERTY},
119     {"depth", FCODE_DEPTH, fcode_opc_DEPTH},
120     {"device-name", FCODE_DEVICE_NAME, fcode_opc_DEVICE_NAME},
121     {"device-type", FCODE_DEVICE_TYPE, fcode_opc_DEVICE_TYPE},
122     {"diagnostic-mode?", FCODE_DIAGNOSTIC_MODEq, fcode_opc_DIAGNOSTIC_MODEq},
123     {"digit", FCODE_DIGIT, fcode_opc_DIGIT},
124     {"draw-character", FCODE_DRAW_CHARACTER, fcode_opc_DRAW_CHARACTER},
125     {"draw-logo", FCODE_DRAW_LOGO, fcode_opc_DRAW_LOGO},
126     {"drop", FCODE_DROP, fcode_opc_DROP},
127     {"2drop", FCODE_2DROP, fcode_opc_2DROP},
128     {"dup", FCODE_DUP, fcode_opc_DUP},
129     {"2dup", FCODE_2DUP, fcode_opc_2DUP},
130     {"?dup", FCODE_qDUP, fcode_opc_qDUP},
131     {"emit", FCODE_EMIT, fcode_opc_EMIT},
132     {"encode+", FCODE_ENCODEplus, fcode_opc_ENCODEplus},
133     {"encode-bytes", FCODE_ENCODE_BYTES, fcode_opc_ENCODE_BYTES},
134     {"encode-int", FCODE_ENCODE_INT, fcode_opc_ENCODE_INT},
135     {"encode-phys", FCODE_ENCODE_PHYS, fcode_opc_ENCODE_PHYS},
136     {"encode-string", FCODE_ENCODE_STRING, fcode_opc_ENCODE_STRING},
137     {"end0", FCODE_END0, fcode_opc_END0},
138     {"end1", FCODE_END1, fcode_opc_END1},
139     {"erase-screen", FCODE_ERASE_SCREEN, fcode_opc_ERASE_SCREEN},
140     {"evaluate", FCODE_EVALUATE, fcode_opc_EVALUATE},
141     {"execute", FCODE_EXECUTE, fcode_opc_EXECUTE},
142     {"exit", FCODE_EXIT, fcode_opc_EXIT},
143     {"expect", FCODE_EXPECT, fcode_opc_EXPECT},
144     {"fb8-blink-screen", FCODE_FB8_BLINK_SCREEN, fcode_opc_FB8_BLINK_SCREEN},
145     {"fb8-delete-chars", FCODE_FB8_DELETE_CHARS, fcode_opc_FB8_DELETE_CHARS},
146     {"fb8-delete-lines", FCODE_FB8_DELETE_LINES, fcode_opc_FB8_DELETE_LINES},
147     {"fb8-draw-character", FCODE_FB8_DRAW_CHARACTER, fcode_opc_FB8_DRAW_CHARACTER},
148     {"fb8-draw-logo", FCODE_FB8_DRAW_LOGO, fcode_opc_FB8_DRAW_LOGO},
149     {"fb8-erase-screen", FCODE_FB8_ERASE_SCREEN, fcode_opc_FB8_ERASE_SCREEN},
150     {"fb8-insert-characters", FCODE_FB8_INSERT_CHARACTERS, fcode_opc_FB8_INSERT_CHARACTERS},
151     {"fb8-insert_lines", FCODE_FB8_INSERT_LINES, fcode_opc_FB8_INSERT_LINES},
152     {"fb8-install", FCODE_FB8_INSTALL, fcode_opc_FB8_INSTALL},
153     {"fb8-invert-screen", FCODE_FB8_INVERT_SCREEN, fcode_opc_FB8_INVERT_SCREEN},
154     {"fb8-reset-screen", FCODE_FB8_RESET_SCREEN, fcode_opc_FB8_RESET_SCREEN},
155     {"fb8-toggle-cursor", FCODE_FB8_TOGGLE_CURSOR, fcode_opc_FB8_TOGGLE_CURSOR},
156     {"fcode-revision", FCODE_FCODE_REVISION, fcode_opc_FCODE_REVISION},
157     {"ferror", FCODE_FERROR, fcode_opc_FERROR},
158     {"fill", FCODE_FILL, fcode_opc_FILL},
159     {"$find", FCODE_dFIND, fcode_opc_dFIND},
160     {"find-method", FCODE_FIND_METHOD, fcode_opc_FIND_METHOD},
161     {"find-package", FCODE_FIND_PACKAGE, fcode_opc_FIND_PACKAGE},
162     {"finish-device", FCODE_FINISH_DEVICE, fcode_opc_FINISH_DEVICE},
163     {">font", FCODE_gtFONT, fcode_opc_gtFONT},
164     {"fontbytes", FCODE_FONTBYTES, fcode_opc_FONTBYTES},
165     {"frame-buffer-adr", FCODE_FRAME_BUFFER_ADR, fcode_opc_FRAME_BUFFER_ADR},
166     {"free-mem", FCODE_FREE_MEM, fcode_opc_FREE_MEM},
167     {"free-virtual", FCODE_FREE_VIRTUAL, fcode_opc_FREE_VIRTUAL},
168     {"get-inherited_propertiy", FCODE_GET_INHERITED_PROPERTIY, fcode_opc_GET_INHERITED_PROPERTIY},
169     {"get-msecs", FCODE_GET_MSECS, fcode_opc_GET_MSECS},
170     {"get-my-property", FCODE_GET_MY_PROPERTY, fcode_opc_GET_MY_PROPERTY},
171     {"get-package_property", FCODE_GET_PACKAGE_PROPERTY, fcode_opc_GET_PACKAGE_PROPERTY},
172     {"get-token", FCODE_GET_TOKEN, fcode_opc_GET_TOKEN},
173     {"here", FCODE_HERE, fcode_opc_HERE},
174     {"hold", FCODE_HOLD, fcode_opc_HOLD},
175     {"i", FCODE_I, fcode_opc_I},
176     {"ihandle>phandle", FCODE_IHANDLEgtPHANDLE, fcode_opc_IHANDLEgtPHANDLE},
177     {"insert-characters", FCODE_INSERT_CHARACTERS, fcode_opc_INSERT_CHARACTERS},
178     {"insert-lines", FCODE_INSERT_LINES, fcode_opc_INSERT_LINES},
179     {"instance", FCODE_INSTANCE, fcode_opc_INSTANCE},
180     {"inverse?", FCODE_INVERSEq, fcode_opc_INVERSEq},
181     {"inverse-screen?", FCODE_INVERSE_SCREENq, fcode_opc_INVERSE_SCREENq},
182     {"invert", FCODE_INVERT, fcode_opc_INVERT},
183     {"invert-screen", FCODE_INVERT_SCREEN, fcode_opc_INVERT_SCREEN},
184     {"is-install", FCODE_IS_INSTALL, fcode_opc_IS_INSTALL},
185     {"is-remove", FCODE_IS_REMOVE, fcode_opc_IS_REMOVE},
186     {"is-selftest", FCODE_IS_SELFTEST, fcode_opc_IS_SELFTEST},
187     {"(is-user-word)", FCODE_bIS_USER_WORDd, fcode_opc_bIS_USER_WORDd},
188     {"j", FCODE_J, fcode_opc_J},
189     {"key", FCODE_KEY, fcode_opc_KEY},
190     {"key?", FCODE_KEYq, fcode_opc_KEYq},
191     {"l!", FCODE_Lex, fcode_opc_Lex},
192     {"l,", FCODE_Lcomma, fcode_opc_Lcomma},
193     {"l@", FCODE_Lat, fcode_opc_Lat},
194     {"/l", FCODE_divL, fcode_opc_divL},
195     {"/l*", FCODE_divLmul, fcode_opc_divLmul},
196     {"la+", FCODE_LAplus, fcode_opc_LAplus},
197     {"la1+", FCODE_LA1plus, fcode_opc_LA1plus},
198     {"lbflip", FCODE_LBFLIP, fcode_opc_LBFLIP},
199     {"lbflips", FCODE_LBFLIPS, fcode_opc_LBFLIPS},
200     {"lbsplit", FCODE_LBSPLIT, fcode_opc_LBSPLIT},
201     {"lcc", FCODE_LCC, fcode_opc_LCC},
202     {"left-parse-string", FCODE_LEFT_PARSE_STRING, fcode_opc_LEFT_PARSE_STRING},
203     {"#line", FCODE_sharpLINE, fcode_opc_sharpLINE},
204     {"#lines", FCODE_sharpLINES, fcode_opc_sharpLINES},
205     {"lpeek", FCODE_LPEEK, fcode_opc_LPEEK},
206     {"lpoke", FCODE_LPOKE, fcode_opc_LPOKE},
207     {"lshift", FCODE_LSHIFT, fcode_opc_LSHIFT},
208     {"lwflip", FCODE_LWFLIP, fcode_opc_LWFLIP},
209     {"lwflips", FCODE_LWFLIPS, fcode_opc_LWFLIPS},
210     {"lwsplit", FCODE_LWSPLIT, fcode_opc_LWSPLIT},
211     {"mac-address", FCODE_MAC_ADDRESS, fcode_opc_MAC_ADDRESS},
212     {"map-low", FCODE_MAP_LOW, fcode_opc_MAP_LOW},
213     {"mask", FCODE_MASK, fcode_opc_MASK},
214     {"max", FCODE_MAX, fcode_opc_MAX},
215     {"memory-test-suite", FCODE_MEMORY_TEST_SUITE, fcode_opc_MEMORY_TEST_SUITE},
216     {"min", FCODE_MIN, fcode_opc_MIN},
217     {"mod", FCODE_MOD, fcode_opc_MOD},
218     {"/mod", FCODE_divMOD, fcode_opc_divMOD},
219     {"model", FCODE_MODEL, fcode_opc_MODEL},
220     {"move", FCODE_MOVE, fcode_opc_MOVE},
221     {"ms", FCODE_MS, fcode_opc_MS},
222     {"my-address", FCODE_MY_ADDRESS, fcode_opc_MY_ADDRESS},
223     {"my-args", FCODE_MY_ARGS, fcode_opc_MY_ARGS},
224     {"my-parent", FCODE_MY_PARENT, fcode_opc_MY_PARENT},
225     {"my-self", FCODE_MY_SELF, fcode_opc_MY_SELF},
226     {"my-space", FCODE_MY_SPACE, fcode_opc_MY_SPACE},
227     {"my-unit", FCODE_MY_UNIT, fcode_opc_MY_UNIT},
228     {"/n", FCODE_slashN, fcode_opc_slashN},
229     {"na+", FCODE_NAplus, fcode_opc_NAplus},
230     {"named-token", FCODE_NAMED_TOKEN, fcode_opc_NAMED_TOKEN},
231     {"negate", FCODE_NEGATE, fcode_opc_NEGATE},
232     {"new-device", FCODE_NEW_DEVICE, fcode_opc_NEW_DEVICE},
233     {"next-property", FCODE_NEXT_PROPERTY, fcode_opc_NEXT_PROPERTY},
234     {"nip", FCODE_NIP, fcode_opc_NIP},
235     {"noop", FCODE_NOOP, fcode_opc_NOOP},
236     {"$number", FCODE_dNUMBER, fcode_opc_dNUMBER},
237     {"off", FCODE_OFF, fcode_opc_OFF},
238     {"offset16", FCODE_OFFSET16, fcode_opc_OFFSET16},
239     {"on", FCODE_ON, fcode_opc_ON},
240     {"open-package", FCODE_OPEN_PACKAGE, fcode_opc_OPEN_PACKAGE},
241     {"$open-package", FCODE_dOPEN_PACKAGE, fcode_opc_dOPEN_PACKAGE},
242     {"or", FCODE_OR, fcode_opc_OR},
243     {"#out", FCODE_sharpOUT, fcode_opc_sharpOUT},
244     {"over", FCODE_OVER, fcode_opc_OVER},
245     {"2over", FCODE_2OVER, fcode_opc_2OVER},
246     {"pack", FCODE_PACK, fcode_opc_PACK},
247     {"parse-2int", FCODE_PARSE_2INT, fcode_opc_PARSE_2INT},
248     {"peer", FCODE_PEER, fcode_opc_PEER},
249     {"pick", FCODE_PICK, fcode_opc_PICK},
250     {"property", FCODE_PROPERTY, fcode_opc_PROPERTY},
251     {"r>", FCODE_Rgt, fcode_opc_Rgt},
252     {"r@", FCODE_Rat, fcode_opc_Rat},
253     {".r", FCODE_dotR, fcode_opc_dotR},
254     {">r", FCODE_gtR, fcode_opc_gtR},
255     {"rb!", FCODE_RBex, fcode_opc_RBex},
256     {"rb@", FCODE_RBat, fcode_opc_RBat},
257     {"reg", FCODE_REG, fcode_opc_REG},
258     {"reset-screen", FCODE_RESET_SCREEN, fcode_opc_RESET_SCREEN},
259     {"rl!", FCODE_RLex, fcode_opc_RLex},
260     {"rl@", FCODE_RLat, fcode_opc_RLat},
261     {"roll", FCODE_ROLL, fcode_opc_ROLL},
262     {"rot", FCODE_ROT, fcode_opc_ROT},
263     {"-rot", FCODE_mROT, fcode_opc_mROT},
264     {"2rot", FCODE_2ROT, fcode_opc_2ROT},
265     {"rshift", FCODE_RSHIFT, fcode_opc_RSHIFT},
266     {"rw!", FCODE_RWex, fcode_opc_RWex},
267     {"rw@", FCODE_RWat, fcode_opc_RWat},
268     {"#s", FCODE_sharpS, fcode_opc_sharpS},
269     {".s", FCODE_dotS, fcode_opc_dotS},
270     {"sbus-intr>cpu", FCODE_SBUS_INTRgtCPU, fcode_opc_SBUS_INTRgtCPU},
271     {"screen-height", FCODE_SCREEN_HEIGHT, fcode_opc_SCREEN_HEIGHT},
272     {"screen-width", FCODE_SCREEN_WIDTH, fcode_opc_SCREEN_WIDTH},
273     {"set-args", FCODE_SET_ARGS, fcode_opc_SET_ARGS},
274     {"set-font", FCODE_SET_FONT, fcode_opc_SET_FONT},
275     {"sign", FCODE_SIGN, fcode_opc_SIGN},
276     {"start0", FCODE_START0, fcode_opc_START0},
277     {"start1", FCODE_START1, fcode_opc_START1},
278     {"start2", FCODE_START2, fcode_opc_START2},
279     {"start4", FCODE_START4, fcode_opc_START4},
280     {"state", FCODE_STATE, fcode_opc_STATE},
281     {"suspend-fcode", FCODE_SUSPEND_FCODE, fcode_opc_SUSPEND_FCODE},
282     {"swap", FCODE_SWAP, fcode_opc_SWAP},
283     {"2swap", FCODE_2SWAP, fcode_opc_2SWAP},
284     {"throw", FCODE_THROW, fcode_opc_THROW},
285     {"toggle-cursor", FCODE_TOGGLE_CURSOR, fcode_opc_TOGGLE_CURSOR},
286     {"tuck", FCODE_TUCK, fcode_opc_TUCK},
287     {"type", FCODE_TYPE, fcode_opc_TYPE},
288     {"u#", FCODE_Usharp, fcode_opc_Usharp},
289     {"u#>", FCODE_Usharpgt, fcode_opc_Usharpgt},
290     {"u#s", FCODE_UsharpS, fcode_opc_UsharpS},
291     {"u.", FCODE_Udot, fcode_opc_Udot},
292     {"u<", FCODE_Ult, fcode_opc_Ult},
293     {"u<=", FCODE_Ultequal, fcode_opc_Ultequal},
294     {"u>", FCODE_Ugt, fcode_opc_Ugt},
295     {"u>=", FCODE_Ugtequal, fcode_opc_Ugtequal},
296     {"u2/", FCODE_U2div, fcode_opc_U2div},
297     {"um*", FCODE_UMmul, fcode_opc_UMmul},
298     {"um/mod", FCODE_UMdivMOD, fcode_opc_UMdivMOD},
299     {"u/mod", FCODE_UdivMOD, fcode_opc_UdivMOD},
300     {"unloop", FCODE_UNLOOP, fcode_opc_UNLOOP},
301     {"upc", FCODE_UPC, fcode_opc_UPC},
302     {"u.r", FCODE_UdotR, fcode_opc_UdotR},
303     {"user-abort", FCODE_USER_ABORT, fcode_opc_USER_ABORT},
304     {"version1", FCODE_VERSION1, fcode_opc_VERSION1},
305     {"w!", FCODE_Wex, fcode_opc_Wex},
306     {"w,", FCODE_Wcomma, fcode_opc_Wcomma},
307     {"w@", FCODE_Wat, fcode_opc_Wat},
308     {"/w", FCODE_slashW, fcode_opc_slashW},
309     {"/w*", FCODE_slashWmul, fcode_opc_slashWmul},
310     {">w@", FCODE_ltWat, fcode_opc_ltWat},
311     {"wa+", FCODE_WAplus, fcode_opc_WAplus},
312     {"wa1+", FCODE_WA1plus, fcode_opc_WA1plus},
313     {"wbflip", FCODE_WBFLIP, fcode_opc_WBFLIP},
314     {"wbflips", FCODE_WBFLIPS, fcode_opc_WBFLIPS},
315     {"wbsplit", FCODE_WBSPLIT, fcode_opc_WBSPLIT},
316     {"window-left", FCODE_WINDOW_LEFT, fcode_opc_WINDOW_LEFT},
317     {"window-top", FCODE_WINDOW_TOP, fcode_opc_WINDOW_TOP},
318     {"within", FCODE_WITHIN, fcode_opc_WITHIN},
319     {"wljoin", FCODE_WLJOIN, fcode_opc_WLJOIN},
320     {"wpeek", FCODE_WPEEK, fcode_opc_WPEEK},
321     {"wpoke", FCODE_WPOKE, fcode_opc_WPOKE},
322     {"xor", FCODE_XOR, fcode_opc_XOR},
323    
324     {"base", FCODE_BASE, fcode_opc_XOR},
325     };
326    
327     forth_word forth_internal_word_table[] = {
328     {"b(\")", FCODE_Bstring, fcode_opc_Bstring},
329     {"b(')", FCODE_Btick, fcode_opc_Btick},
330     {"b(:)", FCODE_Bcolon, fcode_opc_Bcolon},
331     {"b(;)", FCODE_Bsemincolon, fcode_opc_Bsemincolon},
332     {"bbranch", FCODE_BBRANCH, fcode_opc_BBRANCH},
333     {"b?branch", FCODE_BqBRANCH, fcode_opc_BqBRANCH},
334     {"b(buffer:)", FCODE_BBUFFERcol, fcode_opc_BBUFFERcol},
335     {"b(case)", FCODE_BCASE, fcode_opc_BCASE},
336     {"b(constant)", FCODE_BCONSTANT, fcode_opc_BCONSTANT},
337     {"b(create)", FCODE_BCREATE, fcode_opc_BCREATE},
338     {"b(defer)", FCODE_BDEFER, fcode_opc_BDEFER},
339     {"b(do)", FCODE_BDO, fcode_opc_BDO},
340     {"b(?do)", FCODE_BqDO, fcode_opc_BqDO},
341     {"b(endcase)", FCODE_BENDCASE, fcode_opc_BENDCASE},
342     {"b(endof)", FCODE_BENDOF, fcode_opc_BENDOF},
343     {"b(field)", FCODE_BFIELD, fcode_opc_BFIELD},
344     {"b(leave)", FCODE_BLEAVE, fcode_opc_BLEAVE},
345     {"b(lit)", FCODE_BLIT, fcode_opc_BLIT},
346     {"b(loop)", FCODE_BLOOP, fcode_opc_BLOOP},
347     {"b(+loop)", FCODE_BplusLOOP, fcode_opc_BplusLOOP},
348     {"b(<mark)", FCODE_BltMARK, fcode_opc_BltMARK},
349     {"b(of)", FCODE_BOF, fcode_opc_BOF},
350     {"b(>resolve)", FCODE_BgtRESOLVE, fcode_opc_BgtRESOLVE},
351     {"b(to)", FCODE_BTO, fcode_opc_BTO},
352     {"b(value)", FCODE_BVALUE, fcode_opc_BVALUE},
353     {"b(variable)", FCODE_BVARIABLE, fcode_opc_BVARIABLE},
354     {"external-token", FCODE_EXTERNAL_TOKEN, fcode_opc_EXTERNAL_TOKEN},
355     {"new-token", FCODE_NEW_TOKEN, fcode_opc_NEW_TOKEN},
356     };
357    
358     static char *forth_aliases = ""
359     " : << lshift ;"
360     " : >> rshift ;"
361     " : 1+ 1 + ;"
362     " : 1- 1 - ;"
363     " : 2+ 2 + ;"
364     " : 2- 2 - ;"
365     " : 3+ 3 + ;"
366     " : 3- 3 - ;"
367     " : accept span @ -rot expect span @ swap span ! ;"
368     " : blank bl fill ;"
369     " : /c* chars ;"
370     " : ca1+ char+ ;"
371     " : .d base @ swap 10 base ! . base ! ;"
372     " : decimal 10 base ! ;"
373     " : decode-bytes >r over r@ + swap r@ - rot r> ;"
374     " : 3drop 2drop drop ;"
375     " : 3dup 2 pick 2 pick 2 pick ;"
376     " : eval evaluate ;"
377     " : false 0 ;"
378     " : .h base @ swap 16 base ! . base ! ;"
379     " : hex 16 base ! ;"
380     " : /n* cells ;"
381     " : na1+ cell+ ;"
382     " : not invert ;"
383     " : space bl emit ;"
384     " : spaces 0 max 0 ?do space loop ;"
385     " : ;"
386     " : ;"
387     " : ;"
388     " : ;"
389     ;
390    
391     /*
392     * Initialize stuff
393     */
394     static char *forth_prepend = ""
395     " 10 base !"
396     " 1 to line#"
397     " 0 span !"
398     ;
399    
400     void forth_build_vocabulary(Container &vocabulary, ForthVM &vm)
401     {
402     for (uint i=0; i < sizeof forth_word_table/sizeof (forth_word); i++) {
403     vocabulary.insert(new ForthWordBuildIn(forth_word_table[i].name, forth_word_table[i].fcode, forth_word_table[i].func));
404     }
405     vocabulary.insert(new ForthWordString("\"", fwstString));
406     vocabulary.insert(new ForthWordString("s\"", fwstStringWithHex));
407     vocabulary.insert(new ForthWordString(".\"", fwstStringPrint));
408     vocabulary.insert(new ForthWordString(".(", fwstStringPrintBracket));
409     vocabulary.insert(new ForthWordTick("'"));
410     vocabulary.insert(new ForthWordTick("[']"));
411    
412     vocabulary.insert(new ForthVar("base",0));
413     // , FCODE_BASE
414     vocabulary.insert(new ForthVar("line#",0));
415     // , FCODE_LINEsharp
416     vocabulary.insert(new ForthVar("span",0));
417     // , FCODE_SPAN
418     }
419    
420     #include <cstdlib>
421     void forth_disassemble(ForthVM &vm)
422     {
423     String s;
424     vm.mFCodeBuffer = &s;
425     vm.mFCodeBufferIdx = 8;
426     bool offset16 = true;
427     while (1) {
428     uint32 fcode = vm.getFCode();
429     switch (fcode) {
430     case FCODE_Bstring: {
431     byte len = vm.getFCodeByte();
432     printf("b(\") \"");
433     for (int i=0; i<len; i++) {
434     printf("%c", vm.getFCodeByte());
435     }
436     printf("\" ");
437     goto ok;
438     }
439     case FCODE_BLIT: {
440     uint32 a = 0;
441     a |= vm.getFCodeByte(); a<<=8;
442     a |= vm.getFCodeByte(); a<<=8;
443     a |= vm.getFCodeByte(); a<<=8;
444     a |= vm.getFCodeByte();
445     printf("0x%08x ", a);
446     goto ok;
447     }
448     }
449     for (uint i=0; i < sizeof forth_word_table/sizeof (forth_word); i++) {
450     if (forth_word_table[i].fcode == fcode) {
451     printf("%s ", forth_word_table[i].name);
452     goto ok;
453     }
454     }
455     for (uint i=0; i < sizeof forth_internal_word_table/sizeof (forth_word); i++) {
456     if (forth_internal_word_table[i].fcode == fcode) {
457     printf("%s ", forth_internal_word_table[i].name);
458     goto ok2;
459     }
460     }
461     goto test;
462     ok2:
463     switch (fcode) {
464     case FCODE_BqDO:
465     case FCODE_BDO:
466     case FCODE_BLOOP:
467     case FCODE_BOF:
468     case FCODE_BENDOF:
469     case FCODE_BqBRANCH:
470     case FCODE_BBRANCH: {
471     if (offset16) {
472     uint16 a = 0;
473     a |= vm.getFCodeByte(); a<<=8;
474     a |= vm.getFCodeByte();
475     printf("%04x ", a);
476     } else {
477     uint8 a = vm.getFCodeByte();
478     printf("%02x ", a);
479     }
480     break;
481     }
482     case FCODE_Btick:
483     case FCODE_NEW_TOKEN:
484     fcode = vm.getFCode();
485     printf("0x%x ", fcode);
486     break;
487     case FCODE_EXTERNAL_TOKEN:
488     case FCODE_Bstring: {
489     byte len = vm.getFCodeByte();
490     printf("\"");
491     for (int i=0; i<len; i++) {
492     printf("%c", vm.getFCodeByte());
493     }
494     printf("\" ");
495     if (fcode == FCODE_EXTERNAL_TOKEN) {
496     fcode = vm.getFCode();
497     printf("0x%x ", fcode);
498     }
499     break;
500     }
501     }
502     goto ok;
503     test:
504     if (fcode >= 0x800) {
505     printf("user(0x%x) ", fcode);
506     goto ok;
507     }
508     printf("%x unknown\n", fcode);
509     exit(1);
510     ok:;
511     }
512     }
  ViewVC Help
Powered by ViewVC 1.1.26